[Mlir-commits] [mlir] [mlir][bufferization] Move AllocationOpInterface implementations (PR #65578)

[Mehdi Amini]

================
@@ -682,3 +682,59 @@ BufferizationOptions bufferization::getPartialBufferizationOptions() {
   options.opFilter.allowDialect<BufferizationDialect>();
   return options;
 }
+
+//===----------------------------------------------------------------------===//
+// Default AllocationOpInterface implementation and registration
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct DefaultAllocationInterface
+    : public bufferization::AllocationOpInterface::ExternalModel<
+          DefaultAllocationInterface, memref::AllocOp> {
+  static std::optional<Operation *> buildDealloc(OpBuilder &builder,
+                                                 Value alloc) {
+    return builder.create<memref::DeallocOp>(alloc.getLoc(), alloc)
+        .getOperation();
+  }
+  static std::optional<Value> buildClone(OpBuilder &builder, Value alloc) {
+    return builder.create<bufferization::CloneOp>(alloc.getLoc(), alloc)
+        .getResult();
+  }
+  static ::mlir::HoistingKind getHoistingKind() {
+    return HoistingKind::Loop | HoistingKind::Block;
+  }
+  static ::std::optional<::mlir::Operation *>
+  buildPromotedAlloc(OpBuilder &builder, Value alloc) {
+    Operation *definingOp = alloc.getDefiningOp();
+    return builder.create<memref::AllocaOp>(
+        definingOp->getLoc(), cast<MemRefType>(definingOp->getResultTypes()[0]),
+        definingOp->getOperands(), definingOp->getAttrs());
+  }
+};
+
+struct DefaultAutomaticAllocationHoistingInterface
+    : public bufferization::AllocationOpInterface::ExternalModel<
+          DefaultAutomaticAllocationHoistingInterface, memref::AllocaOp> {
+  static ::mlir::HoistingKind getHoistingKind() { return HoistingKind::Loop; }
+};
+
+struct DefaultReallocationInterface
+    : public bufferization::AllocationOpInterface::ExternalModel<
+          DefaultAllocationInterface, memref::ReallocOp> {
+  static std::optional<Operation *> buildDealloc(OpBuilder &builder,
+                                                 Value realloc) {
+    return builder.create<memref::DeallocOp>(realloc.getLoc(), realloc)
+        .getOperation();
+  }
+};
+} // namespace
+
+void bufferization::registerAllocationOpInterfaceExternalModels(
----------------
joker-eph wrote:

> I wouldn't necessarily say that this is just an interface for the memref dialect. I think it's more an interface to customize various bufferization passes (e.g., buffer hoisting). In the extreme case to make them work on other dialects than just memref.

I agree that the interface isn't specific to Memref, but this is one particular implementation of the interface which is specific to the Memref dialect.

> Ideally, we would move the implementation for alloc, alloca, and realloc in MemRef/Transforms/AllocationOpInterfaceImpl.cpp

Right this is what I was pointing out actually :)

>  however, this is not possible because it would introduce a dependency cycle (bufferization <-> memref) 

Actually if it is a library of its own in the Memref dialect, there wouldn't be any cycle.
More importantly, you don't need an actually dependency to implement an interface: that is implementing `AllocationOpInterfaceImpl.cpp` does not need to depend on Bufferization, even if the interface is declared by Bufferization.
(see for example how `mlir/IR` implements a `Bytecode` interface but the `ByteCode` library depends on `IR`)


https://github.com/llvm/llvm-project/pull/65578