[mlir][GreedyPatternRewriter] Add out param to detect changes in IR in `applyPatternsAndFoldGreedily`

[JoelWee]

Summary

This allows users of applyPatternsAndFoldGreedily to detect if any MLIR changes have occurred. An example use-case is where we expect the applyPatternsAndFoldGreedily to change the IR and want to validate that it indeed does change it.

[JoelWee]

Fix variable naming

[mehdi_amini]

mlir/include/mlir/Transforms/GreedyPatternRewriteDriver.h

126

Nit: remove trivial braces here.

[JoelWee]

Fix nit

[JoelWee]

Thank you for the review!

mlir/include/mlir/Transforms/GreedyPatternRewriteDriver.h

 /// repeatedly applying the highest benefit patterns in a greedy work-list
 /// driven manner.
 ///
 /// This variant may stop after a predefined number of iterations, see the
 /// alternative below to provide a specific number of iterations before stopping
 /// in absence of convergence.
 ///
 /// Return success if the iterative process converged and no more patterns can
-/// be matched in the result operation regions.
+/// be matched in the result operation regions. `changed` is set to true if the
+/// IR was modified at all.
 ///
 /// Note: This does not apply patterns to the top-level operation itself.
 ///       These methods also perform folding and simple dead-code elimination
 ///       before attempting to match any of the provided patterns.
 ///
 /// You may configure several aspects of this with GreedyRewriteConfig.
-LogicalResult applyPatternsAndFoldGreedily(
-    Region &region, const FrozenRewritePatternSet &patterns,
-    GreedyRewriteConfig config = GreedyRewriteConfig());
+LogicalResult
+applyPatternsAndFoldGreedily(Region &region,
+                             const FrozenRewritePatternSet &patterns,
+                             GreedyRewriteConfig config = GreedyRewriteConfig(),
+                             bool *changed = nullptr);
 
 /// Rewrite ops in all regions of the given op, which must be isolated from
 /// above.
-inline LogicalResult applyPatternsAndFoldGreedily(
-    Operation *op, const FrozenRewritePatternSet &patterns,
-    GreedyRewriteConfig config = GreedyRewriteConfig()) {
+inline LogicalResult
+applyPatternsAndFoldGreedily(Operation *op,
+                             const FrozenRewritePatternSet &patterns,
+                             GreedyRewriteConfig config = GreedyRewriteConfig(),
+                             bool *changed = nullptr) {
   bool failed = false;
-  for (Region &region : op->getRegions())
-    failed |= applyPatternsAndFoldGreedily(region, patterns, config).failed();
+  for (Region &region : op->getRegions()) {
+    bool regionChanged;
+    failed |=
+        applyPatternsAndFoldGreedily(region, patterns, config, &regionChanged)
+            .failed();
+    if (changed)
+      *changed |= regionChanged;
+  }
   return failure(failed);
 }
 
 /// Applies the specified rewrite patterns on `ops` while also trying to fold
 /// these ops.
 ///
 /// Newly created ops and other pre-existing ops that use results of rewritten
 /// ops or supply operands to such ops are simplified, unless such ops are

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

 public:
   explicit RegionPatternRewriteDriver(MLIRContext *ctx,
                                       const FrozenRewritePatternSet &patterns,
                                       const GreedyRewriteConfig &config,
                                       Region &regions);
 
   /// Simplify ops inside `region` and simplify the region itself. Return
   /// success if the transformation converged.
-  LogicalResult simplify() &&;
+  LogicalResult simplify(bool *changed) &&;
 
 private:
   /// The region that is simplified.
   Region &region;
 };
 } // namespace
 
 RegionPatternRewriteDriver::RegionPatternRewriteDriver(
void print(raw_ostream &os) const override {
     os << "GreedyPatternRewriteIteration(" << iteration << ")";
   }
 
 private:
   int64_t iteration = 0;
 };
 } // namespace
 
-LogicalResult RegionPatternRewriteDriver::simplify() && {
+LogicalResult RegionPatternRewriteDriver::simplify(bool *changed) && {
   auto insertKnownConstant = [&](Operation *op) {
     // Check for existing constants when populating the worklist. This avoids
     // accidentally reversing the constant order during processing.
     Attribute constValue;
     if (matchPattern(op, m_Constant(&constValue)))
       if (!folder.insertKnownConstant(op, constValue))
         return true;
     return false;
   };
 
-  bool changed = false;
+  bool continueRewrites = false;
   int64_t iteration = 0;
   MLIRContext *ctx = getContext();
   do {
     // Check if the iteration limit was reached.
-    if (iteration++ >= config.maxIterations &&
+    if (++iteration > config.maxIterations &&
         config.maxIterations != GreedyRewriteConfig::kNoLimit)
       break;
 
     worklist.clear();
 
     if (!config.useTopDownTraversal) {
       // Add operations to the worklist in postorder.
       region.walk([&](Operation *op) {
if (!config.useTopDownTraversal) {
       });
 
       // Reverse the list so our pop-back loop processes them in-order.
       worklist.reverse();
     }
 
     ctx->executeAction<GreedyPatternRewriteIteration>(
         [&] {
-          changed = processWorklist();
+          continueRewrites = processWorklist();
 
           // After applying patterns, make sure that the CFG of each of the
           // regions is kept up to date.
           if (config.enableRegionSimplification)
-            changed |= succeeded(simplifyRegions(*this, region));
+            continueRewrites |= succeeded(simplifyRegions(*this, region));
         },
         {&region}, iteration);
-  } while (changed);
+  } while (continueRewrites);
+
+  if (changed)
+    *changed = iteration > 1;
 
   // Whether the rewrite converges, i.e. wasn't changed in the last iteration.
-  return success(!changed);
+  return success(!continueRewrites);
 }
 
 LogicalResult
 mlir::applyPatternsAndFoldGreedily(Region &region,
                                    const FrozenRewritePatternSet &patterns,
-                                   GreedyRewriteConfig config) {
+                                   GreedyRewriteConfig config, bool *changed) {
   // The top-level operation must be known to be isolated from above to
   // prevent performing canonicalizations on operations defined at or above
   // the region containing 'op'.
   assert(region.getParentOp()->hasTrait<OpTrait::IsIsolatedFromAbove>() &&
          "patterns can only be applied to operations IsolatedFromAbove");
 
   // Set scope if not specified.
   if (!config.scope)
     config.scope = &region;
 
   // Start the pattern driver.
   RegionPatternRewriteDriver driver(region.getContext(), patterns, config,
                                     region);
-  LogicalResult converged = std::move(driver).simplify();
+  LogicalResult converged = std::move(driver).simplify(changed);
   LLVM_DEBUG(if (failed(converged)) {
     llvm::dbgs() << "The pattern rewrite did not converge after scanning "
                  << config.maxIterations << " times\n";
   });
   return converged;
 }
 
 //===----------------------------------------------------------------------===//