Remove the `run` method from `OpPassManager` and `Pass` and migrate it to `OpToOpPassAdaptor`

[mehdi_amini]

Summary

This makes OpPassManager more of a "container" of passes and not responsible to drive the execution.
As such we also make it constructible publicly, which will allow to build arbitrary pipeline decoupled from the execution. We'll make use of this facility to expose "dynamic pipeline" in the future.

[mehdi_amini]

remove parent

[mehdi_amini]

remove dynamic pass pipeline

mlir/include/mlir/Pass/Pass.h

 #include "mlir/Pass/AnalysisManager.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/Statistic.h"
 
 namespace mlir {
 namespace detail {
+class OpToOpPassAdaptor;
+
 /// The state for a single execution of a pass. This provides a unified
 /// interface for accessing and initializing necessary state for pass execution.
 struct PassExecutionState {
   PassExecutionState(Operation *ir, AnalysisManager analysisManager)
       : irAndPassFailed(ir, false), analysisManager(analysisManager) {}
 
   /// The current operation being transformed and a bool for if the pass
   /// signaled a failure.
protected:
   /// Create a copy of this pass, ignoring statistics and options.
   virtual std::unique_ptr<Pass> clonePass() const = 0;
 
   /// Copy the option values from 'other', which is another instance of this
   /// pass.
   void copyOptionValuesFrom(const Pass *other);
 
 private:
-  /// Forwarding function to execute this pass on the given operation.
-  LLVM_NODISCARD
-  LogicalResult run(Operation *op, AnalysisManager am);
 
   /// Out of line virtual method to ensure vtables and metadata are emitted to a
   /// single .o file.
   virtual void anchor();
 
   /// Represents a unique identifier for the pass.
   TypeID passID;
 
   /// The name of the operation that this pass operates on, or None if this is a
   /// generic OperationPass.
   Optional<StringRef> opName;
 
   /// The current execution state for the pass.
   Optional<detail::PassExecutionState> passState;
 
   /// The set of statistics held by this pass.
   std::vector<Statistic *> statistics;
 
   /// The pass options registered to this pass instance.
   detail::PassOptions passOptions;
 
-  /// Allow access to 'clone' and 'run'.
+  /// Allow access to 'clone'.
   friend class OpPassManager;
 
-  /// Allow access to 'run'.
-  friend class PassManager;
+  /// Allow access to 'passState'.
+  friend detail::OpToOpPassAdaptor;
 
   /// Allow access to 'passOptions'.
   friend class PassInfo;
 };
 
 //===----------------------------------------------------------------------===//
 // Pass Model Definitions
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Pass/PassManager.h

 // OpPassManager
 //===----------------------------------------------------------------------===//
 
 /// This class represents a pass manager that runs passes on a specific
 /// operation type. This class is not constructed directly, but nested within
 /// other OpPassManagers or the top-level PassManager.
 class OpPassManager {
 public:
+  OpPassManager(OperationName name, bool verifyPasses);
   OpPassManager(OpPassManager &&rhs);
   OpPassManager(const OpPassManager &rhs);
   ~OpPassManager();
   OpPassManager &operator=(const OpPassManager &rhs);
 
   /// Iterator over the passes in this pass manager.
   using pass_iterator =
-      llvm::pointee_iterator<std::vector<std::unique_ptr<Pass>>::iterator>;
+      llvm::pointee_iterator<MutableArrayRef<std::unique_ptr<Pass>>::iterator>;
   pass_iterator begin();
   pass_iterator end();
   iterator_range<pass_iterator> getPasses() { return {begin(), end()}; }
 
-  using const_pass_iterator = llvm::pointee_iterator<
-      std::vector<std::unique_ptr<Pass>>::const_iterator>;
+  using const_pass_iterator =
+      llvm::pointee_iterator<ArrayRef<std::unique_ptr<Pass>>::const_iterator>;
   const_pass_iterator begin() const;
   const_pass_iterator end() const;
   iterator_range<const_pass_iterator> getPasses() const {
     return {begin(), end()};
   }
 
-  /// Run the held passes over the given operation.
-  LogicalResult run(Operation *op, AnalysisManager am);
-
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
   OpPassManager &nest(const OperationName &nestedName);
   OpPassManager &nest(StringRef nestedName);
   template <typename OpT> OpPassManager &nest() {
     return nest(OpT::getOperationName());
   }
 
public:
   void mergeStatisticsInto(OpPassManager &other);
 
   /// Register dependent dialects for the current pass manager.
   /// This is forwarding to every pass in this PassManager, see the
   /// documentation for the same method on the Pass class.
   void getDependentDialects(DialectRegistry &dialects) const;
 
 private:
-  OpPassManager(OperationName name, bool verifyPasses);
-
   /// A pointer to an internal implementation instance.
   std::unique_ptr<detail::OpPassManagerImpl> impl;
 
   /// Allow access to the constructor.
   friend class PassManager;
 
   /// Allow access.
   friend detail::OpPassManagerImpl;

mlir/lib/Pass/Pass.cpp

 #include "mlir/Pass/Pass.h"
 #include "PassDetail.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Verifier.h"
 #include "mlir/Support/FileUtilities.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/ToolOutputFile.h"
void Pass::printAsTextualPipeline(raw_ostream &os) {
   StringRef argument = getArgument();
   if (!argument.empty())
     os << argument;
   else
     os << "unknown<" << getName() << ">";
   passOptions.print(os);
 }
 
-/// Forwarding function to execute this pass.
-LogicalResult Pass::run(Operation *op, AnalysisManager am) {
-  passState.emplace(op, am);
-
-  // Instrument before the pass has run.
-  auto pi = am.getPassInstrumentor();
-  if (pi)
-    pi->runBeforePass(this, op);
-
-  // Invoke the virtual runOnOperation method.
-  runOnOperation();
-
-  // Invalidate any non preserved analyses.
-  am.invalidate(passState->preservedAnalyses);
-
-  // Instrument after the pass has run.
-  bool passFailed = passState->irAndPassFailed.getInt();
-  if (pi) {
-    if (passFailed)
-      pi->runAfterPassFailed(this, op);
-    else
-      pi->runAfterPass(this, op);
-  }
-
-  // Return if the pass signaled a failure.
-  return failure(passFailed);
-}
 
 //===----------------------------------------------------------------------===//
 // Verifier Passes
 //===----------------------------------------------------------------------===//
 
 void VerifierPass::runOnOperation() {
   if (failed(verify(getOperation())))
     signalPassFailure();
OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) {
   for (auto &pass : rhs.impl->passes)
     impl->passes.emplace_back(pass->clone());
   return *this;
 }
 
 OpPassManager::~OpPassManager() {}
 
 OpPassManager::pass_iterator OpPassManager::begin() {
-  return impl->passes.begin();
+  return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin();
+}
+OpPassManager::pass_iterator OpPassManager::end() {
+  return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.end();
 }
-OpPassManager::pass_iterator OpPassManager::end() { return impl->passes.end(); }
 
 OpPassManager::const_pass_iterator OpPassManager::begin() const {
-  return impl->passes.begin();
+  return ArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin();
 }
 OpPassManager::const_pass_iterator OpPassManager::end() const {
-  return impl->passes.end();
-}
-
-/// Run all of the passes in this manager over the current operation.
-LogicalResult OpPassManager::run(Operation *op, AnalysisManager am) {
-  // Run each of the held passes.
-  for (auto &pass : impl->passes)
-    if (failed(pass->run(op, am)))
-      return failure();
-  return success();
+  return ArrayRef<std::unique_ptr<Pass>>{impl->passes}.end();
 }
 
 /// Nest a new operation pass manager for the given operation kind under this
 /// pass manager.
 OpPassManager &OpPassManager::nest(const OperationName &nestedName) {
   return impl->nest(nestedName);
 }
 OpPassManager &OpPassManager::nest(StringRef nestedName) {

 void OpPassManager::getDependentDialects(DialectRegistry &dialects) const {
   registerDialectsForPipeline(*this, dialects);
 }
 
 //===----------------------------------------------------------------------===//
 // OpToOpPassAdaptor
 //===----------------------------------------------------------------------===//
 
-/// Utility to run the given operation and analysis manager on a provided op
-/// pass manager.
-static LogicalResult runPipeline(OpPassManager &pm, Operation *op,
+LogicalResult OpToOpPassAdaptor::run(Pass *pass, Operation *op,
                                      AnalysisManager am) {
-  // Run the pipeline over the provided operation.
-  auto result = pm.run(op, am);
+  pass->passState.emplace(op, am);
 
+  // Instrument before the pass has run.
+  PassInstrumentor *pi = am.getPassInstrumentor();
+  if (pi)
+    pi->runBeforePass(pass, op);
+
+  // Invoke the virtual runOnOperation method.
+  pass->runOnOperation();
+
+  // Invalidate any non preserved analyses.
+  am.invalidate(pass->passState->preservedAnalyses);
+
+  // Instrument after the pass has run.
+  bool passFailed = pass->passState->irAndPassFailed.getInt();
+  if (pi) {
+    if (passFailed)
+      pi->runAfterPassFailed(pass, op);
+    else
+      pi->runAfterPass(pass, op);
+  }
+
+  // Return if the pass signaled a failure.
+  return failure(passFailed);
+}
+
+/// Run the given operation and analysis manager on a provided op pass manager.
+LogicalResult OpToOpPassAdaptor::runPipeline(
+    iterator_range<OpPassManager::pass_iterator> passes, Operation *op,
+    AnalysisManager am) {
+  auto scope_exit = llvm::make_scope_exit([&] {
     // Clear out any computed operation analyses. These analyses won't be used
     // any more in this pipeline, and this helps reduce the current working set
     // of memory. If preserving these analyses becomes important in the future
     // we can re-evaluate this.
     am.clear();
-  return result;
+  });
+
+  // Run the pipeline over the provided operation.
+  for (Pass &pass : passes)
+    if (failed(run(&pass, op, am)))
+      return failure();
+
+  return success();
 }
 
 /// Find an operation pass manager that can operate on an operation of the given
 /// type, or nullptr if one does not exist.
 static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
                                          const OperationName &name) {
   auto it = llvm::find_if(
       mgrs, [&](OpPassManager &mgr) { return mgr.getOpName() == name; });
for (auto &block : region) {
       for (auto &op : block) {
         auto *mgr = findPassManagerFor(mgrs, op.getName());
         if (!mgr)
           continue;
 
         // Run the held pipeline over the current operation.
         if (instrumentor)
           instrumentor->runBeforePipeline(mgr->getOpName(), parentInfo);
-        auto result = runPipeline(*mgr, &op, am.slice(&op));
+        auto result = runPipeline(mgr->getPasses(), &op, am.slice(&op));
         if (instrumentor)
           instrumentor->runAfterPipeline(mgr->getOpName(), parentInfo);
 
         if (failed(result))
           return signalPassFailure();
       }
     }
   }
llvm::parallelForEach(
 
           // Get the pass manager for this operation and execute it.
           auto &it = opAMPairs[nextID];
           auto *pm = findPassManagerFor(pms, it.first->getName());
           assert(pm && "expected valid pass manager for operation");
 
           if (instrumentor)
             instrumentor->runBeforePipeline(pm->getOpName(), parentInfo);
-          auto pipelineResult = runPipeline(*pm, it.first, it.second);
+          auto pipelineResult =
+              runPipeline(pm->getPasses(), it.first, it.second);
           if (instrumentor)
             instrumentor->runAfterPipeline(pm->getOpName(), parentInfo);
 
           // Drop this thread from being tracked by the diagnostic handler.
           // After this task has finished, the thread may be used outside of
           // this pass manager context meaning that we don't want to track
           // diagnostics from it anymore.
           diagHandler.eraseOrderIDForThread();
RecoveryReproducerContext context(passes, module, *crashReproducerFileName,
                                     impl->verifyPasses);
 
   // Safely invoke the passes within a recovery context.
   llvm::CrashRecoveryContext::Enable();
   LogicalResult passManagerResult = failure();
   llvm::CrashRecoveryContext recoveryContext;
   recoveryContext.RunSafelyOnThread([&] {
     for (std::unique_ptr<Pass> &pass : passes)
-      if (failed(pass->run(module, am)))
+      if (failed(OpToOpPassAdaptor::run(pass.get(), module, am)))
         return;
     passManagerResult = success();
   });
   llvm::CrashRecoveryContext::Disable();
   if (succeeded(passManagerResult))
     return success();
 
   std::string error;
LogicalResult PassManager::run(ModuleOp module) {
   // Construct an analysis manager for the pipeline.
   ModuleAnalysisManager am(module, instrumentor.get());
 
   // Notify the context that we start running a pipeline for book keeping.
   module.getContext()->enterMultiThreadedExecution();
 
   // If reproducer generation is enabled, run the pass manager with crash
   // handling enabled.
-  LogicalResult result = crashReproducerFileName
-                             ? runWithCrashRecovery(module, am)
-                             : OpPassManager::run(module, am);
+  LogicalResult result =
+      crashReproducerFileName
+          : OpToOpPassAdaptor::runPipeline(getPasses(), module, am);
 
   // Notify the context that the run is done.
   module.getContext()->exitMultiThreadedExecution();
 
   // Dump all of the pass statistics if necessary.
   if (passStatisticsMode)
     dumpStatistics();
   return result;

mlir/lib/Pass/PassDetail.h

 
 private:
   /// Run this pass adaptor synchronously.
   void runOnOperationImpl();
 
   /// Run this pass adaptor asynchronously.
   void runOnOperationAsyncImpl();
 
+  /// Run the given operation and analysis manager on a single pass.
+  static LogicalResult run(Pass *pass, Operation *op, AnalysisManager am);
+
+  /// Run the given operation and analysis manager on a provided op pass
+  /// manager.
+  static LogicalResult
+  runPipeline(iterator_range<OpPassManager::pass_iterator> passes,
+              Operation *op, AnalysisManager am);
+
   /// A set of adaptors to run.
   SmallVector<OpPassManager, 1> mgrs;
 
   /// A set of executors, cloned from the main executor, that run asynchronously
   /// on different threads. This is used when threading is enabled.
   SmallVector<SmallVector<OpPassManager, 1>, 8> asyncExecutors;
+
+  // For accessing "runPipeline".
+  friend class mlir::PassManager;
 };
 
 } // end namespace detail
 } // end namespace mlir
 #endif // MLIR_PASS_PASSDETAIL_H_