AIETargetBCF.cpp

Go to the documentation of this file.

//===- AIETargetBCF.cpp -----------------------------------------*- C++ -*-===//
//
// Copyright (C) 2023 Advanced Micro Devices, Inc.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "aie/Dialect/AIE/IR/AIECoreSymbols.h"
#include "aie/Dialect/AIE/IR/AIEDialect.h"
#include "aie/Dialect/AIEX/IR/AIEXDialect.h"
#include "aie/Targets/AIETargets.h"
 
#include "mlir/IR/IRMapping.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Tools/mlir-translate/MlirTranslateMain.h"
 
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Module.h"
 
using namespace mlir;
using namespace xilinx;
using namespace xilinx::AIE;
using namespace xilinx::AIEX;
 
static std::string utohexstr(uint32_t u) { return "0x" + llvm::utohexstr(u); }
 
namespace xilinx {
namespace AIE {
 
LogicalResult AIETranslateToBCF(ModuleOp module, raw_ostream &output,
                                int tileCol, int tileRow,
                                llvm::StringRef deviceName) {
  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);
  collectBuffers(targetOp, buffers);
 
  // _entry_point _main_init
  // _symbol      _main _after _main_init
  // _symbol      _main_init 0
  // _reserved DMb      0x00000 0x20000
  // _symbol   a        0x38000 0x2000
  // _extern   a
  // _stack    DM_stack 0x20000  0x400 //stack for core
  // _reserved DMb 0x40000 0xc0000 // And everything else the core can't
  // see
  // // Include all symbols from rom.c
  // _include _file rom.o
  for (auto tile : targetOp.getOps<TileOp>())
    if (tile.colIndex() == tileCol && tile.rowIndex() == tileRow) {
      const auto &targetModel = getTargetModel(tile);
      TileID srcCoord = {tile.colIndex(), tile.rowIndex()};
 
      std::string corefunc = coreFrameSymbolName(tile.getCol(), tile.getRow());
      output << "_entry_point _main_init\n";
      output << "_symbol " << corefunc << " _after _main_init\n";
      output << "_symbol _main_init 0\n";
      int dataMemoryStart = targetModel.getMemSouthBaseAddress();
      output << "_reserved DMb 0x00000 " << utohexstr(dataMemoryStart)
             << " // Don't put data in code memory\n";
 
      MemoryRun stackRun;
      if (auto core = tile.getCoreOp()) {
        if (core.getStackBank() && !core.getStackAddress())
          return core.emitOpError(
              "stack_bank has no assigned stack_address; run "
              "--aie-assign-buffer-addresses with bank-aware allocation");
        stackRun = core.getStackRun();
      }
      output << "_stack DM_stack "
             << utohexstr(targetModel.getMemInternalBaseAddress(srcCoord) +
                          stackRun.start)
             << " " << utohexstr(stackRun.size) << " // stack for core\n";
 
      auto doBuffer = [&](std::optional<TileID> tile, int offset,
                          const std::string &dir) {
        if (tile) {
          output << "// " + dir +
 
                        " -------------------------------------------------\n";
          uint32_t localMemSize = targetModel.getLocalMemorySize();
          if (tile != srcCoord)
            output << "_reserved DMb " << utohexstr(offset) << " "
                   << utohexstr(localMemSize) << " "
                   << " // Don't allocate variables in " << dir
                   << " neighbor\n\n";
          // TODO How to set as reserved if no buffer exists (or reserve
          // remaining buffer)
          if (tiles.count(*tile)) {
            for (auto buf : buffers[tiles[*tile]]) {
              if (buf.getCoreData())
                continue;
              std::string bufName(buf.name().getValue());
              int bufferBaseAddr = getBufferBaseAddress(buf);
              int numBytes = buf.getAllocationSize();
              // Every buffer is an external symbol at a reserved address,
              // whether or not it has an `initial_value`. No core object
              // defines a buffer, so there is no data here to overlay. Whoever
              // configures the device writes the initial value.
              output << "_symbol " << bufName << " "
                     << utohexstr(offset + bufferBaseAddr) << " " << numBytes
                     << '\n';
              output << "_extern " << bufName << "\n";
              output << "_reserved DMb " << utohexstr(offset + bufferBaseAddr)
                     << " " << numBytes << '\n';
              output << "\n";
            }
          }
        } else {
          uint32_t localMemSize = targetModel.getLocalMemorySize();
          output << "_reserved DMb " << utohexstr(offset) << " "
                 << utohexstr(localMemSize) << " "
                 << " // No tile with memory exists to the " << dir << ".\n";
        }
      };
 
      output << "\n// mapping neighbors tile memory\n";
      doBuffer(targetModel.getMemSouth(srcCoord),
               targetModel.getMemSouthBaseAddress(), std::string("south"));
      doBuffer(targetModel.getMemWest(srcCoord),
               targetModel.getMemWestBaseAddress(), std::string("west"));
      doBuffer(targetModel.getMemNorth(srcCoord),
               targetModel.getMemNorthBaseAddress(), std::string("north"));
      doBuffer(targetModel.getMemEast(srcCoord),
               targetModel.getMemEastBaseAddress(), std::string("east"));
      output << "// end mapping neighbors tile memory\n\n";
 
      int addressSpaceSize = targetModel.getCoreDataAddressSpaceSize();
      int dataMemoryEnd = targetModel.getMemEastBaseAddress() +
                          targetModel.getLocalMemorySize();
      output << "_reserved DMb " << utohexstr(dataMemoryEnd) << " "
             << utohexstr(addressSpaceSize - dataMemoryEnd)
             << " // And everything else the core can't see\n";
 
      if (auto coreOp = tile.getCoreOp()) {
        // `link_files` holds the final-link inputs (object files)
        if (auto filesAttr = coreOp.getLinkFiles()) {
          // Canonical path: link_files populated by aie-assign-core-link-files.
          for (auto f : filesAttr->getAsRange<mlir::StringAttr>())
            output << "_include _file " << f.getValue() << "\n";
        } else if (auto linkWith = coreOp.getLinkWith()) {
          // Deprecated fallback: core-level link_with was not migrated by
          // aie-assign-core-link-files (e.g., the pass was not run). It carries
          // no mode, so it is always an ordinary link input.
          output << "_include _file " << linkWith->str() << "\n";
        }
      }
      output << "_resolve _main core_" << tile.getCol() << "_" << tile.getRow()
             << "\n";
    }
 
  return success();
}
} // namespace AIE
} // namespace xilinx