Transition AIETarget to use internal aie2xclbin function

build_tools/ci/print_ir_aie2xclbin/buffers_xclbin.mlir

@@ -72,7 +72,7 @@
 // CHECK:         },
 // CHECK:         "instances": [
 // CHECK:           {
-// CHECK:             "name": "dummy2_0"
+// CHECK:             "name": "IREE"
 // CHECK:           }
 // CHECK:         ],
 // CHECK:         "name": "dummy2_0",

build_tools/ci/print_ir_aie2xclbin/print_ir_aie2xclbin.sh

@@ -131,7 +131,6 @@ ${SOURCE_MLIR_FILE} \
 --aie2xclbin-print-ir-after-all \
 --aie2xclbin-print-ir-before-all \
 --aie2xclbin-print-ir-module-scope \
---aie2xclbin-disable-threading \
 --aie2xclbin-timing \
 --mlir-print-ir-after-all \
 --mlir-print-ir-module-scope \

compiler/plugins/target/AMD-AIE/aie/CMakeLists.txt

@@ -313,4 +313,28 @@ iree_cc_library(
     ::AIETransformPassesIncGen
 )
 
+iree_cc_library(
+  NAME
+    AIEPassesFromMLIRAIE
+  SRCS
+    # Passes needed by AIR-AIE lowering
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIEObjectFifoStatefulTransform.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIEAssignLockIDs.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIEObjectFifoRegisterProcess.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIEAssignBufferDescriptorIDs.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIEX/Transforms/AIECreateBroadcastPacket.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIECreatePacketFlows.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIENormalizeAddressSpaces.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIECanonicalizeDevice.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIEX/Transforms/AIELowerMulticast.cpp"
+    "${IREE_MLIR_AIE_SOURCE_DIR}/lib/Dialect/AIE/Transforms/AIEAssignBuffers.cpp"
+  DEPS
+    ::defs
+    ::AIEDialectIR
+    ::AIENormalizeAddressSpacesGen
+    ::AIEXDialectIR
+    ::AIEXTransformPassesIncGen
+    ::AIETransformPassesIncGen
+)
+
 add_subdirectory(test)

compiler/plugins/target/AMD-AIE/iree-amd-aie/Target/AIETarget.cpp

@@ -8,23 +8,42 @@
 
 #include <fstream>
 
+#include "XCLBinGen.h"
 #include "aie/Dialect/AIE/IR/AIEDialect.h"
+#include "aie/Dialect/AIE/Transforms/AIEPasses.h"
+#include "aie/Dialect/AIEVec/IR/AIEVecDialect.h"
 #include "aie/Dialect/AIEX/IR/AIEXDialect.h"
+#include "aie/Dialect/XLLVM/XLLVMDialect.h"
+#include "aie/Passes.h"
+#include "aie/Target/LLVMIR/Dialect/XLLVM/XLLVMToLLVMIRTranslation.h"
 #include "air/Dialect/AIR/AIRDialect.h"
 #include "air/Dialect/AIRRt/AIRRtDialect.h"
 #include "iree-amd-aie/IR/AMDAIEDialect.h"
 #include "iree-amd-aie/Transforms/Passes.h"
+#include "iree-dialects/Dialect/LinalgTransform/Passes.h"
 #include "iree/compiler/Codegen/Dialect/Codegen/IR/IREECodegenDialect.h"
 #include "iree/compiler/Dialect/HAL/Target/TargetRegistry.h"
 #include "iree/compiler/Dialect/LinalgExt/IR/LinalgExtDialect.h"
 #include "iree/compiler/Utils/FlatbufferUtils.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Program.h"
+#include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
+#include "mlir/Conversion/Passes.h"
+#include "mlir/Dialect/DLTI/DLTI.h"
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
+#include "mlir/Dialect/Func/Extensions/AllExtensions.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
+#include "mlir/Dialect/Vector/IR/VectorOps.h"
+#include "mlir/Parser/Parser.h"
+#include "mlir/Pass/PassManager.h"
 #include "mlir/Support/FileUtilities.h"
+#include "mlir/Target/LLVMIR/Dialect/All.h"
+#include "mlir/Target/LLVMIR/Export.h"
 #include "runtime/plugins/AMD-AIE/iree-amd-aie/schemas/xrt_executable_def_builder.h"
 
 #define DEBUG_TYPE "aie-target"
@@ -136,12 +155,27 @@ class AIETargetBackend final : public IREE::HAL::TargetBackend {
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<mlir::iree_compiler::AMDAIE::AMDAIEDialect,
-                    mlir::iree_compiler::IREE::Codegen::IREECodegenDialect,
-                    IREE::LinalgExt::IREELinalgExtDialect,
-                    transform::TransformDialect, xilinx::AIE::AIEDialect,
-                    xilinx::AIEX::AIEXDialect, xilinx::air::airDialect,
-                    xilinx::airrt::AIRRtDialect>();
+    registry.insert<
+        mlir::iree_compiler::AMDAIE::AMDAIEDialect,
+        mlir::iree_compiler::IREE::Codegen::IREECodegenDialect,
+        IREE::LinalgExt::IREELinalgExtDialect, transform::TransformDialect,
+        xilinx::AIE::AIEDialect, xilinx::AIEX::AIEXDialect,
+        xilinx::air::airDialect, xilinx::airrt::AIRRtDialect,
+        xilinx::xllvm::XLLVMDialect, xilinx::aievec::AIEVecDialect,
+        emitc::EmitCDialect, LLVM::LLVMDialect, func::FuncDialect,
+        cf::ControlFlowDialect, DLTIDialect, arith::ArithDialect,
+        memref::MemRefDialect, math::MathDialect, vector::VectorDialect>();
+
+    registerBuiltinDialectTranslation(registry);
+    registerLLVMDialectTranslation(registry);
+    xilinx::xllvm::registerXLLVMDialectTranslation(registry);
+    arith::registerConvertArithToLLVMInterface(registry);
+    cf::registerConvertControlFlowToLLVMInterface(registry);
+    func::registerAllExtensions(registry);
+    registerConvertFuncToLLVMInterface(registry);
+    index::registerConvertIndexToLLVMInterface(registry);
+    registerConvertMathToLLVMInterface(registry);
+    registerConvertMemRefToLLVMInterface(registry);
   }
 
   void buildTranslationPassPipeline(IREE::HAL::ExecutableTargetAttr,
@@ -205,7 +239,6 @@ LogicalResult AIETargetBackend::serializeExecutable(
 
   if (failed(maybeWorkDir)) return failure();
   auto workDir = maybeWorkDir.value();
-
   // collect names of kernels as they need to be in kernels.json
   // generated by `aie2xclbin`
   SmallVector<std::string> entryPointNames;
@@ -251,8 +284,6 @@ LogicalResult AIETargetBackend::serializeExecutable(
     return moduleOp.emitOpError("should contain some entry points");
   }
 
-  SmallString<128> aie2xclbin(options.mlirAieInstallDir);
-  llvm::sys::path::append(aie2xclbin, "bin", "aie2xclbin");
   std::unique_ptr<llvm::MemoryBuffer> xclbinIn;
 
   FlatbufferBuilder builder;
@@ -293,68 +324,52 @@ LogicalResult AIETargetBackend::serializeExecutable(
     SmallString<128> entryPointWorkDir(workDir);
     if (ordinalCount > 1)
       llvm::sys::path::append(entryPointWorkDir, entryPointNamesFb[ordinal]);
+    auto err = llvm::sys::fs::create_directories(entryPointWorkDir);
+    if (err)
+      return moduleOp.emitOpError()
+             << "failed to create working directory for xclbin generation: "
+             << err.message();
+    llvm::outs().flush();
     SmallString<128> xclbinPath(entryPointWorkDir);
     llvm::sys::path::append(xclbinPath, entryPointNamesFb[ordinal] + ".xclbin");
     SmallString<128> npuInstPath(entryPointWorkDir);
     llvm::sys::path::append(npuInstPath,
                             entryPointNamesFb[ordinal] + ".npu.txt");
 
-    SmallVector<StringRef> cmdArgs{aie2xclbin,
-                                   inputMlirPath,
-                                   "--peano",
-                                   options.peanoInstallDir,
-                                   "--xclbin-name",
-                                   xclbinPath,
-                                   "--npu-insts-name",
-                                   npuInstPath,
-                                   "--xclbin-kernel-name",
-                                   entryPointNamesFb[ordinal],
-                                   "--tmpdir",
-                                   entryPointWorkDir};
-
-    auto addOpt = [&](StringRef arg, bool value) {
-      if (value) cmdArgs.push_back(arg);
-    };
-    addOpt("--use-chess", options.useChess);
-    addOpt("-v", options.showInvokedCommands);
-    addOpt("--print-ir-after-all", options.aie2xclbinPrintIrAfterAll);
-    addOpt("--print-ir-before-all", options.aie2xclbinPrintIrBeforeAll);
-    addOpt("--disable-threading", options.aie2xclbinDisableTheading);
-    addOpt("--print-ir-module-scope", options.aie2xclbinPrintIrModuleScope);
-    addOpt("--timing", options.aie2xclbinTiming);
-
-    SmallVector<std::string> cmdEnv{};
-    if (options.useChess) {
-      std::string newVitis = "VITIS=" + options.vitisInstallDir;
-      cmdEnv.push_back(newVitis);
-    }
-
-    if (const char *originalPath = ::getenv("PATH")) {
-      std::string newPath = "PATH=" + std::string(originalPath);
-      cmdEnv.push_back(newPath);
-    }
-
-    // Chess (if used) will look here for the AIEbuild license.
-    if (const char *originalHome = ::getenv("HOME")) {
-      std::string newHome = std::string("HOME=") + std::string(originalHome);
-      cmdEnv.push_back(newHome);
-    }
-
-    if (options.showInvokedCommands) {
-      for (auto s : cmdEnv) llvm::dbgs() << s << " ";
-      for (auto s : cmdArgs) llvm::dbgs() << s << " ";
-      llvm::dbgs() << "\n";
-    }
-
-    {
-      SmallVector<StringRef> cmdEnvRefs{cmdEnv.begin(), cmdEnv.end()};
-      int result = llvm::sys::ExecuteAndWait(cmdArgs[0], cmdArgs, cmdEnvRefs,
-                                             {}, 0, 0, &errorMessage);
-      if (result != 0)
-        return moduleOp.emitOpError()
-               << "Failed to produce an XCLBin with external tool: "
-               << errorMessage;
-    }
+    xilinx::XCLBinGenConfig TK;
+    TK.PrintIRAfterAll = options.aie2xclbinPrintIrAfterAll;
+    TK.PrintIRBeforeAll = options.aie2xclbinPrintIrBeforeAll;
+    TK.PrintIRModuleScope = options.aie2xclbinPrintIrModuleScope;
+    TK.Timing = options.aie2xclbinTiming;
+    TK.TargetArch = "AIE2";
+    TK.TempDir = entryPointWorkDir.str();
+    TK.UseChess = options.useChess;
+    TK.Verbose = options.showInvokedCommands;
+    // The instance name is appended to the kernel name so we dont want it to be
+    // something too long.
+    TK.XCLBinInstanceName = "IREE";
+
+    // Convert ordinal to hexadecimal string for xclbin kernel id.
+    std::stringstream ordinalHex;
+    ordinalHex << "0x" << std::hex << ordinal;
+    TK.XCLBinKernelID = ordinalHex.str();
+    TK.XCLBinKernelName = entryPointNamesFb[ordinal];
+
+    SmallString<64> aieToolsDir(options.vitisInstallDir);
+    llvm::sys::path::append(aieToolsDir, "aietools");
+    TK.AIEToolsDir = aieToolsDir.str();
+    TK.InstallDir = options.mlirAieInstallDir;
+    TK.PeanoDir = options.peanoInstallDir;
+
+    ParserConfig pcfg(variantOp->getContext());
+    llvm::SourceMgr srcMgr;
+
+    OwningOpRef<ModuleOp> owningModuleOp =
+        parseSourceFile<ModuleOp>(inputMlirPath, srcMgr, pcfg);
+
+    if (failed(aie2xclbin(variantOp->getContext(), *owningModuleOp, TK, npuInstPath,
+                          xclbinPath)))
+      return failure();
 
     std::ifstream instrFile(static_cast<std::string>(npuInstPath));
     std::string line;

compiler/plugins/target/AMD-AIE/iree-amd-aie/Target/AIETarget.h

@@ -38,9 +38,6 @@ struct AMDAIEOptions {
   // Print IR before all MLIR passes run in aie2xclbin (to stderr).
   bool aie2xclbinPrintIrBeforeAll{false};
 
-  // Disable theading in MLIR passes in aie2xclbin.
-  bool aie2xclbinDisableTheading{false};
-
   // Print IR at module scope in MLIR passes in aie2xclbin.
   bool aie2xclbinPrintIrModuleScope{false};
 
@@ -73,11 +70,6 @@ struct AMDAIEOptions {
         llvm::cl::desc(
             "If true, print the IR before all MLIR passes run in aie2xclbin"));
 
-    binder.opt<bool>(
-        "aie2xclbin-disable-threading", aie2xclbinDisableTheading,
-        llvm::cl::cat(category),
-        llvm::cl::desc("Disable theading in MLIR passes in aie2xclbin"));
-
     binder.opt<bool>(
         "aie2xclbin-print-ir-module-scope", aie2xclbinPrintIrModuleScope,
         llvm::cl::cat(category),

compiler/plugins/target/AMD-AIE/iree-amd-aie/Target/AIETargetDirect.cpp

@@ -287,6 +287,10 @@ LogicalResult AIETargetDirectBackend::serializeExecutable(
   }
   uint64_t ordinalCount = entryPointOrdinals.size();
 
+  if (entryPointNames.empty()) {
+    return moduleOp.emitOpError("should contain some entry points");
+  }
+
   std::unique_ptr<llvm::MemoryBuffer> xclbinIn;
 
   FlatbufferBuilder builder;
@@ -334,15 +338,17 @@ LogicalResult AIETargetDirectBackend::serializeExecutable(
                             entryPointNamesFb[ordinal] + ".npu.txt");
 
     xilinx::XCLBinGenConfig TK;
-    TK.DisableThreading = options.aie2xclbinDisableTheading;
     TK.PrintIRAfterAll = options.aie2xclbinPrintIrAfterAll;
     TK.PrintIRBeforeAll = options.aie2xclbinPrintIrBeforeAll;
     TK.PrintIRModuleScope = options.aie2xclbinPrintIrModuleScope;
+    TK.Timing = options.aie2xclbinTiming;
     TK.TargetArch = "AIE2";
     TK.TempDir = entryPointWorkDir.str();
     TK.UseChess = options.useChess;
     TK.Verbose = options.showInvokedCommands;
-    TK.XCLBinInstanceName = entryPointNamesFb[ordinal];
+    // The instance name is appended to the kernel name so we dont want it to be
+    // something too long.
+    TK.XCLBinInstanceName = "IREE";
 
     // Convert ordinal to hexadecimal string for xclbin kernel id.
     std::stringstream ordinalHex;

compiler/plugins/target/AMD-AIE/iree-amd-aie/Target/CMakeLists.txt

@@ -24,6 +24,7 @@ iree_cc_library(
     iree::target::amd-aie::aie::AIEDialectIR
     iree::target::amd-aie::aie::AIEXDialectIR
     iree::target::amd-aie::aie::AIEPasses
+    iree::target::amd-aie::aie::AIEPassesFromMLIRAIE
     iree::target::amd-aie::aie::AIEVecDialectIR
     iree::target::amd-aie::aie::AIEVecConvertToLLVM
     MLIRToLLVMIRTranslationRegistration

compiler/plugins/target/AMD-AIE/iree-amd-aie/Target/XCLBinGen.cpp

@@ -12,6 +12,7 @@
 
 #include "AMDAIETargets.h"
 #include "aie/Conversion/AIEVecToLLVM/AIEVecToLLVM.h"
+#include "aie/Dialect/AIE/Transforms/AIEPasses.h"
 #include "aie/Dialect/AIEVec/Pipelines/Passes.h"
 #include "aie/Passes.h"
 #include "aie/Targets/AIETargets.h"
@@ -56,8 +57,6 @@ namespace {
 // manager. These control when (if ever) and what IR gets printed between
 // passes, and whether the pass manager uses multi-theading.
 void applyConfigToPassManager(XCLBinGenConfig &TK, PassManager &pm) {
-  pm.getContext()->disableMultithreading(TK.DisableThreading);
-
   bool printBefore = TK.PrintIRBeforeAll;
   auto shouldPrintBeforePass = [printBefore](Pass *, Operation *) {
     return printBefore;
@@ -686,6 +685,8 @@ static LogicalResult generateUnifiedObject(MLIRContext *context,
 
   pm.addNestedPass<AIE::DeviceOp>(
       mlir::iree_compiler::AMDAIE::createAIELocalizeLocksPass());
+  pm.addNestedPass<AIE::DeviceOp>(
+      xilinx::AIE::createAIENormalizeAddressSpacesPass());
   pm.addPass(mlir::iree_compiler::AMDAIE::createAIECoreToStandardPass());
   pm.addPass(mlir::iree_compiler::AMDAIE::createAIEXToStandardPass());
 

compiler/plugins/target/AMD-AIE/iree-amd-aie/Transforms/CMakeLists.txt

@@ -95,6 +95,7 @@ iree_cc_library(
     iree::compiler::Dialect::LinalgExt::IR
     iree::compiler::Dialect::LinalgExt::Transforms
     iree::compiler::Utils
+    iree::target::amd-aie::aie::AIEPassesFromMLIRAIE
     iree::target::amd-aie::air::AIRConversionPasses
     iree::target::amd-aie::air::AIRTransformPasses
     IREELinalgTransformDialectPasses

compiler/plugins/target/AMD-AIE/iree-amd-aie/Transforms/Passes.cpp

@@ -6,6 +6,9 @@
 
 #include "iree-amd-aie/Transforms/Passes.h"
 
+#include "aie/Dialect/AIE/Transforms/AIEPasses.h"
+#include "aie/Dialect/AIEX/Transforms/AIEXPasses.h"
+#include "aie/Passes.h"
 #include "air/Conversion/Passes.h"
 #include "air/Transform/Passes.h"
 #include "iree-amd-aie/IR/AMDAIEAttrs.h"
@@ -14,6 +17,8 @@
 #include "iree/compiler/Codegen/Common/Passes.h"
 #include "iree/compiler/Dialect/LinalgExt/Transforms/Passes.h"
 #include "iree/compiler/Utils/PassUtils.h"
+#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
+#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/Passes.h"
@@ -581,6 +586,19 @@ void addMLIRAIRAIELoweringPasses(OpPassManager &passManager, bool packPeel) {
 
   passManager.addPass(xilinx::airrt::createAIRRtToNpuPass());
   passManager.addPass(createCanonicalizerPass());
+
+  // Now lower using the AIE passes used by the mlir-air/mlir-aie flow.
+  passManager.addPass(createLowerAffinePass());
+  OpPassManager &devicePM = passManager.nest<xilinx::AIE::DeviceOp>();
+  devicePM.addPass(xilinx::AIE::createAIEAssignLockIDsPass());
+  devicePM.addPass(xilinx::AIE::createAIEObjectFifoRegisterProcessPass());
+  devicePM.addPass(xilinx::AIE::createAIEObjectFifoStatefulTransformPass());
+  devicePM.addPass(xilinx::AIE::createAIEAssignBufferDescriptorIDsPass());
+  devicePM.addPass(xilinx::AIEX::createAIEBroadcastPacketPass());
+  devicePM.addPass(xilinx::AIE::createAIERoutePacketFlowsPass());
+  devicePM.addPass(xilinx::AIEX::createAIELowerMulticastPass());
+  devicePM.addPass(xilinx::AIE::createAIEAssignBufferAddressesPass());
+  passManager.addPass(createConvertSCFToCFPass());
 }
 
 // NOTE: this runs on the top-level program module containing all hal.executable