Rename in-tree AIE passes to AMDAIE

Author: makslevental

compiler/plugins/target/AMD-AIE/aie/AIEAssignBufferAddressesBasic.cpp renamed to compiler/plugins/target/AMD-AIE/aie/AMDAIEAssignBufferAddressesBasic.cpp

@@ -10,39 +10,30 @@
 #include "mlir/IR/Attributes.h"
 #include "mlir/Pass/Pass.h"
 
-#define DEBUG_TYPE "aie-assign-buffers-basic"
+#define DEBUG_TYPE "amdaie-assign-buffers-basic"
 
 using namespace mlir;
-using namespace xilinx;
 using namespace xilinx::AIE;
 
 namespace mlir::iree_compiler::AMDAIE {
-struct AIEAssignBufferAddressesPassBasic : mlir::OperationPass<DeviceOp> {
+struct AMDAIEAssignBufferAddressesPassBasic : mlir::OperationPass<DeviceOp> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
-      AIEAssignBufferAddressesPassBasic)
+      AMDAIEAssignBufferAddressesPassBasic)
 
-  AIEAssignBufferAddressesPassBasic()
+  AMDAIEAssignBufferAddressesPassBasic()
       : mlir::OperationPass<DeviceOp>(resolveTypeID()) {}
-  AIEAssignBufferAddressesPassBasic(
-      const AIEAssignBufferAddressesPassBasic &other)
-      : mlir::OperationPass<DeviceOp>(other) {}
 
   llvm::StringRef getArgument() const override {
-    return "aie-assign-buffer-addresses-basic";
+    return "amdaie-assign-buffer-addresses-basic";
   }
 
   llvm::StringRef getName() const override {
-    return "AIEAssignBufferAddressesBasic";
+    return "AMDAIEAssignBufferAddressesBasic";
   }
 
   std::unique_ptr<mlir::Pass> clonePass() const override {
-    return std::make_unique<AIEAssignBufferAddressesPassBasic>(
-        *static_cast<const AIEAssignBufferAddressesPassBasic *>(this));
-  }
-
-  void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<func::FuncDialect>();
-    registry.insert<AIEDialect>();
+    return std::make_unique<AMDAIEAssignBufferAddressesPassBasic>(
+        *static_cast<const AMDAIEAssignBufferAddressesPassBasic *>(this));
   }
 
   void runOnOperation() override {
@@ -86,7 +77,7 @@ struct AIEAssignBufferAddressesPassBasic : mlir::OperationPass<DeviceOp> {
 
 std::unique_ptr<OperationPass<DeviceOp>>
 createAIEAssignBufferAddressesBasicPass() {
-  return std::make_unique<AIEAssignBufferAddressesPassBasic>();
+  return std::make_unique<AMDAIEAssignBufferAddressesPassBasic>();
 }
 
 void registerAIEAssignBufferAddressesBasic() {

compiler/plugins/target/AMD-AIE/aie/AIEAssignBufferDescriptorIDs.cpp renamed to compiler/plugins/target/AMD-AIE/aie/AMDAIEAssignBufferDescriptorIDs.cpp

@@ -10,22 +10,14 @@
 #include "aie/Dialect/AIE/IR/AIEDialect.h"
 #include "mlir/Pass/Pass.h"
 
-#define DEBUG_TYPE "aie-assign-bd-ids"
+#define DEBUG_TYPE "amdaie-assign-bd-ids"
 #define EVEN_BD_ID_START 0
 #define ODD_BD_ID_START 24
 
 using namespace mlir;
 using namespace xilinx;
 using namespace xilinx::AIE;
 
-#define GEN_PASS_DECL_AIEASSIGNBUFFERDESCRIPTORIDS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DECL_AIEASSIGNBUFFERDESCRIPTORIDS
-
-#define GEN_PASS_DEF_AIEASSIGNBUFFERDESCRIPTORIDS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DEF_AIEASSIGNBUFFERDESCRIPTORIDS
-
 struct BdIdGenerator {
   BdIdGenerator(int col, int row, const AIETargetModel &targetModel)
       : col(col), row(row), isMemTile(targetModel.isMemTile(col, row)) {}
@@ -55,9 +47,26 @@ struct BdIdGenerator {
 
 namespace mlir::iree_compiler::AMDAIE {
 
-struct AIEAssignBufferDescriptorIDsPass
-    : ::impl::AIEAssignBufferDescriptorIDsBase<
-          AIEAssignBufferDescriptorIDsPass> {
+struct AMDAIEAssignBufferDescriptorIDsPass : mlir::OperationPass<DeviceOp> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      AMDAIEAssignBufferDescriptorIDsPass)
+
+  AMDAIEAssignBufferDescriptorIDsPass()
+      : mlir::OperationPass<DeviceOp>(resolveTypeID()) {}
+
+  llvm::StringRef getArgument() const override {
+    return "amdaie-assign-bd-ids";
+  }
+
+  llvm::StringRef getName() const override {
+    return "AMDAIEAssignBufferDescriptorIDsPass";
+  }
+
+  std::unique_ptr<mlir::Pass> clonePass() const override {
+    return std::make_unique<AMDAIEAssignBufferDescriptorIDsPass>(
+        *static_cast<const AMDAIEAssignBufferDescriptorIDsPass *>(this));
+  }
+
   void runOnOperation() override {
     DeviceOp targetOp = getOperation();
     const AIETargetModel &targetModel = targetOp.getTargetModel();
@@ -134,7 +143,7 @@ struct AIEAssignBufferDescriptorIDsPass
 
 std::unique_ptr<OperationPass<DeviceOp>>
 createAIEAssignBufferDescriptorIDsPass() {
-  return std::make_unique<AIEAssignBufferDescriptorIDsPass>();
+  return std::make_unique<AMDAIEAssignBufferDescriptorIDsPass>();
 }
 
 void registerAIEAssignBufferDescriptorIDs() {

compiler/plugins/target/AMD-AIE/aie/AIEAssignLockIDs.cpp renamed to compiler/plugins/target/AMD-AIE/aie/AMDAIEAssignLockIDs.cpp

@@ -16,26 +16,27 @@
 #include "llvm/ADT/DenseMap.h"
 #include "mlir/Pass/Pass.h"
 
-#define DEBUG_TYPE "aie-assign-lock-ids"
+#define DEBUG_TYPE "amdaie-assign-lock-ids"
 
 using namespace mlir;
 using namespace xilinx;
 using namespace xilinx::AIE;
 
-#define GEN_PASS_DECL_AIEASSIGNLOCKIDS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DECL_AIEASSIGNLOCKIDS
+namespace mlir::iree_compiler::AMDAIE {
+struct AMDAIEAssignLockIDsPass : mlir::OperationPass<DeviceOp> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AMDAIEAssignLockIDsPass)
 
-#define GEN_PASS_DEF_AIEASSIGNLOCKIDS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DEF_AIEASSIGNLOCKIDS
+  AMDAIEAssignLockIDsPass() : mlir::OperationPass<DeviceOp>(resolveTypeID()) {}
 
-namespace mlir::iree_compiler::AMDAIE {
-struct AIEAssignLockIDsPass
-    : ::impl::AIEAssignLockIDsBase<AIEAssignLockIDsPass> {
-  void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<func::FuncDialect>();
-    registry.insert<AIEDialect>();
+  llvm::StringRef getArgument() const override {
+    return "amdaie-assign-lock-ids";
+  }
+
+  llvm::StringRef getName() const override { return "AMDAIEAssignLockIDsPass"; }
+
+  std::unique_ptr<mlir::Pass> clonePass() const override {
+    return std::make_unique<AMDAIEAssignLockIDsPass>(
+        *static_cast<const AMDAIEAssignLockIDsPass *>(this));
   }
 
   void runOnOperation() override {
@@ -103,7 +104,7 @@ struct AIEAssignLockIDsPass
   }
 };
 std::unique_ptr<OperationPass<DeviceOp>> createAIEAssignLockIDsPass() {
-  return std::make_unique<AIEAssignLockIDsPass>();
+  return std::make_unique<AMDAIEAssignLockIDsPass>();
 }
 
 void registerAIEAssignLockIDs() {

compiler/plugins/target/AMD-AIE/aie/AIECoreToStandard.cpp renamed to compiler/plugins/target/AMD-AIE/aie/AMDAIECoreToStandard.cpp

@@ -20,19 +20,13 @@
 #include "mlir/Tools/mlir-translate/MlirTranslateMain.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+#define DEBUG_TYPE "amdaie-standard-lowering"
+
 using namespace mlir;
 using namespace mlir::vector;
 using namespace xilinx;
 using namespace xilinx::AIE;
 
-#define GEN_PASS_DECL_AIECORETOSTANDARD
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DECL_AIECORETOSTANDARD
-
-#define GEN_PASS_DEF_AIECORETOSTANDARD
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DEF_AIECORETOSTANDARD
-
 struct AIEUseLockToStdLowering : OpConversionPattern<UseLockOp> {
   using OpConversionPattern::OpConversionPattern;
   LogicalResult matchAndRewrite(
@@ -181,8 +175,41 @@ void outlineOps(DeviceOp device) {
 }
 
 namespace mlir::iree_compiler::AMDAIE {
-struct AIECoreToStandardPass
-    : ::impl::AIECoreToStandardBase<AIECoreToStandardPass> {
+struct AMDAIECoreToStandardPass : mlir::OperationPass<ModuleOp> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AMDAIECoreToStandardPass)
+
+  AMDAIECoreToStandardPass() : mlir::OperationPass<ModuleOp>(resolveTypeID()) {}
+  AMDAIECoreToStandardPass(const AMDAIECoreToStandardPass &other)
+      : mlir::OperationPass<mlir::ModuleOp>(other) {}
+
+  llvm::StringRef getArgument() const override {
+    return "amdaie-standard-lowering";
+  }
+
+  llvm::StringRef getName() const override {
+    return "AMDAIECoreToStandardPass";
+  }
+
+  std::unique_ptr<mlir::Pass> clonePass() const override {
+    return std::make_unique<AMDAIECoreToStandardPass>(
+        *static_cast<const AMDAIECoreToStandardPass *>(this));
+  }
+
+  void getDependentDialects(mlir::DialectRegistry &registry) const override {
+    registry.insert<mlir::func::FuncDialect>();
+    registry.insert<mlir::memref::MemRefDialect>();
+    registry.insert<xilinx::AIE::AIEDialect>();
+  }
+
+  mlir::Pass::Option<unsigned> tileCol{
+      *this, "tilecol",
+      llvm::cl::desc("X coordinate of tile to generate code for"),
+      llvm::cl::init(-1)};
+  mlir::Pass::Option<unsigned> tileRow{
+      *this, "tilerow",
+      llvm::cl::desc("Y coordinate of tile to generate code for"),
+      llvm::cl::init(-1)};
+
   void runOnOperation() override {
     ModuleOp m = getOperation();
     OpBuilder builder = OpBuilder::atBlockEnd(m.getBody());
@@ -244,7 +271,7 @@ struct AIECoreToStandardPass
 };
 
 std::unique_ptr<OperationPass<ModuleOp>> createAIECoreToStandardPass() {
-  return std::make_unique<AIECoreToStandardPass>();
+  return std::make_unique<AMDAIECoreToStandardPass>();
 }
 
 void registerAIECoreToStandard() {

compiler/plugins/target/AMD-AIE/aie/AIECreatePathFindFlows.cpp renamed to compiler/plugins/target/AMD-AIE/aie/AMDAIECreatePathFindFlows.cpp

@@ -23,19 +23,11 @@ using namespace mlir;
 using namespace xilinx;
 using namespace xilinx::AIE;
 
-#define DEBUG_TYPE "aie-create-pathfinder-flows"
+#define DEBUG_TYPE "amdaie-create-pathfinder-flows"
 #define OVER_CAPACITY_COEFF 0.02
 #define USED_CAPACITY_COEFF 0.02
 #define DEMAND_COEFF 1.1
 
-#define GEN_PASS_DECL_AIEROUTEPATHFINDERFLOWS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DECL_AIEROUTEPATHFINDERFLOWS
-
-#define GEN_PASS_DEF_AIEROUTEPATHFINDERFLOWS
-#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
-#undef GEN_PASS_DEF_AIEROUTEPATHFINDERFLOWS
-
 namespace mlir::iree_compiler::AMDAIE {
 struct Port {
   xilinx::AIE::WireBundle bundle;
@@ -1128,12 +1120,26 @@ struct ConvertFlowsToInterconnect : OpConversionPattern<FlowOp> {
 /// 3. rewrite flows to stream-switches using 'weights' from analysis pass.
 /// 4. check a region is legal
 /// 5. rewrite stream-switches (within a bounding box) back to flows
-struct AIEPathfinderPass
-    : ::impl::AIERoutePathfinderFlowsBase<AIEPathfinderPass> {
+struct AMDAIEPathfinderPass : mlir::OperationPass<DeviceOp> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AMDAIEPathfinderPass)
+
+  AMDAIEPathfinderPass() : mlir::OperationPass<DeviceOp>(resolveTypeID()) {}
+
+  llvm::StringRef getArgument() const override {
+    return "amdaie-create-pathfinder-flows";
+  }
+
+  llvm::StringRef getName() const override { return "AMDAIEPathfinderPass"; }
+
+  std::unique_ptr<mlir::Pass> clonePass() const override {
+    return std::make_unique<AMDAIEPathfinderPass>(
+        *static_cast<const AMDAIEPathfinderPass *>(this));
+  }
+
   DynamicTileAnalysis analyzer;
-  AIEPathfinderPass() = default;
-  AIEPathfinderPass(DynamicTileAnalysis analyzer)
-      : analyzer(std::move(analyzer)) {}
+  AMDAIEPathfinderPass(DynamicTileAnalysis analyzer)
+      : mlir::OperationPass<DeviceOp>(resolveTypeID()),
+        analyzer(std::move(analyzer)) {}
 
   void runOnOperation() override;
 
@@ -1156,9 +1162,9 @@ struct AIEPathfinderPass
   SwitchboxOp getSwitchbox(DeviceOp &d, int col, int row);
 };
 
-void AIEPathfinderPass::runOnOperation() {
+void AMDAIEPathfinderPass::runOnOperation() {
   // create analysis pass with routing graph for entire device
-  LLVM_DEBUG(llvm::dbgs() << "---Begin AIEPathfinderPass---\n");
+  LLVM_DEBUG(llvm::dbgs() << "---Begin AMDAIEPathfinderPass---\n");
 
   DeviceOp d = getOperation();
   if (failed(analyzer.runAnalysis(d))) return signalPassFailure();
@@ -1273,10 +1279,9 @@ void AIEPathfinderPass::runOnOperation() {
   }
 }
 
-bool AIEPathfinderPass::attemptFixupMemTileRouting(const OpBuilder &builder,
-                                                   SwitchboxOp northSwOp,
-                                                   SwitchboxOp southSwOp,
-                                                   ConnectOp &problemConnect) {
+bool AMDAIEPathfinderPass::attemptFixupMemTileRouting(
+    const OpBuilder &builder, SwitchboxOp northSwOp, SwitchboxOp southSwOp,
+    ConnectOp &problemConnect) {
   int problemNorthChannel;
   if (problemConnect.getSourceBundle() == WireBundle::North) {
     problemNorthChannel = problemConnect.getSourceChannel();
@@ -1313,12 +1318,12 @@ bool AIEPathfinderPass::attemptFixupMemTileRouting(const OpBuilder &builder,
   return false;
 }
 
-bool AIEPathfinderPass::reconnectConnectOps(const OpBuilder &builder,
-                                            SwitchboxOp sw,
-                                            ConnectOp problemConnect,
-                                            bool isIncomingToSW,
-                                            WireBundle problemBundle,
-                                            int problemChan, int emptyChan) {
+bool AMDAIEPathfinderPass::reconnectConnectOps(const OpBuilder &builder,
+                                               SwitchboxOp sw,
+                                               ConnectOp problemConnect,
+                                               bool isIncomingToSW,
+                                               WireBundle problemBundle,
+                                               int problemChan, int emptyChan) {
   bool hasEmptyChannelSlot = true;
   bool foundCandidateForFixup = false;
   ConnectOp candidate;
@@ -1368,21 +1373,20 @@ bool AIEPathfinderPass::reconnectConnectOps(const OpBuilder &builder,
 }
 
 // Replace connect op
-ConnectOp AIEPathfinderPass::replaceConnectOpWithNewDest(OpBuilder builder,
-                                                         ConnectOp connect,
-                                                         WireBundle newBundle,
-                                                         int newChannel) {
+ConnectOp AMDAIEPathfinderPass::replaceConnectOpWithNewDest(
+    OpBuilder builder, ConnectOp connect, WireBundle newBundle,
+    int newChannel) {
   builder.setInsertionPoint(connect);
   auto newOp = builder.create<ConnectOp>(
       builder.getUnknownLoc(), connect.getSourceBundle(),
       connect.getSourceChannel(), newBundle, newChannel);
   connect.erase();
   return newOp;
 }
-ConnectOp AIEPathfinderPass::replaceConnectOpWithNewSource(OpBuilder builder,
-                                                           ConnectOp connect,
-                                                           WireBundle newBundle,
-                                                           int newChannel) {
+
+ConnectOp AMDAIEPathfinderPass::replaceConnectOpWithNewSource(
+    OpBuilder builder, ConnectOp connect, WireBundle newBundle,
+    int newChannel) {
   builder.setInsertionPoint(connect);
   auto newOp = builder.create<ConnectOp>(builder.getUnknownLoc(), newBundle,
                                          newChannel, connect.getDestBundle(),
@@ -1391,7 +1395,7 @@ ConnectOp AIEPathfinderPass::replaceConnectOpWithNewSource(OpBuilder builder,
   return newOp;
 }
 
-SwitchboxOp AIEPathfinderPass::getSwitchbox(DeviceOp &d, int col, int row) {
+SwitchboxOp AMDAIEPathfinderPass::getSwitchbox(DeviceOp &d, int col, int row) {
   SwitchboxOp output = nullptr;
   d.walk([&](SwitchboxOp swBox) {
     if (swBox.colIndex() == col && swBox.rowIndex() == row) {
@@ -1402,7 +1406,7 @@ SwitchboxOp AIEPathfinderPass::getSwitchbox(DeviceOp &d, int col, int row) {
 }
 
 std::unique_ptr<OperationPass<DeviceOp>> createAIEPathfinderPass() {
-  return std::make_unique<AIEPathfinderPass>();
+  return std::make_unique<AMDAIEPathfinderPass>();
 }
 
 void registerAIERoutePathfinderFlows() {