[mlir][interfaces] Drop `dest` from getTiledImplementation

[springerm]

Summary

getTiledImplementation only computes the tiled operation, but does not insert the result into any tensor.

[springerm]

update

[mravishankar]

Awesome! Thank you!

mlir/include/mlir/Interfaces/TilingInterface.td

let methods = [
       InterfaceMethod<
         /*desc=*/[{
           Method to generate the tiled implementation of an operation.
 
           The iteration space of the operation is returned by
           `getIterationDomain`. The caller provides the information of the
           tile within this iteration space whose implementation the
           caller needs.
-          - `dest` are the Value into which the result of the tiled
-            operation is to be inserted into. The type of the `dest`
-            Values is same as the types returned by
-            `getDestinationOperands` method.
           - `offsets` provides the offset of the tile in the coordinate system
             of the original iteration space, i.e., if an iteration space
             dimension had non-zero offset, it must be included in the offset
             provided here (as opposed to zero-based offset "relative" to the
             iteration space).
           - `sizes` provides the size of the tile.
           - `tileDestOperands` specifies whether to also tile `dest` operands
             or not. Avoiding tiling `dest` operands can be useful for 
             composition with various looping container ops.
 
           The method returns the operation that is the tiled
           implementation.
         }],
         /*retType=*/"SmallVector<Operation *>",
         /*methodName=*/"getTiledImplementation",
         /*args=*/(ins
             "OpBuilder &":$b,
-            "ValueRange ":$dest,
             "ArrayRef<OpFoldResult> ":$offsets,
             "ArrayRef<OpFoldResult> ":$sizes,
             "bool ":$tileDestOperands),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           return {};
         }]
       >,

mlir/lib/Dialect/Linalg/Transforms/Split.cpp

createSplitPart(RewriterBase &b, Location loc, TilingInterface op,
   // Iteration space of the current part.
   SmallVector<OpFoldResult> sizesCopy = llvm::to_vector(sizes);
   SmallVector<OpFoldResult> offsetsCopy = llvm::to_vector(offsets);
   sizesCopy[dimension] = size;
   offsetsCopy[dimension] = offset;
 
   // Create the part as it it were a single tile.
   SmallVector<Operation *> tiled =
-      op.getTiledImplementation(b, resultOperands, offsetsCopy, sizesCopy,
+      op.getTiledImplementation(b, offsetsCopy, sizesCopy,
                                 /*tileDestOperands=*/true);
   assert(tiled.size() == 1 && "expected a single result from tiling");
   auto part = cast<TilingInterface>(tiled.front());
 
   // Insert the results back and populate the `results` list.
   for (auto i : llvm::seq<unsigned>(0, part->getNumResults())) {
     SmallVector<OpFoldResult> resultOffsets, resultSizes;
     if (failed(op.getResultTilePosition(b, i, offsetsCopy, sizesCopy,

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

if (!omitTileOffsetBoundsCheck &&
       tileSizePerThread =
           buildMax(b, loc, {b.getIndexAttr(0), tileSizePerThread});
 
     tiledSizes.push_back(tileSizePerThread);
     ++threadIdIdx;
   }
 
   SmallVector<Operation *> tiledOps =
-      op.getTiledImplementation(b, destOperands, tiledOffsets, tiledSizes,
+      op.getTiledImplementation(b, tiledOffsets, tiledSizes,
                                 /*tileDestOperands=*/true);
   assert(tiledOps.size() == 1 && "expected a single produced tiled op");
   tiledOp = tiledOps.front();
 
   auto tilingInterfaceOp = dyn_cast<TilingInterface>(tiledOp);
   assert(tilingInterfaceOp && "Tiled op does not implement TilingInterface");
   OpBuilder::InsertPoint insertPt = b.saveInsertionPoint();
   for (auto it :

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

return llvm::to_vector(
         llvm::map_range(map.getResults(), [&](AffineExpr loopExpr) {
           OpFoldResult ofr =
               makeComposedFoldedAffineApply(b, loc, loopExpr, allShapesSizes);
           return Range{b.getIndexAttr(0), ofr, b.getIndexAttr(1)};
         }));
   }
 
   // Instantiate the tiled implementation of the operation.
-  SmallVector<Operation *>
-  getTiledImplementation(Operation *op, OpBuilder &b, ValueRange dest,
-                         ArrayRef<OpFoldResult> offsets,
-                         ArrayRef<OpFoldResult> sizes,
-                         bool tileDestOperands) const {
+  SmallVector<Operation *> getTiledImplementation(
+      Operation *op, OpBuilder &b, ArrayRef<OpFoldResult> offsets,
+      ArrayRef<OpFoldResult> sizes, bool tileDestOperands) const {
     // Leave the `sizeBounds` value empty. That is only needed when the `sizes`
     // specified could lead to out of bounds accesses.
     Location loc = op->getLoc();
     LinalgOp linalgOp = cast<LinalgOp>(op);
     SmallVector<Value> valuesToTile = linalgOp.getInputAndOutputOperands();
     SmallVector<Value, 4> tiledOperands = makeTiledShapes(
         b, loc, linalgOp, valuesToTile, offsets, sizes, {}, true);
 
FailureOr<Value> generateResultTileValue(Operation *op, OpBuilder &b,
     for (const auto &resultExpr : llvm::enumerate(indexingMap.getResults())) {
       unsigned dimPosition =
           resultExpr.value().cast<AffineDimExpr>().getPosition();
       iterationTileOffsets[dimPosition] = offsets[resultExpr.index()];
       iterationTileSizes[dimPosition] = sizes[resultExpr.index()];
     }
 
     SmallVector<Operation *> tiledOp = tilingInterfaceOp.getTiledImplementation(
-        b, dest, iterationTileOffsets, iterationTileSizes, tileDestOperands);
+        b, iterationTileOffsets, iterationTileSizes, tileDestOperands);
     if (tiledOp.size() != 1)
       return op->emitOpError("failed to generate tiled implementation");
 
     return tiledOp[0]->getResult(resultNumber);
   }
 
   LogicalResult generateScalarImplementation(Operation *op, OpBuilder &builder,
                                              Location loc,

mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp

LLVM_DEBUG({
         llvm::errs() << "\n";
       }
     });
 
     // 4. Generate the tiled implementation within the inner most loop.
     if (!tilingResult.loops.empty())
       rewriter.setInsertionPoint(
           tilingResult.loops.back().getBody()->getTerminator());
-    SmallVector<Operation *> tiledImplementation = op.getTiledImplementation(
-        rewriter, op.getDestinationOperands(rewriter), offsets, sizes, true);
+    SmallVector<Operation *> tiledImplementation =
+        op.getTiledImplementation(rewriter, offsets, sizes, true);
     if (tiledImplementation.size() != 1) {
       return rewriter.notifyMatchFailure(
           op, "expected tiled implementation to return a single op");
     }
     tilingResult.tiledOp = tiledImplementation[0];
 
     LLVM_DEBUG({
       if (!tilingResult.loops.empty()) {

mlir/lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp

SmallVector<Range> getIterationDomain(Operation *op, OpBuilder &b) const {
     // Initialize all the ranges to {zero, one, one}. All the `ub`s are
     // overwritten.
     SmallVector<Range> loopRanges(reifiedShapes[0].size(), {zero, one, one});
     for (const auto &ub : enumerate(reifiedShapes[0]))
       loopRanges[ub.index()].size = ub.value();
     return loopRanges;
   }
 
-  SmallVector<Operation *>
-  getTiledImplementation(Operation *op, OpBuilder &b, ValueRange dest,
-                         ArrayRef<OpFoldResult> offsets,
-                         ArrayRef<OpFoldResult> sizes,
-                         bool /*tileDestOperands*/) const {
+  SmallVector<Operation *> getTiledImplementation(
+      Operation *op, OpBuilder &b, ArrayRef<OpFoldResult> offsets,
+      ArrayRef<OpFoldResult> sizes, bool /*tileDestOperands*/) const {
     Operation *result =
         tensor::bubbleUpPadSlice(b, cast<PadOp>(op), offsets, sizes);
     if (!result)
       return {};
     return {result};
   }
 
   LogicalResult