Back to PBT run

output.generic.mlir

"builtin.module"() ({
  "llvm.func"() <{CConv = #llvm.cconv<ccc>, function_type = !llvm.func<void (i64)>, linkage = #llvm.linkage<external>, sym_name = "imported_kernel", unnamed_addr = 0 : i64, visibility_ = 0 : i64}> ({
  }) : () -> ()
  "dataflow.thread"() <{domain = #dataflow.thread_domain<dense>, function_type = (memref<8xindex>, memref<8xindex>, memref<4x4xindex>, index) -> (), sym_name = "t0", sym_visibility = "private"}> ({
  ^bb0(%arg13: memref<8xindex>, %arg14: memref<8xindex>, %arg15: memref<4x4xindex>, %arg16: index, %arg17: none):
    %115 = "arith.constant"() <{value = 0 : index}> : () -> index
    %116 = "arith.constant"() <{value = 3 : index}> : () -> index
    "memref.store"(%116, %arg13, %115) : (index, memref<8xindex>, index) -> ()
    %117 = "dataflow.graph.launch"(%arg17, %arg16, %arg14, %arg15) <{callee = @g_t0_0, operandSegmentSizes = array<i32: 1, 1, 0, 2, 0>, resultSegmentSizes = array<i32: 0, 0, 1>, source_maps = []}> : (none, index, memref<8xindex>, memref<4x4xindex>) -> none
    "dataflow.thread.yield"(%117) : (none) -> ()
  }) : () -> ()
  "dataflow.thread"() <{domain = #dataflow.thread_domain<dense>, function_type = (memref<8xindex>, memref<8xindex>, memref<4x4xindex>, index) -> (), sym_name = "t1", sym_visibility = "private"}> ({
  ^bb0(%arg8: memref<8xindex>, %arg9: memref<8xindex>, %arg10: memref<4x4xindex>, %arg11: index, %arg12: none):
    %114 = "dataflow.graph.launch"(%arg12, %arg11, %arg9, %arg10) <{callee = @g_t1_0, operandSegmentSizes = array<i32: 1, 1, 0, 2, 0>, resultSegmentSizes = array<i32: 0, 0, 1>, source_maps = []}> : (none, index, memref<8xindex>, memref<4x4xindex>) -> none
    "dataflow.thread.yield"(%114) : (none) -> ()
  }) : () -> ()
  "dataflow.graph"() <{function_type = (index, memref<8xindex>, memref<4x4xindex>) -> (), input_segments = array<i32: 1, 0, 2>, result_segments = array<i32: 0, 0, 0>, sym_name = "g_t0_0", sym_visibility = "private"}> ({
  ^bb0(%arg4: none, %arg5: index, %arg6: memref<8xindex>, %arg7: memref<4x4xindex>):
    %28 = "dataflow.constant"(%arg4) <{const_value = 0 : index}> : (none) -> index
    %29 = "dataflow.constant"(%arg4) <{const_value = 1 : index}> : (none) -> index
    %30 = "dataflow.constant"(%arg4) <{const_value = 2 : index}> : (none) -> index
    %31 = "dataflow.constant"(%arg4) <{const_value = 3 : index}> : (none) -> index
    %32 = "dataflow.carry"(%35, %arg4, %37#1) : (i1, none, none) -> none
    %33 = "dataflow.carry"(%35, %28, %43) : (i1, index, index) -> index
    %34 = "dataflow.invariant"(%35, %arg5) : (i1, index) -> index
    %35 = "arith.cmpi"(%33, %34) <{predicate = 2 : i64}> : (index, index) -> i1
    %36:2 = "dataflow.demux"(%35, %32) : (i1, none) -> (none, none)
    %37:2 = "dataflow.gate"(%35, %32) : (i1, none) -> (i1, none)
    %38:2 = "dataflow.demux"(%37#0, %37#1) : (i1, none) -> (none, none)
    %39:2 = "dataflow.demux"(%35, %33) : (i1, index) -> (index, index)
    %40 = "dataflow.invariant"(%35, %29) : (i1, index) -> index
    %41:2 = "dataflow.gate"(%35, %40) : (i1, index) -> (i1, index)
    %42:2 = "dataflow.demux"(%41#0, %41#1) : (i1, index) -> (index, index)
    %43 = "arith.addi"(%39#1, %41#1) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %44:2 = "dataflow.demux"(%37#0, %37#1) : (i1, none) -> (none, none)
    %45:3 = "dataflow.sync"(%44#0, %38#0, %42#0) : (none, none, index) -> (none, none, index)
    %46 = "dataflow.mux"(%37#0, %45#0, %44#1) : (i1, none, none) -> none
    %47 = "dataflow.carry"(%35, %arg4, %46) : (i1, none, none) -> none
    %48:2 = "dataflow.demux"(%35, %47) : (i1, none) -> (none, none)
    %49:2 = "dataflow.sync"(%36#0, %48#0) : (none, none) -> (none, none)
    %50:2 = "dataflow.sync"(%49#0, %arg4) : (none, none) -> (none, none)
    %51 = "dataflow.store"(%arg6, %28, %39#0, %50#0) : (memref<8xindex>, index, index, none) -> none
    %52 = "dataflow.carry"(%55, %arg4, %57#1) : (i1, none, none) -> none
    %53 = "dataflow.carry"(%55, %28, %63) : (i1, index, index) -> index
    %54 = "dataflow.invariant"(%55, %arg5) : (i1, index) -> index
    %55 = "arith.cmpi"(%53, %54) <{predicate = 2 : i64}> : (index, index) -> i1
    %56:2 = "dataflow.demux"(%55, %52) : (i1, none) -> (none, none)
    %57:2 = "dataflow.gate"(%55, %52) : (i1, none) -> (i1, none)
    %58:2 = "dataflow.demux"(%57#0, %57#1) : (i1, none) -> (none, none)
    %59:2 = "dataflow.demux"(%55, %53) : (i1, index) -> (index, index)
    %60 = "dataflow.invariant"(%55, %29) : (i1, index) -> index
    %61:2 = "dataflow.gate"(%55, %60) : (i1, index) -> (i1, index)
    %62:2 = "dataflow.demux"(%61#0, %61#1) : (i1, index) -> (index, index)
    %63 = "arith.addi"(%59#1, %61#1) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %64:2 = "dataflow.demux"(%57#0, %57#1) : (i1, none) -> (none, none)
    %65:3 = "dataflow.sync"(%64#0, %58#0, %62#0) : (none, none, index) -> (none, none, index)
    %66 = "dataflow.mux"(%57#0, %65#0, %64#1) : (i1, none, none) -> none
    %67 = "dataflow.carry"(%55, %arg4, %66) : (i1, none, none) -> none
    %68:2 = "dataflow.demux"(%55, %67) : (i1, none) -> (none, none)
    %69:2 = "dataflow.sync"(%56#0, %68#0) : (none, none) -> (none, none)
    %70:2 = "dataflow.sync"(%69#0, %arg4) : (none, none) -> (none, none)
    %71 = "dataflow.store"(%arg6, %29, %59#0, %70#0) : (memref<8xindex>, index, index, none) -> none
    %72 = "dataflow.carry"(%75, %arg4, %77#1) : (i1, none, none) -> none
    %73 = "dataflow.carry"(%75, %28, %83) : (i1, index, index) -> index
    %74 = "dataflow.invariant"(%75, %arg5) : (i1, index) -> index
    %75 = "arith.cmpi"(%73, %74) <{predicate = 2 : i64}> : (index, index) -> i1
    %76:2 = "dataflow.demux"(%75, %72) : (i1, none) -> (none, none)
    %77:2 = "dataflow.gate"(%75, %72) : (i1, none) -> (i1, none)
    %78:2 = "dataflow.demux"(%77#0, %77#1) : (i1, none) -> (none, none)
    %79:2 = "dataflow.demux"(%75, %73) : (i1, index) -> (index, index)
    %80 = "dataflow.invariant"(%75, %29) : (i1, index) -> index
    %81:2 = "dataflow.gate"(%75, %80) : (i1, index) -> (i1, index)
    %82:2 = "dataflow.demux"(%81#0, %81#1) : (i1, index) -> (index, index)
    %83 = "arith.addi"(%79#1, %81#1) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %84:2 = "dataflow.demux"(%77#0, %77#1) : (i1, none) -> (none, none)
    %85:3 = "dataflow.sync"(%84#0, %78#0, %82#0) : (none, none, index) -> (none, none, index)
    %86 = "dataflow.mux"(%77#0, %85#0, %84#1) : (i1, none, none) -> none
    %87 = "dataflow.carry"(%75, %arg4, %86) : (i1, none, none) -> none
    %88:2 = "dataflow.demux"(%75, %87) : (i1, none) -> (none, none)
    %89:2 = "dataflow.sync"(%76#0, %88#0) : (none, none) -> (none, none)
    %90:2 = "dataflow.sync"(%89#0, %arg4) : (none, none) -> (none, none)
    %91 = "dataflow.store"(%arg6, %30, %79#0, %90#0) : (memref<8xindex>, index, index, none) -> none
    %92 = "dataflow.carry"(%95, %arg4, %97#1) : (i1, none, none) -> none
    %93 = "dataflow.carry"(%95, %28, %103) : (i1, index, index) -> index
    %94 = "dataflow.invariant"(%95, %arg5) : (i1, index) -> index
    %95 = "arith.cmpi"(%93, %94) <{predicate = 2 : i64}> : (index, index) -> i1
    %96:2 = "dataflow.demux"(%95, %92) : (i1, none) -> (none, none)
    %97:2 = "dataflow.gate"(%95, %92) : (i1, none) -> (i1, none)
    %98:2 = "dataflow.demux"(%97#0, %97#1) : (i1, none) -> (none, none)
    %99:2 = "dataflow.demux"(%95, %93) : (i1, index) -> (index, index)
    %100 = "dataflow.invariant"(%95, %29) : (i1, index) -> index
    %101:2 = "dataflow.gate"(%95, %100) : (i1, index) -> (i1, index)
    %102:2 = "dataflow.demux"(%101#0, %101#1) : (i1, index) -> (index, index)
    %103 = "arith.addi"(%99#1, %101#1) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %104:2 = "dataflow.demux"(%97#0, %97#1) : (i1, none) -> (none, none)
    %105:3 = "dataflow.sync"(%104#0, %98#0, %102#0) : (none, none, index) -> (none, none, index)
    %106 = "dataflow.mux"(%97#0, %105#0, %104#1) : (i1, none, none) -> none
    %107 = "dataflow.carry"(%95, %arg4, %106) : (i1, none, none) -> none
    %108:2 = "dataflow.demux"(%95, %107) : (i1, none) -> (none, none)
    %109:2 = "dataflow.sync"(%96#0, %108#0) : (none, none) -> (none, none)
    %110:2 = "dataflow.sync"(%109#0, %arg4) : (none, none) -> (none, none)
    %111 = "dataflow.store"(%arg6, %31, %99#0, %110#0) : (memref<8xindex>, index, index, none) -> none
    %112:4 = "dataflow.sync"(%49#0, %69#0, %89#0, %109#0) : (none, none, none, none) -> (none, none, none, none)
    %113:4 = "dataflow.sync"(%51, %71, %91, %111) : (none, none, none, none) -> (none, none, none, none)
    "dataflow.graph.return"(%112#0, %113#0) <{operandSegmentSizes = array<i32: 0, 0, 0, 2>}> : (none, none) -> ()
  }) : () -> ()
  "dataflow.graph"() <{function_type = (index, memref<8xindex>, memref<4x4xindex>) -> (), input_segments = array<i32: 1, 0, 2>, result_segments = array<i32: 0, 0, 0>, sym_name = "g_t1_0", sym_visibility = "private"}> ({
  ^bb0(%arg0: none, %arg1: index, %arg2: memref<8xindex>, %arg3: memref<4x4xindex>):
    %0 = "dataflow.constant"(%arg0) <{const_value = 0 : index}> : (none) -> index
    %1 = "dataflow.constant"(%arg0) <{const_value = 1 : index}> : (none) -> index
    %2 = "arith.cmpi"(%arg1, %0) <{predicate = 4 : i64}> : (index, index) -> i1
    %3:2 = "dataflow.demux"(%2, %arg0) : (i1, none) -> (none, none)
    %4:2 = "dataflow.demux"(%2, %arg0) : (i1, none) -> (none, none)
    %5:2 = "dataflow.demux"(%2, %1) : (i1, index) -> (index, index)
    %6:2 = "dataflow.demux"(%2, %0) : (i1, index) -> (index, index)
    %7:2 = "dataflow.demux"(%2, %arg1) : (i1, index) -> (index, index)
    %8 = "arith.index_cast"(%6#1) : (index) -> i32
    %9 = "arith.index_cast"(%7#1) : (index) -> i32
    %10 = "arith.index_cast"(%5#1) : (index) -> i32
    %11:2 = "dataflow.stream"(%8, %9, %10) <{predicate = 2 : i64, step_kind = 0 : i32}> : (i32, i32, i32) -> (i32, i1)
    %12 = "dataflow.carry"(%11#1, %3#1, %13#1) : (i1, none, none) -> none
    %13:2 = "dataflow.demux"(%11#1, %12) : (i1, none) -> (none, none)
    %14 = "dataflow.carry"(%11#1, %6#1, %19) : (i1, index, index) -> index
    %15:2 = "dataflow.demux"(%11#1, %14) : (i1, index) -> (index, index)
    %16 = "dataflow.invariant"(%11#1, %5#1) : (i1, index) -> index
    %17:2 = "dataflow.gate"(%11#1, %16) : (i1, index) -> (i1, index)
    %18:2 = "dataflow.demux"(%17#0, %17#1) : (i1, index) -> (index, index)
    %19 = "arith.addi"(%15#1, %17#1) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %20 = "arith.cmpi"(%8, %9) <{predicate = 2 : i64}> : (i32, i32) -> i1
    %21:2 = "dataflow.demux"(%20, %13#0) : (i1, none) -> (none, none)
    %22:2 = "dataflow.sync"(%21#1, %18#0) : (none, index) -> (none, index)
    %23 = "dataflow.mux"(%20, %21#0, %22#0) : (i1, none, none) -> none
    %24:2 = "dataflow.sync"(%23, %4#1) : (none, none) -> (none, none)
    %25 = "dataflow.store"(%arg2, %6#1, %15#0, %24#0) : (memref<8xindex>, index, index, none) -> none
    %26 = "dataflow.mux"(%2, %4#0, %25) : (i1, none, none) -> none
    %27 = "dataflow.mux"(%2, %3#0, %23) : (i1, none, none) -> none
    "dataflow.graph.return"(%27, %26) <{operandSegmentSizes = array<i32: 0, 0, 0, 2>}> : (none, none) -> ()
  }) : () -> ()
}) : () -> ()