// Graph-local SCF-to-Dataflow memory input for loom-lower-graph-memory.
// One dataflow.graph whose entry block holds one straight-line logical source
// strand of canonical memory actors and fences over graph memory inputs.

start: {new COUNT = random.randint(2, 6); new I = 0; new MEM = '%a'}
       prologue items epilogue;

prologue: 'dataflow.graph private @sb_strand(\n'
          '    %start: none, %idx: index, %val: i32, %exp: i32, %des: i32,\n'
          '    %a: memref<16xi32>, %b: memref<16xi32>) -> ()\n'
          '    attributes {input_segments = array<i32: 4, 0, 2>,\n'
          '                result_segments = array<i32: 0, 0, 0>} {\n';

epilogue: '  dataflow.graph.return %start : none\n'
          '}\n';

items: (I < COUNT) pick actor {I += 1} items
     | (I == COUNT) '';

pick: {MEM = random.choice(['%a', '%b'])} '';

actor: atomic_load
     | atomic_store
     | volatile_load
     | volatile_store
     | plain_load
     | plain_store
     | fence_op
     | fence_acq
     | fence_rel
     | atomic_volatile_store
     | rmw_op;

atomic_load: '  %r' [str(I)] ', %d' [str(I)] ' = dataflow.load ' [MEM]
             '[%idx] %start {contract = #dataflow.atomic_access<ordering = acquire, sync_scope = <system>, source_alignment_bytes = 4>, sb_index = '
             [str(I)] ' : i64} : memref<16xi32>\n';

atomic_store: '  %d' [str(I)] ' = dataflow.store ' [MEM]
              '[%idx] %val %start {contract = #dataflow.atomic_access<ordering = release, sync_scope = <system>, source_alignment_bytes = 4>, sb_index = '
              [str(I)] ' : i64} : memref<16xi32>\n';

volatile_load: '  %r' [str(I)] ', %d' [str(I)] ' = dataflow.load ' [MEM]
               '[%idx] %start {contract = #dataflow.plain_access<is_volatile = true>, sb_index = '
               [str(I)] ' : i64} : memref<16xi32>\n';

volatile_store: '  %d' [str(I)] ' = dataflow.store ' [MEM]
                '[%idx] %val %start {contract = #dataflow.plain_access<is_volatile = true>, sb_index = '
                [str(I)] ' : i64} : memref<16xi32>\n';

plain_load: '  %r' [str(I)] ', %d' [str(I)] ' = dataflow.load ' [MEM]
            '[%idx] %start {sb_index = ' [str(I)]
            ' : i64} : memref<16xi32>\n';

plain_store: '  %d' [str(I)] ' = dataflow.store ' [MEM]
             '[%idx] %val %start {sb_index = ' [str(I)]
             ' : i64} : memref<16xi32>\n';

fence_op: '  %d' [str(I)]
          ' = dataflow.fence %start {contract = #dataflow.fence_contract<ordering = seq_cst, sync_scope = <system>>, sb_index = '
          [str(I)] ' : i64}\n';

fence_acq: '  %d' [str(I)]
           ' = dataflow.fence %start {contract = #dataflow.fence_contract<ordering = acquire, sync_scope = <system>>, sb_index = '
           [str(I)] ' : i64}\n';

fence_rel: '  %d' [str(I)]
           ' = dataflow.fence %start {contract = #dataflow.fence_contract<ordering = release, sync_scope = <system>>, sb_index = '
           [str(I)] ' : i64}\n';

atomic_volatile_store: '  %d' [str(I)] ' = dataflow.store ' [MEM]
                       '[%idx] %val %start {contract = #dataflow.atomic_access<ordering = seq_cst, sync_scope = <system>, source_alignment_bytes = 4, is_volatile = true>, sb_index = '
                       [str(I)] ' : i64} : memref<16xi32>\n';

rmw_op: '  %r' [str(I)] ', %d' [str(I)] ' = dataflow.atomic_rmw ' [MEM]
        '[%idx] %val %start {contract = #dataflow.rmw_contract<kind = add, access = <ordering = monotonic, sync_scope = <system>, source_alignment_bytes = 4>>, sb_index = '
        [str(I)] ' : i64} : memref<16xi32>\n';