[mlir][linalg] Remove tile and fuse test pass (NFC).

[gysit]

Summary

Remove the tile and fuse test pass that has been replaced by codegen strategy.

Depends On D114067

mlir/include/mlir/Dialect/Linalg/Passes.h

 /// Create a pass to convert named Linalg operations to Linalg generic
 /// operations.
 std::unique_ptr<OperationPass<FuncOp>> createLinalgGeneralizationPass();
 
 /// Create a pass to convert Linalg operations to equivalent operations that
 /// work on primitive types, if possible.
 std::unique_ptr<Pass> createLinalgDetensorizePass();
 
-/// Create a pass to tile a LinalgOp and fuse its producers.
-std::unique_ptr<OperationPass<FuncOp>> createLinalgTileAndFuseTensorOpsPass();
-
 //===----------------------------------------------------------------------===//
 /// Linalg strategy passes.
 //===----------------------------------------------------------------------===//
 /// Create a LinalgStrategyTileAndFusePass.
 std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyTileAndFusePass(
     StringRef opName = "", linalg::LinalgTilingAndFusionOptions opt = {},
     linalg::LinalgTransformationFilter filter =
         linalg::LinalgTransformationFilter());

mlir/include/mlir/Dialect/Linalg/Passes.td

2. Detensor the operands of the op and replace it with a primitive
        equivalent.
 
     In addition to detensoring individual ops, this pass detensors internal
     control flow inside a function. All blocks except for the entry block are
     detensored by converting their arguments whenever possible.
   }];
 }
 
-def LinalgTileAndFuseTensorOps
-    : FunctionPass<"linalg-tile-and-fuse-tensor-ops"> {
-  let summary = "Tile a LinalgOp and fuse its producers.";
-  let constructor = "mlir::createLinalgTileAndFuseTensorOpsPass()";
-  let options = [
-    ListOption<"tileSizes", "tile-sizes", "int64_t", "Tile sizes",
-           "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
-    ListOption<"tileInterchange", "tile-interchange", "int64_t",
-           "Tile loop interchange",
-           "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
-  ];
-  let dependentDialects = ["linalg::LinalgDialect", "scf::SCFDialect"];
-}
-
 def LinalgStrategyTileAndFusePass
     : FunctionPass<"linalg-strategy-tile-and-fuse-pass"> {
   let summary = "Configurable pass to apply pattern-based tiling and fusion.";
   let constructor = "mlir::createLinalgStrategyTileAndFusePass()";
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",

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

mlir::linalg::tileConsumerAndFuseProducers(OpBuilder &b, LinalgOp consumerOp,
   innerTileSizes.append(split, 0);
   innerTileSizes.append(tileSizes.begin() + split, tileSizes.end());
   if (failed(tileLoopNest.tileRootOp(b, innerTileSizes, tileInterchange)))
     return failure();
   fuseProducersGreedily(tileLoopNest.getRootOp().getInputOperands());
 
   return tileLoopNest;
 }
-
-namespace {
-struct LinalgTileAndFuseTensorOps
-    : public LinalgTileAndFuseTensorOpsBase<LinalgTileAndFuseTensorOps> {
-
-  void notifyFailure(StringRef message) {
-    llvm::errs() << " - LinalgTileAndFuseTensorOps: " << message << "\n";
-    signalPassFailure();
-  }
-
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
-    OpBuilder b(funcOp.getContext());
-
-    // Heuristic to find a good operation to tile and start fusion. Walk all
-    // operations and select the one with the maximal backward slice of fusion
-    // candidates.
-    LinalgOp rootOp = nullptr;
-    int64_t numFusionCandidates = -1;
-    funcOp.walk([&](LinalgOp linalgOp) {
-      SetVector<Operation *> backwardSlice;
-      getBackwardSlice(linalgOp, &backwardSlice);
-      int64_t backwardSliceSize = count_if(
-          backwardSlice, [](Operation *op) { return isa<LinalgOp>(op); });
-      if (backwardSliceSize > numFusionCandidates) {
-        rootOp = linalgOp;
-        numFusionCandidates = backwardSliceSize;
-      }
-    });
-    if (!rootOp)
-      return notifyFailure("expect to find a root operation");
-
-    // Check `tileSizes` contains a tile size for every `rootOp` loop dimension.
-    if (tileSizes.size() < rootOp.getNumLoops())
-      return notifyFailure("expect #tile sizes >= #loops");
-
-    // Check `tileInterchange` contains no entries or as many as `tileSizes`.
-    if (!tileInterchange.empty() &&
-        tileInterchange.size() != tileSizes.size()) {
-      return notifyFailure(
-          "expect the number of tile sizes and interchange dims to match");
-    }
-
-    // Copy the `tileSizes` and `tileInterchange` prefixes needed to tile
-    // `rootOp` or use the identity interchange if `tileInterchange` is empty.
-    SmallVector<int64_t> rootTileSizes(
-        tileSizes.begin(), tileSizes.begin() + rootOp.getNumLoops());
-    SmallVector<int64_t> rootInterchange =
-        tileInterchange.empty()
-            ? llvm::to_vector<6>(llvm::seq<int64_t>(0, rootOp.getNumLoops()))
-            : SmallVector<int64_t>(tileInterchange.begin(),
-                                   tileInterchange.begin() +
-                                       rootOp.getNumLoops());
-
-    // Check `rootInterchange` is a permutation of the `rootOp` loop dimensions.
-    // It has to be a permutation since the tiling cannot tile the same loop
-    // dimension multiple times.
-    if (!isPermutation(rootInterchange))
-      return notifyFailure(
-          "expect the tile interchange permutes the root loops");
-
-    // Tile `rootOp` and fuse its producers.
-    FailureOr<TileLoopNest> tileLoopNest =
-        tileConsumerAndFuseProducers(b, rootOp, rootTileSizes, rootInterchange);
-    if (failed(tileLoopNest))
-      return notifyFailure("tileConsumerAndFuseProducers failed unexpectedly");
-
-    // Replace all uses of the tiled loop operation.
-    rootOp->replaceAllUsesWith(tileLoopNest->getRootOpReplacementResults());
-  }
-};
-} // namespace
-
-std::unique_ptr<OperationPass<FuncOp>>
-mlir::createLinalgTileAndFuseTensorOpsPass() {
-  return std::make_unique<LinalgTileAndFuseTensorOps>();
-}