From 12ea9faee20df0c09f1cec460d496567f6c568c3 Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Wed, 22 Oct 2025 20:52:59 -0400 Subject: [PATCH 1/7] Add compiled_ii information to code generation output --- .../Transforms/GenerateCodePass.cpp | 27 ++++++++++++++++--- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp index f0a5e8bd..420fc0b7 100644 --- a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp +++ b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp @@ -60,6 +60,7 @@ struct Tile { struct ArrayConfig { int columns; int rows; + int compiled_ii = -1; std::vector cores; }; @@ -317,6 +318,15 @@ struct GenerateCodePass return {columns, rows}; } + int getCompiledII(func::FuncOp function) { + if (auto mapping_info = function->getAttrOfType("mapping_info")) { + if (auto compiled_ii = dyn_cast_or_null(mapping_info.get("compiled_ii"))) { + return compiled_ii.getInt(); + } + } + return -1; + } + // ---------- Single-walk indexing ----------. // Do everything that needs walks in a single pass:. // - record operation_placements. @@ -571,8 +581,8 @@ struct GenerateCodePass } } - ArrayConfig buildArrayConfig(int columns, int rows) { - ArrayConfig config{columns, rows, {}}; + ArrayConfig buildArrayConfig(int columns, int rows, int compiled_ii = -1) { + ArrayConfig config{columns, rows, compiled_ii, {}}; std::map, std::vector> tile_insts; // Flattens and sorts by timesteps. @@ -600,7 +610,11 @@ struct GenerateCodePass llvm::raw_fd_ostream yaml_out("tmp-generated-instructions.yaml", ec); if (ec) return; - yaml_out << "array_config:\n columns: " << config.columns << "\n rows: " << config.rows << "\n cores:\n"; + yaml_out << "array_config:\n columns: " << config.columns << "\n rows: " << config.rows; + if (config.compiled_ii >= 0) { + yaml_out << "\n compiled_ii: " << config.compiled_ii; + } + yaml_out << "\n cores:\n"; for (const Tile &core : config.cores) { yaml_out << " - column: " << core.col_idx << "\n row: " << core.row_idx << "\n core_id: \"" << core.core_id << "\"\n entries:\n"; @@ -657,6 +671,10 @@ struct GenerateCodePass llvm::raw_fd_ostream asm_out("tmp-generated-instructions.asm", ec); if (ec) return; + if (config.compiled_ii >= 0) { + asm_out << "# Compiled II: " << config.compiled_ii << "\n\n"; + } + for (const Tile &core : config.cores) { asm_out << "PE(" << core.col_idx << "," << core.row_idx << "):\n"; @@ -765,7 +783,8 @@ struct GenerateCodePass expandMovImpl(op, topo, reserve_to_phi_map); logUnresolvedOperands(); - ArrayConfig config = buildArrayConfig(columns, rows); + int compiled_ii = getCompiledII(func); + ArrayConfig config = buildArrayConfig(columns, rows, compiled_ii); writeYAMLOutput(config); writeASMOutput(config); } From d76b64bd6c74a0dcb27ccfe043ebb1711219d0de Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Wed, 22 Oct 2025 21:58:14 -0400 Subject: [PATCH 2/7] Add compiled_II and show regsister's local id for each tile in ir, only grab local id for yaml and asm file, modify the test file with reg id --- .../NeuraDialect/Architecture/Architecture.h | 6 +- .../LlvmToNeura/LlvmToNeuraPass.cpp | 122 ++++++++++++++++++ .../Architecture/Architecture.cpp | 12 +- lib/NeuraDialect/Mapping/MappingState.cpp | 10 +- .../Transforms/GenerateCodePass.cpp | 11 +- test/e2e/fir/fir_kernel.mlir | 24 ++-- test/e2e/fir/fir_kernel_vec.mlir | 24 ++-- test/e2e/histogram/histogram_kernel.mlir | 36 +++--- test/mapping_quality/branch_for.mlir | 1 + test/neura/ctrl/branch_for.mlir | 1 + 10 files changed, 195 insertions(+), 52 deletions(-) diff --git a/include/NeuraDialect/Architecture/Architecture.h b/include/NeuraDialect/Architecture/Architecture.h index ca7a4951..dd6bdb9e 100644 --- a/include/NeuraDialect/Architecture/Architecture.h +++ b/include/NeuraDialect/Architecture/Architecture.h @@ -260,9 +260,12 @@ class Link : public BasicResource { class Register : public BasicResource { public: - Register(int id); + Register(int id, int local_id); int getId() const override; + + int getLocalId() const; + void setLocalId(int local_id); std::string getType() const override { return "register"; } @@ -280,6 +283,7 @@ class Register : public BasicResource { private: int id; + int local_id; RegisterFile *register_file; }; diff --git a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp index 1195565d..9c199112 100644 --- a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp +++ b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp @@ -501,6 +501,123 @@ struct LlvmReturnToNeuraReturn : public OpRewritePattern { } }; +struct LlvmXOrToNeuraOr : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(LLVM::XOrOp op, + PatternRewriter &rewriter) const override { + // Gets operands. + Value lhs = op.getLhs(); + Value rhs = op.getRhs(); + Type result_type = op.getType(); + + // Replaces with neura.or operation. + rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); + return success(); + } +}; + +struct LlvmAndToNeuraMul : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(LLVM::AndOp op, + PatternRewriter &rewriter) const override { + // Gets operands. + Value lhs = op.getLhs(); + Value rhs = op.getRhs(); + Type result_type = op.getType(); + + // For boolean AND, uses multiplication (a AND b = a * b for boolean values). + rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); + return success(); + } +}; + +struct LlvmFNegToNeuraFSub : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(LLVM::FNegOp op, + PatternRewriter &rewriter) const override { + // Gets operand. + Value operand = op.getOperand(); + Type result_type = op.getType(); + Location loc = op.getLoc(); + + // Creates constant 0.0. + auto zero_attr = rewriter.getFloatAttr(result_type, 0.0); + auto zero_const = rewriter.create(loc, result_type, zero_attr); + + // Replaces with 0.0 - operand. + rewriter.replaceOpWithNewOp(op, result_type, zero_const, operand); + return success(); + } +}; + +struct LlvmLShrToNeuraShl : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(LLVM::LShrOp op, + PatternRewriter &rewriter) const override { + // Gets operands. + Value lhs = op.getLhs(); + Value rhs = op.getRhs(); + Type result_type = op.getType(); + Location loc = op.getLoc(); + + // Implements logical right shift as left shift with negative amount. + // lshr(x, n) = shl(x, -n). + // Creates constant 0. + auto zero_attr = rewriter.getIntegerAttr(rhs.getType(), 0); + auto zero_const = rewriter.create(loc, rhs.getType(), zero_attr); + + // Negates the shift amount: -n = 0 - n. + auto neg_rhs = rewriter.create(loc, rhs.getType(), zero_const, rhs); + + // Replaces with shl(lhs, -rhs). + rewriter.replaceOpWithNewOp(op, result_type, lhs, neg_rhs); + return success(); + } +}; + +struct LlvmSelectToNeuraOps : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(LLVM::SelectOp op, + PatternRewriter &rewriter) const override { + // Gets operands: condition, true_value, false_value. + Value condition = op.getCondition(); + Value true_value = op.getTrueValue(); + Value false_value = op.getFalseValue(); + Type result_type = op.getType(); + Location loc = op.getLoc(); + + // Implements: result = condition * true_value + (1 - condition) * false_value. + // For i1 (boolean), this works perfectly since i1 is 0 or 1. + + // Step 1: Computes condition * true_value. + auto cond_times_true = rewriter.create( + loc, result_type, condition, true_value); + + // Step 2: Creates constant 1. + auto one_attr = rewriter.getIntegerAttr(result_type, 1); + auto one_const = rewriter.create(loc, result_type, one_attr); + + // Step 3: Computes (1 - condition). + auto not_condition = rewriter.create( + loc, result_type, one_const, condition); + + // Step 4: Computes (1 - condition) * false_value. + auto not_cond_times_false = rewriter.create( + loc, result_type, not_condition, false_value); + + // Step 5: Computes result = cond_times_true + not_cond_times_false. + rewriter.replaceOpWithNewOp( + op, result_type, cond_times_true, not_cond_times_false); + + return success(); + } +}; + struct FuncReturnToNeuraReturn : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -752,6 +869,11 @@ struct LowerLlvmToNeuraPass patterns.add(&getContext()); patterns.add(&getContext()); patterns.add(&getContext()); + patterns.add(&getContext()); + patterns.add(&getContext()); + patterns.add(&getContext()); + patterns.add(&getContext()); + patterns.add(&getContext()); FrozenRewritePatternSet frozen(std::move(patterns)); diff --git a/lib/NeuraDialect/Architecture/Architecture.cpp b/lib/NeuraDialect/Architecture/Architecture.cpp index 26c5ebd1..783c2aeb 100644 --- a/lib/NeuraDialect/Architecture/Architecture.cpp +++ b/lib/NeuraDialect/Architecture/Architecture.cpp @@ -252,10 +252,14 @@ Tile *FunctionUnit::getTile() const { return this->tile; } // Register //===----------------------------------------------------------------------===// -Register::Register(int id) { this->id = id; } +Register::Register(int id, int local_id) : id(id), local_id(local_id) {} int Register::getId() const { return id; } +int Register::getLocalId() const { return local_id; } + +void Register::setLocalId(int local_id) { this->local_id = local_id; } + Tile *Register::getTile() const { return this->register_file ? register_file->getTile() : nullptr; } @@ -344,10 +348,11 @@ void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int RegisterFileCluster *register_file_cluster = new RegisterFileCluster(tile->getId()); // Creates registers as a register file. + int local_reg_id = 0; for (int file_idx = 0; file_idx < k_num_regfiles_per_cluster; ++file_idx) { RegisterFile *register_file = new RegisterFile(file_idx); for (int reg_idx = 0; reg_idx < k_num_regs_per_regfile; ++reg_idx) { - Register *reg = new Register(reg_id++); + Register *reg = new Register(reg_id++, local_reg_id++); register_file->addRegister(reg); } register_file_cluster->addRegisterFile(register_file); @@ -388,10 +393,11 @@ void Architecture::recreateRegisterFileCluster(Tile *tile, int num_registers) { // Creates registers with new capacity. int reg_id = tile->getId() * 1000; // Use tile ID as base to avoid conflicts. + int local_reg_id = 0; for (int file_idx = 0; file_idx < kNumRegfilesPerCluster; ++file_idx) { RegisterFile *register_file = new RegisterFile(file_idx); for (int reg_idx = 0; reg_idx < kNumRegsPerRegfile; ++reg_idx) { - Register *reg = new Register(reg_id++); + Register *reg = new Register(reg_id++, local_reg_id++); register_file->addRegister(reg); } new_register_file_cluster->addRegisterFile(register_file); diff --git a/lib/NeuraDialect/Mapping/MappingState.cpp b/lib/NeuraDialect/Mapping/MappingState.cpp index 4177fa27..e3741db3 100644 --- a/lib/NeuraDialect/Mapping/MappingState.cpp +++ b/lib/NeuraDialect/Mapping/MappingState.cpp @@ -263,13 +263,21 @@ void MappingState::encodeMappingState() { mapping_entries.push_back(dict); } else if (loc.resource->getKind() == ResourceKind::Register) { kind_str = "register"; + Register *reg = static_cast(loc.resource); + int global_id = loc.resource->getId(); + int local_register_id = reg->getLocalId(); + auto dict = mlir::DictionaryAttr::get( ctx, {mlir::NamedAttribute(mlir::StringAttr::get(ctx, "resource"), mlir::StringAttr::get(ctx, kind_str)), mlir::NamedAttribute( mlir::StringAttr::get(ctx, "id"), mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), - loc.resource->getId())), + global_id)), + mlir::NamedAttribute( + mlir::StringAttr::get(ctx, "local_register_id"), + mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), + local_register_id)), mlir::NamedAttribute( mlir::StringAttr::get(ctx, "time_step"), mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), diff --git a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp index 420fc0b7..09adbd17 100644 --- a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp +++ b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp @@ -110,8 +110,9 @@ static std::optional getMappedRegId(Operation *op) { auto resource_attr = dyn_cast_or_null(location_dict.get("resource")); if (!resource_attr) continue; if (resource_attr.getValue() == "register" || resource_attr.getValue() == "reg") { - if (auto register_id = dyn_cast_or_null(location_dict.get("id"))) - return register_id.getInt(); + if (auto local_register_id = dyn_cast_or_null(location_dict.get("local_register_id"))) { + return local_register_id.getInt(); + } } } } @@ -249,10 +250,10 @@ static SmallVector collectRegSteps(Operation *op) { auto resource_attr = dyn_cast_or_null(location_dict.get("resource")); if (!resource_attr) continue; if (resource_attr.getValue() == "register" || resource_attr.getValue() == "reg") { - auto register_id = dyn_cast_or_null(location_dict.get("id")); + auto local_register_id = dyn_cast_or_null(location_dict.get("local_register_id")); auto time_step = dyn_cast_or_null(location_dict.get("time_step")); - if (!register_id || !time_step) continue; - steps.push_back({(int)register_id.getInt(), (int)time_step.getInt()}); + if (!local_register_id || !time_step) continue; + steps.push_back({(int)local_register_id.getInt(), (int)time_step.getInt()}); } } } diff --git a/test/e2e/fir/fir_kernel.mlir b/test/e2e/fir/fir_kernel.mlir index caf1e4a4..1061cf25 100644 --- a/test/e2e/fir/fir_kernel.mlir +++ b/test/e2e/fir/fir_kernel.mlir @@ -33,41 +33,41 @@ // MAPPING-NEXT: %0 = "neura.grant_once"() <{constant_value = 0 : i64}> {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 0 : i32, x = 3 : i32, y = 2 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.grant_once"() <{constant_value = 0 : i32}> {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 3 : i32, x = 0 : i32, y = 1 : i32}]} : () -> !neura.data // MAPPING-NEXT: %2 = neura.reserve : !neura.data -// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 4 : i32, x = 0 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 37 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 3 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %12 = "neura.data_mov"(%7) {mapping_locs = [{id = 36 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.gep"(%12) <{operandSegmentSizes = array}> {lhs_value = "%arg2", mapping_locs = [{id = 7 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 21 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.load"(%14) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 3 : i32}, {id = 34 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %18 = "neura.mul"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 5 : i32}, {id = 42 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %21 = "neura.add"(%19, %20) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 7 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %23 = "neura.add"(%22) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 2 : i32}], rhs_value = 1 : i64} : (!neura.data) -> !neura.data // MAPPING-NEXT: %24 = "neura.data_mov"(%23) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %25 = "neura.icmp"(%24) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 32 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.not"(%26) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %30 = neura.grant_predicate %28, %29 {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 %30 -> %5 {mapping_locs = [{id = 32 : i32, resource = "link", time_step = 5 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %31 = "neura.data_mov"(%21) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %33 = neura.grant_predicate %31, %32 {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 8 : i32, x = 0 : i32, y = 2 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: neura.ctrl_mov %33 -> %2 {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 8 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %34 = "neura.data_mov"(%21) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = neura.grant_predicate %34, %35 {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: %37 = "neura.data_mov"(%36) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 8 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: "neura.return"(%37) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 9 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> () @@ -78,5 +78,5 @@ // ASM: PE(0,1): // ASM-NEXT: { -// ASM-NEXT: GRANT_ONCE, [#0] -> [$128] +// ASM-NEXT: GRANT_ONCE, [#0] -> [$0] // ASM-NEXT: } (t=3) diff --git a/test/e2e/fir/fir_kernel_vec.mlir b/test/e2e/fir/fir_kernel_vec.mlir index ddc6f7d0..c6c9b5fb 100644 --- a/test/e2e/fir/fir_kernel_vec.mlir +++ b/test/e2e/fir/fir_kernel_vec.mlir @@ -33,41 +33,41 @@ // MAPPING-NEXT: %0 = "neura.grant_once"() <{constant_value = 0 : i64}> {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 0 : i32, x = 3 : i32, y = 2 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.grant_once"() <{constant_value = dense<0> : vector<4xi32>}> {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 3 : i32, x = 0 : i32, y = 1 : i32}]} : () -> !neura.data, i1> // MAPPING-NEXT: %2 = neura.reserve : !neura.data, i1> -// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 4 : i32, x = 0 : i32, y = 1 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 37 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 3 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data, i1> // MAPPING-NEXT: %12 = "neura.data_mov"(%7) {mapping_locs = [{id = 36 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.gep"(%12) <{operandSegmentSizes = array}> {lhs_value = "%arg2", mapping_locs = [{id = 7 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 21 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.load"(%14) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data, i1> // MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 3 : i32}, {id = 34 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %18 = "neura.vmul"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 5 : i32}, {id = 42 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %21 = "neura.vadd"(%19, %20) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 7 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %23 = "neura.add"(%22) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 2 : i32}], rhs_value = 4 : i64} : (!neura.data) -> !neura.data // MAPPING-NEXT: %24 = "neura.data_mov"(%23) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %25 = "neura.icmp"(%24) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 32 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.not"(%26) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %30 = neura.grant_predicate %28, %29 {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 %30 -> %5 {mapping_locs = [{id = 32 : i32, resource = "link", time_step = 5 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %31 = "neura.data_mov"(%21) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %33 = neura.grant_predicate %31, %32 {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 8 : i32, x = 0 : i32, y = 2 : i32}]} : !neura.data, i1>, !neura.data -> !neura.data, i1> // MAPPING-NEXT: neura.ctrl_mov %33 -> %2 {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 8 : i32}]} : !neura.data, i1> !neura.data, i1> // MAPPING-NEXT: %34 = "neura.data_mov"(%21) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = neura.grant_predicate %34, %35 {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 1 : i32}]} : !neura.data, i1>, !neura.data -> !neura.data, i1> // MAPPING-NEXT: %37 = "neura.data_mov"(%36) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 8 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %38 = "neura.vector.reduce.add"(%37) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 9 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data, i1>) -> !neura.data @@ -80,6 +80,6 @@ // ASM: PE(0,1): // ASM-NEXT: { -// ASM-NEXT: GRANT_ONCE, [] -> [$128] +// ASM-NEXT: GRANT_ONCE, [] -> [$0] // ASM-NEXT: } (t=3) diff --git a/test/e2e/histogram/histogram_kernel.mlir b/test/e2e/histogram/histogram_kernel.mlir index 4d546124..c1db6c16 100644 --- a/test/e2e/histogram/histogram_kernel.mlir +++ b/test/e2e/histogram/histogram_kernel.mlir @@ -15,7 +15,7 @@ // RUN: --transform-ctrl-to-data-flow \ // RUN: --fold-constant \ // RUN: --insert-data-mov \ -// RUN: --map-to-accelerator="mapping-strategy=heuristic" \ +// RUN: --map-to-accelerator="mapping-strategy=heuristic backtrack-config=customized" \ // RUN: --architecture-spec=%S/../../arch_spec/architecture.yaml \ // RUN: --generate-code -o %t-mapping.mlir // RUN: FileCheck %s --input-file=%t-mapping.mlir -check-prefix=MAPPING @@ -39,20 +39,20 @@ // MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {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: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 34 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 448 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %12 = "neura.data_mov"(%11) {mapping_locs = [{id = 448 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %12 = "neura.data_mov"(%11) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.fadd"(%12) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 3 : i32}], rhs_value = -1.000000e+00 : f32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 448 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.fmul"(%14) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}], rhs_value = 5.000000e+00 : f32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 448 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %17 = "neura.data_mov"(%4) {mapping_locs = [{id = 34 : i32, resource = "link", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %18 = "neura.fdiv"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 6 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 448 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %20 = "neura.cast"(%19) <{cast_type = "fptosi"}> {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 7 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %21 = "neura.data_mov"(%20) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %22 = neura.sext %21 {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 3 : i32}]} : !neura.data -> !neura.data @@ -62,21 +62,21 @@ // MAPPING-NEXT: %26 = "neura.load"(%25) {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 10 : i32, x = 0 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.data_mov"(%26) {mapping_locs = [{id = 24 : i32, resource = "link", time_step = 10 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %28 = "neura.add"(%27) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 11 : i32, x = 1 : i32, y = 2 : i32}], rhs_value = 1 : i32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%28) {mapping_locs = [{id = 288 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %30 = "neura.data_mov"(%24) {mapping_locs = [{id = 38 : i32, resource = "link", time_step = 9 : i32}, {id = 42 : i32, resource = "link", time_step = 10 : i32}, {id = 289 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%28) {mapping_locs = [{id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %30 = "neura.data_mov"(%24) {mapping_locs = [{id = 38 : i32, resource = "link", time_step = 9 : i32}, {id = 42 : i32, resource = "link", time_step = 10 : i32}, {id = 289 : i32, local_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: "neura.store"(%29, %30) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 12 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> () -// MAPPING-NEXT: %31 = "neura.data_mov"(%7) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %31 = "neura.data_mov"(%7) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %32 = "neura.add"(%31) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 1 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %33 = "neura.data_mov"(%32) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %33 = "neura.data_mov"(%32) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %34 = "neura.icmp"(%33) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 20 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %35 = "neura.data_mov"(%34) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%34) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = "neura.not"(%35) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %37 = "neura.data_mov"(%32) {mapping_locs = [{id = 321 : i32, resource = "register", time_step = 2 : i32}, {id = 321 : i32, resource = "register", time_step = 3 : i32}, {id = 321 : i32, resource = "register", time_step = 4 : i32}, {id = 321 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %38 = "neura.data_mov"(%36) {mapping_locs = [{id = 320 : i32, resource = "register", time_step = 4 : i32}, {id = 320 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %37 = "neura.data_mov"(%32) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 2 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 3 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %38 = "neura.data_mov"(%36) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %39 = neura.grant_predicate %37, %38 {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 6 : i32, x = 2 : i32, y = 2 : i32}]} : !neura.data, !neura.data -> !neura.data -// MAPPING-NEXT: neura.ctrl_mov %39 -> %5 {mapping_locs = [{id = 321 : i32, resource = "register", time_step = 6 : i32}, {id = 321 : i32, resource = "register", time_step = 7 : i32}, {id = 321 : i32, resource = "register", time_step = 8 : i32}]} : !neura.data !neura.data -// MAPPING-NEXT: %40 = "neura.data_mov"(%4) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 5 : i32}, {id = 192 : i32, resource = "register", time_step = 6 : i32}, {id = 192 : i32, resource = "register", time_step = 7 : i32}, {id = 192 : i32, resource = "register", time_step = 8 : i32}, {id = 192 : i32, resource = "register", time_step = 9 : i32}, {id = 192 : i32, resource = "register", time_step = 10 : i32}, {id = 192 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %41 = "neura.data_mov"(%36) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 4 : i32}, {id = 193 : i32, resource = "register", time_step = 5 : i32}, {id = 193 : i32, resource = "register", time_step = 6 : i32}, {id = 193 : i32, resource = "register", time_step = 7 : i32}, {id = 193 : i32, resource = "register", time_step = 8 : i32}, {id = 193 : i32, resource = "register", time_step = 9 : i32}, {id = 193 : i32, resource = "register", time_step = 10 : i32}, {id = 193 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %39 -> %5 {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 8 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %40 = "neura.data_mov"(%4) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 5 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 8 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 9 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 10 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %41 = "neura.data_mov"(%36) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 4 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 5 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 8 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 9 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 10 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %42 = neura.grant_predicate %40, %41 {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 12 : i32, x = 2 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: neura.ctrl_mov %42 -> %2 {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 12 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: "neura.return"() {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 12 : i32, x = 3 : i32, y = 3 : i32}]} : () -> () @@ -88,5 +88,5 @@ // ASM: PE(2,2): // ASM-NEXT: { -// ASM-NEXT: GRANT_ONCE, [#0] -> [$320] +// ASM-NEXT: GRANT_ONCE, [#0] -> [$0] // ASM-NEXT: } (t=0) diff --git a/test/mapping_quality/branch_for.mlir b/test/mapping_quality/branch_for.mlir index 05349589..a73107ec 100644 --- a/test/mapping_quality/branch_for.mlir +++ b/test/mapping_quality/branch_for.mlir @@ -196,6 +196,7 @@ func.func @loop_test() -> f32 { // YAML: array_config: // YAML-NEXT: columns: 4 // YAML-NEXT: rows: 4 +// YAML-NEXT: compiled_ii: 5 // YAML-NEXT: cores: // YAML-NEXT: - column: 0 // YAML-NEXT: row: 1 diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir index 40837e08..6e5da358 100644 --- a/test/neura/ctrl/branch_for.mlir +++ b/test/neura/ctrl/branch_for.mlir @@ -200,6 +200,7 @@ func.func @loop_test() -> f32 { // YAML: array_config: // YAML-NEXT: columns: 4 // YAML-NEXT: rows: 4 +// YAML-NEXT: compiled_ii: 4 // YAML-NEXT: cores: // YAML-NEXT: - column: 0 // YAML-NEXT: row: 0 From aa7b5a4e7cc9da7adef48a9c01b3d4ebf9b2b19e Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Wed, 22 Oct 2025 22:16:48 -0400 Subject: [PATCH 3/7] Remove FFT conversion rules for clean codebase - Removed LlvmXOrToNeuraOr conversion rule - Removed LlvmAndToNeuraMul conversion rule - Removed LlvmFNegToNeuraFSub conversion rule - Removed LlvmLShrToNeuraShl conversion rule - Removed LlvmSelectToNeuraOps conversion rule - Removed corresponding pattern registrations These rules were added for FFT testing and are not needed in the main codebase. --- .../LlvmToNeura/LlvmToNeuraPass.cpp | 117 ------------------ 1 file changed, 117 deletions(-) diff --git a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp index 9c199112..a514d4ff 100644 --- a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp +++ b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp @@ -501,122 +501,10 @@ struct LlvmReturnToNeuraReturn : public OpRewritePattern { } }; -struct LlvmXOrToNeuraOr : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(LLVM::XOrOp op, - PatternRewriter &rewriter) const override { - // Gets operands. - Value lhs = op.getLhs(); - Value rhs = op.getRhs(); - Type result_type = op.getType(); - - // Replaces with neura.or operation. - rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); - return success(); - } -}; - -struct LlvmAndToNeuraMul : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(LLVM::AndOp op, - PatternRewriter &rewriter) const override { - // Gets operands. - Value lhs = op.getLhs(); - Value rhs = op.getRhs(); - Type result_type = op.getType(); - - // For boolean AND, uses multiplication (a AND b = a * b for boolean values). - rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); - return success(); - } -}; -struct LlvmFNegToNeuraFSub : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(LLVM::FNegOp op, - PatternRewriter &rewriter) const override { - // Gets operand. - Value operand = op.getOperand(); - Type result_type = op.getType(); - Location loc = op.getLoc(); - // Creates constant 0.0. - auto zero_attr = rewriter.getFloatAttr(result_type, 0.0); - auto zero_const = rewriter.create(loc, result_type, zero_attr); - // Replaces with 0.0 - operand. - rewriter.replaceOpWithNewOp(op, result_type, zero_const, operand); - return success(); - } -}; -struct LlvmLShrToNeuraShl : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(LLVM::LShrOp op, - PatternRewriter &rewriter) const override { - // Gets operands. - Value lhs = op.getLhs(); - Value rhs = op.getRhs(); - Type result_type = op.getType(); - Location loc = op.getLoc(); - - // Implements logical right shift as left shift with negative amount. - // lshr(x, n) = shl(x, -n). - // Creates constant 0. - auto zero_attr = rewriter.getIntegerAttr(rhs.getType(), 0); - auto zero_const = rewriter.create(loc, rhs.getType(), zero_attr); - - // Negates the shift amount: -n = 0 - n. - auto neg_rhs = rewriter.create(loc, rhs.getType(), zero_const, rhs); - - // Replaces with shl(lhs, -rhs). - rewriter.replaceOpWithNewOp(op, result_type, lhs, neg_rhs); - return success(); - } -}; - -struct LlvmSelectToNeuraOps : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(LLVM::SelectOp op, - PatternRewriter &rewriter) const override { - // Gets operands: condition, true_value, false_value. - Value condition = op.getCondition(); - Value true_value = op.getTrueValue(); - Value false_value = op.getFalseValue(); - Type result_type = op.getType(); - Location loc = op.getLoc(); - - // Implements: result = condition * true_value + (1 - condition) * false_value. - // For i1 (boolean), this works perfectly since i1 is 0 or 1. - - // Step 1: Computes condition * true_value. - auto cond_times_true = rewriter.create( - loc, result_type, condition, true_value); - - // Step 2: Creates constant 1. - auto one_attr = rewriter.getIntegerAttr(result_type, 1); - auto one_const = rewriter.create(loc, result_type, one_attr); - - // Step 3: Computes (1 - condition). - auto not_condition = rewriter.create( - loc, result_type, one_const, condition); - - // Step 4: Computes (1 - condition) * false_value. - auto not_cond_times_false = rewriter.create( - loc, result_type, not_condition, false_value); - - // Step 5: Computes result = cond_times_true + not_cond_times_false. - rewriter.replaceOpWithNewOp( - op, result_type, cond_times_true, not_cond_times_false); - - return success(); - } -}; struct FuncReturnToNeuraReturn : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -869,11 +757,6 @@ struct LowerLlvmToNeuraPass patterns.add(&getContext()); patterns.add(&getContext()); patterns.add(&getContext()); - patterns.add(&getContext()); - patterns.add(&getContext()); - patterns.add(&getContext()); - patterns.add(&getContext()); - patterns.add(&getContext()); FrozenRewritePatternSet frozen(std::move(patterns)); From d9d79e791b07ebea8dfce70b9d8be44476a6b008 Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Thu, 23 Oct 2025 00:06:03 -0400 Subject: [PATCH 4/7] Add per_tile_register_id support and compiled_ii output - Add per_tile_register_id field to Register class - Update MappingState to output both global ID and per_tile_register_id - Modify GenerateCodePass to use local register IDs in ASM/YAML output - Add compiled_ii information to YAML and ASM output - Update test files to expect per_tile_register_id and local register IDs - Refactor Architecture.cpp to remove recreateRegisterFileCluster and enhance createRegisterFileCluster --- .../NeuraDialect/Architecture/Architecture.h | 10 +- .../LlvmToNeura/LlvmToNeuraPass.cpp | 125 +++++++++++++++++- .../Architecture/Architecture.cpp | 62 +++------ lib/NeuraDialect/Mapping/MappingState.cpp | 6 +- .../Transforms/GenerateCodePass.cpp | 10 +- test/e2e/fir/fir_kernel.mlir | 22 +-- test/e2e/fir/fir_kernel_vec.mlir | 22 +-- test/e2e/histogram/histogram_kernel.mlir | 32 ++--- 8 files changed, 193 insertions(+), 96 deletions(-) diff --git a/include/NeuraDialect/Architecture/Architecture.h b/include/NeuraDialect/Architecture/Architecture.h index dd6bdb9e..8724f6ab 100644 --- a/include/NeuraDialect/Architecture/Architecture.h +++ b/include/NeuraDialect/Architecture/Architecture.h @@ -260,12 +260,11 @@ class Link : public BasicResource { class Register : public BasicResource { public: - Register(int id, int local_id); + Register(int global_id, int per_tile_id); int getId() const override; - int getLocalId() const; - void setLocalId(int local_id); + int getPerTileId() const; std::string getType() const override { return "register"; } @@ -283,7 +282,7 @@ class Register : public BasicResource { private: int id; - int local_id; + int per_tile_id; RegisterFile *register_file; }; @@ -410,8 +409,7 @@ class Architecture { void applyTileOverrides(const std::vector& tile_overrides); void createLinks(const LinkDefaults& link_defaults, BaseTopology base_topology); void applyLinkOverrides(const std::vector& link_overrides); - void createRegisterFileCluster(Tile *tile, int num_registers, int ®_id); - void recreateRegisterFileCluster(Tile *tile, int num_registers); + void createRegisterFileCluster(Tile *tile, int num_registers, int &num_already_assigned_global_registers, int global_id_start = -1); bool linkExists(Tile *src_tile, Tile *dst_tile); // Helper methods for creating different topology links. diff --git a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp index a514d4ff..711fb94b 100644 --- a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp +++ b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp @@ -501,10 +501,122 @@ struct LlvmReturnToNeuraReturn : public OpRewritePattern { } }; - - - - +// struct LlvmXOrToNeuraOr : public OpRewritePattern { +// using OpRewritePattern::OpRewritePattern; + +// LogicalResult matchAndRewrite(LLVM::XOrOp op, +// PatternRewriter &rewriter) const override { +// // Gets operands. +// Value lhs = op.getLhs(); +// Value rhs = op.getRhs(); +// Type result_type = op.getType(); + +// // Replaces with neura.or operation. +// rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); +// return success(); +// } +// }; + +// struct LlvmAndToNeuraMul : public OpRewritePattern { +// using OpRewritePattern::OpRewritePattern; + +// LogicalResult matchAndRewrite(LLVM::AndOp op, +// PatternRewriter &rewriter) const override { +// // Gets operands. +// Value lhs = op.getLhs(); +// Value rhs = op.getRhs(); +// Type result_type = op.getType(); + +// // For boolean AND, uses multiplication (a AND b = a * b for boolean values). +// rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); +// return success(); +// } +// }; + +// struct LlvmFNegToNeuraFSub : public OpRewritePattern { +// using OpRewritePattern::OpRewritePattern; + +// LogicalResult matchAndRewrite(LLVM::FNegOp op, +// PatternRewriter &rewriter) const override { +// // Gets operand. +// Value operand = op.getOperand(); +// Type result_type = op.getType(); +// Location loc = op.getLoc(); + +// // Creates constant 0.0. +// auto zero_attr = rewriter.getFloatAttr(result_type, 0.0); +// auto zero_const = rewriter.create(loc, result_type, zero_attr); + +// // Replaces with 0.0 - operand. +// rewriter.replaceOpWithNewOp(op, result_type, zero_const, operand); +// return success(); +// } +// }; + +// struct LlvmLShrToNeuraShl : public OpRewritePattern { +// using OpRewritePattern::OpRewritePattern; + +// LogicalResult matchAndRewrite(LLVM::LShrOp op, +// PatternRewriter &rewriter) const override { +// // Gets operands. +// Value lhs = op.getLhs(); +// Value rhs = op.getRhs(); +// Type result_type = op.getType(); +// Location loc = op.getLoc(); + +// // Implements logical right shift as left shift with negative amount. +// // lshr(x, n) = shl(x, -n). +// // Creates constant 0. +// auto zero_attr = rewriter.getIntegerAttr(rhs.getType(), 0); +// auto zero_const = rewriter.create(loc, rhs.getType(), zero_attr); + +// // Negates the shift amount: -n = 0 - n. +// auto neg_rhs = rewriter.create(loc, rhs.getType(), zero_const, rhs); + +// // Replaces with shl(lhs, -rhs). +// rewriter.replaceOpWithNewOp(op, result_type, lhs, neg_rhs); +// return success(); +// } +// }; + +// struct LlvmSelectToNeuraOps : public OpRewritePattern { +// using OpRewritePattern::OpRewritePattern; + +// LogicalResult matchAndRewrite(LLVM::SelectOp op, +// PatternRewriter &rewriter) const override { +// // Gets operands: condition, true_value, false_value. +// Value condition = op.getCondition(); +// Value true_value = op.getTrueValue(); +// Value false_value = op.getFalseValue(); +// Type result_type = op.getType(); +// Location loc = op.getLoc(); + +// // Implements: result = condition * true_value + (1 - condition) * false_value. +// // For i1 (boolean), this works perfectly since i1 is 0 or 1. + +// // Step 1: Computes condition * true_value. +// auto cond_times_true = rewriter.create( +// loc, result_type, condition, true_value); + +// // Step 2: Creates constant 1. +// auto one_attr = rewriter.getIntegerAttr(result_type, 1); +// auto one_const = rewriter.create(loc, result_type, one_attr); + +// // Step 3: Computes (1 - condition). +// auto not_condition = rewriter.create( +// loc, result_type, one_const, condition); + +// // Step 4: Computes (1 - condition) * false_value. +// auto not_cond_times_false = rewriter.create( +// loc, result_type, not_condition, false_value); + +// // Step 5: Computes result = cond_times_true + not_cond_times_false. +// rewriter.replaceOpWithNewOp( +// op, result_type, cond_times_true, not_cond_times_false); + +// return success(); +// } +// }; struct FuncReturnToNeuraReturn : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -757,6 +869,11 @@ struct LowerLlvmToNeuraPass patterns.add(&getContext()); patterns.add(&getContext()); patterns.add(&getContext()); + // patterns.add(&getContext()); + // patterns.add(&getContext()); + // patterns.add(&getContext()); + // patterns.add(&getContext()); + // patterns.add(&getContext()); FrozenRewritePatternSet frozen(std::move(patterns)); diff --git a/lib/NeuraDialect/Architecture/Architecture.cpp b/lib/NeuraDialect/Architecture/Architecture.cpp index 783c2aeb..0d042287 100644 --- a/lib/NeuraDialect/Architecture/Architecture.cpp +++ b/lib/NeuraDialect/Architecture/Architecture.cpp @@ -252,13 +252,11 @@ Tile *FunctionUnit::getTile() const { return this->tile; } // Register //===----------------------------------------------------------------------===// -Register::Register(int id, int local_id) : id(id), local_id(local_id) {} +Register::Register(int global_id, int per_tile_id) : id(global_id), per_tile_id(per_tile_id) {} int Register::getId() const { return id; } -int Register::getLocalId() const { return local_id; } - -void Register::setLocalId(int local_id) { this->local_id = local_id; } +int Register::getPerTileId() const { return per_tile_id; } Tile *Register::getTile() const { return this->register_file ? register_file->getTile() : nullptr; @@ -341,19 +339,24 @@ void Architecture::initializeTiles(int per_cgra_rows, int per_cgra_columns) { } // Creates register file cluster for a tile. -void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int ®_id) { +void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int &num_already_assigned_global_registers, int global_id_start) { const int k_num_regs_per_regfile = 8; // Keep this fixed for now. const int k_num_regfiles_per_cluster = num_registers / k_num_regs_per_regfile; + // If global_id_start is specified, use it instead of the passed reference. + if (global_id_start >= 0) { + num_already_assigned_global_registers = global_id_start; + } + RegisterFileCluster *register_file_cluster = new RegisterFileCluster(tile->getId()); // Creates registers as a register file. int local_reg_id = 0; for (int file_idx = 0; file_idx < k_num_regfiles_per_cluster; ++file_idx) { RegisterFile *register_file = new RegisterFile(file_idx); - for (int reg_idx = 0; reg_idx < k_num_regs_per_regfile; ++reg_idx) { - Register *reg = new Register(reg_id++, local_reg_id++); - register_file->addRegister(reg); + for (int reg = 0; reg < k_num_regs_per_regfile; ++reg) { + Register *new_register = new Register(num_already_assigned_global_registers++, local_reg_id++); + register_file->addRegister(new_register); } register_file_cluster->addRegisterFile(register_file); } @@ -363,13 +366,13 @@ void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int // Configures default tile settings. void Architecture::configureDefaultTileSettings(const TileDefaults& tile_defaults) { - int reg_id = 0; + int num_already_assigned_global_registers = 0; for (int y = 0; y < getPerCgraRows(); ++y) { for (int x = 0; x < getPerCgraColumns(); ++x) { Tile *tile = getTile(x, y); // Creates register file cluster with default capacity. - createRegisterFileCluster(tile, tile_defaults.num_registers, reg_id); + createRegisterFileCluster(tile, tile_defaults.num_registers, num_already_assigned_global_registers); // Configures function units based on tile_defaults.operations. configureTileFunctionUnits(tile, tile_defaults.operations); @@ -377,35 +380,6 @@ void Architecture::configureDefaultTileSettings(const TileDefaults& tile_default } } -// Recreates register file cluster with new capacity. -void Architecture::recreateRegisterFileCluster(Tile *tile, int num_registers) { - constexpr int kNumRegsPerRegfile = 8; // Keep this fixed for now. - const int kNumRegfilesPerCluster = num_registers / kNumRegsPerRegfile; - - // Removes existing register file cluster. - if (tile->getRegisterFileCluster()) { - delete tile->getRegisterFileCluster(); - } - - // Creates new register file cluster with override capacity. - RegisterFileCluster *new_register_file_cluster = - new RegisterFileCluster(tile->getId()); - - // Creates registers with new capacity. - int reg_id = tile->getId() * 1000; // Use tile ID as base to avoid conflicts. - int local_reg_id = 0; - for (int file_idx = 0; file_idx < kNumRegfilesPerCluster; ++file_idx) { - RegisterFile *register_file = new RegisterFile(file_idx); - for (int reg_idx = 0; reg_idx < kNumRegsPerRegfile; ++reg_idx) { - Register *reg = new Register(reg_id++, local_reg_id++); - register_file->addRegister(reg); - } - new_register_file_cluster->addRegisterFile(register_file); - } - - // Adds new register file cluster to the tile. - tile->addRegisterFileCluster(new_register_file_cluster); -} // Applies tile overrides to modify specific tiles. void Architecture::applyTileOverrides(const std::vector& tile_overrides) { @@ -423,7 +397,15 @@ void Architecture::applyTileOverrides(const std::vector& tile_over // Overrides num_registers if specified. if (override.num_registers > 0) { - recreateRegisterFileCluster(tile, override.num_registers); + // Removes existing register file cluster. + if (tile->getRegisterFileCluster()) { + delete tile->getRegisterFileCluster(); + } + + // Creates new register file cluster with override capacity. + // Uses tile ID as base to avoid conflicts with existing registers. + int dummy_ref = 0; // Not used when global_id_start is specified. + createRegisterFileCluster(tile, override.num_registers, dummy_ref, tile->getId() * 1000); } } } diff --git a/lib/NeuraDialect/Mapping/MappingState.cpp b/lib/NeuraDialect/Mapping/MappingState.cpp index e3741db3..cfb946da 100644 --- a/lib/NeuraDialect/Mapping/MappingState.cpp +++ b/lib/NeuraDialect/Mapping/MappingState.cpp @@ -265,7 +265,7 @@ void MappingState::encodeMappingState() { kind_str = "register"; Register *reg = static_cast(loc.resource); int global_id = loc.resource->getId(); - int local_register_id = reg->getLocalId(); + int per_tile_register_id = reg->getPerTileId(); auto dict = mlir::DictionaryAttr::get( ctx, {mlir::NamedAttribute(mlir::StringAttr::get(ctx, "resource"), @@ -275,9 +275,9 @@ void MappingState::encodeMappingState() { mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), global_id)), mlir::NamedAttribute( - mlir::StringAttr::get(ctx, "local_register_id"), + mlir::StringAttr::get(ctx, "per_tile_register_id"), mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), - local_register_id)), + per_tile_register_id)), mlir::NamedAttribute( mlir::StringAttr::get(ctx, "time_step"), mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 32), diff --git a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp index 09adbd17..0a322eeb 100644 --- a/lib/NeuraDialect/Transforms/GenerateCodePass.cpp +++ b/lib/NeuraDialect/Transforms/GenerateCodePass.cpp @@ -110,8 +110,8 @@ static std::optional getMappedRegId(Operation *op) { auto resource_attr = dyn_cast_or_null(location_dict.get("resource")); if (!resource_attr) continue; if (resource_attr.getValue() == "register" || resource_attr.getValue() == "reg") { - if (auto local_register_id = dyn_cast_or_null(location_dict.get("local_register_id"))) { - return local_register_id.getInt(); + if (auto per_tile_register_id = dyn_cast_or_null(location_dict.get("per_tile_register_id"))) { + return per_tile_register_id.getInt(); } } } @@ -250,10 +250,10 @@ static SmallVector collectRegSteps(Operation *op) { auto resource_attr = dyn_cast_or_null(location_dict.get("resource")); if (!resource_attr) continue; if (resource_attr.getValue() == "register" || resource_attr.getValue() == "reg") { - auto local_register_id = dyn_cast_or_null(location_dict.get("local_register_id")); + auto per_tile_register_id = dyn_cast_or_null(location_dict.get("per_tile_register_id")); auto time_step = dyn_cast_or_null(location_dict.get("time_step")); - if (!local_register_id || !time_step) continue; - steps.push_back({(int)local_register_id.getInt(), (int)time_step.getInt()}); + if (!per_tile_register_id || !time_step) continue; + steps.push_back({(int)per_tile_register_id.getInt(), (int)time_step.getInt()}); } } } diff --git a/test/e2e/fir/fir_kernel.mlir b/test/e2e/fir/fir_kernel.mlir index 1061cf25..59b140d9 100644 --- a/test/e2e/fir/fir_kernel.mlir +++ b/test/e2e/fir/fir_kernel.mlir @@ -33,41 +33,41 @@ // MAPPING-NEXT: %0 = "neura.grant_once"() <{constant_value = 0 : i64}> {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 0 : i32, x = 3 : i32, y = 2 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.grant_once"() <{constant_value = 0 : i32}> {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 3 : i32, x = 0 : i32, y = 1 : i32}]} : () -> !neura.data // MAPPING-NEXT: %2 = neura.reserve : !neura.data -// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 4 : i32, x = 0 : i32, y = 1 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 37 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 3 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %12 = "neura.data_mov"(%7) {mapping_locs = [{id = 36 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.gep"(%12) <{operandSegmentSizes = array}> {lhs_value = "%arg2", mapping_locs = [{id = 7 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 21 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.load"(%14) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 3 : i32}, {id = 34 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %18 = "neura.mul"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 5 : i32}, {id = 42 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %21 = "neura.add"(%19, %20) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 7 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %23 = "neura.add"(%22) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 2 : i32}], rhs_value = 1 : i64} : (!neura.data) -> !neura.data // MAPPING-NEXT: %24 = "neura.data_mov"(%23) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %25 = "neura.icmp"(%24) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 32 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.not"(%26) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %30 = neura.grant_predicate %28, %29 {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 %30 -> %5 {mapping_locs = [{id = 32 : i32, resource = "link", time_step = 5 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %31 = "neura.data_mov"(%21) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %33 = neura.grant_predicate %31, %32 {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 8 : i32, x = 0 : i32, y = 2 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: neura.ctrl_mov %33 -> %2 {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 8 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %34 = "neura.data_mov"(%21) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = neura.grant_predicate %34, %35 {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: %37 = "neura.data_mov"(%36) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 8 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: "neura.return"(%37) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 9 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> () diff --git a/test/e2e/fir/fir_kernel_vec.mlir b/test/e2e/fir/fir_kernel_vec.mlir index c6c9b5fb..bceb67e3 100644 --- a/test/e2e/fir/fir_kernel_vec.mlir +++ b/test/e2e/fir/fir_kernel_vec.mlir @@ -33,41 +33,41 @@ // MAPPING-NEXT: %0 = "neura.grant_once"() <{constant_value = 0 : i64}> {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 0 : i32, x = 3 : i32, y = 2 : i32}]} : () -> !neura.data // MAPPING-NEXT: %1 = "neura.grant_once"() <{constant_value = dense<0> : vector<4xi32>}> {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 3 : i32, x = 0 : i32, y = 1 : i32}]} : () -> !neura.data, i1> // MAPPING-NEXT: %2 = neura.reserve : !neura.data, i1> -// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 128 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {mapping_locs = [{id = 4 : i32, resource = "tile", time_step = 4 : i32, x = 0 : i32, y = 1 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 1 : i32, x = 3 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 37 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 480 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 3 : i32, x = 3 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data, i1> // MAPPING-NEXT: %12 = "neura.data_mov"(%7) {mapping_locs = [{id = 36 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.gep"(%12) <{operandSegmentSizes = array}> {lhs_value = "%arg2", mapping_locs = [{id = 7 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 21 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.load"(%14) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data) -> !neura.data, i1> // MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 3 : i32}, {id = 34 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %17 = "neura.data_mov"(%11) {mapping_locs = [{id = 46 : i32, resource = "link", time_step = 3 : i32}, {id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %18 = "neura.vmul"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 5 : i32}, {id = 42 : i32, resource = "link", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> +// MAPPING-NEXT: %20 = "neura.data_mov"(%4) {mapping_locs = [{id = 10 : i32, resource = "link", time_step = 4 : i32}, {id = 16 : i32, resource = "link", time_step = 5 : i32}, {id = 288 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %21 = "neura.vadd"(%19, %20) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 7 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, i1>, !neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %22 = "neura.data_mov"(%7) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %23 = "neura.add"(%22) {mapping_locs = [{id = 11 : i32, resource = "tile", time_step = 2 : i32, x = 3 : i32, y = 2 : i32}], rhs_value = 4 : i64} : (!neura.data) -> !neura.data // MAPPING-NEXT: %24 = "neura.data_mov"(%23) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %25 = "neura.icmp"(%24) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 32 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %26 = "neura.data_mov"(%25) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.not"(%26) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %28 = "neura.data_mov"(%23) {mapping_locs = [{id = 352 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}, {id = 35 : i32, resource = "link", time_step = 3 : i32}, {id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%27) {mapping_locs = [{id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %30 = neura.grant_predicate %28, %29 {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 %30 -> %5 {mapping_locs = [{id = 32 : i32, resource = "link", time_step = 5 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: %31 = "neura.data_mov"(%21) {mapping_locs = [{id = 27 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %32 = "neura.data_mov"(%27) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 4 : i32}, {id = 27 : i32, resource = "link", time_step = 5 : i32}, {id = 256 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 256 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %33 = neura.grant_predicate %31, %32 {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 8 : i32, x = 0 : i32, y = 2 : i32}]} : !neura.data, i1>, !neura.data -> !neura.data, i1> // MAPPING-NEXT: neura.ctrl_mov %33 -> %2 {mapping_locs = [{id = 25 : i32, resource = "link", time_step = 8 : i32}]} : !neura.data, i1> !neura.data, i1> // MAPPING-NEXT: %34 = "neura.data_mov"(%21) {mapping_locs = [{id = 29 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> -// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%25) {mapping_locs = [{id = 31 : i32, resource = "link", time_step = 3 : i32}, {id = 29 : i32, resource = "link", time_step = 4 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 5 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 160 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = neura.grant_predicate %34, %35 {mapping_locs = [{id = 5 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 1 : i32}]} : !neura.data, i1>, !neura.data -> !neura.data, i1> // MAPPING-NEXT: %37 = "neura.data_mov"(%36) {mapping_locs = [{id = 14 : i32, resource = "link", time_step = 8 : i32}]} : (!neura.data, i1>) -> !neura.data, i1> // MAPPING-NEXT: %38 = "neura.vector.reduce.add"(%37) {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 9 : i32, x = 2 : i32, y = 1 : i32}]} : (!neura.data, i1>) -> !neura.data diff --git a/test/e2e/histogram/histogram_kernel.mlir b/test/e2e/histogram/histogram_kernel.mlir index c1db6c16..eed15247 100644 --- a/test/e2e/histogram/histogram_kernel.mlir +++ b/test/e2e/histogram/histogram_kernel.mlir @@ -39,20 +39,20 @@ // MAPPING-NEXT: %3 = "neura.data_mov"(%1) {mapping_locs = [{id = 35 : i32, resource = "link", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %4 = "neura.phi"(%2, %3) {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: %5 = neura.reserve : !neura.data -// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %6 = "neura.data_mov"(%0) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 0 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %7 = "neura.phi"(%5, %6) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 1 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> !neura.data // MAPPING-NEXT: %8 = "neura.data_mov"(%7) {mapping_locs = [{id = 34 : i32, resource = "link", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %9 = "neura.gep"(%8) <{operandSegmentSizes = array}> {lhs_value = "%arg0", mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %10 = "neura.data_mov"(%9) {mapping_locs = [{id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %11 = "neura.load"(%10) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %12 = "neura.data_mov"(%11) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %12 = "neura.data_mov"(%11) {mapping_locs = [{id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %13 = "neura.fadd"(%12) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 3 : i32}], rhs_value = -1.000000e+00 : f32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %14 = "neura.data_mov"(%13) {mapping_locs = [{id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %15 = "neura.fmul"(%14) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 5 : i32, x = 2 : i32, y = 3 : i32}], rhs_value = 5.000000e+00 : f32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %16 = "neura.data_mov"(%15) {mapping_locs = [{id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %17 = "neura.data_mov"(%4) {mapping_locs = [{id = 34 : i32, resource = "link", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %18 = "neura.fdiv"(%16, %17) {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 6 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data, !neura.data) -> !neura.data -// MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 448 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %19 = "neura.data_mov"(%18) {mapping_locs = [{id = 448 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %20 = "neura.cast"(%19) <{cast_type = "fptosi"}> {mapping_locs = [{id = 14 : i32, resource = "tile", time_step = 7 : i32, x = 2 : i32, y = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %21 = "neura.data_mov"(%20) {mapping_locs = [{id = 43 : i32, resource = "link", time_step = 7 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %22 = neura.sext %21 {mapping_locs = [{id = 13 : i32, resource = "tile", time_step = 8 : i32, x = 1 : i32, y = 3 : i32}]} : !neura.data -> !neura.data @@ -62,21 +62,21 @@ // MAPPING-NEXT: %26 = "neura.load"(%25) {mapping_locs = [{id = 8 : i32, resource = "tile", time_step = 10 : i32, x = 0 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %27 = "neura.data_mov"(%26) {mapping_locs = [{id = 24 : i32, resource = "link", time_step = 10 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %28 = "neura.add"(%27) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 11 : i32, x = 1 : i32, y = 2 : i32}], rhs_value = 1 : i32} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %29 = "neura.data_mov"(%28) {mapping_locs = [{id = 288 : i32, local_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %30 = "neura.data_mov"(%24) {mapping_locs = [{id = 38 : i32, resource = "link", time_step = 9 : i32}, {id = 42 : i32, resource = "link", time_step = 10 : i32}, {id = 289 : i32, local_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %29 = "neura.data_mov"(%28) {mapping_locs = [{id = 288 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %30 = "neura.data_mov"(%24) {mapping_locs = [{id = 38 : i32, resource = "link", time_step = 9 : i32}, {id = 42 : i32, resource = "link", time_step = 10 : i32}, {id = 289 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: "neura.store"(%29, %30) {mapping_locs = [{id = 9 : i32, resource = "tile", time_step = 12 : i32, x = 1 : i32, y = 2 : i32}]} : (!neura.data, !neura.data) -> () -// MAPPING-NEXT: %31 = "neura.data_mov"(%7) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %31 = "neura.data_mov"(%7) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 1 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %32 = "neura.add"(%31) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 2 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 1 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %33 = "neura.data_mov"(%32) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %33 = "neura.data_mov"(%32) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 2 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %34 = "neura.icmp"(%33) <{cmpType = "eq"}> {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 3 : i32, x = 2 : i32, y = 2 : i32}], rhs_value = 20 : i64} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %35 = "neura.data_mov"(%34) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %35 = "neura.data_mov"(%34) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 3 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %36 = "neura.not"(%35) {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 4 : i32, x = 2 : i32, y = 2 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %37 = "neura.data_mov"(%32) {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 2 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 3 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 4 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %38 = "neura.data_mov"(%36) {mapping_locs = [{id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 4 : i32}, {id = 320 : i32, local_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %37 = "neura.data_mov"(%32) {mapping_locs = [{id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 2 : i32}, {id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 3 : i32}, {id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 4 : i32}, {id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %38 = "neura.data_mov"(%36) {mapping_locs = [{id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 4 : i32}, {id = 320 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 5 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %39 = neura.grant_predicate %37, %38 {mapping_locs = [{id = 10 : i32, resource = "tile", time_step = 6 : i32, x = 2 : i32, y = 2 : i32}]} : !neura.data, !neura.data -> !neura.data -// MAPPING-NEXT: neura.ctrl_mov %39 -> %5 {mapping_locs = [{id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 321 : i32, local_register_id = 1 : i32, resource = "register", time_step = 8 : i32}]} : !neura.data !neura.data -// MAPPING-NEXT: %40 = "neura.data_mov"(%4) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 5 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 7 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 8 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 9 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 10 : i32}, {id = 192 : i32, local_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data -// MAPPING-NEXT: %41 = "neura.data_mov"(%36) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 4 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 5 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 8 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 9 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 10 : i32}, {id = 193 : i32, local_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: neura.ctrl_mov %39 -> %5 {mapping_locs = [{id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 321 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 8 : i32}]} : !neura.data !neura.data +// MAPPING-NEXT: %40 = "neura.data_mov"(%4) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 5 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 6 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 7 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 8 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 9 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 10 : i32}, {id = 192 : i32, per_tile_register_id = 0 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data +// MAPPING-NEXT: %41 = "neura.data_mov"(%36) {mapping_locs = [{id = 33 : i32, resource = "link", time_step = 4 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 5 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 6 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 7 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 8 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 9 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 10 : i32}, {id = 193 : i32, per_tile_register_id = 1 : i32, resource = "register", time_step = 11 : i32}]} : (!neura.data) -> !neura.data // MAPPING-NEXT: %42 = neura.grant_predicate %40, %41 {mapping_locs = [{id = 6 : i32, resource = "tile", time_step = 12 : i32, x = 2 : i32, y = 1 : i32}]} : !neura.data, !neura.data -> !neura.data // MAPPING-NEXT: neura.ctrl_mov %42 -> %2 {mapping_locs = [{id = 20 : i32, resource = "link", time_step = 12 : i32}]} : !neura.data !neura.data // MAPPING-NEXT: "neura.return"() {mapping_locs = [{id = 15 : i32, resource = "tile", time_step = 12 : i32, x = 3 : i32, y = 3 : i32}]} : () -> () From d51e134f783754f4354f79f354628ac914e3f2e8 Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Thu, 23 Oct 2025 00:12:43 -0400 Subject: [PATCH 5/7] Clean up commented FFT conversion rules Remove commented-out FFT-related conversion rules from LlvmToNeuraPass.cpp to keep codebase clean --- .../LlvmToNeura/LlvmToNeuraPass.cpp | 121 ------------------ 1 file changed, 121 deletions(-) diff --git a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp index 711fb94b..8b6fcf82 100644 --- a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp +++ b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp @@ -501,122 +501,6 @@ struct LlvmReturnToNeuraReturn : public OpRewritePattern { } }; -// struct LlvmXOrToNeuraOr : public OpRewritePattern { -// using OpRewritePattern::OpRewritePattern; - -// LogicalResult matchAndRewrite(LLVM::XOrOp op, -// PatternRewriter &rewriter) const override { -// // Gets operands. -// Value lhs = op.getLhs(); -// Value rhs = op.getRhs(); -// Type result_type = op.getType(); - -// // Replaces with neura.or operation. -// rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); -// return success(); -// } -// }; - -// struct LlvmAndToNeuraMul : public OpRewritePattern { -// using OpRewritePattern::OpRewritePattern; - -// LogicalResult matchAndRewrite(LLVM::AndOp op, -// PatternRewriter &rewriter) const override { -// // Gets operands. -// Value lhs = op.getLhs(); -// Value rhs = op.getRhs(); -// Type result_type = op.getType(); - -// // For boolean AND, uses multiplication (a AND b = a * b for boolean values). -// rewriter.replaceOpWithNewOp(op, result_type, lhs, rhs); -// return success(); -// } -// }; - -// struct LlvmFNegToNeuraFSub : public OpRewritePattern { -// using OpRewritePattern::OpRewritePattern; - -// LogicalResult matchAndRewrite(LLVM::FNegOp op, -// PatternRewriter &rewriter) const override { -// // Gets operand. -// Value operand = op.getOperand(); -// Type result_type = op.getType(); -// Location loc = op.getLoc(); - -// // Creates constant 0.0. -// auto zero_attr = rewriter.getFloatAttr(result_type, 0.0); -// auto zero_const = rewriter.create(loc, result_type, zero_attr); - -// // Replaces with 0.0 - operand. -// rewriter.replaceOpWithNewOp(op, result_type, zero_const, operand); -// return success(); -// } -// }; - -// struct LlvmLShrToNeuraShl : public OpRewritePattern { -// using OpRewritePattern::OpRewritePattern; - -// LogicalResult matchAndRewrite(LLVM::LShrOp op, -// PatternRewriter &rewriter) const override { -// // Gets operands. -// Value lhs = op.getLhs(); -// Value rhs = op.getRhs(); -// Type result_type = op.getType(); -// Location loc = op.getLoc(); - -// // Implements logical right shift as left shift with negative amount. -// // lshr(x, n) = shl(x, -n). -// // Creates constant 0. -// auto zero_attr = rewriter.getIntegerAttr(rhs.getType(), 0); -// auto zero_const = rewriter.create(loc, rhs.getType(), zero_attr); - -// // Negates the shift amount: -n = 0 - n. -// auto neg_rhs = rewriter.create(loc, rhs.getType(), zero_const, rhs); - -// // Replaces with shl(lhs, -rhs). -// rewriter.replaceOpWithNewOp(op, result_type, lhs, neg_rhs); -// return success(); -// } -// }; - -// struct LlvmSelectToNeuraOps : public OpRewritePattern { -// using OpRewritePattern::OpRewritePattern; - -// LogicalResult matchAndRewrite(LLVM::SelectOp op, -// PatternRewriter &rewriter) const override { -// // Gets operands: condition, true_value, false_value. -// Value condition = op.getCondition(); -// Value true_value = op.getTrueValue(); -// Value false_value = op.getFalseValue(); -// Type result_type = op.getType(); -// Location loc = op.getLoc(); - -// // Implements: result = condition * true_value + (1 - condition) * false_value. -// // For i1 (boolean), this works perfectly since i1 is 0 or 1. - -// // Step 1: Computes condition * true_value. -// auto cond_times_true = rewriter.create( -// loc, result_type, condition, true_value); - -// // Step 2: Creates constant 1. -// auto one_attr = rewriter.getIntegerAttr(result_type, 1); -// auto one_const = rewriter.create(loc, result_type, one_attr); - -// // Step 3: Computes (1 - condition). -// auto not_condition = rewriter.create( -// loc, result_type, one_const, condition); - -// // Step 4: Computes (1 - condition) * false_value. -// auto not_cond_times_false = rewriter.create( -// loc, result_type, not_condition, false_value); - -// // Step 5: Computes result = cond_times_true + not_cond_times_false. -// rewriter.replaceOpWithNewOp( -// op, result_type, cond_times_true, not_cond_times_false); - -// return success(); -// } -// }; struct FuncReturnToNeuraReturn : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -869,11 +753,6 @@ struct LowerLlvmToNeuraPass patterns.add(&getContext()); patterns.add(&getContext()); patterns.add(&getContext()); - // patterns.add(&getContext()); - // patterns.add(&getContext()); - // patterns.add(&getContext()); - // patterns.add(&getContext()); - // patterns.add(&getContext()); FrozenRewritePatternSet frozen(std::move(patterns)); From dfe15c6f907b618fd5ed13cbec381efc3f8bc93b Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Thu, 23 Oct 2025 12:59:33 -0400 Subject: [PATCH 6/7] Rename Register id to global_id and improve ID assignment logic --- include/NeuraDialect/Architecture/Architecture.h | 2 +- lib/NeuraDialect/Architecture/Architecture.cpp | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/include/NeuraDialect/Architecture/Architecture.h b/include/NeuraDialect/Architecture/Architecture.h index 8724f6ab..0ba944dc 100644 --- a/include/NeuraDialect/Architecture/Architecture.h +++ b/include/NeuraDialect/Architecture/Architecture.h @@ -281,7 +281,7 @@ class Register : public BasicResource { RegisterFile *getRegisterFile() const; private: - int id; + int global_id; int per_tile_id; RegisterFile *register_file; }; diff --git a/lib/NeuraDialect/Architecture/Architecture.cpp b/lib/NeuraDialect/Architecture/Architecture.cpp index 0d042287..11d9298f 100644 --- a/lib/NeuraDialect/Architecture/Architecture.cpp +++ b/lib/NeuraDialect/Architecture/Architecture.cpp @@ -252,9 +252,9 @@ Tile *FunctionUnit::getTile() const { return this->tile; } // Register //===----------------------------------------------------------------------===// -Register::Register(int global_id, int per_tile_id) : id(global_id), per_tile_id(per_tile_id) {} +Register::Register(int global_id, int per_tile_id) : global_id(global_id), per_tile_id(per_tile_id) {} -int Register::getId() const { return id; } +int Register::getId() const { return global_id; } int Register::getPerTileId() const { return per_tile_id; } @@ -343,9 +343,9 @@ void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int const int k_num_regs_per_regfile = 8; // Keep this fixed for now. const int k_num_regfiles_per_cluster = num_registers / k_num_regs_per_regfile; - // If global_id_start is specified, use it instead of the passed reference. + // If global_id_start is specified, ensures it doesn't go backwards. if (global_id_start >= 0) { - num_already_assigned_global_registers = global_id_start; + num_already_assigned_global_registers = std::max(num_already_assigned_global_registers, global_id_start); } RegisterFileCluster *register_file_cluster = new RegisterFileCluster(tile->getId()); From a3b8e9a9cbb7c261500a808ed71ab16a85c0dd79 Mon Sep 17 00:00:00 2001 From: n0thingNoob Date: Thu, 23 Oct 2025 19:53:55 -0400 Subject: [PATCH 7/7] revise the architecture.cpp --- lib/NeuraDialect/Architecture/Architecture.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/lib/NeuraDialect/Architecture/Architecture.cpp b/lib/NeuraDialect/Architecture/Architecture.cpp index 11d9298f..0ce5a6ad 100644 --- a/lib/NeuraDialect/Architecture/Architecture.cpp +++ b/lib/NeuraDialect/Architecture/Architecture.cpp @@ -343,10 +343,8 @@ void Architecture::createRegisterFileCluster(Tile *tile, int num_registers, int const int k_num_regs_per_regfile = 8; // Keep this fixed for now. const int k_num_regfiles_per_cluster = num_registers / k_num_regs_per_regfile; - // If global_id_start is specified, ensures it doesn't go backwards. - if (global_id_start >= 0) { - num_already_assigned_global_registers = std::max(num_already_assigned_global_registers, global_id_start); - } + // Ensures global register IDs are monotonically increasing. + num_already_assigned_global_registers = std::max(num_already_assigned_global_registers, global_id_start); RegisterFileCluster *register_file_cluster = new RegisterFileCluster(tile->getId());