[mlir][NFC] GreedyPatternRewriteDriver: Remove single-op entry point

[springerm]

Summary

This is to simplify the API. The multi-op entry point can be used directly. GreedyRewriteStrictness must now be specified explicitly.

Depends On: D142611

[mehdi_amini]

This is to simplify the API

I'm a bit confused: how is this simplifying the API? From the client point of view at least it seems like it does not?

[springerm]

Mixup in Differential Revision part of the commit message.

[springerm]

restore diff

[springerm]

rebase

[springerm]

In D142613#4084371, @mehdi_amini wrote:

This is to simplify the API

I'm a bit confused: how is this simplifying the API? From the client point of view at least it seems like it does not?

Rebased it on top of all the other changes. There are now two almost identical overloads. There is a chance that the ArrayRef<Operation *> overload can be accidentally called because Operation * can implicitly convert to ArrayRef<Operation *>. And the first bool * parameter of each overload is a different one (erased vs changed).

mlir/include/mlir/Transforms/GreedyPatternRewriteDriver.h

 /// `allOpsErased` is set to true if all ops in `ops` were erased.
 LogicalResult applyOpPatternsAndFold(ArrayRef<Operation *> ops,
                                      const FrozenRewritePatternSet &patterns,
                                      GreedyRewriteStrictness strictMode,
                                      bool *changed = nullptr,
                                      bool *allErased = nullptr,
                                      Region *scope = nullptr);
 
-/// Applies the specified patterns on `op` alone while also trying to fold it,
-/// by selecting the highest benefits patterns in a greedy manner. Returns
-/// success if no more patterns can be matched. `erased` is set to true if `op`
-/// was folded away or erased as a result of becoming dead.
-///
-/// Returns success if the iterative process converged and no more patterns can
-/// be matched.
-inline LogicalResult
-applyOpPatternsAndFold(Operation *op, const FrozenRewritePatternSet &patterns,
-                       bool *erased = nullptr) {
-  return applyOpPatternsAndFold(ArrayRef(op), patterns,
-                                GreedyRewriteStrictness::ExistingOps,
-                                /*changed=*/nullptr, erased);
-}
-
 } // namespace mlir
 
 #endif // MLIR_TRANSFORMS_GREEDYPATTERNREWRITEDRIVER_H_

mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp

if (!opGroupQueue.empty()) {
         lbShift = d * step;
       }
 
       if (res) {
         // Simplify/canonicalize the affine.for.
         RewritePatternSet patterns(res.getContext());
         AffineForOp::getCanonicalizationPatterns(patterns, res.getContext());
         bool erased;
-        (void)applyOpPatternsAndFold(res, std::move(patterns), &erased);
+        (void)applyOpPatternsAndFold(res.getOperation(), std::move(patterns),
+                                     GreedyRewriteStrictness::ExistingOps,
+                                     /*changed=*/nullptr, &erased);
 
         if (!erased && !prologue)
           prologue = res;
         if (!erased)
           epilogue = res;
       }
     } else {
       // Start of first interval.

mlir/lib/Dialect/Affine/Utils/Utils.cpp

LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   // hoisting check to be correct (operands should be composed), and to be more
   // effective (no unused operands). Since the pattern rewriter's folding is
   // entangled with application of patterns, we may fold/end up erasing the op,
   // in which case we return with `folded` being set.
   RewritePatternSet patterns(ifOp.getContext());
   AffineIfOp::getCanonicalizationPatterns(patterns, ifOp.getContext());
   bool erased;
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
-  (void)applyOpPatternsAndFold(ifOp, frozenPatterns, &erased);
+  (void)applyOpPatternsAndFold(ifOp.getOperation(), frozenPatterns,
+                               GreedyRewriteStrictness::ExistingOps,
+                               /*changed=*/nullptr, &erased);
   if (erased) {
     if (folded)
       *folded = true;
     return failure();
   }
   if (folded)
     *folded = false;
 

mlir/lib/Reducer/ReductionTreePass.cpp

static void applyPatterns(Region &region,
 
   // `applyOpPatternsAndFold` may erase the ops so we can't do the pattern
   // matching in above iteration. Besides, erase op not-in-range may end up in
   // invalid module, so `applyOpPatternsAndFold` should come before that
   // transform.
   for (Operation *op : opsInRange)
     // `applyOpPatternsAndFold` returns whether the op is convered. Omit it
     // because we don't have expectation this reduction will be success or not.
-    (void)applyOpPatternsAndFold(op, patterns);
+    (void)applyOpPatternsAndFold(op, patterns,
+                                 GreedyRewriteStrictness::ExistingOps);
 
   if (eraseOpNotInRange)
     for (Operation *op : opsNotInRange) {
       op->dropAllUses();
       op->erase();
     }
 }