[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),
+            "ArrayRef<OpFoldResult> ":$sizes),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           return {};
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Method to return the position of the result tile computed by the tiled operation.
let methods = [
           implementation of the operation given a tile of the
           iteration space. This method generates a tiled
           implementation of the operation based on the tile of the
           result required. This method enables fusion by using tile
           and fuse. The method returns failure if the operation can't be
           tiled to generate the result tile. In practical terms this
           implies it cannot be tiled and fused with its consumers.        
 
-          - `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.
         }],
         /*retType=*/"FailureOr<Value>",
         /*methodName=*/"generateResultTileValue",
         /*args=*/(ins
           "OpBuilder &":$b,
           "unsigned":$resultNumber,
-          "ValueRange":$dest,
           "ArrayRef<OpFoldResult>":$offsets,
-          "ArrayRef<OpFoldResult>":$sizes,
-          "bool":$tileDestOperands),
+          "ArrayRef<OpFoldResult>":$sizes),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           return failure();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Generates the scalar implementation of the operation. 

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

if (!containingOp->isProperAncestor(sliceOp))
       continue;
     sliceOps.push_back(sliceOp);
   }
 
   // Check for a non-empty list of fusion opportunities.
   if (sliceOps.empty())
     return failure();
 
-  SmallVector<Value> destinationOperands =
-      tileableProducer.getDestinationOperands(rewriter);
-
   // Try to fuse the producer in-place.
   SmallVector<Operation *> fusedOps;
   for (tensor::ExtractSliceOp sliceOp : sliceOps) {
     OpBuilder::InsertionGuard guard(rewriter);
     rewriter.setInsertionPoint(sliceOp);
 
     // Tile the producer.
     FailureOr<Value> tiledProducer = tileableProducer.generateResultTileValue(
-        rewriter, /*resultNumber=*/0, destinationOperands,
-        sliceOp.getMixedOffsets(), sliceOp.getMixedSizes(), true);
+        rewriter, /*resultNumber=*/0, sliceOp.getMixedOffsets(),
+        sliceOp.getMixedSizes());
     if (failed(tiledProducer))
       return failure();
     fusedOps.push_back(tiledProducer->getDefiningOp());
   }
 
   // Replace the extract op.
   for (const auto &en : enumerate(sliceOps))
     rewriter.replaceOp(en.value(), fusedOps[en.index()]->getResult(0));

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,
-                                /*tileDestOperands=*/true);
+      op.getTiledImplementation(b, offsetsCopy, sizesCopy);
   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,
                                         resultOffsets, resultSizes)))

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,
-                                /*tileDestOperands=*/true);
+      op.getTiledImplementation(b, tiledOffsets, tiledSizes);
   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 :
        llvm::zip(llvm::seq(unsigned(0), unsigned(destOperands.size())),

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

return llvm::to_vector(
           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,
+  getTiledImplementation(Operation *op, OpBuilder &b,
                          ArrayRef<OpFoldResult> offsets,
-                         ArrayRef<OpFoldResult> sizes,
-                         bool tileDestOperands) const {
+                         ArrayRef<OpFoldResult> sizes) 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);
 
SliceParameters sliceParams =
                                /*ubs*/ {}, subShapeSizes, true);
     resultOffsets = sliceParams.offsets;
     resultSizes = sliceParams.sizes;
     return success();
   }
 
   FailureOr<Value> generateResultTileValue(Operation *op, OpBuilder &b,
                                            unsigned resultNumber,
-                                           ValueRange dest,
                                            ArrayRef<OpFoldResult> offsets,
-                                           ArrayRef<OpFoldResult> sizes,
-                                           bool tileDestOperands) const {
+                                           ArrayRef<OpFoldResult> sizes) const {
     auto linalgOp = cast<LinalgOp>(op);
 
     // Check that the indexing map used for the output is a projected
     // permutation. This could be relaxed with a more general approach that can
     // map the offsets and sizes from the result to iteration space tiles
     // (filling in full extent for dimensions not used to access the result).
     AffineMap indexingMap =
         linalgOp.getTiedIndexingMapForResult(op->getResult(resultNumber));
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);
     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);
     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 {
     // 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,
+  getTiledImplementation(Operation *op, OpBuilder &b,
                          ArrayRef<OpFoldResult> offsets,
-                         ArrayRef<OpFoldResult> sizes,
-                         bool /*tileDestOperands*/) const {
+                         ArrayRef<OpFoldResult> sizes) const {
     Operation *result =
         tensor::bubbleUpPadSlice(b, cast<PadOp>(op), offsets, sizes);
     if (!result)
       return {};
     return {result};
   }
 
   LogicalResult

mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducer.cpp

FailureOr<Value> tensor::replaceExtractSliceWithTiledProducer(
 
   // `TilingInterface` currently only supports strides being 1.
   if (llvm::any_of(sliceOp.getMixedStrides(), [](OpFoldResult ofr) {
         return !isConstantIntValue(ofr, 1);
       }))
     return failure();
 
   FailureOr<Value> tiledResult = producerOp.generateResultTileValue(
-      builder, producer.getResultNumber(),
-      producerOp.getDestinationOperands(builder), sliceOp.getMixedOffsets(),
-      sliceOp.getMixedSizes(), true);
+      builder, producer.getResultNumber(), sliceOp.getMixedOffsets(),
+      sliceOp.getMixedSizes());
   if (failed(tiledResult))
     return failure();
 
   return tiledResult.value();
 }