AIETargets.cpp

Go to the documentation of this file.

//===- AIETargets.cpp -------------------------------------------*- C++ -*-===//
//
// Copyright (C) 2021-2022 Xilinx, Inc.
// Copyright (C) 2022-2026 Advanced Micro Devices, Inc.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "aie/Targets/AIETargets.h"
 
#include "aie/Dialect/AIE/IR/AIEDialect.h"
#include "aie/Dialect/AIEVec/IR/AIEVecDialect.h"
#include "aie/Dialect/AIEX/IR/AIEXDialect.h"
#include "aie/Dialect/AIEX/Transforms/AIEXPasses.h"
 
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Index/IR/IndexDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Ptr/IR/PtrOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/UB/IR/UBOps.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/Attributes.h"
#include "mlir/Target/LLVMIR/Export.h"
#include "mlir/Target/LLVMIR/Import.h"
#include "mlir/Tools/mlir-translate/Translation.h"
 
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/JSON.h"
#include "llvm/Support/raw_ostream.h"
 
#include <fstream>
#include <iostream>
#include <set>
 
#define DEBUG_TYPE "aie-targets"
 
using namespace mlir;
using namespace mlir::vector;
using namespace xilinx;
using namespace xilinx::AIE;
 
static llvm::json::Value attrToJSON(Attribute &attr) {
  if (auto a = llvm::dyn_cast<StringAttr>(attr))
    return {a.getValue().str()};
 
  if (auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr)) {
    llvm::json::Array arrayJSON;
    for (auto a : arrayAttr)
      arrayJSON.push_back(attrToJSON(a));
    return llvm::json::Value(std::move(arrayJSON));
  }
 
  if (auto dictAttr = llvm::dyn_cast<DictionaryAttr>(attr)) {
    llvm::json::Object dictJSON;
    for (auto a : dictAttr) {
      auto ident = a.getName();
      auto attr = a.getValue();
      dictJSON[ident.str()] = attrToJSON(attr);
    }
    return llvm::json::Value(std::move(dictJSON));
  }
 
  if (auto intAttr = llvm::dyn_cast<IntegerAttr>(attr))
    return llvm::json::Value(intAttr.getInt());
 
  return llvm::json::Value(std::string(""));
}
 
namespace xilinx::AIE {
 
static void registerDialects(DialectRegistry &registry) {
  registry.insert<xilinx::AIE::AIEDialect>();
  registry.insert<xilinx::AIEX::AIEXDialect>();
  registry.insert<xilinx::aievec::AIEVecDialect>();
  registry.insert<func::FuncDialect>();
  registry.insert<scf::SCFDialect>();
  registry.insert<cf::ControlFlowDialect>();
  registry.insert<DLTIDialect>();
  registry.insert<arith::ArithDialect>();
  registry.insert<affine::AffineDialect>();
  registry.insert<ub::UBDialect>();
  registry.insert<math::MathDialect>();
  registry.insert<memref::MemRefDialect>();
  registry.insert<VectorDialect>();
  registry.insert<LLVM::LLVMDialect>();
  registry.insert<emitc::EmitCDialect>();
  registry.insert<index::IndexDialect>();
  registry.insert<ptr::PtrDialect>();
}
 
// Output the buffer map for the given buffer operations, with the given offset.
// The offset is different depending on where the buffers are accessed from.
static void writeBufferMap(raw_ostream &output, BufferOp buf, int offset) {
  std::string bufName(buf.name().getValue());
  int bufferBaseAddr = getBufferBaseAddress(buf);
  int numBytes = buf.getAllocationSize();
  output << "_symbol " << bufName << " "
         << "0x" << llvm::utohexstr(offset + bufferBaseAddr) << " " << numBytes
         << '\n';
}
 
LogicalResult AIETranslateToTargetArch(ModuleOp module, raw_ostream &output,
                                       llvm::StringRef deviceName) {
  DeviceOp targetOp = AIE::DeviceOp::getForSymbolInModule(module, deviceName);
  AIEArch arch = AIEArch::AIE1;
  if (targetOp) {
    arch = targetOp.getTargetModel().getTargetArch();
  }
  if (arch == AIEArch::AIE1)
    output << "AIE\n";
  else
    output << stringifyEnum(arch) << "\n";
  return success();
}
 
void registerAIETranslations() {
  static llvm::cl::opt<int> tileCol(
      "tilecol", llvm::cl::desc("column coordinate of core to translate"),
      llvm::cl::init(0));
  static llvm::cl::opt<int> tileRow(
      "tilerow", llvm::cl::desc("row coordinate of core to translate"),
      llvm::cl::init(0));
 
  static llvm::cl::opt<std::string> workDirPath(
      "work-dir-path", llvm::cl::Optional,
      llvm::cl::desc("Absolute path to working directory"));
 
  static llvm::cl::opt<bool> bigEndian("big-endian", llvm::cl::init(false),
                                       llvm::cl::desc("Endianness"));
 
  static llvm::cl::opt<bool> cdoUnified(
      "cdo-unified", llvm::cl::init(false),
      llvm::cl::desc("Emit unified CDO bin (or separate bins)"));
  static llvm::cl::opt<bool> cdoDebug("cdo-debug", llvm::cl::init(false),
                                      llvm::cl::desc("Emit cdo debug info"));
  static llvm::cl::opt<bool> cdoAieSim(
      "cdo-aiesim", llvm::cl::init(false),
      llvm::cl::desc("AIESIM target cdo generation"));
  static llvm::cl::opt<bool> cdoXaieDebug(
      "cdo-xaie-debug", llvm::cl::init(false),
      llvm::cl::desc("Emit libxaie debug info"));
  static llvm::cl::opt<size_t> cdoEnableCores(
      "cdo-enable-cores", llvm::cl::init(true),
      llvm::cl::desc("Enable cores in CDO"));
 
  static llvm::cl::opt<bool> outputBinary(
      "aie-output-binary", llvm::cl::init(true),
      llvm::cl::desc(
          "Select binary (true) or text (false) output for supported "
          "translations. e.g. aie-npu-to-binary, aie-ctrlpkt-to-bin"));
  static llvm::cl::opt<bool> npuFoldDDRAddrOffset(
      "aie-npu-fold-ddr-addr-offset", llvm::cl::init(true),
      llvm::cl::desc(
          "For aie-npu-to-binary and aie-npu-to-cpp: fold the AIE "
          "DDR-aperture offset into the arg_plus of DDR address patches for "
          "host arguments beyond the firmware-translated set. Required for "
          "the xclbin + instruction-buffer runtime; must be false for the "
          "full-ELF (xrt.ext.kernel) runtime and for HRX, which translate "
          "every host buffer address themselves."));
  static llvm::cl::opt<bool> npuEmitDispatchShim(
      "aie-npu-emit-dispatch-shim", llvm::cl::init(false),
      llvm::cl::desc(
          "For aie-npu-to-cpp: also emit the extern \"C\" dispatch_abi() and "
          "dispatch_generate() entry points the JIT dispatch bridge loads via "
          "ctypes. Requires exactly one aie.runtime_sequence."));
  static llvm::cl::opt<std::string> deviceName(
      "aie-device-name", llvm::cl::init(""),
      llvm::cl::desc("Specify which device to translate"));
  static llvm::cl::opt<std::string> sequenceName(
      "aie-sequence-name", llvm::cl::init(""),
      llvm::cl::desc(
          "Specify the name of the aiex.runtime_sequence to translate"));
  static llvm::cl::opt<std::string> npuEmitLocmap(
      "aie-npu-emit-locmap", llvm::cl::init(""),
      llvm::cl::value_desc("filename"),
      llvm::cl::desc(
          "For aie-npu-to-binary, also write a JSON sidecar mapping each "
          "transaction word's byte offset to its source MLIR Location (and "
          "regdb register name where applicable) to the given file. The binary "
          "is still emitted to the main output."));
 
  TranslateFromMLIRRegistration registrationMMap(
      "aie-generate-mmap", "Generate AIE memory map",
      [](ModuleOp module, raw_ostream &output) {
        DenseMap<TileID, Operation *> tiles;
        DenseMap<Operation *, SmallVector<BufferOp, 4>> buffers;
 
        DeviceOp targetOp =
            AIE::DeviceOp::getForSymbolInModule(module, deviceName);
        if (!targetOp) {
          module.emitOpError("expected AIE.device operation at toplevel");
        }
 
        collectTiles(targetOp, tiles);
        // sort the tiles for deterministic output
        using tileType = std::pair<TileID, Operation *>;
        struct tileCmp {
          bool operator()(const tileType &lhs, const tileType &rhs) const {
            return lhs.first < rhs.first;
          }
        };
        std::set<tileType, tileCmp> sortedTiles;
        for (auto tile : tiles)
          sortedTiles.insert(tileType{tile.first, tile.second});
 
        collectBuffers(targetOp, buffers);
 
        for (auto tile : sortedTiles) {
          Operation *srcTileOp = tile.second;
          TileID srcCoord = cast<TileOp>(srcTileOp).getTileID();
          int srcCol = srcCoord.col;
          int srcRow = srcCoord.row;
 
          output << "// Tile(" << srcCol << ", " << srcRow << ")\n";
          output << "// Memory map: name base_address num_bytes\n";
 
          auto doBuffer = [&](std::optional<TileID> tile, int offset) {
            if (tiles.count(*tile))
              for (auto buf : buffers[tiles[*tile]])
                writeBufferMap(output, buf, offset);
          };
 
          const auto &targetModel = xilinx::AIE::getTargetModel(srcTileOp);
 
          if (auto tile = targetModel.getMemSouth(srcCoord))
            doBuffer(tile, targetModel.getMemSouthBaseAddress());
          if (auto tile = targetModel.getMemWest(srcCoord))
            doBuffer(tile, targetModel.getMemWestBaseAddress());
          if (auto tile = targetModel.getMemNorth(srcCoord))
            doBuffer(tile, targetModel.getMemNorthBaseAddress());
          if (auto tile = targetModel.getMemEast(srcCoord))
            doBuffer(tile, targetModel.getMemEastBaseAddress());
        }
        return success();
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationShimDMAToJSON(
      "aie-generate-json", "Transform AIE shim DMA allocation info into JSON",
      [](ModuleOp module, raw_ostream &output) {
        DeviceOp d =
            AIE::DeviceOp::getForSymbolInModuleOrError(module, deviceName);
        if (!d) {
          return failure();
        }
        llvm::json::Object moduleJSON;
        for (auto shimDMAMeta : d.getOps<ShimDMAAllocationOp>()) {
          llvm::json::Object shimJSON;
          auto channelDir = shimDMAMeta.getChannelDirAttr();
          shimJSON["channelDir"] = attrToJSON(channelDir);
          auto channelIndex = shimDMAMeta.getChannelIndexAttr();
          shimJSON["channelIndex"] = attrToJSON(channelIndex);
          AIE::TileOp tile = shimDMAMeta.getTileOp();
          if (!tile) {
            shimDMAMeta.emitError(
                "shim DMA allocation must reference a valid TileOp");
            return failure();
          }
          auto col = tile.getColAttr();
          shimJSON["col"] = attrToJSON(col);
          moduleJSON[shimDMAMeta.getSymName()] =
              llvm::json::Value(std::move(shimJSON));
        }
        llvm::json::Value topv(std::move(moduleJSON));
        std::string ret;
        llvm::raw_string_ostream ss(ret);
        ss << llvm::formatv("{0:2}", topv) << "\n";
        output << ss.str();
        return success();
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationLDScript(
      "aie-generate-ldscript", "Generate AIE loader script",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateToLdScript(module, output, tileCol, tileRow,
                                      deviceName);
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationBCF(
      "aie-generate-bcf", "Generate AIE bcf",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateToBCF(module, output, tileCol, tileRow, deviceName);
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationTargetArch(
      "aie-generate-target-arch", "Get the target architecture",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateToTargetArch(module, output, deviceName);
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationCoreList(
      "aie-generate-corelist", "Generate python list of cores",
      [](ModuleOp module, raw_ostream &output) {
        DeviceOp targetOp =
            AIE::DeviceOp::getForSymbolInModule(module, deviceName);
        if (!targetOp) {
          module.emitOpError("expected AIE.device operation at toplevel");
          return failure();
        }
 
        output << "[";
        for (auto tileOp : targetOp.getOps<TileOp>()) {
          int col = tileOp.colIndex();
          int row = tileOp.rowIndex();
          if (auto coreOp = tileOp.getCoreOp()) {
            std::string elfFile = "None";
            if (auto fileAttr = coreOp.getElfFile())
              elfFile = "\"" + fileAttr.value().str() + "\"";
            output << '(' << col << ',' << row << ',' << elfFile << "),";
          }
        }
        output << "]\n";
        return success();
      },
      registerDialects);
 
  TranslateFromMLIRRegistration registrationXAIE(
      "aie-generate-xaie", "Generate libxaie configuration",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateToXAIEV2(module, output, deviceName);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationXJSON(
      "aie-flows-to-json", "Translate AIE flows to JSON",
      [](ModuleOp module, raw_ostream &output) {
        return AIEFlowsToJSON(module, output, deviceName);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationXPE(
      "aie-mlir-to-xpe", "Translate AIE design to XPE file for simulation",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateGraphXPE(module, output, deviceName);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationSCSimConfig(
      "aie-mlir-to-scsim-config",
      "Translate AIE design to SCSimConfig file for simulation",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateSCSimConfig(module, output, deviceName);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationShimSolution(
      "aie-mlir-to-shim-solution",
      "Translate AIE design to ShimSolution file for simulation",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateShimSolution(module, output, deviceName);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationCDODirect(
      "aie-generate-cdo", "Generate libxaie for CDO directly",
      [](ModuleOp module, raw_ostream &) {
        SmallString<128> workDirPath_;
        if (workDirPath.getNumOccurrences() == 0) {
          if (llvm::sys::fs::current_path(workDirPath_))
            llvm::report_fatal_error(
                "couldn't get cwd to use as work-dir-path");
        } else
          workDirPath_ = workDirPath.getValue();
        LLVM_DEBUG(llvm::dbgs() << "work-dir-path: " << workDirPath_ << "\n");
        return AIETranslateToCDODirect(module, workDirPath_.c_str(), deviceName,
                                       bigEndian, cdoUnified, cdoDebug,
                                       cdoAieSim, cdoXaieDebug, cdoEnableCores);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationNPU(
      "aie-npu-to-binary", "Translate npu instructions to binary",
      [](ModuleOp module, raw_ostream &output) {
        std::vector<uint32_t> instructions;
        std::vector<TxnLocEntry> locmap;
        bool emitLocmap = !npuEmitLocmap.empty();
        auto r = AIETranslateNpuToBinary(
            module, instructions, deviceName, sequenceName,
            emitLocmap ? &locmap : nullptr, npuFoldDDRAddrOffset);
        if (failed(r))
          return r;
        // The binary (or hex text) is always emitted to the main output.
        if (outputBinary) {
          output.write(reinterpret_cast<const char *>(instructions.data()),
                       instructions.size() * sizeof(uint32_t));
        } else {
          for (auto w : instructions)
            output << llvm::format("%08X\n", w);
        }
        // With -aie-npu-emit-locmap=<file>, additionally write the JSON
        // location sidecar (mapping each transaction word's byte offset to its
        // source MLIR Location) to that file.
        if (emitLocmap) {
          std::error_code ec;
          llvm::raw_fd_ostream locFile(npuEmitLocmap, ec,
                                       llvm::sys::fs::OF_Text);
          if (ec) {
            llvm::errs() << "Error opening locmap file '" << npuEmitLocmap
                         << "': " << ec.message() << "\n";
            return failure();
          }
          emitNpuLocmapJSON(locFile, deviceName, /*binaryName=*/"", locmap);
        }
        return success();
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationNpuToCpp(
      "aie-npu-to-cpp",
      "Translate npu instructions to a C++ TXN-builder function",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateNpuToCpp(module, output, npuFoldDDRAddrOffset,
                                    npuEmitDispatchShim);
      },
      registerDialects);
  TranslateFromMLIRRegistration registrationCtrlPkt(
      "aie-ctrlpkt-to-bin", "Translate aiex.control_packet ops to binary",
      [](ModuleOp module, raw_ostream &output) {
        std::vector<uint32_t> instructions;
        auto r = AIETranslateControlPacketsToUI32Vec(module, instructions,
                                                     deviceName, sequenceName);
        if (failed(r))
          return r;
        if (outputBinary) {
          output.write(reinterpret_cast<const char *>(instructions.data()),
                       instructions.size() * sizeof(uint32_t));
        } else {
          for (auto w : instructions)
            output << llvm::format("%08X\n", w);
        }
        return success();
      },
      registerDialects);
 
  // Translate cert dialect operations to assembly
  TranslateFromMLIRRegistration registrationCertToAsm(
      "aie-cert-to-asm", "Translate cert operations to assembly",
      [](ModuleOp module, raw_ostream &output) {
        return AIETranslateToUcDma(module, output);
      },
      registerDialects);
}
} // namespace xilinx::AIE