From 5b8f212975666108247db06685317677199a519f Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Sun, 20 Jul 2025 14:31:25 +0800 Subject: [PATCH 1/8] promote live-in values to block args --- include/NeuraDialect/NeuraPasses.h | 1 + include/NeuraDialect/NeuraPasses.td | 10 + lib/NeuraDialect/Transforms/CMakeLists.txt | 1 + .../Transforms/NeuraCanonicalizePass.cpp | 174 ++++++++++ .../TransformCtrlToDataFlowPass.cpp | 14 +- .../complex_nested/complex_nested.mlir | 2 +- .../non_perfect_nested.mlir | 2 +- .../perfect_nested/perfect_nested.mlir | 2 +- .../perfect_reduction/perfect_reduction.mlir | 2 +- .../simpleloop/simpleloop.mlir | 2 +- test/neura/ctrl/branch.mlir | 1 + test/neura/ctrl/branch_for.mlir | 306 +++++++++++------- .../ctrl/branch_with_and_without_arg.mlir | 1 + test/neura/ctrl/branch_without_arg.mlir | 1 + test/neura/ctrl/nested_branch.mlir | 2 + 15 files changed, 391 insertions(+), 130 deletions(-) create mode 100644 lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp diff --git a/include/NeuraDialect/NeuraPasses.h b/include/NeuraDialect/NeuraPasses.h index 0c8c252a..47df969e 100644 --- a/include/NeuraDialect/NeuraPasses.h +++ b/include/NeuraDialect/NeuraPasses.h @@ -27,6 +27,7 @@ std::unique_ptr createLeveragePredicatedValuePass(); std::unique_ptr createMapToAcceleratorPass(); std::unique_ptr createGenerateCodePass(); std::unique_ptr createFuseControlFlowPass(); +std::unique_ptr createNeuraCanonicalizePass(); #define GEN_PASS_REGISTRATION #include "NeuraDialect/NeuraPasses.h.inc" diff --git a/include/NeuraDialect/NeuraPasses.td b/include/NeuraDialect/NeuraPasses.td index 98a0402b..5029c74f 100644 --- a/include/NeuraDialect/NeuraPasses.td +++ b/include/NeuraDialect/NeuraPasses.td @@ -75,4 +75,14 @@ def FuseControlFlow: Pass<"fuse-control-flow", "ModuleOp">{ let constructor = "neura::createFuseControlFlowPass()"; } +def NeuraCanonicalize : Pass<"neura-canonicalize", "ModuleOp"> { + let summary = "Canonicalizes operations in the Neura dialect"; + let description = [{ + This pass applies canonicalization transformations to Neura dialect operations. + The canonicalization includes: + 1. Converting all live-in values of each basic block to block arguments. + }]; + let constructor = "neura::createNeuraCanonicalizePass()"; +} + #endif // NEURA_PASSES_TD \ No newline at end of file diff --git a/lib/NeuraDialect/Transforms/CMakeLists.txt b/lib/NeuraDialect/Transforms/CMakeLists.txt index 0979725f..e3d41ed3 100644 --- a/lib/NeuraDialect/Transforms/CMakeLists.txt +++ b/lib/NeuraDialect/Transforms/CMakeLists.txt @@ -11,6 +11,7 @@ add_mlir_library( MapToAcceleratorPass.cpp GenerateCodePass.cpp FuseControlFlowPass.cpp + NeuraCanonicalizePass.cpp DEPENDS MLIRNeuraTransformsIncGen diff --git a/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp b/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp new file mode 100644 index 00000000..e5526a5b --- /dev/null +++ b/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp @@ -0,0 +1,174 @@ +#include "NeuraDialect/NeuraOps.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/IR/Operation.h" +#include "mlir/IR/PatternMatch.h" +#include "mlir/IR/Value.h" +#include "mlir/Pass/Pass.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "llvm/ADT/MapVector.h" +#include "llvm/Support/Casting.h" + +using namespace mlir; + +#define GEN_PASS_DEF_NEURACANONICALIZE +#include "NeuraDialect/NeuraPasses.h.inc" + +namespace { +LogicalResult promoteLiveInValuesToBlockArgs(Operation *op) { + auto func_op = dyn_cast(op); + if (!func_op) + return success(); + + for (Block &block : func_op.getBlocks()) { + // Skips the entry block. + if (&block == &func_op.getBlocks().front()) + continue; + + // Identifies all the live-in values in the block. + llvm::SetVector live_ins; + + // Iterates over each operation in the block and its operands. + for (Operation &op : block.getOperations()) { + for (Value operand : op.getOperands()) { + // If the operand is not a block argument and is defined outside the + // current block, it is a live-in value. + if (!dyn_cast(operand)) { + Operation *defOp = operand.getDefiningOp(); + if (defOp && defOp->getBlock() != &block) { + live_ins.insert(operand); + } + } else if (dyn_cast(operand).getOwner() != &block) { + // If it is a block argument but defined in another block, + // it is also considered a live-in value. + live_ins.insert(operand); + } + } + } + + if (live_ins.empty()) + continue; + + // Adds new block arguments for each live-in value. + unsigned originalNumArgs = block.getNumArguments(); + for (Value value : live_ins) { + block.addArgument(value.getType(), value.getLoc()); + } + + // Creates a mapping from live-in values to the new block arguments. + DenseMap value_to_arg; + for (unsigned i = 0; i < live_ins.size(); ++i) { + value_to_arg[live_ins[i]] = block.getArgument(originalNumArgs + i); + } + + // Updates all operations in the block to use the new block arguments + // instead of the live-in values. + for (Operation &op : block.getOperations()) { + for (unsigned i = 0; i < op.getNumOperands(); ++i) { + Value operand = op.getOperand(i); + auto it = value_to_arg.find(operand); + if (it != value_to_arg.end()) { + op.setOperand(i, it->second); + } + } + } + + // Updates the terminator of predecessor blocks to include the new block + // arguments. + for (Block *pred_block : block.getPredecessors()) { + Operation *pred_op = pred_block->getTerminator(); + // Handles br operations. + if (auto br_op = dyn_cast(pred_op)) { + if (br_op.getDest() == &block) { + // Creates a new operand list, including the original operands. + SmallVector new_operands; + + for (Value operand : br_op.getOperands()) { + new_operands.push_back(operand); + } + + // Adds live-in values as new operands + for (Value live_in : live_ins) { + new_operands.push_back(live_in); + } + + // Creates a new branch operation with the updated operands. + OpBuilder builder(br_op); + builder.create(br_op.getLoc(), new_operands, &block); + + // Erases the old branch operation. + br_op.erase(); + } + } + // Handles conditional branch operations. + else if (auto cond_br_op = dyn_cast(pred_op)) { + OpBuilder builder(cond_br_op); + bool needs_update = false; + + SmallVector true_operands, false_operands; + Block *true_dest = cond_br_op.getTrueDest(); + Block *false_dest = cond_br_op.getFalseDest(); + + for (Value operand : cond_br_op.getTrueArgs()) { + true_operands.push_back(operand); + } + for (Value operand : cond_br_op.getFalseArgs()) { + false_operands.push_back(operand); + } + + // Checks if the true branch destination is the current block. + if (true_dest == &block) { + needs_update = true; + for (Value live_in : live_ins) { + true_operands.push_back(live_in); + } + } + + // Checks if the false branch destination is the current block. + if (false_dest == &block) { + needs_update = true; + for (Value live_in : live_ins) { + false_operands.push_back(live_in); + } + } + + if (needs_update) { + // Predicated bit defaults to null. + builder.create( + cond_br_op.getLoc(), cond_br_op.getCondition(), nullptr, + true_operands, false_operands, true_dest, false_dest); + + cond_br_op.erase(); + } + } + } + } + + return success(); +} + +struct NeuraCanonicalizePass + : public PassWrapper> { + MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(NeuraCanonicalizePass) + + StringRef getArgument() const override { return "neura-canonicalize"; } + StringRef getDescription() const override { + return "Canonicalizes operations in the Neura dialect"; + } + + void runOnOperation() override { + ModuleOp module_op = getOperation(); + module_op->walk([&](func::FuncOp func) { + if (failed(promoteLiveInValuesToBlockArgs(func))) { + signalPassFailure(); + return; + } + }); + } +}; +} // namespace + +namespace mlir::neura { +std::unique_ptr createNeuraCanonicalizePass() { + return std::make_unique(); +} +} // namespace mlir::neura \ No newline at end of file diff --git a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp index 5518005f..afd41ba1 100644 --- a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp +++ b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp @@ -141,7 +141,6 @@ void assertLiveOutValuesDominatedByBlockArgs(Region ®ion) { continue; } - llvm::errs() << "[ctrl2data] Checking block: " << block << "\n"; DenseSet live_out_values; for (Operation &op : block) { for (Value result : op.getResults()) { @@ -160,13 +159,12 @@ void assertLiveOutValuesDominatedByBlockArgs(Region ®ion) { DenseSet dominated_values; - for (Operation &op : block) { - for (Value operand : op.getOperands()) { - if (!operand.getDefiningOp() || - operand.getDefiningOp()->getBlock() != &block) { - dominated_values.insert(operand); - } - } + if (block.getNumArguments() == 0 && !live_out_values.empty()) { + assert(false && "Block without arguments has live-out values"); + } + + for (BlockArgument arg : block.getArguments()) { + dominated_values.insert(arg); } bool changed = true; diff --git a/test/controflow_fuse/complex_nested/complex_nested.mlir b/test/controflow_fuse/complex_nested/complex_nested.mlir index c01e44bf..4191c1f5 100644 --- a/test/controflow_fuse/complex_nested/complex_nested.mlir +++ b/test/controflow_fuse/complex_nested/complex_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir index 8c91e7cd..8473a129 100644 --- a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir +++ b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/controflow_fuse/perfect_nested/perfect_nested.mlir b/test/controflow_fuse/perfect_nested/perfect_nested.mlir index 1dbbcaf1..762f8a58 100644 --- a/test/controflow_fuse/perfect_nested/perfect_nested.mlir +++ b/test/controflow_fuse/perfect_nested/perfect_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir index cc04b7f0..4b86b69f 100644 --- a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir +++ b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/controflow_fuse/simpleloop/simpleloop.mlir b/test/controflow_fuse/simpleloop/simpleloop.mlir index 0684bc9f..88c704bd 100644 --- a/test/controflow_fuse/simpleloop/simpleloop.mlir +++ b/test/controflow_fuse/simpleloop/simpleloop.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z10simpleloopv() -> i32 attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/neura/ctrl/branch.mlir b/test/neura/ctrl/branch.mlir index fe0bc979..dbb1cf9d 100644 --- a/test/neura/ctrl/branch.mlir +++ b/test/neura/ctrl/branch.mlir @@ -7,6 +7,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir index 83f87d11..4352e4ef 100644 --- a/test/neura/ctrl/branch_for.mlir +++ b/test/neura/ctrl/branch_for.mlir @@ -7,6 +7,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA @@ -14,6 +15,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ @@ -22,22 +24,23 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ -// RUN: --map-to-accelerator="mapping-strategy=heuristic" \ -// RUN: | FileCheck %s -check-prefix=MAPPING +// RU: --map-to-accelerator="mapping-strategy=heuristic" \ +// RU: | FileCheck %s -check-prefix=MAPPING // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ -// RUN: --map-to-accelerator="mapping-strategy=heuristic" \ -// RUN: --generate-code - -// RU: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST +// RU: --map-to-accelerator="mapping-strategy=heuristic" \ +// RU: --generate-code +// RUN: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST func.func @loop_test() -> f32 { %n = llvm.mlir.constant(10 : i64) : i64 @@ -74,128 +77,197 @@ func.func @loop_test() -> f32 { // CHECK-NEXT: "neura.return"(%10) : (!neura.data) -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { +// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { // CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %10 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %11 = "neura.phi"(%10, %9) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %12 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %13 = "neura.phi"(%12, %3) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %14 = "neura.fadd"(%11, %7) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %15 = "neura.add"(%13, %5) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.icmp"(%15, %1) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %17 = neura.grant_predicate %15, %16 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %17 -> %12 : !neura.data !neura.data -// CTRL2DATA-NEXT: %18 = neura.grant_predicate %14, %16 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %18 -> %10 : !neura.data !neura.data -// CTRL2DATA-NEXT: %19 = "neura.not"(%16) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %20 = neura.grant_predicate %14, %19 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: "neura.return"(%20) : (!neura.data) -> () +// CTRL2DATA-NEXT: %2 = "neura.grant_once"(%0) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %5 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.grant_always"(%5) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%5) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.grant_always"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %12 = "neura.grant_once"(%11) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %13 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %14 = "neura.phi"(%13, %2) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %15 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %16 = "neura.phi"(%15, %7) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %17 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %18 = "neura.phi"(%17, %10) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %19 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %20 = "neura.phi"(%19, %12) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %21 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %22 = "neura.phi"(%21, %4) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %23 = "neura.fadd"(%20, %18) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %24 = "neura.add"(%22, %16) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %25 = "neura.icmp"(%24, %14) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %26 = neura.grant_predicate %24, %25 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %26 -> %21 : !neura.data !neura.data +// CTRL2DATA-NEXT: %27 = neura.grant_predicate %23, %25 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %27 -> %19 : !neura.data !neura.data +// CTRL2DATA-NEXT: %28 = neura.grant_predicate %10, %25 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %28 -> %17 : !neura.data !neura.data +// CTRL2DATA-NEXT: %29 = neura.grant_predicate %7, %25 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %29 -> %15 : !neura.data !neura.data +// CTRL2DATA-NEXT: %30 = neura.grant_predicate %2, %25 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %30 -> %13 : !neura.data !neura.data +// CTRL2DATA-NEXT: %31 = "neura.not"(%25) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %32 = neura.grant_predicate %23, %31 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: "neura.return"(%32) : (!neura.data) -> () // CTRL2DATA-NEXT: } // MOV: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { -// MOV-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data +// MOV-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data // MOV-NEXT: %1 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data // MOV-NEXT: %2 = "neura.grant_always"(%1) : (!neura.data) -> !neura.data -// MOV-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// MOV-NEXT: %4 = "neura.data_mov"(%3) : (!neura.data) -> !neura.data -// MOV-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data -// MOV-NEXT: %6 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data -// MOV-NEXT: %7 = "neura.data_mov"(%6) : (!neura.data) -> !neura.data -// MOV-NEXT: %8 = "neura.grant_always"(%7) : (!neura.data) -> !neura.data -// MOV-NEXT: %9 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// MOV-NEXT: %10 = "neura.data_mov"(%9) : (!neura.data) -> !neura.data -// MOV-NEXT: %11 = "neura.grant_always"(%10) : (!neura.data) -> !neura.data -// MOV-NEXT: %12 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data -// MOV-NEXT: %13 = "neura.data_mov"(%12) : (!neura.data) -> !neura.data -// MOV-NEXT: %14 = "neura.grant_once"(%13) : (!neura.data) -> !neura.data -// MOV-NEXT: %15 = neura.reserve : !neura.data -// MOV-NEXT: %16 = "neura.data_mov"(%14) : (!neura.data) -> !neura.data -// MOV-NEXT: %17 = "neura.phi"(%15, %16) : (!neura.data, !neura.data) -> !neura.data -// MOV-NEXT: %18 = neura.reserve : !neura.data -// MOV-NEXT: %19 = "neura.data_mov"(%5) : (!neura.data) -> !neura.data -// MOV-NEXT: %20 = "neura.phi"(%18, %19) : (!neura.data, !neura.data) -> !neura.data -// MOV-NEXT: %21 = "neura.data_mov"(%17) : (!neura.data) -> !neura.data -// MOV-NEXT: %22 = "neura.data_mov"(%11) : (!neura.data) -> !neura.data -// MOV-NEXT: %23 = "neura.fadd"(%21, %22) : (!neura.data, !neura.data) -> !neura.data -// MOV-NEXT: %24 = "neura.data_mov"(%20) : (!neura.data) -> !neura.data -// MOV-NEXT: %25 = "neura.data_mov"(%8) : (!neura.data) -> !neura.data -// MOV-NEXT: %26 = "neura.add"(%24, %25) : (!neura.data, !neura.data) -> !neura.data -// MOV-NEXT: %27 = "neura.data_mov"(%26) : (!neura.data) -> !neura.data -// MOV-NEXT: %28 = "neura.data_mov"(%2) : (!neura.data) -> !neura.data -// MOV-NEXT: %29 = "neura.icmp"(%27, %28) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// MOV-NEXT: %30 = "neura.data_mov"(%26) : (!neura.data) -> !neura.data -// MOV-NEXT: %31 = "neura.data_mov"(%29) : (!neura.data) -> !neura.data -// MOV-NEXT: %32 = neura.grant_predicate %30, %31 : !neura.data, !neura.data -> !neura.data -// MOV-NEXT: neura.ctrl_mov %32 -> %18 : !neura.data !neura.data -// MOV-NEXT: %33 = "neura.data_mov"(%23) : (!neura.data) -> !neura.data -// MOV-NEXT: %34 = "neura.data_mov"(%29) : (!neura.data) -> !neura.data -// MOV-NEXT: %35 = neura.grant_predicate %33, %34 : !neura.data, !neura.data -> !neura.data -// MOV-NEXT: neura.ctrl_mov %35 -> %15 : !neura.data !neura.data -// MOV-NEXT: %36 = "neura.data_mov"(%29) : (!neura.data) -> !neura.data -// MOV-NEXT: %37 = "neura.not"(%36) : (!neura.data) -> !neura.data -// MOV-NEXT: %38 = "neura.data_mov"(%23) : (!neura.data) -> !neura.data -// MOV-NEXT: %39 = "neura.data_mov"(%37) : (!neura.data) -> !neura.data -// MOV-NEXT: %40 = neura.grant_predicate %38, %39 : !neura.data, !neura.data -> !neura.data -// MOV-NEXT: %41 = "neura.data_mov"(%40) : (!neura.data) -> !neura.data -// MOV-NEXT: "neura.return"(%41) : (!neura.data) -> () +// MOV-NEXT: %3 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data +// MOV-NEXT: %4 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data +// MOV-NEXT: %5 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// MOV-NEXT: %6 = "neura.data_mov"(%5) : (!neura.data) -> !neura.data +// MOV-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// MOV-NEXT: %8 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// MOV-NEXT: %9 = "neura.data_mov"(%8) : (!neura.data) -> !neura.data +// MOV-NEXT: %10 = "neura.grant_always"(%9) : (!neura.data) -> !neura.data +// MOV-NEXT: %11 = "neura.data_mov"(%8) : (!neura.data) -> !neura.data +// MOV-NEXT: %12 = "neura.grant_once"(%11) : (!neura.data) -> !neura.data +// MOV-NEXT: %13 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// MOV-NEXT: %14 = "neura.data_mov"(%13) : (!neura.data) -> !neura.data +// MOV-NEXT: %15 = "neura.grant_always"(%14) : (!neura.data) -> !neura.data +// MOV-NEXT: %16 = "neura.data_mov"(%13) : (!neura.data) -> !neura.data +// MOV-NEXT: %17 = "neura.grant_once"(%16) : (!neura.data) -> !neura.data +// MOV-NEXT: %18 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data +// MOV-NEXT: %19 = "neura.data_mov"(%18) : (!neura.data) -> !neura.data +// MOV-NEXT: %20 = "neura.grant_once"(%19) : (!neura.data) -> !neura.data +// MOV-NEXT: %21 = neura.reserve : !neura.data +// MOV-NEXT: %22 = "neura.data_mov"(%4) : (!neura.data) -> !neura.data +// MOV-NEXT: %23 = "neura.phi"(%21, %22) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %24 = neura.reserve : !neura.data +// MOV-NEXT: %25 = "neura.data_mov"(%12) : (!neura.data) -> !neura.data +// MOV-NEXT: %26 = "neura.phi"(%24, %25) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %27 = neura.reserve : !neura.data +// MOV-NEXT: %28 = "neura.data_mov"(%17) : (!neura.data) -> !neura.data +// MOV-NEXT: %29 = "neura.phi"(%27, %28) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %30 = neura.reserve : !neura.data +// MOV-NEXT: %31 = "neura.data_mov"(%20) : (!neura.data) -> !neura.data +// MOV-NEXT: %32 = "neura.phi"(%30, %31) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %33 = neura.reserve : !neura.data +// MOV-NEXT: %34 = "neura.data_mov"(%7) : (!neura.data) -> !neura.data +// MOV-NEXT: %35 = "neura.phi"(%33, %34) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %36 = "neura.data_mov"(%32) : (!neura.data) -> !neura.data +// MOV-NEXT: %37 = "neura.data_mov"(%29) : (!neura.data) -> !neura.data +// MOV-NEXT: %38 = "neura.fadd"(%36, %37) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %39 = "neura.data_mov"(%35) : (!neura.data) -> !neura.data +// MOV-NEXT: %40 = "neura.data_mov"(%26) : (!neura.data) -> !neura.data +// MOV-NEXT: %41 = "neura.add"(%39, %40) : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %42 = "neura.data_mov"(%41) : (!neura.data) -> !neura.data +// MOV-NEXT: %43 = "neura.data_mov"(%23) : (!neura.data) -> !neura.data +// MOV-NEXT: %44 = "neura.icmp"(%42, %43) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// MOV-NEXT: %45 = "neura.data_mov"(%41) : (!neura.data) -> !neura.data +// MOV-NEXT: %46 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %47 = neura.grant_predicate %45, %46 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: neura.ctrl_mov %47 -> %33 : !neura.data !neura.data +// MOV-NEXT: %48 = "neura.data_mov"(%38) : (!neura.data) -> !neura.data +// MOV-NEXT: %49 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %50 = neura.grant_predicate %48, %49 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: neura.ctrl_mov %50 -> %30 : !neura.data !neura.data +// MOV-NEXT: %51 = "neura.data_mov"(%17) : (!neura.data) -> !neura.data +// MOV-NEXT: %52 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %53 = neura.grant_predicate %51, %52 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: neura.ctrl_mov %53 -> %27 : !neura.data !neura.data +// MOV-NEXT: %54 = "neura.data_mov"(%12) : (!neura.data) -> !neura.data +// MOV-NEXT: %55 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %56 = neura.grant_predicate %54, %55 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: neura.ctrl_mov %56 -> %24 : !neura.data !neura.data +// MOV-NEXT: %57 = "neura.data_mov"(%4) : (!neura.data) -> !neura.data +// MOV-NEXT: %58 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %59 = neura.grant_predicate %57, %58 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: neura.ctrl_mov %59 -> %21 : !neura.data !neura.data +// MOV-NEXT: %60 = "neura.data_mov"(%44) : (!neura.data) -> !neura.data +// MOV-NEXT: %61 = "neura.not"(%60) : (!neura.data) -> !neura.data +// MOV-NEXT: %62 = "neura.data_mov"(%38) : (!neura.data) -> !neura.data +// MOV-NEXT: %63 = "neura.data_mov"(%61) : (!neura.data) -> !neura.data +// MOV-NEXT: %64 = neura.grant_predicate %62, %63 : !neura.data, !neura.data -> !neura.data +// MOV-NEXT: %65 = "neura.data_mov"(%64) : (!neura.data) -> !neura.data +// MOV-NEXT: "neura.return"(%65) : (!neura.data) -> () // MOV-NEXT: } -// MAPPING: func.func @loop_test() -> f32 attributes {CompiledII = 4 : i32, RecMII = 4 : i32, ResMII = 1 : i32, accelerator = "neura"} { -// MAPPING-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 0 : i32, x = 1 : i32, y = 1 : i32}]} : () -> !neura.data +// MAPPING: func.func @loop_test() -> f32 attributes {CompiledII = 6 : i32, RecMII = 4 : i32, ResMII = 2 : i32, accelerator = "neura"} { +// MAPPING-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 0 : i32, x = 1 : i32, y = 1 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.data_mov"(%0) {mapping_locs = []} : (!neura.data) -> !neura.data // MAPPING-NEXT: %2 = "neura.grant_always"(%1) {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 1 : i32, x = 1 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 0 : i32, x = 1 : i32, y = 2 : i32}]} : () -> !neura.data -// MAPPING-NEXT: %4 = "neura.data_mov"(%3) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %5 = "neura.grant_once"(%4) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 1 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %6 = "neura.constant"() <{predicate = true, value = 1 : i64}> {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 0 : i32, x = 2 : i32, y = 1 : i32}]} : () -> !neura.data -// MAPPING-NEXT: %7 = "neura.data_mov"(%6) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %8 = "neura.grant_always"(%7) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %9 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 0 : i32, x = 2 : i32, y = 2 : i32}]} : () -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %11 = "neura.grant_always"(%10) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %12 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 2 : i32}]} : () -> !neura.data -// MAPPING-NEXT: %13 = "neura.data_mov"(%12) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %14 = "neura.grant_once"(%13) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %15 = neura.reserve : !neura.data -// MAPPING-NEXT: %16 = "neura.data_mov"(%14) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %17 = "neura.phi"(%15, %16) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %18 = neura.reserve : !neura.data -// MAPPING-NEXT: %19 = "neura.data_mov"(%5) {mapping_locs = [{id = 19 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %20 = "neura.phi"(%18, %19) {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 2 : i32, x = 1 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %21 = "neura.data_mov"(%17) {mapping_locs = [{id = 28 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %22 = "neura.data_mov"(%11) {mapping_locs = [{id = 32 : i32, resource = "link", time_step = 2 : i32}, {id = 44 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %23 = "neura.fadd"(%21, %22) {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 4 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %24 = "neura.data_mov"(%20) {mapping_locs = [{id = 15 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %25 = "neura.data_mov"(%8) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 1 : i32}, {id = 24 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %26 = "neura.add"(%24, %25) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 3 : i32, x = 1 : i32, y = 0 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %27 = "neura.data_mov"(%26) {mapping_locs = [{id = 11 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %28 = "neura.data_mov"(%2) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 1 : i32}, {id = 29 : i32, resource = "link", time_step = 2 : i32}, {id = 29 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.icmp"(%27, %28) <{cmpType = "slt"}> {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 0 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %30 = "neura.data_mov"(%26) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %31 = "neura.data_mov"(%29) {mapping_locs = [{id = 24 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %32 = neura.grant_predicate %30, %31 {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 5 : i32, x = 1 : i32, y = 0 : i32}]} : !neura.data, !neura.data -> !neura.data -// MAPPING-NEXT: neura.ctrl_mov %32 -> %18 {mapping_locs = [{id = 12 : i32, resource = "link", time_step = 5 : i32}]} : !neura.data !neura.data -// MAPPING-NEXT: %33 = "neura.data_mov"(%23) {mapping_locs = [{id = 41 : i32, resource = "link", time_step = 4 : i32}, {id = 38 : i32, resource = "link", time_step = 5 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %34 = "neura.data_mov"(%29) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %35 = neura.grant_predicate %33, %34 {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 6 : i32, x = 2 : i32, y = 0 : i32}]} : !neura.data, !neura.data -> !neura.data -// MAPPING-NEXT: neura.ctrl_mov %35 -> %15 {mapping_locs = [{id = 26 : i32, resource = "link", time_step = 6 : i32}]} : !neura.data !neura.data -// MAPPING-NEXT: %36 = "neura.data_mov"(%29) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %37 = "neura.not"(%36) {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 0 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %38 = "neura.data_mov"(%23) {mapping_locs = []} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %39 = "neura.data_mov"(%37) {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 5 : i32}, {id = 39 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %40 = neura.grant_predicate %38, %39 {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 7 : i32, x = 3 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data -// MAPPING-NEXT: %41 = "neura.data_mov"(%40) {mapping_locs = [{id = 42 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: "neura.return"(%41) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 8 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data) -> () -// MAPPING-NEXT: } +// MAPPING-NEXT: %3 = "neura.data_mov"(%0) {mapping_locs = [{id = 16 : i32, resource = "link", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %4 = "neura.grant_once"(%3) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 1 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %5 = "neura.constant"() <{predicate = true, value = 0 : i64}> {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 0 : i32, x = 1 : i32, y = 2 : i32}]} : () -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%5) {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %7 = "neura.grant_once"(%6) {mapping_locs = [{id = 7 : i32, resource = "tile", time_step = 1 : i32, x = 1 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %8 = "neura.constant"() <{predicate = true, value = 1 : i64}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 0 : i32, x = 2 : i32, y = 2 : i32}]} : () -> !neura.data +// MAPPING-NEXT: %9 = "neura.data_mov"(%8) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.grant_always"(%9) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %11 = "neura.data_mov"(%8) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %12 = "neura.grant_once"(%11) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %13 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 0 : i32, x = 2 : i32, y = 1 : i32}]} : () -> !neura.data +// MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 28 : i32, resource = "link", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %15 = "neura.grant_always"(%14) {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %16 = "neura.data_mov"(%13) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %17 = "neura.grant_once"(%16) {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %18 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 0 : i32, x = 3 : i32, y = 2 : i32}]} : () -> !neura.data +// MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %20 = "neura.grant_once"(%19) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %21 = neura.reserve : !neura.data +// MAPPING-NEXT: %22 = "neura.data_mov"(%4) {mapping_locs = [{id = 19 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %23 = "neura.phi"(%21, %22) {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 2 : i32, x = 1 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %24 = neura.reserve : !neura.data +// MAPPING-NEXT: %25 = "neura.data_mov"(%12) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %26 = "neura.phi"(%24, %25) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %27 = neura.reserve : !neura.data +// MAPPING-NEXT: %28 = "neura.data_mov"(%17) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.phi"(%27, %28) {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 0 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %30 = neura.reserve : !neura.data +// MAPPING-NEXT: %31 = "neura.data_mov"(%20) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %32 = "neura.phi"(%30, %31) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %33 = neura.reserve : !neura.data +// MAPPING-NEXT: %34 = "neura.data_mov"(%7) {mapping_locs = [{id = 23 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.phi"(%33, %34) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 2 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %36 = "neura.data_mov"(%32) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 2 : i32}, {id = 19 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %37 = "neura.data_mov"(%29) {mapping_locs = [{id = 24 : i32, resource = "link", time_step = 2 : i32}, {id = 12 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %38 = "neura.fadd"(%36, %37) {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 4 : i32, x = 1 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %39 = "neura.data_mov"(%35) {mapping_locs = [{id = 18 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %40 = "neura.data_mov"(%26) {mapping_locs = [{id = 30 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %41 = "neura.add"(%39, %40) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %42 = "neura.data_mov"(%41) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %43 = "neura.data_mov"(%23) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 2 : i32}, {id = 14 : i32, resource = "link", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %44 = "neura.icmp"(%42, %43) <{cmpType = "slt"}> {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data +// MAPPING-NEXT: %45 = "neura.data_mov"(%41) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %46 = "neura.data_mov"(%44) {mapping_locs = [{id = 30 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %47 = neura.grant_predicate %45, %46 {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 2 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %47 -> %33 {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 5 : i32}, {id = 31 : i32, resource = "link", time_step = 6 : i32}, {id = 31 : i32, resource = "link", time_step = 7 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %48 = "neura.data_mov"(%38) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %49 = "neura.data_mov"(%44) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %50 = neura.grant_predicate %48, %49 {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 5 : i32, x = 1 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %50 -> %30 {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 5 : i32}, {id = 30 : i32, resource = "link", time_step = 6 : i32}, {id = 30 : i32, resource = "link", time_step = 7 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %51 = "neura.data_mov"(%17) {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 1 : i32}, {id = 39 : i32, resource = "link", time_step = 2 : i32}, {id = 39 : i32, resource = "link", time_step = 3 : i32}, {id = 39 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %52 = "neura.data_mov"(%44) {mapping_locs = [{id = 28 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %53 = neura.grant_predicate %51, %52 {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 5 : i32, x = 3 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %53 -> %27 {mapping_locs = [{id = 41 : i32, resource = "link", time_step = 5 : i32}, {id = 38 : i32, resource = "link", time_step = 6 : i32}, {id = 38 : i32, resource = "link", time_step = 7 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %54 = "neura.data_mov"(%12) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %55 = "neura.data_mov"(%44) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %56 = neura.grant_predicate %54, %55 {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 9 : i32, x = 2 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %56 -> %24 {mapping_locs = []} : !neura.data !neura.data +// MAPPING-NEXT: %57 = "neura.data_mov"(%4) {mapping_locs = [{id = 18 : i32, resource = "link", time_step = 1 : i32}, {id = 33 : i32, resource = "link", time_step = 2 : i32}, {id = 27 : i32, resource = "link", time_step = 3 : i32}, {id = 15 : i32, resource = "link", time_step = 4 : i32}, {id = 15 : i32, resource = "link", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %58 = "neura.data_mov"(%44) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 24 : i32, resource = "link", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %59 = neura.grant_predicate %57, %58 {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 6 : i32, x = 1 : i32, y = 0 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %59 -> %21 {mapping_locs = [{id = 12 : i32, resource = "link", time_step = 6 : i32}, {id = 12 : i32, resource = "link", time_step = 7 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %60 = "neura.data_mov"(%44) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %61 = "neura.not"(%60) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %62 = "neura.data_mov"(%38) {mapping_locs = [{id = 13 : i32, resource = "link", time_step = 4 : i32}, {id = 3 : i32, resource = "link", time_step = 5 : i32}, {id = 0 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %63 = "neura.data_mov"(%61) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 15 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %64 = neura.grant_predicate %62, %63 {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 7 : i32, x = 1 : i32, y = 0 : i32}]} : !neura.data, !neura.data -> !neura.data +// MAPPING-NEXT: %65 = "neura.data_mov"(%64) {mapping_locs = []} : (!neura.data) -> !neura.data +// MAPPING-NEXT: "neura.return"(%65) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 0 : i32}]} : (!neura.data) -> () +// MAPPING-NEXT: } // INST: "name": "neura.fadd", // INST-NEXT: "operands": [ diff --git a/test/neura/ctrl/branch_with_and_without_arg.mlir b/test/neura/ctrl/branch_with_and_without_arg.mlir index f3be5d0c..e0ad00b0 100644 --- a/test/neura/ctrl/branch_with_and_without_arg.mlir +++ b/test/neura/ctrl/branch_with_and_without_arg.mlir @@ -7,6 +7,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/branch_without_arg.mlir b/test/neura/ctrl/branch_without_arg.mlir index 10ef442b..5d38d645 100644 --- a/test/neura/ctrl/branch_without_arg.mlir +++ b/test/neura/ctrl/branch_without_arg.mlir @@ -7,6 +7,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/nested_branch.mlir b/test/neura/ctrl/nested_branch.mlir index 116d8b1e..1af938c4 100644 --- a/test/neura/ctrl/nested_branch.mlir +++ b/test/neura/ctrl/nested_branch.mlir @@ -1,6 +1,8 @@ // RUN: mlir-neura-opt \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: %s | FileCheck %s From fb750769aad2cc2e56fedf6425ef5a8ace91ba29 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Sun, 20 Jul 2025 23:40:29 +0800 Subject: [PATCH 2/8] promote func args to constants --- .../bert/bert_node0/bert_node0.mlir | 8 +- .../bert/bert_node1/bert_node1.mlir | 12 +- .../bert/bert_node2/bert_node2.mlir | 16 +- .../bert/bert_node28/bert_node28.mlir | 16 +- .../bert/bert_node3/bert_node3.mlir | 8 +- .../bert/bert_node8/bert_node8.mlir | 8 +- .../bert/bert_node9/bert_node9.mlir | 8 +- .../complex_nested/complex_nested.mlir | 360 ++++++++++-------- .../non_perfect_nested.mlir | 258 +++++++------ .../perfect_nested/perfect_nested.mlir | 14 +- .../perfect_reduction/perfect_reduction.mlir | 18 +- .../simpleloop/simpleloop.mlir | 18 +- test/lit.cfg.in | 1 + test/neura/ctrl/branch.mlir | 81 ++-- test/neura/ctrl/branch_for.mlir | 30 +- .../ctrl/branch_with_and_without_arg.mlir | 73 ++-- test/neura/ctrl/branch_without_arg.mlir | 77 ++-- test/neura/ctrl/nested_branch.mlir | 91 +++-- test/neura/for_loop/test.mlir | 239 ++++++++++-- 19 files changed, 830 insertions(+), 506 deletions(-) diff --git a/test/affine2neura/bert/bert_node0/bert_node0.mlir b/test/affine2neura/bert/bert_node0/bert_node0.mlir index 12f98cfd..28d2221d 100644 --- a/test/affine2neura/bert/bert_node0/bert_node0.mlir +++ b/test/affine2neura/bert/bert_node0/bert_node0.mlir @@ -15,10 +15,10 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node0PA128_KiPA128_b(%arg0: memref, %arg1: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb2 diff --git a/test/affine2neura/bert/bert_node1/bert_node1.mlir b/test/affine2neura/bert/bert_node1/bert_node1.mlir index f9cf5a7e..c9ad5116 100644 --- a/test/affine2neura/bert/bert_node1/bert_node1.mlir +++ b/test/affine2neura/bert/bert_node1/bert_node1.mlir @@ -14,9 +14,9 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %3 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%4: i64): // 2 preds: ^bb0, ^bb5 @@ -46,11 +46,11 @@ module attributes {} { // CTRL2DATA: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura"} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %6 = "neura.cast"(%4) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data diff --git a/test/affine2neura/bert/bert_node2/bert_node2.mlir b/test/affine2neura/bert/bert_node2/bert_node2.mlir index 0bc0a274..0c9e6831 100644 --- a/test/affine2neura/bert/bert_node2/bert_node2.mlir +++ b/test/affine2neura/bert/bert_node2/bert_node2.mlir @@ -28,14 +28,14 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node2PA128_KiPA768_KfPA128_A768_f(%arg0: memref, %arg1: memref, %arg2: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %3 = "neura.constant"() <{value = false}> : () -> i1 -// CHECK-NEXT: %4 = "neura.constant"() <{value = 30521 : i32}> : () -> i32 -// CHECK-NEXT: %5 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %6 = "neura.constant"() <{value = 30522 : i32}> : () -> i32 -// CHECK-NEXT: %7 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = false}> : () -> i1 +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 30521 : i32}> : () -> i32 +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %6 = "neura.constant"() <{predicate = true, value = 30522 : i32}> : () -> i32 +// CHECK-NEXT: %7 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %8 = "neura.cast"(%7) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %8 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%9: i64): // 2 preds: ^bb0, ^bb9 diff --git a/test/affine2neura/bert/bert_node28/bert_node28.mlir b/test/affine2neura/bert/bert_node28/bert_node28.mlir index 6f6daf41..90bb38f6 100644 --- a/test/affine2neura/bert/bert_node28/bert_node28.mlir +++ b/test/affine2neura/bert/bert_node28/bert_node28.mlir @@ -19,10 +19,10 @@ module attributes {} { } } // CHECK: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref, %arg1: memref, %arg2: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb8 @@ -66,13 +66,13 @@ module attributes {} { // CTRL2DATA: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref, %arg1: memref, %arg2: memref) attributes {accelerator = "neura"} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %8 = "neura.cast"(%6) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data diff --git a/test/affine2neura/bert/bert_node3/bert_node3.mlir b/test/affine2neura/bert/bert_node3/bert_node3.mlir index 19d121e4..1988367f 100644 --- a/test/affine2neura/bert/bert_node3/bert_node3.mlir +++ b/test/affine2neura/bert/bert_node3/bert_node3.mlir @@ -15,10 +15,10 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node3PA128_A768_KfS2_PA128_A768_f(%arg0: memref, %arg1: memref, %arg2: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb5 diff --git a/test/affine2neura/bert/bert_node8/bert_node8.mlir b/test/affine2neura/bert/bert_node8/bert_node8.mlir index b0cb6345..38b8e0f3 100644 --- a/test/affine2neura/bert/bert_node8/bert_node8.mlir +++ b/test/affine2neura/bert/bert_node8/bert_node8.mlir @@ -13,10 +13,10 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node8PA128_A1_KfPA128_A1_f(%arg0: memref, %arg1: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 7.680000e+02 : f32}> : () -> f32 -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 7.680000e+02 : f32}> : () -> f32 +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb2 diff --git a/test/affine2neura/bert/bert_node9/bert_node9.mlir b/test/affine2neura/bert/bert_node9/bert_node9.mlir index 333589ab..90862cbc 100644 --- a/test/affine2neura/bert/bert_node9/bert_node9.mlir +++ b/test/affine2neura/bert/bert_node9/bert_node9.mlir @@ -15,10 +15,10 @@ module attributes {} { // CHECK: func.func @_Z10bert_node9PA128_A768_KfPA128_A768_d(%arg0: memref, %arg1: memref) attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb5 diff --git a/test/controflow_fuse/complex_nested/complex_nested.mlir b/test/controflow_fuse/complex_nested/complex_nested.mlir index 4191c1f5..d836c382 100644 --- a/test/controflow_fuse/complex_nested/complex_nested.mlir +++ b/test/controflow_fuse/complex_nested/complex_nested.mlir @@ -48,14 +48,14 @@ module attributes {} { } } -// CHECK: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 32 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : i32}> : () -> i32 -// CHECK-NEXT: %3 = "neura.constant"() <{value = -128 : i32}> : () -> i32 -// CHECK-NEXT: %4 = "neura.constant"() <{value = 32 : i32}> : () -> i32 -// CHECK-NEXT: %5 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %6 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 32 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> i32 +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = -128 : i32}> : () -> i32 +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 32 : i32}> : () -> i32 +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %6 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %7 = "neura.cast"(%6) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %7 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%8: i64): // 2 preds: ^bb0, ^bb22 @@ -158,150 +158,204 @@ module attributes {} { // CHECK-NEXT: "neura.return"() : () -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 32 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 128 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{value = -128 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.constant"() <{value = 32 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %10 = "neura.grant_always"(%9) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %11 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %12 = "neura.grant_always"(%11) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %13 = "neura.grant_once"(%11) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %14 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %15 = "neura.grant_always"(%14) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.cast"(%14) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %17 = "neura.grant_once"(%16) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %18 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %19 = "neura.phi"(%18, %17) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %20 = "neura.cast"(%19) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %21 = "neura.icmp"(%20, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %22 = "neura.not"(%21) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %23 = neura.grant_predicate %15, %21 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %24 = "neura.cast"(%23) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %25 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %26 = "neura.phi"(%25, %24) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %27 = "neura.cast"(%26) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %28 = "neura.icmp"(%27, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %29 = "neura.not"(%28) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %30 = neura.grant_predicate %12, %28 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %31 = neura.grant_predicate %20, %28 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %32 = neura.grant_predicate %27, %28 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %30 to %arg1[%31, %32 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %33 = neura.grant_predicate %15, %28 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %34 = "neura.cast"(%33) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %35 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %36 = "neura.phi"(%35, %34) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %37 = "neura.cast"(%36) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %38 = "neura.icmp"(%37, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %39 = "neura.not"(%38) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %40 = neura.grant_predicate %20, %38 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %41 = neura.grant_predicate %27, %38 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %42 = neura.grant_predicate %37, %38 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %43 = neura.load_indexed %arg0[%40, %41, %42 : !neura.data, !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %44 = neura.load_indexed %arg1[%40, %41 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %45 = "neura.add"(%44, %43) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %45 to %arg1[%40, %41 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %46 = neura.grant_predicate %1, %38 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %47 = "neura.add"(%42, %46) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %48 = "neura.cast"(%47) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %48 -> %35 : !neura.data !neura.data -// CTRL2DATA-NEXT: %49 = neura.grant_predicate %27, %39 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %50 = neura.grant_predicate %1, %39 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %51 = "neura.add"(%49, %50) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %52 = "neura.cast"(%51) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %52 -> %25 : !neura.data !neura.data -// CTRL2DATA-NEXT: %53 = neura.grant_predicate %15, %29 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %54 = "neura.cast"(%53) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %55 = neura.grant_predicate %13, %29 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %56 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %57 = "neura.phi"(%56, %55) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %58 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %59 = "neura.phi"(%58, %54) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %60 = "neura.cast"(%59) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %61 = "neura.icmp"(%60, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %62 = "neura.not"(%61) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %63 = neura.grant_predicate %20, %61 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %64 = neura.grant_predicate %60, %61 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %65 = neura.load_indexed %arg1[%63, %64 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %66 = "neura.add"(%57, %65) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %67 = neura.grant_predicate %1, %61 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %68 = "neura.add"(%64, %67) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %69 = "neura.cast"(%68) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %69 -> %58 : !neura.data !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %66 -> %56 : !neura.data !neura.data -// CTRL2DATA-NEXT: %70 = neura.grant_predicate %10, %62 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %71 = "neura.div"(%57, %70) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %72 = neura.grant_predicate %15, %62 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %73 = "neura.cast"(%72) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %74 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %75 = "neura.phi"(%74, %73) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %76 = "neura.cast"(%75) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %77 = "neura.icmp"(%76, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %78 = "neura.not"(%77) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %79 = neura.grant_predicate %15, %77 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %80 = "neura.cast"(%79) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %81 = neura.grant_predicate %8, %77 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %82 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %83 = "neura.phi"(%82, %81) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %84 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %85 = "neura.phi"(%84, %80) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %86 = "neura.cast"(%85) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %87 = "neura.icmp"(%86, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %88 = "neura.not"(%87) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %89 = neura.grant_predicate %86, %87 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %90 = neura.grant_predicate %76, %87 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %91 = neura.grant_predicate %20, %87 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %92 = neura.load_indexed %arg0[%89, %90, %91 : !neura.data, !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %93 = "neura.icmp"(%92, %83) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %94 = "neura.sel"(%92, %83, %93) : (!neura.data, !neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %95 = neura.grant_predicate %1, %87 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %96 = "neura.add"(%89, %95) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %97 = "neura.cast"(%96) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %97 -> %84 : !neura.data !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %94 -> %82 : !neura.data !neura.data -// CTRL2DATA-NEXT: %98 = neura.grant_predicate %20, %88 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %99 = neura.grant_predicate %76, %88 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %100 = neura.load_indexed %arg1[%98, %99 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %101 = "neura.mul"(%100, %83) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %102 = neura.grant_predicate %5, %88 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %103 = "neura.div"(%101, %102) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %103 to %arg1[%98, %99 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %104 = neura.grant_predicate %1, %88 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %105 = "neura.add"(%99, %104) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %106 = "neura.cast"(%105) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %106 -> %74 : !neura.data !neura.data -// CTRL2DATA-NEXT: %107 = neura.grant_predicate %15, %78 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %108 = "neura.cast"(%107) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %109 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %110 = "neura.phi"(%109, %108) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %111 = "neura.cast"(%110) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %112 = "neura.icmp"(%111, %3) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %113 = "neura.not"(%112) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %114 = neura.grant_predicate %20, %112 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %115 = neura.grant_predicate %111, %112 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %116 = neura.load_indexed %arg1[%114, %115 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %117 = neura.grant_predicate %71, %112 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %118 = "neura.icmp"(%116, %117) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %119 = "neura.not"(%118) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %120 = neura.grant_predicate %71, %118 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %121 = neura.grant_predicate %20, %118 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %122 = neura.grant_predicate %111, %118 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %120 to %arg1[%121, %122 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %123 = neura.grant_predicate %111, %119 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %124 = neura.grant_predicate %1, %119 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %125 = "neura.add"(%123, %124) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %126 = "neura.cast"(%125) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %126 -> %109 : !neura.data !neura.data -// CTRL2DATA-NEXT: %127 = neura.grant_predicate %20, %113 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %128 = neura.grant_predicate %1, %113 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %129 = "neura.add"(%127, %128) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %130 = "neura.cast"(%129) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %130 -> %18 : !neura.data !neura.data +// CTRL2DATA: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data, i1> +// CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %2 = "neura.grant_once"(%0) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data, i1> +// CTRL2DATA-NEXT: %4 = "neura.grant_always"(%3) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%3) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.constant"() <{predicate = true, value = 32 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.grant_always"(%9) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.grant_once"(%9) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %12 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %13 = "neura.grant_always"(%12) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %14 = "neura.grant_once"(%12) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %15 = "neura.constant"() <{predicate = true, value = -128 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %16 = "neura.grant_always"(%15) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %17 = "neura.grant_once"(%15) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %18 = "neura.constant"() <{predicate = true, value = 32 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %19 = "neura.grant_always"(%18) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %20 = "neura.grant_once"(%18) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %21 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %22 = "neura.grant_always"(%21) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %23 = "neura.grant_once"(%21) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %24 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %25 = "neura.grant_always"(%24) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %26 = "neura.grant_once"(%24) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %27 = "neura.cast"(%24) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %28 = "neura.grant_once"(%27) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %29 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %30 = "neura.phi"(%29, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %31 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %32 = "neura.phi"(%31, %28) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %33 = "neura.cast"(%32) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %34 = "neura.icmp"(%33, %30) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %35 = "neura.not"(%34) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %36 = neura.grant_predicate %26, %34 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %37 = "neura.cast"(%36) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %38 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %39 = "neura.phi"(%38, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %40 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %41 = "neura.phi"(%40, %37) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %42 = "neura.cast"(%41) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %43 = "neura.icmp"(%42, %39) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %44 = neura.grant_predicate %23, %43 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %45 = neura.grant_predicate %5, %43 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %46 = neura.grant_predicate %33, %43 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %47 = neura.grant_predicate %42, %43 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %48 = neura.grant_predicate %26, %43 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %49 = "neura.not"(%43) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %50 = neura.grant_predicate %26, %49 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %51 = neura.grant_predicate %23, %49 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %44 to %45[%46, %47 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %52 = "neura.cast"(%48) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %53 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %54 = "neura.phi"(%53, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %55 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %56 = "neura.phi"(%55, %52) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %57 = "neura.cast"(%56) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %58 = "neura.icmp"(%57, %54) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %59 = neura.grant_predicate %2, %58 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %60 = neura.grant_predicate %33, %58 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %61 = neura.grant_predicate %42, %58 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %62 = neura.grant_predicate %57, %58 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %63 = neura.grant_predicate %5, %58 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %64 = neura.grant_predicate %8, %58 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %65 = neura.grant_predicate %11, %58 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %66 = "neura.not"(%58) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %67 = neura.grant_predicate %42, %66 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %68 = neura.grant_predicate %8, %66 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %69 = neura.grant_predicate %11, %66 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %70 = neura.load_indexed %59[%60, %61, %62 : !neura.data, !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %71 = neura.load_indexed %63[%60, %61 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %72 = "neura.add"(%71, %70) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %72 to %63[%60, %61 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %73 = "neura.add"(%62, %64) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %74 = "neura.cast"(%73) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %74 -> %55 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %65 -> %53 : !neura.data !neura.data +// CTRL2DATA-NEXT: %75 = "neura.add"(%67, %68) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %76 = "neura.cast"(%75) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %76 -> %40 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %69 -> %38 : !neura.data !neura.data +// CTRL2DATA-NEXT: %77 = "neura.cast"(%50) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %78 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %79 = "neura.phi"(%78, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %80 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %81 = "neura.phi"(%80, %51) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %82 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %83 = "neura.phi"(%82, %77) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %84 = "neura.cast"(%83) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %85 = "neura.icmp"(%84, %79) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %86 = neura.grant_predicate %5, %85 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %87 = neura.grant_predicate %33, %85 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %88 = neura.grant_predicate %84, %85 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %89 = neura.grant_predicate %81, %85 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %90 = neura.grant_predicate %8, %85 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %91 = neura.grant_predicate %11, %85 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %92 = "neura.not"(%85) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %93 = neura.grant_predicate %81, %92 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %94 = neura.grant_predicate %20, %92 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %95 = neura.grant_predicate %26, %92 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %96 = neura.load_indexed %86[%87, %88 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %97 = "neura.add"(%89, %96) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %98 = "neura.add"(%88, %90) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %99 = "neura.cast"(%98) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %99 -> %82 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %97 -> %80 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %91 -> %78 : !neura.data !neura.data +// CTRL2DATA-NEXT: %100 = "neura.div"(%93, %94) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %101 = "neura.cast"(%95) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %102 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %103 = "neura.phi"(%102, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %104 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %105 = "neura.phi"(%104, %101) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %106 = "neura.cast"(%105) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %107 = "neura.icmp"(%106, %103) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %108 = neura.grant_predicate %26, %107 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %109 = neura.grant_predicate %17, %107 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %110 = "neura.not"(%107) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %111 = neura.grant_predicate %26, %110 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %112 = "neura.cast"(%108) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %113 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %114 = "neura.phi"(%113, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %115 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %116 = "neura.phi"(%115, %109) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %117 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %118 = "neura.phi"(%117, %112) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %119 = "neura.cast"(%118) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %120 = "neura.icmp"(%119, %114) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %121 = neura.grant_predicate %2, %120 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %122 = neura.grant_predicate %119, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %123 = neura.grant_predicate %106, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %124 = neura.grant_predicate %33, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %125 = neura.grant_predicate %116, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %126 = neura.grant_predicate %8, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %127 = neura.grant_predicate %11, %120 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %128 = "neura.not"(%120) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %129 = neura.grant_predicate %5, %128 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %130 = neura.grant_predicate %33, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %131 = neura.grant_predicate %106, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %132 = neura.grant_predicate %116, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %133 = neura.grant_predicate %14, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %134 = neura.grant_predicate %8, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %135 = neura.grant_predicate %11, %128 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %136 = neura.load_indexed %121[%122, %123, %124 : !neura.data, !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %137 = "neura.icmp"(%136, %125) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %138 = "neura.sel"(%136, %125, %137) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %139 = "neura.add"(%122, %126) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %140 = "neura.cast"(%139) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %140 -> %117 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %138 -> %115 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %127 -> %113 : !neura.data !neura.data +// CTRL2DATA-NEXT: %141 = neura.load_indexed %129[%130, %131 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %142 = "neura.mul"(%141, %132) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %143 = "neura.div"(%142, %133) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %143 to %129[%130, %131 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %144 = "neura.add"(%131, %134) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %145 = "neura.cast"(%144) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %145 -> %104 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %135 -> %102 : !neura.data !neura.data +// CTRL2DATA-NEXT: %146 = "neura.cast"(%111) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %147 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %148 = "neura.phi"(%147, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %149 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %150 = "neura.phi"(%149, %146) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %151 = "neura.cast"(%150) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %152 = "neura.icmp"(%151, %148) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %153 = neura.grant_predicate %5, %152 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %154 = neura.grant_predicate %33, %152 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %155 = neura.grant_predicate %151, %152 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %156 = neura.grant_predicate %100, %152 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %157 = "neura.not"(%152) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %158 = neura.grant_predicate %33, %157 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %159 = neura.grant_predicate %8, %157 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %160 = neura.grant_predicate %11, %157 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %161 = neura.load_indexed %153[%154, %155 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %162 = "neura.icmp"(%161, %156) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %163 = neura.grant_predicate %100, %162 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %164 = neura.grant_predicate %5, %162 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %165 = neura.grant_predicate %33, %162 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %166 = neura.grant_predicate %151, %162 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %167 = "neura.not"(%162) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %168 = neura.grant_predicate %151, %167 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %169 = neura.grant_predicate %8, %167 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %170 = neura.grant_predicate %11, %167 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %163 to %164[%165, %166 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %171 = "neura.phi"(%170, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %172 = "neura.phi"(%169, %8) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %173 = "neura.phi"(%168, %151) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %174 = "neura.add"(%173, %172) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %175 = "neura.cast"(%174) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %175 -> %149 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %171 -> %147 : !neura.data !neura.data +// CTRL2DATA-NEXT: %176 = "neura.add"(%158, %159) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %177 = "neura.cast"(%176) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %177 -> %31 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %160 -> %29 : !neura.data !neura.data // CTRL2DATA-NEXT: "neura.return"() : () -> () // CTRL2DATA-NEXT: } \ No newline at end of file diff --git a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir index 8473a129..f1537e1a 100644 --- a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir +++ b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir @@ -49,19 +49,19 @@ module attributes {} { } // CHECK: func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 4 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 3 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 2 : index}> : () -> index -// CHECK-NEXT: %3 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %4 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %5 = "neura.constant"() <{value = 100 : i32}> : () -> i32 -// CHECK-NEXT: %6 = "neura.constant"() <{value = 3 : i32}> : () -> i32 -// CHECK-NEXT: %7 = "neura.constant"() <{value = 2 : i32}> : () -> i32 -// CHECK-NEXT: %8 = "neura.constant"() <{value = 1000 : i32}> : () -> i32 -// CHECK-NEXT: %9 = "neura.constant"() <{value = -1000 : i32}> : () -> i32 -// CHECK-NEXT: %10 = "neura.constant"() <{value = 128 : i32}> : () -> i32 -// CHECK-NEXT: %11 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %12 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 4 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 3 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 2 : index}> : () -> index +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 100 : i32}> : () -> i32 +// CHECK-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3 : i32}> : () -> i32 +// CHECK-NEXT: %7 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> i32 +// CHECK-NEXT: %8 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> i32 +// CHECK-NEXT: %9 = "neura.constant"() <{predicate = true, value = -1000 : i32}> : () -> i32 +// CHECK-NEXT: %10 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> i32 +// CHECK-NEXT: %11 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %12 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %13 = "neura.cast"(%12) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %13 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%14: i64): // 2 preds: ^bb0, ^bb9 @@ -120,108 +120,138 @@ module attributes {} { // CHECK-NEXT: "neura.return"() : () -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 4 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 3 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 2 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA: func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data, i1> +// CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %2 = "neura.grant_once"(%0) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data, i1> +// CTRL2DATA-NEXT: %4 = "neura.grant_always"(%3) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%3) : (!neura.data, i1>) -> !neura.data, i1> +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 4 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.grant_always"(%8) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %10 = "neura.constant"() <{value = 100 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %11 = "neura.grant_always"(%10) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %12 = "neura.constant"() <{value = 3 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %13 = "neura.grant_always"(%12) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %14 = "neura.constant"() <{value = 2 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %15 = "neura.grant_always"(%14) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.constant"() <{value = 1000 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %17 = "neura.grant_always"(%16) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %18 = "neura.grant_once"(%16) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %19 = "neura.constant"() <{value = -1000 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %20 = "neura.grant_always"(%19) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %21 = "neura.grant_once"(%19) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %22 = "neura.constant"() <{value = 128 : i32}> : () -> !neura.data -// CTRL2DATA-NEXT: %23 = "neura.grant_always"(%22) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %24 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.constant"() <{predicate = true, value = 3 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.grant_always"(%9) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.grant_once"(%9) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %12 = "neura.constant"() <{predicate = true, value = 2 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %13 = "neura.grant_always"(%12) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %14 = "neura.grant_once"(%12) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %15 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %16 = "neura.grant_always"(%15) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %17 = "neura.grant_once"(%15) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %18 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %19 = "neura.grant_always"(%18) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %20 = "neura.grant_once"(%18) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %21 = "neura.constant"() <{predicate = true, value = 100 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %22 = "neura.grant_always"(%21) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %23 = "neura.grant_once"(%21) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %24 = "neura.constant"() <{predicate = true, value = 3 : i32}> : () -> !neura.data // CTRL2DATA-NEXT: %25 = "neura.grant_always"(%24) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %26 = "neura.grant_once"(%24) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %27 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data -// CTRL2DATA-NEXT: %28 = "neura.grant_always"(%27) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %29 = "neura.cast"(%27) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %30 = "neura.grant_once"(%29) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %31 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %32 = "neura.phi"(%31, %30) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %33 = "neura.cast"(%32) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %34 = "neura.icmp"(%33, %9) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %35 = "neura.not"(%34) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %36 = neura.grant_predicate %33, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %37 = "neura.cast"(%36) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %38 = neura.grant_predicate %15, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %39 = "neura.div"(%37, %38) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %40 = "neura.mul"(%38, %39) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %41 = "neura.sub"(%37, %40) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %42 = neura.grant_predicate %25, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %43 = "neura.icmp"(%41, %42) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %44 = neura.grant_predicate %13, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %45 = "neura.sel"(%38, %44, %43) : (!neura.data, !neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %46 = neura.grant_predicate %28, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %47 = "neura.cast"(%46) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %48 = neura.grant_predicate %18, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %49 = neura.grant_predicate %21, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %50 = neura.grant_predicate %26, %34 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %51 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %52 = "neura.phi"(%51, %50) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %53 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %54 = "neura.phi"(%53, %49) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %55 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %56 = "neura.phi"(%55, %48) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %57 = neura.reserve : !neura.data -// CTRL2DATA-NEXT: %58 = "neura.phi"(%57, %47) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %59 = "neura.cast"(%58) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %60 = "neura.icmp"(%59, %9) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %61 = "neura.not"(%60) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %62 = neura.grant_predicate %33, %60 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %63 = neura.grant_predicate %59, %60 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %64 = neura.load_indexed %arg0[%62, %63 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %65 = neura.grant_predicate %45, %60 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %66 = "neura.mul"(%64, %65) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %66 to %arg1[%62, %63 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %67 = neura.load_indexed %arg0[%62, %63 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %68 = "neura.add"(%52, %67) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %69 = "neura.icmp"(%67, %54) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %70 = "neura.sel"(%67, %54, %69) : (!neura.data, !neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %71 = "neura.icmp"(%67, %56) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %72 = "neura.sel"(%67, %56, %71) : (!neura.data, !neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %73 = neura.grant_predicate %7, %60 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %74 = "neura.add"(%63, %73) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %75 = "neura.cast"(%74) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %75 -> %57 : !neura.data !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %72 -> %55 : !neura.data !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %70 -> %53 : !neura.data !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %68 -> %51 : !neura.data !neura.data -// CTRL2DATA-NEXT: %76 = neura.grant_predicate %23, %61 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %77 = "neura.div"(%52, %76) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %78 = "neura.sub"(%54, %56) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %79 = neura.grant_predicate %25, %61 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %80 = "neura.icmp"(%78, %79) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %81 = "neura.not"(%80) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %82 = neura.grant_predicate %77, %80 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %83 = neura.grant_predicate %11, %80 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %84 = "neura.mul"(%82, %83) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %85 = neura.grant_predicate %78, %80 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %86 = "neura.div"(%84, %85) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %87 = neura.grant_predicate %77, %81 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %88 = "neura.phi"(%86, %87) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %77 to %arg1[%33, %28 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %54 to %arg1[%33, %7 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %56 to %arg1[%33, %5 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %88 to %arg1[%33, %3 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: neura.store_indexed %78 to %arg1[%33, %1 : !neura.data, !neura.data] memref : !neura.data -// CTRL2DATA-NEXT: %89 = "neura.add"(%33, %7) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %90 = "neura.cast"(%89) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: neura.ctrl_mov %90 -> %31 : !neura.data !neura.data +// CTRL2DATA-NEXT: %27 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %28 = "neura.grant_always"(%27) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %29 = "neura.grant_once"(%27) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %30 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %31 = "neura.grant_always"(%30) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %32 = "neura.grant_once"(%30) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %33 = "neura.constant"() <{predicate = true, value = -1000 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %34 = "neura.grant_always"(%33) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %35 = "neura.grant_once"(%33) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %36 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %37 = "neura.grant_always"(%36) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %38 = "neura.grant_once"(%36) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %39 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %40 = "neura.grant_always"(%39) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %41 = "neura.grant_once"(%39) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %42 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %43 = "neura.grant_always"(%42) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %44 = "neura.grant_once"(%42) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %45 = "neura.cast"(%42) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %46 = "neura.grant_once"(%45) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %47 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %48 = "neura.phi"(%47, %20) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %49 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %50 = "neura.phi"(%49, %46) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %51 = "neura.cast"(%50) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %52 = "neura.icmp"(%51, %48) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %53 = "neura.not"(%52) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %54 = neura.grant_predicate %51, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %55 = neura.grant_predicate %29, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %56 = neura.grant_predicate %41, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %57 = neura.grant_predicate %26, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %58 = neura.grant_predicate %44, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %59 = neura.grant_predicate %32, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %60 = neura.grant_predicate %35, %52 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %61 = "neura.cast"(%54) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %62 = "neura.div"(%61, %55) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %63 = "neura.mul"(%55, %62) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %64 = "neura.sub"(%61, %63) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %65 = "neura.icmp"(%64, %56) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %66 = "neura.sel"(%55, %57, %65) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %67 = "neura.cast"(%58) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %68 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %69 = "neura.phi"(%68, %20) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %70 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %71 = "neura.phi"(%70, %56) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %72 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %73 = "neura.phi"(%72, %60) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %74 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %75 = "neura.phi"(%74, %59) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %76 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %77 = "neura.phi"(%76, %67) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %78 = "neura.cast"(%77) <{cast_type = "int_to_index"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %79 = "neura.icmp"(%78, %69) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %80 = neura.grant_predicate %2, %79 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %81 = neura.grant_predicate %51, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %82 = neura.grant_predicate %78, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %83 = neura.grant_predicate %66, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %84 = neura.grant_predicate %5, %79 : !neura.data, i1>, !neura.data -> !neura.data, i1> +// CTRL2DATA-NEXT: %85 = neura.grant_predicate %71, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %86 = neura.grant_predicate %73, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %87 = neura.grant_predicate %75, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %88 = neura.grant_predicate %17, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %89 = neura.grant_predicate %20, %79 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %90 = "neura.not"(%79) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %91 = neura.grant_predicate %71, %90 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %92 = neura.grant_predicate %38, %90 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %93 = neura.grant_predicate %73, %90 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %94 = neura.grant_predicate %75, %90 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %95 = neura.grant_predicate %41, %90 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %96 = neura.load_indexed %80[%81, %82 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %97 = "neura.mul"(%96, %83) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %97 to %84[%81, %82 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %98 = neura.load_indexed %80[%81, %82 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %99 = "neura.add"(%85, %98) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %100 = "neura.icmp"(%98, %86) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %101 = "neura.sel"(%98, %86, %100) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %102 = "neura.icmp"(%98, %87) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %103 = "neura.sel"(%98, %87, %102) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %104 = "neura.add"(%82, %88) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %105 = "neura.cast"(%104) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %105 -> %76 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %103 -> %74 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %101 -> %72 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %99 -> %70 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %89 -> %68 : !neura.data !neura.data +// CTRL2DATA-NEXT: %106 = "neura.div"(%91, %92) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %107 = "neura.sub"(%93, %94) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %108 = "neura.icmp"(%107, %95) <{cmpType = "sgt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %109 = neura.grant_predicate %106, %108 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %110 = neura.grant_predicate %23, %108 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %111 = neura.grant_predicate %107, %108 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %112 = "neura.not"(%108) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %113 = neura.grant_predicate %106, %112 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %114 = "neura.mul"(%109, %110) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %115 = "neura.div"(%114, %111) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %116 = "neura.phi"(%115, %113) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %106 to %5[%51, %44 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %73 to %5[%51, %17 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %75 to %5[%51, %14 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %116 to %5[%51, %11 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: neura.store_indexed %107 to %5[%51, %8 : !neura.data, !neura.data] !neura.data, i1> : !neura.data +// CTRL2DATA-NEXT: %117 = "neura.add"(%51, %17) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %118 = "neura.cast"(%117) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %118 -> %49 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %20 -> %47 : !neura.data !neura.data // CTRL2DATA-NEXT: "neura.return"() : () -> () -// CTRL2DATA-NEXT: } +// CTRL2DATA-NEXT: } \ No newline at end of file diff --git a/test/controflow_fuse/perfect_nested/perfect_nested.mlir b/test/controflow_fuse/perfect_nested/perfect_nested.mlir index 762f8a58..a54aaaa1 100644 --- a/test/controflow_fuse/perfect_nested/perfect_nested.mlir +++ b/test/controflow_fuse/perfect_nested/perfect_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { @@ -15,9 +15,9 @@ module attributes {} { } // CHECK: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %3 : i64 to ^bb1 // CHECK-NEXT: ^bb1(%4: i64): // 2 preds: ^bb0, ^bb5 @@ -46,11 +46,11 @@ module attributes {} { // CHECK-NEXT: } // CTRL2DATA: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref, %arg1: memref) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %5 = "neura.grant_always"(%4) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %6 = "neura.cast"(%4) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data diff --git a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir index 4b86b69f..d5e6f446 100644 --- a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir +++ b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { @@ -19,10 +19,10 @@ module attributes {} { // CHECK: func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4, %2 : i64, i32 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64, %6: i32): // 2 preds: ^bb0, ^bb5 @@ -51,13 +51,13 @@ module attributes {} { // CHECK-NEXT: } // CTRL2DATA: func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data // CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %8 = "neura.cast"(%6) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data diff --git a/test/controflow_fuse/simpleloop/simpleloop.mlir b/test/controflow_fuse/simpleloop/simpleloop.mlir index 88c704bd..53ff98fe 100644 --- a/test/controflow_fuse/simpleloop/simpleloop.mlir +++ b/test/controflow_fuse/simpleloop/simpleloop.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z10simpleloopv() -> i32 attributes {llvm.linkage = #llvm.linkage} { @@ -15,10 +15,10 @@ module attributes {} { } // CHECK: func.func @_Z10simpleloopv() -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index -// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index -// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32 -// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32 +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64 // CHECK-NEXT: neura.br %4, %2 : i64, i32 to ^bb1 // CHECK-NEXT: ^bb1(%5: i64, %6: i32): // 2 preds: ^bb0, ^bb2 @@ -37,13 +37,13 @@ module attributes {} { // CTRL2DATA: func.func @_Z10simpleloopv() -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data // CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{value = 0 : index}> : () -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> !neura.data // CTRL2DATA-NEXT: %7 = "neura.cast"(%6) <{cast_type = "index_to_int"}> : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %8 = "neura.grant_once"(%7) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %9 = neura.reserve : !neura.data diff --git a/test/lit.cfg.in b/test/lit.cfg.in index 2530f5c3..d93c0990 100644 --- a/test/lit.cfg.in +++ b/test/lit.cfg.in @@ -16,3 +16,4 @@ config.substitutions.append(('FileCheck', '@FILECHECK@')) config.substitutions.append(('mlir-opt', '@MLIR_OPT@')) config.substitutions.append(('mlir-translate', '@MLIR_TRANSLATE@')) config.substitutions.append(('llc', '@LLC@')) +config.substitutions.append(('clang', '@CLANG@')) \ No newline at end of file diff --git a/test/neura/ctrl/branch.mlir b/test/neura/ctrl/branch.mlir index dbb1cf9d..e088f65c 100644 --- a/test/neura/ctrl/branch.mlir +++ b/test/neura/ctrl/branch.mlir @@ -1,6 +1,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s @@ -34,43 +35,45 @@ func.func @test(%in: i64) -> f32 { } -// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %5 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CHECK-NEXT: neura.cond_br %5 : !neura.data then %3, %4 : !neura.data, !neura.data to ^bb2 else %1, %2 : !neura.data, !neura.data to ^bb1 -// CHECK-NEXT: ^bb1(%6: !neura.data, %7: !neura.data): // pred: ^bb0 -// CHECK-NEXT: %8 = "neura.fadd"(%6, %7) : (!neura.data, !neura.data) -> !neura.data -// CHECK-NEXT: neura.br %8 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb2(%9: !neura.data, %10: !neura.data): // pred: ^bb0 -// CHECK-NEXT: %11 = "neura.fmul"(%9, %10) : (!neura.data, !neura.data) -> !neura.data -// CHECK-NEXT: neura.br %11 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb3(%12: !neura.data): // 2 preds: ^bb1, ^bb2 -// CHECK-NEXT: "neura.return"(%12) : (!neura.data) -> () -// CHECK-NEXT: } +// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %6 : !neura.data then %4, %5 : !neura.data, !neura.data to ^bb2 else %2, %3 : !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb1(%7: !neura.data, %8: !neura.data): // pred: ^bb0 +// CHECK-NEXT: %9 = "neura.fadd"(%7, %8) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %9 : !neura.data to ^bb3 +// CHECK-NEXT: ^bb2(%10: !neura.data, %11: !neura.data): // pred: ^bb0 +// CHECK-NEXT: %12 = "neura.fmul"(%10, %11) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %12 : !neura.data to ^bb3 +// CHECK-NEXT: ^bb3(%13: !neura.data): // 2 preds: ^bb1, ^bb2 +// CHECK-NEXT: "neura.return"(%13) : (!neura.data) -> () +// CHECK-NEXT: } -// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.grant_once"(%1) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.grant_once"(%5) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %7 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.grant_once"(%7) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %10 = "neura.grant_once"(%9) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %11 = neura.grant_predicate %6, %10 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %12 = neura.grant_predicate %8, %10 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %13 = "neura.not"(%10) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %14 = neura.grant_predicate %2, %13 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %15 = neura.grant_predicate %4, %13 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.fadd"(%14, %15) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %17 = "neura.fmul"(%11, %12) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %18 = "neura.phi"(%16, %17) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data) -> () -// CTRL2DATA-NEXT: } +// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.grant_once"(%10) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %12 = neura.grant_predicate %7, %11 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %13 = neura.grant_predicate %9, %11 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %14 = "neura.not"(%11) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %15 = neura.grant_predicate %3, %14 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %16 = neura.grant_predicate %5, %14 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %17 = "neura.fadd"(%15, %16) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %18 = "neura.fmul"(%12, %13) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %19 = "neura.phi"(%17, %18) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: "neura.return"(%19) : (!neura.data) -> () +// CTRL2DATA-NEXT: } diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir index 4352e4ef..3255df9b 100644 --- a/test/neura/ctrl/branch_for.mlir +++ b/test/neura/ctrl/branch_for.mlir @@ -21,26 +21,26 @@ // RUN: --insert-data-mov \ // RUN: | FileCheck %s -check-prefix=MOV -// RUN: mlir-neura-opt %s \ -// RUN: --assign-accelerator \ -// RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ -// RUN: --leverage-predicated-value \ -// RUN: --transform-ctrl-to-data-flow \ -// RUN: --insert-data-mov \ +// RU: mlir-neura-opt %s \ +// RU: --assign-accelerator \ +// RU: --lower-llvm-to-neura \ +// RU: --neura-canonicalize \ +// RU: --leverage-predicated-value \ +// RU: --transform-ctrl-to-data-flow \ +// RU: --insert-data-mov \ // RU: --map-to-accelerator="mapping-strategy=heuristic" \ // RU: | FileCheck %s -check-prefix=MAPPING -// RUN: mlir-neura-opt %s \ -// RUN: --assign-accelerator \ -// RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ -// RUN: --leverage-predicated-value \ -// RUN: --transform-ctrl-to-data-flow \ -// RUN: --insert-data-mov \ +// RU: mlir-neura-opt %s \ +// RU: --assign-accelerator \ +// RU: --lower-llvm-to-neura \ +// RU: --neura-canonicalize \ +// RU: --leverage-predicated-value \ +// RU: --transform-ctrl-to-data-flow \ +// RU: --insert-data-mov \ // RU: --map-to-accelerator="mapping-strategy=heuristic" \ // RU: --generate-code -// RUN: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST +// RU: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST func.func @loop_test() -> f32 { %n = llvm.mlir.constant(10 : i64) : i64 diff --git a/test/neura/ctrl/branch_with_and_without_arg.mlir b/test/neura/ctrl/branch_with_and_without_arg.mlir index e0ad00b0..e689ad1b 100644 --- a/test/neura/ctrl/branch_with_and_without_arg.mlir +++ b/test/neura/ctrl/branch_with_and_without_arg.mlir @@ -1,6 +1,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s @@ -32,40 +33,42 @@ func.func @test(%in: i64) -> f32 { return %v : f32 } -// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %4 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CHECK-NEXT: neura.cond_br %4 : !neura.data then %3 : !neura.data to ^bb2 else %1, %2 : !neura.data, !neura.data to ^bb1 -// CHECK-NEXT: ^bb1(%5: !neura.data, %6: !neura.data): // pred: ^bb0 -// CHECK-NEXT: %7 = "neura.fadd"(%5, %6) : (!neura.data, !neura.data) -> !neura.data -// CHECK-NEXT: neura.br %7 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb2(%8: !neura.data): // pred: ^bb0 -// CHECK-NEXT: %9 = "neura.fmul"(%8, %2) : (!neura.data, !neura.data) -> !neura.data -// CHECK-NEXT: neura.br %9 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb3(%10: !neura.data): // 2 preds: ^bb1, ^bb2 -// CHECK-NEXT: "neura.return"(%10) : (!neura.data) -> () +// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %5 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %5 : !neura.data then %4, %3 : !neura.data, !neura.data to ^bb2 else %2, %3 : !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb1(%6: !neura.data, %7: !neura.data): // pred: ^bb0 +// CHECK-NEXT: %8 = "neura.fadd"(%6, %7) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %8 : !neura.data to ^bb3 +// CHECK-NEXT: ^bb2(%9: !neura.data, %10: !neura.data): // pred: ^bb0 +// CHECK-NEXT: %11 = "neura.fmul"(%9, %10) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %11 : !neura.data to ^bb3 +// CHECK-NEXT: ^bb3(%12: !neura.data): // 2 preds: ^bb1, ^bb2 +// CHECK-NEXT: "neura.return"(%12) : (!neura.data) -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.grant_once"(%1) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.grant_always"(%3) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %10 = neura.grant_predicate %7, %9 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %11 = "neura.not"(%9) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %12 = neura.grant_predicate %2, %11 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %13 = neura.grant_predicate %5, %11 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %14 = "neura.fadd"(%12, %13) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %15 = "neura.fmul"(%10, %4) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.phi"(%14, %15) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: "neura.return"(%16) : (!neura.data) -> () -// CTRL2DATA-NEXT: } \ No newline at end of file +// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %10 = neura.grant_predicate %7, %9 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %11 = neura.grant_predicate %5, %9 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %12 = "neura.not"(%9) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %13 = neura.grant_predicate %3, %12 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %14 = neura.grant_predicate %5, %12 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %15 = "neura.fadd"(%13, %14) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %16 = "neura.fmul"(%10, %11) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %17 = "neura.phi"(%15, %16) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: "neura.return"(%17) : (!neura.data) -> () +// CTRL2DATA-NEXT: } \ No newline at end of file diff --git a/test/neura/ctrl/branch_without_arg.mlir b/test/neura/ctrl/branch_without_arg.mlir index 5d38d645..37a53032 100644 --- a/test/neura/ctrl/branch_without_arg.mlir +++ b/test/neura/ctrl/branch_without_arg.mlir @@ -1,6 +1,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s @@ -33,43 +34,45 @@ func.func @test(%in: i64) -> f32 { return %v : f32 } -// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data -// CHECK-NEXT: %5 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CHECK-NEXT: neura.cond_br %5 : !neura.data then %3, %4 : !neura.data, !neura.data to ^bb2 else to ^bb1 -// CHECK-NEXT: ^bb1: // pred: ^bb0 -// CHECK-NEXT: %6 = "neura.fadd"(%1, %2) : (!neura.data, !neura.data) -> !neura.data -// CHECK-NEXT: neura.br %6 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb2(%7: !neura.data, %8: !neura.data): // pred: ^bb0 -// CHECK-NEXT: %9 = "neura.fmul"(%7, %8) : (!neura.data, !neura.data) -> !neura.data +// CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %6 : !neura.data then %4, %5 : !neura.data, !neura.data to ^bb2 else %2, %3 : !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb1(%7: !neura.data, %8: !neura.data): +// CHECK-NEXT: %9 = "neura.fadd"(%7, %8) : (!neura.data, !neura.data) -> !neura.data // CHECK-NEXT: neura.br %9 : !neura.data to ^bb3 -// CHECK-NEXT: ^bb3(%10: !neura.data): // 2 preds: ^bb1, ^bb2 -// CHECK-NEXT: "neura.return"(%10) : (!neura.data) -> () +// CHECK-NEXT: ^bb2(%10: !neura.data, %11: !neura.data): +// CHECK-NEXT: %12 = "neura.fmul"(%10, %11) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %12 : !neura.data to ^bb3 +// CHECK-NEXT: ^bb3(%13: !neura.data): +// CHECK-NEXT: "neura.return"(%13) : (!neura.data) -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data -// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %2 = "neura.grant_always"(%1) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %4 = "neura.grant_always"(%3) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %5 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %6 = "neura.grant_once"(%5) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %7 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data -// CTRL2DATA-NEXT: %8 = "neura.grant_once"(%7) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %9 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %10 = "neura.grant_once"(%9) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %11 = "neura.not"(%10) : (!neura.data) -> !neura.data -// CTRL2DATA-NEXT: %12 = neura.grant_predicate %6, %10 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %13 = neura.grant_predicate %8, %10 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %14 = neura.grant_predicate %2, %11 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %15 = neura.grant_predicate %4, %11 : !neura.data, !neura.data -> !neura.data -// CTRL2DATA-NEXT: %16 = "neura.fadd"(%14, %15) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %17 = "neura.fmul"(%12, %13) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: %18 = "neura.phi"(%16, %17) : (!neura.data, !neura.data) -> !neura.data -// CTRL2DATA-NEXT: "neura.return"(%18) : (!neura.data) -> () -// CTRL2DATA-NEXT: } \ No newline at end of file +// CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %3 = "neura.grant_once"(%2) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %5 = "neura.grant_once"(%4) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.grant_once"(%10) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %12 = neura.grant_predicate %7, %11 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %13 = neura.grant_predicate %9, %11 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %14 = "neura.not"(%11) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %15 = neura.grant_predicate %3, %14 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %16 = neura.grant_predicate %5, %14 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %17 = "neura.fadd"(%15, %16) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %18 = "neura.fmul"(%12, %13) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %19 = "neura.phi"(%17, %18) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: "neura.return"(%19) : (!neura.data) -> () +// CTRL2DATA-NEXT: } \ No newline at end of file diff --git a/test/neura/ctrl/nested_branch.mlir b/test/neura/ctrl/nested_branch.mlir index 1af938c4..f4a6a55c 100644 --- a/test/neura/ctrl/nested_branch.mlir +++ b/test/neura/ctrl/nested_branch.mlir @@ -1,10 +1,17 @@ -// RUN: mlir-neura-opt \ +// RUN: mlir-neura-opt %s \ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ +// RUN: | FileCheck %s + +// RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ // RUN: --neura-canonicalize \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ -// RUN: %s | FileCheck %s +// RUN: | FileCheck %s -check-prefix=CTRL2DATA func.func @complex_test(%in: i64) -> f32 { %c0 = llvm.mlir.constant(0 : i64) : i64 @@ -32,25 +39,61 @@ func.func @complex_test(%in: i64) -> f32 { } // CHECK: func.func @complex_test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { -// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64 -// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> f32 -// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> f32 -// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> f32 -// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> f32 -// CHECK-NEXT: %5 = "neura.icmp"(%arg0, %0) <{cmpType = "eq"}> : (i64, i64) -> i1 -// CHECK-NEXT: %6 = "neura.not"(%5) : (i1) -> i1 -// CHECK-NEXT: %7 = neura.grant_predicate %1, %6 : f32, i1 -> f32 -// CHECK-NEXT: %8 = neura.reserve : f32 -// CHECK-NEXT: %9 = "neura.phi"(%8, %7) : (f32, f32) -> f32 -// CHECK-NEXT: %10 = "neura.fcmp"(%9, %2) <{cmpType = "olt"}> : (f32, f32) -> i1 -// CHECK-NEXT: %11 = neura.grant_predicate %9, %10 : f32, i1 -> f32 -// CHECK-NEXT: %12 = "neura.not"(%10) : (i1) -> i1 -// CHECK-NEXT: %13 = neura.grant_predicate %9, %12 : f32, i1 -> f32 -// CHECK-NEXT: %14 = "neura.fadd"(%11, %1) : (f32, f32) -> f32 -// CHECK-NEXT: neura.ctrl_mov %14 -> %8 : f32 f32 -// CHECK-NEXT: %15 = neura.grant_predicate %3, %5 : f32, i1 -> f32 -// CHECK-NEXT: %16 = neura.grant_predicate %4, %5 : f32, i1 -> f32 -// CHECK-NEXT: %17 = "neura.fmul"(%15, %16) : (f32, f32) -> f32 -// CHECK-NEXT: %18 = "neura.phi"(%13, %17) : (f32, f32) -> f32 -// CHECK-NEXT: "neura.return"(%18) : (f32) -> () -// CHECK-NEXT: } \ No newline at end of file +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CHECK-NEXT: %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %6 : !neura.data then %4, %5 : !neura.data, !neura.data to ^bb3 else %2, %3 : !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb1(%7: !neura.data, %8: !neura.data): // 2 preds: ^bb0, ^bb2 +// CHECK-NEXT: %9 = "neura.fcmp"(%7, %8) <{cmpType = "olt"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %9 : !neura.data then %7, %2, %3 : !neura.data, !neura.data, !neura.data to ^bb2 else %7 : !neura.data to ^bb4 +// CHECK-NEXT: ^bb2(%10: !neura.data, %11: !neura.data, %12: !neura.data): // pred: ^bb1 +// CHECK-NEXT: %13 = "neura.fadd"(%10, %11) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %13, %12 : !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb3(%14: !neura.data, %15: !neura.data): // pred: ^bb0 +// CHECK-NEXT: %16 = "neura.fmul"(%14, %15) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.br %16 : !neura.data to ^bb4 +// CHECK-NEXT: ^bb4(%17: !neura.data): // 2 preds: ^bb1, ^bb3 +// CHECK-NEXT: "neura.return"(%17) : (!neura.data) -> () +// CHECK-NEXT: } + +// CTRL2DATA: func.func @complex_test(%arg0: i64) -> f32 attributes {accelerator = "neura"} { +// CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CTRL2DATA-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CTRL2DATA-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %3 = "neura.grant_always"(%2) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %4 = "neura.grant_once"(%2) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %5 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %6 = "neura.grant_always"(%5) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %7 = "neura.grant_once"(%5) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %8 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %10 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data +// CTRL2DATA-NEXT: %11 = "neura.grant_once"(%10) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %12 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %13 = "neura.grant_once"(%12) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %14 = neura.grant_predicate %9, %13 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %15 = neura.grant_predicate %11, %13 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %16 = "neura.not"(%13) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %17 = neura.grant_predicate %4, %16 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %18 = neura.grant_predicate %7, %16 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %19 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %20 = "neura.phi"(%19, %18) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %21 = neura.reserve : !neura.data +// CTRL2DATA-NEXT: %22 = "neura.phi"(%21, %17) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %23 = "neura.fcmp"(%22, %20) <{cmpType = "olt"}> : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %24 = neura.grant_predicate %22, %23 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %25 = neura.grant_predicate %4, %23 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %26 = neura.grant_predicate %7, %23 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %27 = "neura.not"(%23) : (!neura.data) -> !neura.data +// CTRL2DATA-NEXT: %28 = neura.grant_predicate %22, %27 : !neura.data, !neura.data -> !neura.data +// CTRL2DATA-NEXT: %29 = "neura.fadd"(%24, %25) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %29 -> %21 : !neura.data !neura.data +// CTRL2DATA-NEXT: neura.ctrl_mov %26 -> %19 : !neura.data !neura.data +// CTRL2DATA-NEXT: %30 = "neura.fmul"(%14, %15) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: %31 = "neura.phi"(%28, %30) : (!neura.data, !neura.data) -> !neura.data +// CTRL2DATA-NEXT: "neura.return"(%31) : (!neura.data) -> () +// CTRL2DATA-NEXT: } \ No newline at end of file diff --git a/test/neura/for_loop/test.mlir b/test/neura/for_loop/test.mlir index ae5dfd8b..375c2b49 100644 --- a/test/neura/for_loop/test.mlir +++ b/test/neura/for_loop/test.mlir @@ -4,36 +4,223 @@ // TODO: Enable --insert-mov once the backward ctrl flow mov is supported. // Lowers to neura. -// TODO: Make `--leverage-predicated-value` work. Segmentation fault for now. -// https://github.com/coredac/dataflow/issues/84. -// RUN: mlir-neura-opt \ +// RUN: mlir-neura-opt %t-kernel.mlir\ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RN: --leverage-predicated-value \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ +// RUN: | FileCheck %s + +// RUN: mlir-neura-opt %t-kernel.mlir\ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --fuse-patterns \ -// RN: --insert-mov \ -// RUN: %t-kernel.mlir > %t-lowered.mlir +// RUN: | FileCheck %s --check-prefix=CHECK-FUSED -// RUN: FileCheck %s < %t-lowered.mlir +// RUN: mlir-neura-opt %t-kernel.mlir\ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ +// RUN: --transform-ctrl-to-data-flow \ +// RUN: --fuse-patterns \ +// RUN: --insert-data-mov \ +// RUN: | FileCheck %s --check-prefix=CHECK-MOV + +// CHECK: llvm.func local_unnamed_addr @_Z6kernelPfS_S_(%arg0: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}, %arg1: !llvm.ptr {llvm.nocapture, llvm.noundef}, %arg2: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}) attributes {accelerator = "neura", memory_effects = #llvm.memory_effects, no_unwind, passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["uwtable", "2"], ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic"} { +// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data +// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = "%arg2"}> : () -> !neura.data +// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-NEXT: %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// CHECK-NEXT: %5 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data +// CHECK-NEXT: %6 = "neura.load"(%1) : (!neura.data) -> !neura.data +// CHECK-NEXT: neura.br %3, %6, %0, %2, %1, %4, %5 : !neura.data, !neura.data, !neura.data, !neura.data, !neura.data, !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb1(%7: !neura.data, %8: !neura.data, %9: !neura.data, %10: !neura.data, %11: !neura.data, %12: !neura.data, %13: !neura.data): // 2 preds: ^bb0, ^bb1 +// CHECK-NEXT: %14 = "neura.gep"(%9, %7) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: %15 = "neura.load"(%14) : (!neura.data) -> !neura.data +// CHECK-NEXT: %16 = "neura.gep"(%10, %7) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: %17 = "neura.load"(%16) : (!neura.data) -> !neura.data +// CHECK-NEXT: %18 = "neura.fmul"(%15, %17) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: %19 = "neura.fadd"(%8, %18) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: "neura.store"(%19, %11) : (!neura.data, !neura.data) -> () +// CHECK-NEXT: %20 = "neura.add"(%7, %12) : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: %21 = "neura.icmp"(%20, %13) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-NEXT: neura.cond_br %21 : !neura.data then to ^bb2 else %20, %19, %0, %2, %1, %4, %5 : !neura.data, !neura.data, !neura.data, !neura.data, !neura.data, !neura.data, !neura.data to ^bb1 +// CHECK-NEXT: ^bb2: // pred: ^bb1 +// CHECK-NEXT: "neura.return"() : () -> () +// CHECK-NEXT: } // Verifies the neura ops are generated. And fusion happens. -// CHECK: accelerator = "neura" -// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64 -// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64 -// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> i64 -// CHECK-NEXT: %3 = neura.reserve : i64 -// CHECK-NEXT: %4 = "neura.phi"(%3, %0) : (i64, i64) -> i64 -// CHECK-NEXT: %5 = "neura.gep"(%arg0, %4) : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %6 = "neura.load"(%5) : (!llvm.ptr) -> f32 -// CHECK-NEXT: %7 = "neura.gep"(%arg2, %4) : (!llvm.ptr, i64) -> !llvm.ptr -// CHECK-NEXT: %8 = "neura.load"(%7) : (!llvm.ptr) -> f32 -// CHECK-NEXT: %9 = "neura.load"(%arg1) : (!llvm.ptr) -> f32 -// CHECK-NEXT: %10 = "neura.fmul_fadd"(%6, %8, %9) : (f32, f32, f32) -> f32 -// CHECK-NEXT: "neura.store"(%10, %arg1) : (f32, !llvm.ptr) -> () -// CHECK-NEXT: %11 = "neura.add"(%4, %1) : (i64, i64) -> i64 -// CHECK-NEXT: %12 = "neura.icmp"(%11, %2) <{cmpType = "eq"}> : (i64, i64) -> i1 -// CHECK-NEXT: %13 = "neura.not"(%12) : (i1) -> i1 -// CHECK-NEXT: %14 = neura.grant_predicate %11, %13 : i64, i1 -> i64 -// CHECK-NEXT: neura.ctrl_mov %14 -> %3 : i64 i64 -// CHECK-NEXT: "neura.return"() : () -> () \ No newline at end of file +// CHECK-FUSED: llvm.func local_unnamed_addr @_Z6kernelPfS_S_(%arg0: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}, %arg1: !llvm.ptr {llvm.nocapture, llvm.noundef}, %arg2: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}) attributes {accelerator = "neura", memory_effects = #llvm.memory_effects, no_unwind, passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["uwtable", "2"], ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic"} { +// CHECK-FUSED: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-FUSED-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %2 = "neura.grant_once"(%0) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %3 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data +// CHECK-FUSED-NEXT: %4 = "neura.grant_always"(%3) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %5 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %6 = "neura.constant"() <{predicate = true, value = "%arg2"}> : () -> !neura.data +// CHECK-FUSED-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %8 = "neura.grant_once"(%6) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %9 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-FUSED-NEXT: %10 = "neura.grant_once"(%9) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %11 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// CHECK-FUSED-NEXT: %12 = "neura.grant_always"(%11) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %13 = "neura.grant_once"(%11) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %14 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data +// CHECK-FUSED-NEXT: %15 = "neura.grant_always"(%14) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %16 = "neura.grant_once"(%14) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %17 = "neura.load"(%3) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %18 = "neura.grant_once"(%17) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %19 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %20 = "neura.phi"(%19, %16) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %21 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %22 = "neura.phi"(%21, %13) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %23 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %24 = "neura.phi"(%23, %5) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %25 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %26 = "neura.phi"(%25, %8) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %27 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %28 = "neura.phi"(%27, %2) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %29 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %30 = "neura.phi"(%29, %18) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %31 = neura.reserve : !neura.data +// CHECK-FUSED-NEXT: %32 = "neura.phi"(%31, %10) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %33 = "neura.gep"(%28, %32) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %34 = "neura.load"(%33) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %35 = "neura.gep"(%26, %32) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %36 = "neura.load"(%35) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %37 = "neura.fmul_fadd"(%34, %36, %30) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: "neura.store"(%37, %24) : (!neura.data, !neura.data) -> () +// CHECK-FUSED-NEXT: %38 = "neura.add"(%32, %22) : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %39 = "neura.icmp"(%38, %20) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %40 = "neura.not"(%39) : (!neura.data) -> !neura.data +// CHECK-FUSED-NEXT: %41 = neura.grant_predicate %38, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %41 -> %31 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %42 = neura.grant_predicate %37, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %42 -> %29 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %43 = neura.grant_predicate %2, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %43 -> %27 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %44 = neura.grant_predicate %8, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %44 -> %25 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %45 = neura.grant_predicate %5, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %45 -> %23 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %46 = neura.grant_predicate %13, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %46 -> %21 : !neura.data !neura.data +// CHECK-FUSED-NEXT: %47 = neura.grant_predicate %16, %40 : !neura.data, !neura.data -> !neura.data +// CHECK-FUSED-NEXT: neura.ctrl_mov %47 -> %19 : !neura.data !neura.data +// CHECK-FUSED-NEXT: "neura.return"() : () -> () +// CHECK-FUSED-NEXT: } + +// CHECK-MOV: llvm.func local_unnamed_addr @_Z6kernelPfS_S_(%arg0: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}, %arg1: !llvm.ptr {llvm.nocapture, llvm.noundef}, %arg2: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}) attributes {accelerator = "neura", memory_effects = #llvm.memory_effects, no_unwind, passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["uwtable", "2"], ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic"} { +// CHECK-MOV-NEXT: %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data +// CHECK-MOV-NEXT: %1 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %2 = "neura.grant_always"(%1) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %3 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %4 = "neura.grant_once"(%3) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %5 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data +// CHECK-MOV-NEXT: %6 = "neura.data_mov"(%5) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %7 = "neura.grant_always"(%6) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %8 = "neura.data_mov"(%5) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %9 = "neura.grant_once"(%8) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %10 = "neura.constant"() <{predicate = true, value = "%arg2"}> : () -> !neura.data +// CHECK-MOV-NEXT: %11 = "neura.data_mov"(%10) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %12 = "neura.grant_always"(%11) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %13 = "neura.data_mov"(%10) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %14 = "neura.grant_once"(%13) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %15 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CHECK-MOV-NEXT: %16 = "neura.data_mov"(%15) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %17 = "neura.grant_once"(%16) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %18 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// CHECK-MOV-NEXT: %19 = "neura.data_mov"(%18) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %20 = "neura.grant_always"(%19) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %21 = "neura.data_mov"(%18) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %22 = "neura.grant_once"(%21) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %23 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data +// CHECK-MOV-NEXT: %24 = "neura.data_mov"(%23) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %25 = "neura.grant_always"(%24) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %26 = "neura.data_mov"(%23) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %27 = "neura.grant_once"(%26) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %28 = "neura.data_mov"(%5) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %29 = "neura.load"(%28) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %30 = "neura.data_mov"(%29) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %31 = "neura.grant_once"(%30) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %32 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %33 = "neura.data_mov"(%27) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %34 = "neura.phi"(%32, %33) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %35 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %36 = "neura.data_mov"(%22) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %37 = "neura.phi"(%35, %36) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %38 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %39 = "neura.data_mov"(%9) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %40 = "neura.phi"(%38, %39) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %41 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %42 = "neura.data_mov"(%14) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %43 = "neura.phi"(%41, %42) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %44 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %45 = "neura.data_mov"(%4) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %46 = "neura.phi"(%44, %45) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %47 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %48 = "neura.data_mov"(%31) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %49 = "neura.phi"(%47, %48) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %50 = neura.reserve : !neura.data +// CHECK-MOV-NEXT: %51 = "neura.data_mov"(%17) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %52 = "neura.phi"(%50, %51) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %53 = "neura.data_mov"(%46) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %54 = "neura.data_mov"(%52) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %55 = "neura.gep"(%53, %54) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %56 = "neura.data_mov"(%55) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %57 = "neura.load"(%56) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %58 = "neura.data_mov"(%43) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %59 = "neura.data_mov"(%52) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %60 = "neura.gep"(%58, %59) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %61 = "neura.data_mov"(%60) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %62 = "neura.load"(%61) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %63 = "neura.data_mov"(%57) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %64 = "neura.data_mov"(%62) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %65 = "neura.data_mov"(%49) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %66 = "neura.fmul_fadd"(%63, %64, %65) : (!neura.data, !neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %67 = "neura.data_mov"(%66) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %68 = "neura.data_mov"(%40) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: "neura.store"(%67, %68) : (!neura.data, !neura.data) -> () +// CHECK-MOV-NEXT: %69 = "neura.data_mov"(%52) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %70 = "neura.data_mov"(%37) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %71 = "neura.add"(%69, %70) : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %72 = "neura.data_mov"(%71) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %73 = "neura.data_mov"(%34) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %74 = "neura.icmp"(%72, %73) <{cmpType = "eq"}> : (!neura.data, !neura.data) -> !neura.data +// CHECK-MOV-NEXT: %75 = "neura.data_mov"(%74) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %76 = "neura.not"(%75) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %77 = "neura.data_mov"(%71) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %78 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %79 = neura.grant_predicate %77, %78 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %79 -> %50 : !neura.data !neura.data +// CHECK-MOV-NEXT: %80 = "neura.data_mov"(%66) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %81 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %82 = neura.grant_predicate %80, %81 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %82 -> %47 : !neura.data !neura.data +// CHECK-MOV-NEXT: %83 = "neura.data_mov"(%4) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %84 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %85 = neura.grant_predicate %83, %84 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %85 -> %44 : !neura.data !neura.data +// CHECK-MOV-NEXT: %86 = "neura.data_mov"(%14) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %87 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %88 = neura.grant_predicate %86, %87 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %88 -> %41 : !neura.data !neura.data +// CHECK-MOV-NEXT: %89 = "neura.data_mov"(%9) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %90 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %91 = neura.grant_predicate %89, %90 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %91 -> %38 : !neura.data !neura.data +// CHECK-MOV-NEXT: %92 = "neura.data_mov"(%22) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %93 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %94 = neura.grant_predicate %92, %93 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %94 -> %35 : !neura.data !neura.data +// CHECK-MOV-NEXT: %95 = "neura.data_mov"(%27) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %96 = "neura.data_mov"(%76) : (!neura.data) -> !neura.data +// CHECK-MOV-NEXT: %97 = neura.grant_predicate %95, %96 : !neura.data, !neura.data -> !neura.data +// CHECK-MOV-NEXT: neura.ctrl_mov %97 -> %32 : !neura.data !neura.data +// CHECK-MOV-NEXT: "neura.return"() : () -> () +// CHECK-MOV-NEXT: } \ No newline at end of file From bea4965be5df66751541ed44458ae6d6ca589ba5 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Sun, 20 Jul 2025 23:54:32 +0800 Subject: [PATCH 3/8] [fix] add more changed files --- CMakeLists.txt | 1 + include/NeuraDialect/NeuraOps.td | 14 ++-- .../ArithToNeura/ArithToNeuraPass.cpp | 2 +- lib/NeuraDialect/Mapping/mapping_util.cpp | 1 + .../Transforms/FusePatternsPass.cpp | 14 ++-- .../Transforms/NeuraCanonicalizePass.cpp | 74 +++++++++++++++++-- .../TransformCtrlToDataFlowPass.cpp | 17 ++--- test/neura/ctrl/branch_for.mlir | 38 +++++----- 8 files changed, 112 insertions(+), 49 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e92ff1d5..008e3eaa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,6 +48,7 @@ set(FILECHECK ${LLVM_TOOLS_BINARY_DIR}/FileCheck) set(MLIR_OPT ${LLVM_TOOLS_BINARY_DIR}/mlir-opt) set(MLIR_TRANSLATE ${LLVM_TOOLS_BINARY_DIR}/mlir-translate) set(LLC ${LLVM_TOOLS_BINARY_DIR}/llc) +set(CLANG ${LLVM_TOOLS_BINARY_DIR}/clang) # Configures lit.cfg from lit.cfg.in configure_file( diff --git a/include/NeuraDialect/NeuraOps.td b/include/NeuraDialect/NeuraOps.td index 537e3b41..9a301055 100644 --- a/include/NeuraDialect/NeuraOps.td +++ b/include/NeuraDialect/NeuraOps.td @@ -110,11 +110,11 @@ def Neura_ICmpOp : Op { def Neura_FCmpOp : Op { let summary = "Floating-point compare operation"; let opName = "fcmp"; - let arguments = (ins AnyFloat:$lhs, - AnyFloat:$rhs, + let arguments = (ins AnyType:$lhs, + AnyType:$rhs, Optional:$predicate, StrAttr:$cmpType); - let results = (outs I1:$result); + let results = (outs AnyType:$result); // let assemblyFormat = "$lhs `,` $rhs `,` $cmpType attr-dict `:` type($result)"; // let traits = [SameOperandsAndResultElementType]; } @@ -239,16 +239,16 @@ def Neura_VFMulOp : Op { def Neura_FAddFAddOp : Op { let summary = "Fused fadd(fadd(a, b), c)"; - let arguments = (ins AnyFloat:$a, AnyFloat:$b, AnyFloat:$c, Optional:$predicate); - let results = (outs AnyFloat:$result); + let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c, Optional:$predicate); + let results = (outs AnyType:$result); // let assemblyFormat = "$a `,` $b `,` $c `,` $predicate attr-dict `:` type($result)"; let traits = [SameOperandsAndResultElementType]; } def Neura_FMulFAddOp : Op { let summary = "Fused fadd(fmul(a, b), c)"; - let arguments = (ins AnyFloat:$a, AnyFloat:$b, AnyFloat:$c, Optional:$predicate); - let results = (outs AnyFloat:$result); + let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c, Optional:$predicate); + let results = (outs AnyType:$result); // let assemblyFormat = "$a `,` $b `,` $c `,` $predicate attr-dict `:` type($result)"; let traits = [SameOperandsAndResultElementType]; } diff --git a/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp b/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp index e7ddf1a5..2b5694e5 100644 --- a/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp +++ b/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp @@ -39,7 +39,7 @@ struct ArithConstantToNeuraConstant Attribute value = op.getValue(); // Optional predicate parameter can be null. rewriter.replaceOpWithNewOp(op, result_type, value, - nullptr); + rewriter.getBoolAttr(true)); return success(); } }; diff --git a/lib/NeuraDialect/Mapping/mapping_util.cpp b/lib/NeuraDialect/Mapping/mapping_util.cpp index a69d7a07..0ea1659e 100644 --- a/lib/NeuraDialect/Mapping/mapping_util.cpp +++ b/lib/NeuraDialect/Mapping/mapping_util.cpp @@ -376,6 +376,7 @@ bool mlir::neura::tryRouteDataMove(Operation *mov_op, MappingLoc src_loc, Operation *mlir::neura::getMaterializedProducer(Value operand) { Operation *producer = operand.getDefiningOp(); + llvm::errs() << "Operand: " << operand << ", producer: " << *producer << "\n"; assert(isa(producer) && "Expected operand to be defined by a DataMovOp"); // Finds the actual producer. diff --git a/lib/NeuraDialect/Transforms/FusePatternsPass.cpp b/lib/NeuraDialect/Transforms/FusePatternsPass.cpp index dd95ad8b..ef7c4327 100644 --- a/lib/NeuraDialect/Transforms/FusePatternsPass.cpp +++ b/lib/NeuraDialect/Transforms/FusePatternsPass.cpp @@ -1,8 +1,8 @@ +#include "NeuraDialect/NeuraOps.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/IR/PatternMatch.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h" -#include "mlir/IR/PatternMatch.h" -#include "mlir/Dialect/Func/IR/FuncOps.h" -#include "NeuraDialect/NeuraOps.h" using namespace mlir; @@ -96,11 +96,14 @@ struct FuseFMulFAddPattern : public OpRewritePattern { } }; -struct FusePatternsPass : public PassWrapper> { +struct FusePatternsPass + : public PassWrapper> { MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FusePatternsPass) StringRef getArgument() const override { return "fuse-patterns"; } - StringRef getDescription() const override { return "Apply Neura fusion patterns."; } + StringRef getDescription() const override { + return "Apply Neura fusion patterns."; + } void runOnOperation() override { RewritePatternSet patterns(&getContext()); @@ -131,4 +134,3 @@ std::unique_ptr createFusePatternsPass() { return std::make_unique(); } } // namespace mlir::neura - diff --git a/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp b/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp index e5526a5b..e5f712e1 100644 --- a/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp +++ b/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp @@ -1,12 +1,16 @@ +#include "NeuraDialect/NeuraDialect.h" #include "NeuraDialect/NeuraOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/IR/Operation.h" #include "mlir/IR/PatternMatch.h" +#include "mlir/IR/Region.h" #include "mlir/IR/Value.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "llvm/ADT/MapVector.h" #include "llvm/Support/Casting.h" +#include using namespace mlir; @@ -14,14 +18,39 @@ using namespace mlir; #include "NeuraDialect/NeuraPasses.h.inc" namespace { -LogicalResult promoteLiveInValuesToBlockArgs(Operation *op) { - auto func_op = dyn_cast(op); - if (!func_op) +LogicalResult promoteFunctionArgsToConstants(Region ®ion) { + if (region.empty()) { return success(); + } + + Block &entryBlock = region.front(); + OpBuilder builder(&entryBlock, entryBlock.begin()); + + // Collects all function arguments. + SmallVector args(entryBlock.getArguments().begin(), + entryBlock.getArguments().end()); + + // Creates a constant operation for each function argument. + for (auto [idx, arg] : llvm::enumerate(args)) { + // For constant operation, the default predicate is true. + auto constOp = builder.create( + arg.getLoc(), arg.getType(), + builder.getStringAttr("\%arg" + std::to_string(idx)), + builder.getBoolAttr(true)); + arg.replaceAllUsesWith(constOp.getResult()); + } + + return success(); +} - for (Block &block : func_op.getBlocks()) { +LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { + if (region.empty()) { + return success(); + } + + for (Block &block : region.getBlocks()) { // Skips the entry block. - if (&block == &func_op.getBlocks().front()) + if (&block == ®ion.front()) continue; // Identifies all the live-in values in the block. @@ -154,11 +183,42 @@ struct NeuraCanonicalizePass StringRef getDescription() const override { return "Canonicalizes operations in the Neura dialect"; } + void getDependentDialects(DialectRegistry ®istry) const override { + registry.insert(); + registry.insert(); + registry.insert(); + } void runOnOperation() override { ModuleOp module_op = getOperation(); - module_op->walk([&](func::FuncOp func) { - if (failed(promoteLiveInValuesToBlockArgs(func))) { + module_op.walk([&](Operation *op) { + Region *region = nullptr; + if (auto func_op = dyn_cast(op)) { + auto accel_attr = func_op->getAttrOfType("accelerator"); + if (!accel_attr || accel_attr.getValue() != "neura") { + return; + } + region = &func_op.getBody(); + } else if (auto llvmFunc = dyn_cast(op)) { + auto accel_attr = llvmFunc->getAttrOfType("accelerator"); + if (!accel_attr || accel_attr.getValue() != "neura") { + return; + } + region = &llvmFunc.getBody(); + } else { + return; + } + + if (!region || region->empty()) { + return; + } + + if (failed(promoteFunctionArgsToConstants(*region))) { + signalPassFailure(); + return; + } + + if (failed(promoteLiveInValuesToBlockArgs(*region))) { signalPassFailure(); return; } diff --git a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp index afd41ba1..5f06eb04 100644 --- a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp +++ b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp @@ -186,7 +186,6 @@ void assertLiveOutValuesDominatedByBlockArgs(Region ®ion) { } } for (Value live_out : live_out_values) { - llvm::errs() << "[ctrl2data] Live-out value: " << live_out << "\n"; if (!dominated_values.count(live_out)) { assert(false && "Live-out value not dominated by block arguments or " "live-in values"); @@ -305,10 +304,11 @@ Value getPrecessedCondition(Value condition, bool is_not_condition, return not_condition; } -void createReserveAndPhiOps(Region ®ion, ControlFlowInfo &ctrl_info, - llvm::MapVector &arg_to_reserve, - llvm::MapVector &arg_to_phi_result, - OpBuilder &builder) { +void createReserveAndPhiOps( + Region ®ion, ControlFlowInfo &ctrl_info, + llvm::MapVector &arg_to_reserve, + llvm::MapVector &arg_to_phi_result, + OpBuilder &builder) { DominanceInfo dom_info(region.getParentOp()); // ================================================ @@ -573,8 +573,7 @@ void createReserveAndPhiOps(Region ®ion, ControlFlowInfo &ctrl_info, } // Transforms control flow into data flow. -void transformControlFlowToDataFlow(Region ®ion, - ControlFlowInfo &ctrl_info, +void transformControlFlowToDataFlow(Region ®ion, ControlFlowInfo &ctrl_info, DominanceInfo &dom_info, OpBuilder &builder) { @@ -669,7 +668,8 @@ struct TransformCtrlToDataFlowPass GrantPredicateInEntryBlock(®ion->front(), builder); assertLiveOutValuesDominatedByBlockArgs(*region); } else if (auto llvmFunc = dyn_cast(op)) { - if (llvmFunc.isDeclaration()) return; + if (llvmFunc.isDeclaration()) + return; auto accel_attr = llvmFunc->getAttrOfType("accelerator"); if (!accel_attr || accel_attr.getValue() != "neura") { return; @@ -678,7 +678,6 @@ struct TransformCtrlToDataFlowPass domInfo = DominanceInfo(llvmFunc); GrantPredicateInEntryBlock(®ion->front(), builder); assertLiveOutValuesDominatedByBlockArgs(*region); - // Skips SSA live-out dominance assert. } else { return; } diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir index 3255df9b..862f9022 100644 --- a/test/neura/ctrl/branch_for.mlir +++ b/test/neura/ctrl/branch_for.mlir @@ -21,26 +21,26 @@ // RUN: --insert-data-mov \ // RUN: | FileCheck %s -check-prefix=MOV -// RU: mlir-neura-opt %s \ -// RU: --assign-accelerator \ -// RU: --lower-llvm-to-neura \ -// RU: --neura-canonicalize \ -// RU: --leverage-predicated-value \ -// RU: --transform-ctrl-to-data-flow \ -// RU: --insert-data-mov \ -// RU: --map-to-accelerator="mapping-strategy=heuristic" \ -// RU: | FileCheck %s -check-prefix=MAPPING +// RUN: mlir-neura-opt %s \ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ +// RUN: --transform-ctrl-to-data-flow \ +// RUN: --insert-data-mov \ +// RUN: --map-to-accelerator="mapping-strategy=heuristic" \ +// RUN: | FileCheck %s -check-prefix=MAPPING -// RU: mlir-neura-opt %s \ -// RU: --assign-accelerator \ -// RU: --lower-llvm-to-neura \ -// RU: --neura-canonicalize \ -// RU: --leverage-predicated-value \ -// RU: --transform-ctrl-to-data-flow \ -// RU: --insert-data-mov \ -// RU: --map-to-accelerator="mapping-strategy=heuristic" \ -// RU: --generate-code -// RU: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST +// RUN: mlir-neura-opt %s \ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --neura-canonicalize \ +// RUN: --leverage-predicated-value \ +// RUN: --transform-ctrl-to-data-flow \ +// RUN: --insert-data-mov \ +// RUN: --map-to-accelerator="mapping-strategy=heuristic" \ +// RUN: --generate-code +// RUN: FileCheck %s --input-file=generated-instructions.json -check-prefix=INST func.func @loop_test() -> f32 { %n = llvm.mlir.constant(10 : i64) : i64 From 7a971aaf57cf11257904c5651a30006b69c34dc0 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Mon, 21 Jul 2025 02:29:58 +0800 Subject: [PATCH 4/8] [fix] support clang build --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index c23378af..69b78041 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -43,7 +43,7 @@ jobs: git checkout 6146a88 mkdir build && cd build cmake -G Ninja ../llvm \ - -DLLVM_ENABLE_PROJECTS="mlir" \ + -DLLVM_ENABLE_PROJECTS="mlir;clang" \ -DLLVM_BUILD_EXAMPLES=OFF \ -DLLVM_TARGETS_TO_BUILD="Native" \ -DCMAKE_BUILD_TYPE=Release \ @@ -59,7 +59,7 @@ jobs: -DCMAKE_CXX_COMPILER_LAUNCHER=ccache cmake --build . --target check-mlir - + cmake --build . --target check-clang # setup mlir-cgra - name: setup dataflow tool-chain working-directory: ${{github.workspace}} From b38cbd32774a8a2ce4d969074a41b2e256f0ba92 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Mon, 21 Jul 2025 13:05:14 +0800 Subject: [PATCH 5/8] rename the pass & add test --- include/NeuraDialect/NeuraPasses.h | 2 +- include/NeuraDialect/NeuraPasses.td | 7 ++-- lib/NeuraDialect/Mapping/mapping_util.cpp | 1 - lib/NeuraDialect/Transforms/CMakeLists.txt | 2 +- ...izePass.cpp => CanonicalizeLiveInPass.cpp} | 14 +++---- .../TransformCtrlToDataFlowPass.cpp | 3 +- .../complex_nested/complex_nested.mlir | 2 +- .../non_perfect_nested.mlir | 2 +- test/neura/ctrl/branch.mlir | 4 +- test/neura/ctrl/branch_for.mlir | 39 +++++++++++++++---- .../ctrl/branch_with_and_without_arg.mlir | 4 +- test/neura/ctrl/branch_without_arg.mlir | 4 +- test/neura/ctrl/nested_branch.mlir | 4 +- test/neura/for_loop/test.mlir | 6 +-- 14 files changed, 59 insertions(+), 35 deletions(-) rename lib/NeuraDialect/Transforms/{NeuraCanonicalizePass.cpp => CanonicalizeLiveInPass.cpp} (94%) diff --git a/include/NeuraDialect/NeuraPasses.h b/include/NeuraDialect/NeuraPasses.h index 47df969e..0e35a4b3 100644 --- a/include/NeuraDialect/NeuraPasses.h +++ b/include/NeuraDialect/NeuraPasses.h @@ -27,7 +27,7 @@ std::unique_ptr createLeveragePredicatedValuePass(); std::unique_ptr createMapToAcceleratorPass(); std::unique_ptr createGenerateCodePass(); std::unique_ptr createFuseControlFlowPass(); -std::unique_ptr createNeuraCanonicalizePass(); +std::unique_ptr createCanonicalizeLiveInPass(); #define GEN_PASS_REGISTRATION #include "NeuraDialect/NeuraPasses.h.inc" diff --git a/include/NeuraDialect/NeuraPasses.td b/include/NeuraDialect/NeuraPasses.td index 5029c74f..5c19bf94 100644 --- a/include/NeuraDialect/NeuraPasses.td +++ b/include/NeuraDialect/NeuraPasses.td @@ -75,14 +75,15 @@ def FuseControlFlow: Pass<"fuse-control-flow", "ModuleOp">{ let constructor = "neura::createFuseControlFlowPass()"; } -def NeuraCanonicalize : Pass<"neura-canonicalize", "ModuleOp"> { - let summary = "Canonicalizes operations in the Neura dialect"; +def CanonicalizeLiveIn : Pass<"canonicalize-live-in", "ModuleOp"> { + let summary = "Canonicalizes live-in values/operations in each basic block."; let description = [{ This pass applies canonicalization transformations to Neura dialect operations. The canonicalization includes: 1. Converting all live-in values of each basic block to block arguments. + 2. Promoting function arguments to neura constant operations. }]; - let constructor = "neura::createNeuraCanonicalizePass()"; + let constructor = "neura::createCanonicalizeLiveInPass()"; } #endif // NEURA_PASSES_TD \ No newline at end of file diff --git a/lib/NeuraDialect/Mapping/mapping_util.cpp b/lib/NeuraDialect/Mapping/mapping_util.cpp index 0ea1659e..a69d7a07 100644 --- a/lib/NeuraDialect/Mapping/mapping_util.cpp +++ b/lib/NeuraDialect/Mapping/mapping_util.cpp @@ -376,7 +376,6 @@ bool mlir::neura::tryRouteDataMove(Operation *mov_op, MappingLoc src_loc, Operation *mlir::neura::getMaterializedProducer(Value operand) { Operation *producer = operand.getDefiningOp(); - llvm::errs() << "Operand: " << operand << ", producer: " << *producer << "\n"; assert(isa(producer) && "Expected operand to be defined by a DataMovOp"); // Finds the actual producer. diff --git a/lib/NeuraDialect/Transforms/CMakeLists.txt b/lib/NeuraDialect/Transforms/CMakeLists.txt index e3d41ed3..15ba146f 100644 --- a/lib/NeuraDialect/Transforms/CMakeLists.txt +++ b/lib/NeuraDialect/Transforms/CMakeLists.txt @@ -11,7 +11,7 @@ add_mlir_library( MapToAcceleratorPass.cpp GenerateCodePass.cpp FuseControlFlowPass.cpp - NeuraCanonicalizePass.cpp + CanonicalizeLiveInPass.cpp DEPENDS MLIRNeuraTransformsIncGen diff --git a/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp similarity index 94% rename from lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp rename to lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp index e5f712e1..4d0277b8 100644 --- a/lib/NeuraDialect/Transforms/NeuraCanonicalizePass.cpp +++ b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp @@ -175,13 +175,13 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { return success(); } -struct NeuraCanonicalizePass - : public PassWrapper> { - MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(NeuraCanonicalizePass) +struct CanonicalizeLiveInPass + : public PassWrapper> { + MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CanonicalizeLiveInPass) - StringRef getArgument() const override { return "neura-canonicalize"; } + StringRef getArgument() const override { return "canonicalize-live-in"; } StringRef getDescription() const override { - return "Canonicalizes operations in the Neura dialect"; + return "Canonicalizes live-in values/operations in each basic block."; } void getDependentDialects(DialectRegistry ®istry) const override { registry.insert(); @@ -228,7 +228,7 @@ struct NeuraCanonicalizePass } // namespace namespace mlir::neura { -std::unique_ptr createNeuraCanonicalizePass() { - return std::make_unique(); +std::unique_ptr createCanonicalizeLiveInPass() { + return std::make_unique(); } } // namespace mlir::neura \ No newline at end of file diff --git a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp index 5f06eb04..a78b0f36 100644 --- a/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp +++ b/lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp @@ -668,8 +668,9 @@ struct TransformCtrlToDataFlowPass GrantPredicateInEntryBlock(®ion->front(), builder); assertLiveOutValuesDominatedByBlockArgs(*region); } else if (auto llvmFunc = dyn_cast(op)) { - if (llvmFunc.isDeclaration()) + if (llvmFunc.isDeclaration()) { return; + } auto accel_attr = llvmFunc->getAttrOfType("accelerator"); if (!accel_attr || accel_attr.getValue() != "neura") { return; diff --git a/test/controflow_fuse/complex_nested/complex_nested.mlir b/test/controflow_fuse/complex_nested/complex_nested.mlir index d836c382..18e8c76f 100644 --- a/test/controflow_fuse/complex_nested/complex_nested.mlir +++ b/test/controflow_fuse/complex_nested/complex_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --canonicalize-live-in --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir index f1537e1a..de13abdd 100644 --- a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir +++ b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s --lower-affine --convert-scf-to-cf --convert-cf-to-llvm -o %t-llvm.mlir // RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura | FileCheck %s -// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --neura-canonicalize --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA +// RUN: mlir-neura-opt %t-llvm.mlir --assign-accelerator --lower-arith-to-neura --lower-memref-to-neura --lower-builtin-to-neura --lower-llvm-to-neura --canonicalize-live-in --leverage-predicated-value --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA module attributes {} { func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { diff --git a/test/neura/ctrl/branch.mlir b/test/neura/ctrl/branch.mlir index e088f65c..60aae1ef 100644 --- a/test/neura/ctrl/branch.mlir +++ b/test/neura/ctrl/branch.mlir @@ -1,14 +1,14 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir index 862f9022..d93befed 100644 --- a/test/neura/ctrl/branch_for.mlir +++ b/test/neura/ctrl/branch_for.mlir @@ -7,7 +7,14 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ +// RUN: --leverage-predicated-value \ +// RUN: | FileCheck %s -check-prefix=CANONICALIZE + +// RUN: mlir-neura-opt %s \ +// RUN: --assign-accelerator \ +// RUN: --lower-llvm-to-neura \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA @@ -15,7 +22,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ @@ -24,7 +31,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ @@ -34,7 +41,7 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --insert-data-mov \ @@ -77,7 +84,23 @@ func.func @loop_test() -> f32 { // CHECK-NEXT: "neura.return"(%10) : (!neura.data) -> () // CHECK-NEXT: } -// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { +// CANONICALIZE: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { +// CANONICALIZE-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data +// CANONICALIZE-NEXT: %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data +// CANONICALIZE-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data +// CANONICALIZE-NEXT: %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data +// CANONICALIZE-NEXT: %4 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data +// CANONICALIZE-NEXT: neura.br %1, %4, %3, %2, %0 : !neura.data, !neura.data, !neura.data, !neura.data, !neura.data to ^bb1 +// CANONICALIZE-NEXT: ^bb1(%5: !neura.data, %6: !neura.data, %7: !neura.data, %8: !neura.data, %9: !neura.data): // 2 preds: ^bb0, ^bb1 +// CANONICALIZE-NEXT: %10 = "neura.fadd"(%6, %7) : (!neura.data, !neura.data) -> !neura.data +// CANONICALIZE-NEXT: %11 = "neura.add"(%5, %8) : (!neura.data, !neura.data) -> !neura.data +// CANONICALIZE-NEXT: %12 = "neura.icmp"(%11, %9) <{cmpType = "slt"}> : (!neura.data, !neura.data) -> !neura.data +// CANONICALIZE-NEXT: neura.cond_br %12 : !neura.data then %11, %10, %3, %2, %0 : !neura.data, !neura.data, !neura.data, !neura.data, !neura.data to ^bb1 else %10 : !neura.data to ^bb2 +// CANONICALIZE-NEXT: ^bb2(%13: !neura.data): // pred: ^bb1 +// CANONICALIZE-NEXT: "neura.return"(%13) : (!neura.data) -> () +// CANONICALIZE-NEXT: } + +// CTRL2DATA: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { // CTRL2DATA-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data // CTRL2DATA-NEXT: %1 = "neura.grant_always"(%0) : (!neura.data) -> !neura.data // CTRL2DATA-NEXT: %2 = "neura.grant_once"(%0) : (!neura.data) -> !neura.data @@ -119,8 +142,8 @@ func.func @loop_test() -> f32 { // CTRL2DATA-NEXT: "neura.return"(%32) : (!neura.data) -> () // CTRL2DATA-NEXT: } -// MOV: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { -// MOV-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data +// MOV: func.func @loop_test() -> f32 attributes {accelerator = "neura"} { +// MOV-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data // MOV-NEXT: %1 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data // MOV-NEXT: %2 = "neura.grant_always"(%1) : (!neura.data) -> !neura.data // MOV-NEXT: %3 = "neura.data_mov"(%0) : (!neura.data) -> !neura.data @@ -194,7 +217,7 @@ func.func @loop_test() -> f32 { // MOV-NEXT: "neura.return"(%65) : (!neura.data) -> () // MOV-NEXT: } -// MAPPING: func.func @loop_test() -> f32 attributes {CompiledII = 6 : i32, RecMII = 4 : i32, ResMII = 2 : i32, accelerator = "neura"} { +// MAPPING: func.func @loop_test() -> f32 attributes {CompiledII = 6 : i32, RecMII = 4 : i32, ResMII = 2 : i32, accelerator = "neura"} { // MAPPING-NEXT: %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 0 : i32, x = 1 : i32, y = 1 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.data_mov"(%0) {mapping_locs = []} : (!neura.data) -> !neura.data // MAPPING-NEXT: %2 = "neura.grant_always"(%1) {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 1 : i32, x = 1 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data diff --git a/test/neura/ctrl/branch_with_and_without_arg.mlir b/test/neura/ctrl/branch_with_and_without_arg.mlir index e689ad1b..88439f1a 100644 --- a/test/neura/ctrl/branch_with_and_without_arg.mlir +++ b/test/neura/ctrl/branch_with_and_without_arg.mlir @@ -1,14 +1,14 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/branch_without_arg.mlir b/test/neura/ctrl/branch_without_arg.mlir index 37a53032..7cec73c1 100644 --- a/test/neura/ctrl/branch_without_arg.mlir +++ b/test/neura/ctrl/branch_without_arg.mlir @@ -1,14 +1,14 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/ctrl/nested_branch.mlir b/test/neura/ctrl/nested_branch.mlir index f4a6a55c..30984b67 100644 --- a/test/neura/ctrl/nested_branch.mlir +++ b/test/neura/ctrl/nested_branch.mlir @@ -1,14 +1,14 @@ // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s // RUN: mlir-neura-opt %s \ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: | FileCheck %s -check-prefix=CTRL2DATA diff --git a/test/neura/for_loop/test.mlir b/test/neura/for_loop/test.mlir index 375c2b49..531e113e 100644 --- a/test/neura/for_loop/test.mlir +++ b/test/neura/for_loop/test.mlir @@ -7,14 +7,14 @@ // RUN: mlir-neura-opt %t-kernel.mlir\ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: | FileCheck %s // RUN: mlir-neura-opt %t-kernel.mlir\ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --fuse-patterns \ @@ -23,7 +23,7 @@ // RUN: mlir-neura-opt %t-kernel.mlir\ // RUN: --assign-accelerator \ // RUN: --lower-llvm-to-neura \ -// RUN: --neura-canonicalize \ +// RUN: --canonicalize-live-in \ // RUN: --leverage-predicated-value \ // RUN: --transform-ctrl-to-data-flow \ // RUN: --fuse-patterns \ From ccaa737fca2dd4e1133072bcfd3c9fb9acf88b73 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Mon, 21 Jul 2025 14:59:04 +0800 Subject: [PATCH 6/8] change README and add sort the bbs --- README.md | 3 +- .../Transforms/CanonicalizeLiveInPass.cpp | 70 +++++++++++++++---- 2 files changed, 57 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index ba1ad588..5fe4fbb2 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ Build LLVM & Neura $ mkdir build && cd build # May need install ccache and lld. $ cmake -G Ninja ../llvm \ - -DLLVM_ENABLE_PROJECTS="mlir" \ + -DLLVM_ENABLE_PROJECTS="mlir;clang" \ -DLLVM_BUILD_EXAMPLES=OFF \ -DLLVM_TARGETS_TO_BUILD="Native" \ -DCMAKE_BUILD_TYPE=Release \ @@ -28,6 +28,7 @@ Build LLVM & Neura -DCMAKE_C_COMPILER_LAUNCHER=ccache \ -DCMAKE_CXX_COMPILER_LAUNCHER=ccache $ cmake --build . --target check-mlir + $ cmake --build . --target check-clang ``` - Build Neura: diff --git a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp index 4d0277b8..8cc9507d 100644 --- a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp +++ b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp @@ -2,6 +2,7 @@ #include "NeuraDialect/NeuraOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/IR/Block.h" #include "mlir/IR/Operation.h" #include "mlir/IR/PatternMatch.h" #include "mlir/IR/Region.h" @@ -18,26 +19,62 @@ using namespace mlir; #include "NeuraDialect/NeuraPasses.h.inc" namespace { +// Returns blocks in a region in topological order +SmallVector getBlocksInTopologicalOrder(Region ®ion) { + if (region.empty()) + return {}; + + SmallVector ordered_blocks; + + DenseSet visited; + + std::function dfs = [&](Block *block) { + visited.insert(block); + + Operation *terminator = block->getTerminator(); + if (terminator) { + for (unsigned i = 0; i < terminator->getNumSuccessors(); ++i) { + Block *succ = terminator->getSuccessor(i); + if (!visited.count(succ)) { + dfs(succ); + } + } + } + ordered_blocks.push_back(block); + }; + + dfs(®ion.front()); + + for (Block &block : region) { + if (!visited.count(&block)) { + dfs(&block); + } + } + + std::reverse(ordered_blocks.begin(), ordered_blocks.end()); + return ordered_blocks; +} + LogicalResult promoteFunctionArgsToConstants(Region ®ion) { if (region.empty()) { return success(); } - Block &entryBlock = region.front(); - OpBuilder builder(&entryBlock, entryBlock.begin()); + Block &entry_block = region.front(); + OpBuilder builder(&entry_block, entry_block.begin()); // Collects all function arguments. - SmallVector args(entryBlock.getArguments().begin(), - entryBlock.getArguments().end()); + SmallVector args(entry_block.getArguments().begin(), + entry_block.getArguments().end()); // Creates a constant operation for each function argument. for (auto [idx, arg] : llvm::enumerate(args)) { // For constant operation, the default predicate is true. - auto constOp = builder.create( + auto const_op = builder.create( arg.getLoc(), arg.getType(), builder.getStringAttr("\%arg" + std::to_string(idx)), builder.getBoolAttr(true)); - arg.replaceAllUsesWith(constOp.getResult()); + arg.replaceAllUsesWith(const_op.getResult()); } return success(); @@ -48,7 +85,10 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { return success(); } - for (Block &block : region.getBlocks()) { + SmallVector sorted_blocks = getBlocksInTopologicalOrder(region); + + for (Block *block_ptr : sorted_blocks) { + Block &block = *block_ptr; // Skips the entry block. if (&block == ®ion.front()) continue; @@ -62,8 +102,8 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { // If the operand is not a block argument and is defined outside the // current block, it is a live-in value. if (!dyn_cast(operand)) { - Operation *defOp = operand.getDefiningOp(); - if (defOp && defOp->getBlock() != &block) { + Operation *def_op = operand.getDefiningOp(); + if (def_op && def_op->getBlock() != &block) { live_ins.insert(operand); } } else if (dyn_cast(operand).getOwner() != &block) { @@ -78,7 +118,7 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { continue; // Adds new block arguments for each live-in value. - unsigned originalNumArgs = block.getNumArguments(); + unsigned original_num_args = block.getNumArguments(); for (Value value : live_ins) { block.addArgument(value.getType(), value.getLoc()); } @@ -86,7 +126,7 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { // Creates a mapping from live-in values to the new block arguments. DenseMap value_to_arg; for (unsigned i = 0; i < live_ins.size(); ++i) { - value_to_arg[live_ins[i]] = block.getArgument(originalNumArgs + i); + value_to_arg[live_ins[i]] = block.getArgument(original_num_args + i); } // Updates all operations in the block to use the new block arguments @@ -115,7 +155,7 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { new_operands.push_back(operand); } - // Adds live-in values as new operands + // Adds live-in values as new operands. for (Value live_in : live_ins) { new_operands.push_back(live_in); } @@ -199,12 +239,12 @@ struct CanonicalizeLiveInPass return; } region = &func_op.getBody(); - } else if (auto llvmFunc = dyn_cast(op)) { - auto accel_attr = llvmFunc->getAttrOfType("accelerator"); + } else if (auto llvm_func = dyn_cast(op)) { + auto accel_attr = llvm_func->getAttrOfType("accelerator"); if (!accel_attr || accel_attr.getValue() != "neura") { return; } - region = &llvmFunc.getBody(); + region = &llvm_func.getBody(); } else { return; } From c728feae507338d2c2c0c62ef221cc6aeeaa1b3a Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Mon, 21 Jul 2025 16:47:22 +0800 Subject: [PATCH 7/8] change the test scripts --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 69b78041..b4214ef0 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -58,8 +58,8 @@ jobs: -DCMAKE_C_COMPILER_LAUNCHER=ccache \ -DCMAKE_CXX_COMPILER_LAUNCHER=ccache + cmake --build . cmake --build . --target check-mlir - cmake --build . --target check-clang # setup mlir-cgra - name: setup dataflow tool-chain working-directory: ${{github.workspace}} From e1430584e72365421fc813a147e398588846e077 Mon Sep 17 00:00:00 2001 From: ShangkunLI Date: Tue, 22 Jul 2025 00:11:50 +0800 Subject: [PATCH 8/8] remove block sort function --- .../Transforms/CanonicalizeLiveInPass.cpp | 42 +------------------ 1 file changed, 2 insertions(+), 40 deletions(-) diff --git a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp index 8cc9507d..832a7341 100644 --- a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp +++ b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp @@ -11,6 +11,7 @@ #include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "llvm/ADT/MapVector.h" #include "llvm/Support/Casting.h" +#include "llvm/Support/raw_ostream.h" #include using namespace mlir; @@ -19,42 +20,6 @@ using namespace mlir; #include "NeuraDialect/NeuraPasses.h.inc" namespace { -// Returns blocks in a region in topological order -SmallVector getBlocksInTopologicalOrder(Region ®ion) { - if (region.empty()) - return {}; - - SmallVector ordered_blocks; - - DenseSet visited; - - std::function dfs = [&](Block *block) { - visited.insert(block); - - Operation *terminator = block->getTerminator(); - if (terminator) { - for (unsigned i = 0; i < terminator->getNumSuccessors(); ++i) { - Block *succ = terminator->getSuccessor(i); - if (!visited.count(succ)) { - dfs(succ); - } - } - } - ordered_blocks.push_back(block); - }; - - dfs(®ion.front()); - - for (Block &block : region) { - if (!visited.count(&block)) { - dfs(&block); - } - } - - std::reverse(ordered_blocks.begin(), ordered_blocks.end()); - return ordered_blocks; -} - LogicalResult promoteFunctionArgsToConstants(Region ®ion) { if (region.empty()) { return success(); @@ -85,10 +50,7 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region ®ion) { return success(); } - SmallVector sorted_blocks = getBlocksInTopologicalOrder(region); - - for (Block *block_ptr : sorted_blocks) { - Block &block = *block_ptr; + for (Block &block : region.getBlocks()) { // Skips the entry block. if (&block == ®ion.front()) continue;