[MLIR][NFC] applyPatternsGreedily -> applyPatternsAndFoldGreedily

[bondhugula]

Summary

Rename mlir::applyPatternsGreedily -> applyPatternsAndFoldGreedily. The
new name is a more accurate description of the method - it performs
both, application of the specified patterns and folding of all ops in
the op's region irrespective of whether any patterns have been supplied.

[bondhugula]

Ping reviewers. @rriddle, @mehdi_amini

[bondhugula]

Rebase

[bondhugula]

Fix for upstream changes.

[bondhugula]

Fix for upstream changes.

[bondhugula]

Ping reviewers.

[bondhugula]

Rebase - update another use.

mlir/include/mlir/IR/PatternMatch.h

 /// Rewrite the regions of the specified operation, which must be isolated from
 /// above, by repeatedly applying the highest benefit patterns in a greedy
 /// work-list driven manner. Return true if no more patterns can be matched in
 /// the result operation regions.
 /// Note: This does not apply patterns to the top-level operation itself.
 /// Note: These methods also perform folding and simple dead-code elimination
 ///       before attempting to match any of the provided patterns.
 ///
-bool applyPatternsGreedily(Operation *op,
+bool applyPatternsAndFoldGreedily(Operation *op,
                                   const OwningRewritePatternList &patterns);
 /// Rewrite the given regions, which must be isolated from above.
-bool applyPatternsGreedily(MutableArrayRef<Region> regions,
+bool applyPatternsAndFoldGreedily(MutableArrayRef<Region> regions,
                                   const OwningRewritePatternList &patterns);
 } // end namespace mlir
 
 #endif // MLIR_PATTERN_MATCH_H

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void runOnOperation() override {
     });
 
     OwningRewritePatternList patterns;
 
     // Apply in-dialect lowering first. In-dialect lowering will replace ops
     // which need to be lowered further, which is not supported by a single
     // conversion pass.
     populateGpuRewritePatterns(m.getContext(), patterns);
-    applyPatternsGreedily(m, patterns);
+    applyPatternsAndFoldGreedily(m, patterns);
     patterns.clear();
 
     populateStdToLLVMConversionPatterns(converter, patterns);
     populateGpuToNVVMConversionPatterns(converter, patterns);
     LLVMConversionTarget target(getContext());
     target.addIllegalDialect<gpu::GPUDialect>();
     target.addIllegalOp<LLVM::CosOp, LLVM::ExpOp, LLVM::FAbsOp, LLVM::FCeilOp,
                         LLVM::LogOp, LLVM::Log10Op, LLVM::Log2Op>();

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

struct SPIRVLegalization final
   void runOnOperation() override;
 };
 } // namespace
 
 void SPIRVLegalization::runOnOperation() {
   OwningRewritePatternList patterns;
   auto *context = &getContext();
   populateStdLegalizationPatternsForSPIRVLowering(context, patterns);
-  applyPatternsGreedily(getOperation()->getRegions(), patterns);
+  applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns);
 }
 
 std::unique_ptr<Pass> mlir::createLegalizeStdOpsForSPIRVLoweringPass() {
   return std::make_unique<SPIRVLegalization>();
 }

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

 
 void LowerVectorToLLVMPass::runOnOperation() {
   // Perform progressive lowering of operations on slices and
   // all contraction operations. Also applies folding and DCE.
   {
     OwningRewritePatternList patterns;
     populateVectorSlicesLoweringPatterns(patterns, &getContext());
     populateVectorContractLoweringPatterns(patterns, &getContext());
-    applyPatternsGreedily(getOperation(), patterns);
+    applyPatternsAndFoldGreedily(getOperation(), patterns);
   }
 
   // Convert to the LLVM IR dialect.
   LLVMTypeConverter converter(&getContext());
   OwningRewritePatternList patterns;
   populateVectorToLLVMMatrixConversionPatterns(converter, patterns);
   populateVectorToLLVMConversionPatterns(converter, patterns);
   populateVectorToLLVMMatrixConversionPatterns(converter, patterns);

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

 
 /// Pass that fuses generic ops on tensors. Used only for testing.
 struct FusionOfTensorOpsPass
     : public LinalgFusionOfTensorOpsBase<FusionOfTensorOpsPass> {
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     Operation *op = getOperation();
     patterns.insert<FuseGenericTensorOps>(op->getContext());
-    applyPatternsGreedily(op->getRegions(), patterns);
+    applyPatternsAndFoldGreedily(op->getRegions(), patterns);
   };
 };
 
 struct LinalgFusionPass : public LinalgFusionBase<LinalgFusionPass> {
   void runOnFunction() override { fuseLinalgOpsGreedily(getFunction()); }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLinalgFusionPass() {
   return std::make_unique<LinalgFusionPass>();
 }
 
 std::unique_ptr<Pass> mlir::createLinalgFusionOfTensorOpsPass() {
   return std::make_unique<FusionOfTensorOpsPass>();
 }

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

static void lowerLinalgToLoopsImpl(Operation *op, MLIRContext *context) {
   // Canonicalization and folding patterns applied greedily allow cleaning up
   // the emitted IR on the fly.
   // TODO(ntv) fold view and subview ops?
   FillRewritePatterns<LoopType, IndexedValueType>(patterns, context);
   DimOp::getCanonicalizationPatterns(patterns, context);
   AffineApplyOp::getCanonicalizationPatterns(patterns, context);
   patterns.insert<FoldAffineOp>(context);
   // Just apply the patterns greedily.
-  applyPatternsGreedily(op, patterns);
+  applyPatternsAndFoldGreedily(op, patterns);
 }
 
 namespace {
 struct LowerToAffineLoops
     : public LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
   void runOnFunction() override {
     lowerLinalgToLoopsImpl<AffineForOp, AffineIndexedValue>(getFunction(),
                                                             &getContext());

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

QuantizedConstRewrite::matchAndRewrite(QuantizeCastOp qbarrier,
   return success();
 }
 
 void ConvertConstPass::runOnFunction() {
   OwningRewritePatternList patterns;
   auto func = getFunction();
   auto *context = &getContext();
   patterns.insert<QuantizedConstRewrite>(context);
-  applyPatternsGreedily(func, patterns);
+  applyPatternsAndFoldGreedily(func, patterns);
 }
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::quant::createConvertConstPass() {
   return std::make_unique<ConvertConstPass>();
 }

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

 
 void ConvertSimulatedQuantPass::runOnFunction() {
   bool hadFailure = false;
   OwningRewritePatternList patterns;
   auto func = getFunction();
   auto ctx = func.getContext();
   patterns.insert<ConstFakeQuantRewrite, ConstFakeQuantPerAxisRewrite>(
       ctx, &hadFailure);
-  applyPatternsGreedily(func, patterns);
+  applyPatternsAndFoldGreedily(func, patterns);
   if (hadFailure)
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::quant::createConvertSimulatedQuantPass() {
   return std::make_unique<ConvertSimulatedQuantPass>();
 }

mlir/lib/Transforms/Canonicalizer.cpp

void runOnOperation() override {
     // TODO: Instead of adding all known patterns from the whole system lazily
     // add and cache the canonicalization patterns for ops we see in practice
     // when building the worklist.  For now, we just grab everything.
     auto *context = &getContext();
     for (auto *op : context->getRegisteredOperations())
       op->getCanonicalizationPatterns(patterns, context);
 
     Operation *op = getOperation();
-    applyPatternsGreedily(op->getRegions(), patterns);
+    applyPatternsAndFoldGreedily(op->getRegions(), patterns);
   }
 };
 } // end anonymous namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
   return std::make_unique<Canonicalizer>();
 }

mlir/lib/Transforms/Inliner.cpp

llvm::parallel::for_each_n(
       llvm::parallel::par, /*Begin=*/size_t(0),
       /*End=*/nodesToCanonicalize.size(), [&](size_t index) {
         // Set the order for this thread so that diagnostics will be properly
         // ordered.
         canonicalizationHandler.setOrderIDForThread(index);
 
         // Apply the canonicalization patterns to this region.
         auto *node = nodesToCanonicalize[index];
-        applyPatternsGreedily(*node->getCallableRegion(), canonPatterns);
+        applyPatternsAndFoldGreedily(*node->getCallableRegion(), canonPatterns);
 
         // Make sure to reset the order ID for the diagnostic handler, as this
         // thread may be used in a different context.
         canonicalizationHandler.eraseOrderIDForThread();
       });
 
   // Recompute the uses held by each of the nodes.
   for (CallGraphNode *node : nodesToCanonicalize)

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

 class GreedyPatternRewriteDriver : public PatternRewriter {
 public:
   explicit GreedyPatternRewriteDriver(MLIRContext *ctx,
                                       const OwningRewritePatternList &patterns)
       : PatternRewriter(ctx), matcher(patterns), folder(ctx) {
     worklist.reserve(64);
   }
 
-  /// Perform the rewrites. Return true if the rewrite converges in
-  /// `maxIterations`.
+  /// Perform the rewrites while folding and erasing any dead ops. Return true
+  /// if the rewrite converges in `maxIterations`.
   bool simplify(MutableArrayRef<Region> regions, int maxIterations);
 
   void addToWorklist(Operation *op) {
     // Check to see if the worklist already contains this op.
     if (worklistMap.count(op))
       return;
 
     worklistMap[op] = worklist.size();
private:
   std::vector<Operation *> worklist;
   DenseMap<Operation *, unsigned> worklistMap;
 
   /// Non-pattern based folder for operations.
   OperationFolder folder;
 };
 } // end anonymous namespace
 
-/// Perform the rewrites.
+/// Perform the rewrites while folding and erasing any dead ops.
 bool GreedyPatternRewriteDriver::simplify(MutableArrayRef<Region> regions,
                                           int maxIterations) {
   // Add the given operation to the worklist.
   auto collectOps = [this](Operation *op) { addToWorklist(op); };
 
   bool changed = false;
   int i = 0;
   do {

 }
 
 /// Rewrite the regions of the specified operation, which must be isolated from
 /// above, by repeatedly applying the highest benefit patterns in a greedy
 /// work-list driven manner. Return true if no more patterns can be matched in
 /// the result operation regions.
 /// Note: This does not apply patterns to the top-level operation itself.
 ///
-bool mlir::applyPatternsGreedily(Operation *op,
-                                 const OwningRewritePatternList &patterns) {
-  return applyPatternsGreedily(op->getRegions(), patterns);
+bool mlir::applyPatternsAndFoldGreedily(
+    Operation *op, const OwningRewritePatternList &patterns) {
+  return applyPatternsAndFoldGreedily(op->getRegions(), patterns);
 }
 
 /// Rewrite the given regions, which must be isolated from above.
-bool mlir::applyPatternsGreedily(MutableArrayRef<Region> regions,
-                                 const OwningRewritePatternList &patterns) {
+bool mlir::applyPatternsAndFoldGreedily(
+    MutableArrayRef<Region> regions, const OwningRewritePatternList &patterns) {
   if (regions.empty())
     return true;
 
   // 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'.
   auto regionIsIsolated = [](Region &region) {
     return region.getParentOp()->isKnownIsolatedFromAbove();

mlir/test/lib/Dialect/Test/TestPatterns.cpp

 struct TestPatternDriver : public PassWrapper<TestPatternDriver, FunctionPass> {
   void runOnFunction() override {
     mlir::OwningRewritePatternList patterns;
     populateWithGenerated(&getContext(), &patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.insert<TestNamedPatternRule>(&getContext());
 
-    applyPatternsGreedily(getFunction(), patterns);
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // ReturnType Driver.
 //===----------------------------------------------------------------------===//
 

mlir/test/lib/Transforms/TestAllReduceLowering.cpp

 using namespace mlir;
 
 namespace {
 struct TestAllReduceLoweringPass
     : public PassWrapper<TestAllReduceLoweringPass, OperationPass<ModuleOp>> {
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     populateGpuRewritePatterns(&getContext(), patterns);
-    applyPatternsGreedily(getOperation(), patterns);
+    applyPatternsAndFoldGreedily(getOperation(), patterns);
   }
 };
 } // namespace
 
 namespace mlir {
 void registerTestAllReduceLoweringPass() {
   PassRegistration<TestAllReduceLoweringPass> pass(
       "test-all-reduce-lowering",
       "Lowers gpu.all-reduce ops within the GPU dialect.");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

 
 /// Apply transformations specified as patterns.
 void TestLinalgTransforms::runOnFunction() {
   OwningRewritePatternList patterns;
   auto funcOp = getFunction();
 
   // Add the generated patterns to the list.
   linalg::populateWithGenerated(&getContext(), &patterns);
-  applyPatternsGreedily(funcOp, patterns);
+  applyPatternsAndFoldGreedily(funcOp, patterns);
 
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
     op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
 void registerTestLinalgTransforms() {
   PassRegistration<TestLinalgTransforms>(
       "test-linalg-transform-patterns",
       "Test Linalg transformation patterns by applying them greedily.");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestVectorToLoopsConversion.cpp

 namespace {
 
 struct TestVectorToLoopsPass
     : public PassWrapper<TestVectorToLoopsPass, FunctionPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = &getContext();
     populateVectorToAffineLoopsConversionPatterns(context, patterns);
-    applyPatternsGreedily(getFunction(), patterns);
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestVectorToLoopsPass() {
   PassRegistration<TestVectorToLoopsPass> pass(
       "test-convert-vector-to-loops",
       "Converts vector transfer ops to loops over scalars and vector casts");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestVectorTransforms.cpp

 struct TestVectorToVectorConversion
     : public PassWrapper<TestVectorToVectorConversion, FunctionPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = &getContext();
     populateWithGenerated(context, &patterns);
     populateVectorToVectorCanonicalizationPatterns(patterns, context);
     populateVectorToVectorTransformationPatterns(patterns, context);
-    applyPatternsGreedily(getFunction(), patterns);
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 
 struct TestVectorSlicesConversion
     : public PassWrapper<TestVectorSlicesConversion, FunctionPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     populateVectorSlicesLoweringPatterns(patterns, &getContext());
-    applyPatternsGreedily(getFunction(), patterns);
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 
 struct TestVectorContractionConversion
     : public PassWrapper<TestVectorContractionConversion, FunctionPass> {
   TestVectorContractionConversion() = default;
   TestVectorContractionConversion(const TestVectorContractionConversion &pass) {
   }
 
   Option<bool> lowerToLLVMMatrixIntrinsics{
       *this, "vector-lower-matrix-intrinsics",
       llvm::cl::desc("Lower vector.contract to llvm.intr.matrix.multiply"),
       llvm::cl::init(false)};
 
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     VectorTransformsOptions options{
         /*lowerToLLVMMatrixIntrinsics=*/lowerToLLVMMatrixIntrinsics};
     populateVectorContractLoweringPatterns(patterns, &getContext(), options);
-    applyPatternsGreedily(getFunction(), patterns);
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestVectorConversions() {
   PassRegistration<TestVectorToVectorConversion> vectorToVectorPass(