[P1] Interpreting for loop in dataflow style

[tancheng]

A for loop is transformed from ctrl flow to data flow in #39:

dataflow/test/neura/ctrl/branch_for.mlir

Lines 57 to 82 in df70824

	// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
	// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
	// CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
	// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: neura.ctrl_mov %19 -> %12 : !neura.data<f32, i1> !neura.data<f32, i1>
	// CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1>, !neura.data<i1, i1> -> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %10 : !neura.data<i64, i1> !neura.data<i64, i1>
	// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1>) -> ()
	// CTRL2DATA-NEXT: }

@Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-)

[itemkelvin]

A for loop is transformed from ctrl flow to data flow in #39:

dataflow/test/neura/ctrl/branch_for.mlir

Lines 57 to 82 in df70824

// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1>
// CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1>
// CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %19 -> %12 : !neura.data<f32, i1> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1>, !neura.data<i1, i1> -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %10 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1>) -> ()
// CTRL2DATA-NEXT: }
@Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-)

A for loop is transformed from ctrl flow to data flow in #39:

dataflow/test/neura/ctrl/branch_for.mlir

Lines 57 to 82 in df70824

// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1>
// CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1>
// CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %19 -> %12 : !neura.data<f32, i1> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1>, !neura.data<i1, i1> -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %10 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1>) -> ()
// CTRL2DATA-NEXT: }
@Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-)

I've recently been implementing the dataflow mode for the interpreter. It mainly realizes simple loops by constructing a data dependency graph between instructions. Currently, simple loops can run, but redundant instructions are propagated.
The test case is
func.func @loop_test() -> f32 {
%0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
%1 = "neura.grant_always"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
%2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
%3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
%4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
%5 = "neura.grant_always"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
%6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
%7 = "neura.grant_always"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
%8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
%9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
%10 = "neura.reserve"() : () -> (!neura.data<i64, i1>)
%11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
%12 = "neura.reserve"() : () -> (!neura.data<f32, i1>)
%13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
%14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
%15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
%16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
%17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
%18 = "neura.grant_predicate"(%14, %17) : (!neura.data<f32, i1>, !neura.data<i1, i1>) -> !neura.data<f32, i1>
%19 = "neura.grant_predicate"(%14, %16) : (!neura.data<f32, i1>, !neura.data<i1, i1>) -> !neura.data<f32, i1>
"neura.ctrl_mov"(%19, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> ()
%20 = "neura.grant_predicate"(%15, %16) : (!neura.data<i64, i1>, !neura.data<i1, i1>) -> !neura.data<i64, i1>
"neura.ctrl_mov"(%20, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> ()
"neura.return"(%18) : (!neura.data<f32, i1>) -> ()
}

[ShangkunLi]

A for loop is transformed from ctrl flow to data flow in #39:
dataflow/test/neura/ctrl/branch_for.mlir
Lines 57 to 82 in df70824
// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1>
// CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1>
// CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %19 -> %12 : !neura.data<f32, i1> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1>, !neura.data<i1, i1> -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %10 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1>) -> ()
// CTRL2DATA-NEXT: }
@Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-)

A for loop is transformed from ctrl flow to data flow in #39:
dataflow/test/neura/ctrl/branch_for.mlir
Lines 57 to 82 in df70824
// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1>
// CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1>
// CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %19 -> %12 : !neura.data<f32, i1> !neura.data<f32, i1>
// CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1>, !neura.data<i1, i1> -> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %10 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1>) -> ()
// CTRL2DATA-NEXT: }
@Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-)

I've recently been implementing the dataflow mode for the interpreter. It mainly realizes simple loops by constructing a data dependency graph between instructions. Currently, simple loops can run, but redundant instructions are propagated. The test case is func.func @loop_test() -> f32 { %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1> %1 = "neura.grant_always"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1> %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1> %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1> %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1> %5 = "neura.grant_always"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1> %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1> %7 = "neura.grant_always"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1> %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1> %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1> %10 = "neura.reserve"() : () -> (!neura.data<i64, i1>) %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1> %12 = "neura.reserve"() : () -> (!neura.data<f32, i1>) %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1> %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1> %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1> %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1> %17 = "neura.not"(%16) : (!neura.data<i1, i1>) -> !neura.data<i1, i1> %18 = "neura.grant_predicate"(%14, %17) : (!neura.data<f32, i1>, !neura.data<i1, i1>) -> !neura.data<f32, i1> %19 = "neura.grant_predicate"(%14, %16) : (!neura.data<f32, i1>, !neura.data<i1, i1>) -> !neura.data<f32, i1> "neura.ctrl_mov"(%19, %12) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> () %20 = "neura.grant_predicate"(%15, %16) : (!neura.data<i64, i1>, !neura.data<i1, i1>) -> !neura.data<i64, i1> "neura.ctrl_mov"(%20, %10) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> () "neura.return"(%18) : (!neura.data<f32, i1>) -> () }

Hi~

What do you mean by "redundant instructions are propagated"? For now, please refer branch_for.mlir for the newest version of dataflow representation. We have removed redundant grant_always and constant operations here.

[itemkelvin]

&nbsp;grant_once is not defined with a constant value in TableGen. Does this definition need to be modified?&nbsp; 发自我的iPhone

…

------------------ Original ------------------ From: Shangkun LI ***@***.***&gt; Date: Tue,Aug 5,2025 10:30 PM To: coredac/dataflow ***@***.***&gt; Cc: item ***@***.***&gt;, Assign ***@***.***&gt; Subject: Re: [coredac/dataflow] [P1] Interpreting for loop in dataflow style(Issue #42) ShangkunLi left a comment (coredac/dataflow#42) A for loop is transformed from ctrl flow to data flow in #39: dataflow/test/neura/ctrl/branch_for.mlir Lines 57 to 82 in df70824 // CTRL2DATA: func.func @loop_test() -&gt; f32 attributes {accelerator = "neura"} { // CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}&gt; : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i1, i1&gt; // CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1&gt;) -&gt; !neura.data<i1, i1&gt; // CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: neura.ctrl_mov %19 -&gt; %12 : !neura.data<f32, i1&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: neura.ctrl_mov %20 -&gt; %10 : !neura.data<i64, i1&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1&gt;) -&gt; () // CTRL2DATA-NEXT: } @Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-) A for loop is transformed from ctrl flow to data flow in #39: dataflow/test/neura/ctrl/branch_for.mlir Lines 57 to 82 in df70824 // CTRL2DATA: func.func @loop_test() -&gt; f32 attributes {accelerator = "neura"} { // CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}&gt; : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i1, i1&gt; // CTRL2DATA-NEXT: %17 = "neura.not"(%16) : (!neura.data<i1, i1&gt;) -&gt; !neura.data<i1, i1&gt; // CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %17 : !neura.data<f32, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %19 = neura.grant_predicate %14, %16 : !neura.data<f32, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: neura.ctrl_mov %19 -&gt; %12 : !neura.data<f32, i1&gt; !neura.data<f32, i1&gt; // CTRL2DATA-NEXT: %20 = neura.grant_predicate %15, %16 : !neura.data<i64, i1&gt;, !neura.data<i1, i1&gt; -&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: neura.ctrl_mov %20 -&gt; %10 : !neura.data<i64, i1&gt; !neura.data<i64, i1&gt; // CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data<f32, i1&gt;) -&gt; () // CTRL2DATA-NEXT: } @Yfeng-44 It would be perfect if you could help with this dataflow for loop support in the interpreter as your next step. Plz let me know if anything is not clear to you. Thanks :-) I've recently been implementing the dataflow mode for the interpreter. It mainly realizes simple loops by constructing a data dependency graph between instructions. Currently, simple loops can run, but redundant instructions are propagated. The test case is func.func @loop_test() -&gt; f32 { %0 = "neura.constant"() <{predicate = true, value = 10 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; %1 = "neura.grant_always"(%0) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; %2 = "neura.constant"() <{predicate = true, value = 0 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; %4 = "neura.constant"() <{predicate = true, value = 1 : i64}&gt; : () -&gt; !neura.data<i64, i1&gt; %5 = "neura.grant_always"(%4) : (!neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; %7 = "neura.grant_always"(%6) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}&gt; : () -&gt; !neura.data<f32, i1&gt; %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; %10 = "neura.reserve"() : () -&gt; (!neura.data<i64, i1&gt;) %11 = "neura.phi"(%3, %10) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; %12 = "neura.reserve"() : () -&gt; (!neura.data<f32, i1&gt;) %13 = "neura.phi"(%9, %12) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; %14 = "neura.fadd"(%13, %7) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; !neura.data<f32, i1&gt; %15 = "neura.add"(%11, %5) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i64, i1&gt; %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}&gt; : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; !neura.data<i1, i1&gt; %17 = "neura.not"(%16) : (!neura.data<i1, i1&gt;) -&gt; !neura.data<i1, i1&gt; %18 = "neura.grant_predicate"(%14, %17) : (!neura.data<f32, i1&gt;, !neura.data<i1, i1&gt;) -&gt; !neura.data<f32, i1&gt; %19 = "neura.grant_predicate"(%14, %16) : (!neura.data<f32, i1&gt;, !neura.data<i1, i1&gt;) -&gt; !neura.data<f32, i1&gt; "neura.ctrl_mov"(%19, %12) : (!neura.data<f32, i1&gt;, !neura.data<f32, i1&gt;) -&gt; () %20 = "neura.grant_predicate"(%15, %16) : (!neura.data<i64, i1&gt;, !neura.data<i1, i1&gt;) -&gt; !neura.data<i64, i1&gt; "neura.ctrl_mov"(%20, %10) : (!neura.data<i64, i1&gt;, !neura.data<i64, i1&gt;) -&gt; () "neura.return"(%18) : (!neura.data<f32, i1&gt;) -&gt; () } Hi~ What do you mean by "redundant instructions are propagated"? For now, please refer branch_for.mlir for the newest version of dataflow representation. We have removed redundant grant_always and constant operations here. — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were assigned.Message ID: ***@***.***&gt;

[ShangkunLi]

 grant_once is not defined with a constant value in TableGen. Does this definition need to be modified? 

发自我的iPhone
…

We have added a $constant_value attribute to denote the value that grant_once processed.

def Neura_GrantOnceOp : Op<NeuraDialect, "grant_once"> {
  let summary = "Marks a value as valid once.";
  let description = [{
    Either grants a value a one-time predicate, or creates a constant value with a one-time predicate. The resulting value is considered valid
    only during its first activation. Used to initialize recurrence cycles.
    
    Example:
      %v = neura.grant_once %init : !neura.data<f32, i1> -> !neura.data<f32, i1>
      %c = neura.grant_once <{value = 42 : i64}> : !neura.data<i64, i1>
  }];

  let arguments = (ins 
  Optional<AnyType>:$value,
  OptionalAttr<AnyAttr>:$constant_value);
  let results = (outs AnyType:$result);

  // let assemblyFormat = "$value attr-dict `:` type($value) `->` type($result)";
}

[itemkelvin]

The simple loop is now running properly. Do we need to test the nested loops? &nbsp; Jeromer ***@***.*** &nbsp;

…

------------------&nbsp;原始邮件&nbsp;------------------ 发件人: "YIJIA ***@***.***&gt;; 发送时间: 2025年8月5日(星期二) 晚上11:47 收件人: ***@***.***&gt;; 抄送: ***@***.***&gt;; ***@***.***&gt;; 主题: Re: [coredac/dataflow] [P1] Interpreting for loop in dataflow style (Issue #42) ShangkunLi left a comment (coredac/dataflow#42) &nbsp;grant_once is not defined with a constant value in TableGen. Does this definition need to be modified?&nbsp; 发自我的iPhone … We have added a $constant_value attribute to denote the value that grant_once processed. def Neura_GrantOnceOp : Op<NeuraDialect, "grant_once"&gt; { let summary = "Marks a value as valid once."; let description = [{ Either grants a value a one-time predicate, or creates a constant value with a one-time predicate. The resulting value is considered valid only during its first activation. Used to initialize recurrence cycles. Example: %v = neura.grant_once %init : !neura.data<f32, i1&gt; -&gt; !neura.data<f32, i1&gt; %c = neura.grant_once <{value = 42 : i64}&gt; : !neura.data<i64, i1&gt; }]; let arguments = (ins Optional<AnyType&gt;:$value, OptionalAttr<AnyAttr&gt;:$constant_value); let results = (outs AnyType:$result); // let assemblyFormat = "$value attr-dict `:` type($value) `-&gt;` type($result)"; } — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were assigned.Message ID: ***@***.***&gt;

[tancheng]

Hi @itemkelvin, thanks for the effort. We prefer tiny PR. Let's check in your support for simple test first. Thanks~!

[tancheng]

Hi @itemkelvin, thanks for #105~!

Plz let me know what is your next TODO, IIRC, you have some pending tests that cannot be supported by #105?

[itemkelvin]

Hi @itemkelvin, thanks for #105~!

Plz let me know what is your next TODO, IIRC, you have some pending tests that cannot be supported by #105?

The interpreter currently analyzes log files to verify the correctness of execution. However, logs for a simple for-loop can already have thousands of lines. Therefore, should we add a breakpoint mechanism to the interpreter to better debug and verify the Neura Dialect?