[mlir][linalg] Pad independent of application order (NFC).

[gysit]

Summary

This revision makes the padding pattern independent of the application order. It addresses the concern that we cannot rely on the execution order of the greedy rewriter (https://reviews.llvm.org/D114689). Instead, the pattern is updated to apply repeatedly till all operations are padded.

[gysit]

@mehdi_amini this patch makes the padding robust with respect to the pattern application order and should address the concern you raised in https://reviews.llvm.org/D114689.

[mehdi_amini]

Great, thanks!

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

void runOnFunction() override {
     RewritePatternSet paddingPattern(funcOp.getContext());
     if (!anchorOpName.empty()) {
       paddingPattern.add<LinalgPaddingPattern>(
           anchorOpName, funcOp.getContext(), options, filter);
     } else {
       paddingPattern.add<LinalgPaddingPattern>(funcOp.getContext(), options,
                                                filter);
     }
-    // Traverse the operations top down to pad producers before consumers. The
-    // extract slice operation introduced after every padded operation enables
-    // padding its consumers. Padding an operation whose producers have not been
-    // padded before fails due to the missing extract slice operations. In this
-    // case, the padding pattern increments the transformation marker without
-    // padding the operation. The top down traversal is thus not only a
-    // performance optimization but also needed to pad all operations along the
-    // use-def chains.
-    GreedyRewriteConfig config;
-    config.useTopDownTraversal = true;
-    if (failed(applyPatternsAndFoldGreedily(funcOp, std::move(paddingPattern),
-                                            config)))
-      signalPassFailure();
+    (void)applyPatternsAndFoldGreedily(funcOp, std::move(paddingPattern));
   }
 
   LinalgPaddingOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply pattern-based linalg generalization.
 struct LinalgStrategyGeneralizePass

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

LogicalResult mlir::linalg::LinalgPaddingPattern::matchAndRewrite(
   if (failed(filter.checkAndNotify(rewriter, op)))
     return failure();
 
   // Pad the operation.
   LinalgOp paddedOp;
   FailureOr<SmallVector<Value>> newResults = rewriteAsPaddedOp(
       rewriter, linalgOp, options.paddingValueComputationFunction,
       options.paddingNoFoldComputationFunction, paddedOp);
-  if (failed(newResults)) {
-    filter.replaceLinalgTransformationFilter(rewriter, linalgOp);
+  if (failed(newResults))
     return failure();
-  }
 
   // Compute the desired hoisting depths.
   SmallVector<int64_t> depths;
   if (options.paddingHoistComputationFunction) {
     for (OpOperand *opOperand : linalgOp.getInputAndOutputOperands())
       depths.push_back(options.paddingHoistComputationFunction(*opOperand));
   }