[mlir] Add a new context flag for disabling/enabling multi-threading

[rriddle]

Summary

This is useful for several reasons:

• In some situations the user can guarantee that thread-safety isn't necessary and don't want to pay the cost of synchronization, e.g., when parsing a very large module.

• For things like logging threading is not desirable as the output is not guaranteed to be in stable order.

This flag also subsumes the pass manager flag for multi-threading.

[lattner]

Awesome, thank you for tackling this River, I added some suggestions above.

When this lands, I'll let you know what speedup I see on my example (and see if anything else should be guarded by this). Thank you again for working on this!

mlir/docs/PassManagement.md

804

Bikeshed: I'm not sure the precedence on this, I think that "-disable-mlir-threading" would read better and be more discoverable than "-mlir-disable-threading".

mlir/lib/IR/MLIRContext.cpp

55

When this shows up in mlir-opt etc, I think this is effectively "Disabling multi-threading in MLIR" - right? The passmgr and everything else that would create threads should be gated on the MLIRContext bit this sets.

156

Maybe it is just the way my brain works, but I'd recommend changing the internal flag (and the parameters that pass it around) to "threadingIsEnabled" to make the conditions easier to read.

You can still make it default to the same behavior of course.

[rriddle]

Resolve comments

mlir/docs/PassManagement.md

804

It's consistent with the other flags we have in IR/. I started doing that a while ago to make it easier to find flags that only relate to MLIR.

[lattner]

Very nice River! I incorporated this into my stuff and it sped up the parser by 18%!

Random follow-on question - would it make sense to incorporate this into mlir-translate, mlir-opt etc for the "parsing the input" phases?

mlir/docs/PassManagement.md

 
 In this mode, the results are displayed in a list sorted by total time with each
 pass/analysis instance aggregated into one unique result. This view is useful
 for getting an overview of what analyses/passes are taking the most time in a
 pipeline. This display mode is available in mlir-opt via
 `-pass-timing-display=list`.
 
 ```shell
-$ mlir-opt foo.mlir -disable-pass-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -pass-timing -pass-timing-display=list
+$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -pass-timing -pass-timing-display=list
 
 ===-------------------------------------------------------------------------===
                       ... Pass execution timing report ...
 ===-------------------------------------------------------------------------===
   Total Execution Time: 0.0203 seconds
 
    ---Wall Time---  --- Name ---
    0.0047 ( 55.9%)  Canonicalizer
    0.0019 ( 22.2%)  VerifierPass
    0.0016 ( 18.5%)  LLVMLoweringPass
    0.0003 (  3.4%)  CSE
    0.0002 (  1.9%)  (A) DominanceInfo
    0.0084 (100.0%)  Total
 ```
 
 ##### Pipeline Display Mode
 
 In this mode, the results are displayed in a nested pipeline view that mirrors
 the internal pass pipeline that is being executed in the pass manager. This view
 is useful for understanding specifically which parts of the pipeline are taking
 the most time, and can also be used to identify when analyses are being
 invalidated and recomputed. This is the default display mode.
 
 ```shell
-$ mlir-opt foo.mlir -disable-pass-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -pass-timing
+$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -pass-timing
 
 ===-------------------------------------------------------------------------===
                       ... Pass execution timing report ...
 ===-------------------------------------------------------------------------===
   Total Execution Time: 0.0249 seconds
 
    ---Wall Time---  --- Name ---
    0.0058 ( 70.8%)  'func' Pipeline
func @simple_constant() -> (i32, i32) {
   return %c1_i32, %c1_i32 : i32, i32
 }
 ```
 
 *   `print-ir-module-scope`
     *   Always print the top-level module operation, regardless of pass type or
         operation nesting level.
     *   Note: Printing at module scope should only be used when multi-threading
-        is disabled(`-disable-pass-threading`)
+        is disabled(`-mlir-disable-threading`)
 
 ```shell
-$ mlir-opt foo.mlir -disable-pass-threading -pass-pipeline='func(cse)' -print-ir-after=cse -print-ir-module-scope
+$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse)' -print-ir-after=cse -print-ir-module-scope
 
 *** IR Dump After CSE ***  ('func' operation: @bar)
 func @bar(%arg0: f32, %arg1: f32) -> f32 {
   ...
 }
 
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = constant 1 : i32

mlir/include/mlir/IR/MLIRContext.h

public:
   }
 
   /// Return true if we allow to create operation for unregistered dialects.
   bool allowsUnregisteredDialects();
 
   /// Enables creating operations in unregistered dialects.
   void allowUnregisteredDialects(bool allow = true);
 
+  /// Return true if multi-threading is enabled by the context.
+  bool isMultithreadingEnabled();
+
+  /// Set the flag specifying if multi-threading is disabled by the context.
+  void disableMultithreading(bool disable = true);
+
   /// Return true if we should attach the operation to diagnostics emitted via
   /// Operation::emit.
   bool shouldPrintOpOnDiagnostic();
 
   /// Set the flag specifying if we should attach the operation to diagnostics
   /// emitted via Operation::emit.
   void printOpOnDiagnostic(bool enable);
 

mlir/include/mlir/Pass/PassManager.h

public:
   /// Note: The quality of the string representation depends entirely on the
   /// the correctness of per-pass overrides of Pass::printAsTextualPipeline.
   void printAsTextualPipeline(raw_ostream &os);
 
   /// Merge the pass statistics of this class into 'other'.
   void mergeStatisticsInto(OpPassManager &other);
 
 private:
-  OpPassManager(OperationName name, bool disableThreads, bool verifyPasses);
+  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.
public:
   // If verifyPasses is true, the verifier is run after each pass.
   PassManager(MLIRContext *ctx, bool verifyPasses = true);
   ~PassManager();
 
   /// Run the passes within this manager on the provided module.
   LLVM_NODISCARD
   LogicalResult run(ModuleOp module);
 
-  /// Disable support for multi-threading within the pass manager.
-  void disableMultithreading(bool disable = true);
-
-  /// Return true if the pass manager is configured with multi-threading
-  /// enabled.
-  bool isMultithreadingEnabled();
-
   /// Enable support for the pass manager to generate a reproducer on the event
   /// of a crash or a pass failure. `outputFile` is a .mlir filename used to
   /// write the generated reproducer. If `genLocalReproducer` is true, the pass
   /// manager will attempt to generate a local reproducer that contains the
   /// smallest pipeline.
   void enableCrashReproducerGeneration(StringRef outputFile,
                                        bool genLocalReproducer = false);
 

mlir/include/mlir/Support/StorageUniquer.h

 ///      that is called when erasing a storage instance. This should cleanup any
 ///      fields of the storage as necessary and not attempt to free the memory
 ///      of the storage itself.
 class StorageUniquer {
 public:
   StorageUniquer();
   ~StorageUniquer();
 
+  /// Set the flag specifying if multi-threading is disabled within the uniquer.
+  void disableMultithreading(bool disable = true);
+
   /// This class acts as the base storage that all storage classes must derived
   /// from.
   class BaseStorage {
   public:
     /// Get the kind classification of this storage.
     unsigned getKind() const { return kind; }
 
   protected:

mlir/lib/IR/MLIRContext.cpp

 // MLIRContext CommandLine Options
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This struct contains command line options that can be used to initialize
 /// various bits of an MLIRContext. This uses a struct wrapper to avoid the need
 /// for global command line options.
 struct MLIRContextOptions {
+  llvm::cl::opt<bool> disableThreading{
+      "mlir-disable-threading",
+      llvm::cl::desc("Disabling multi-threading within MLIR")};
+
   llvm::cl::opt<bool> printOpOnDiagnostic{
       "mlir-print-op-on-diagnostic",
       llvm::cl::desc("When a diagnostic is emitted on an operation, also print "
                      "the operation as an attached note"),
       llvm::cl::init(true)};
 
   llvm::cl::opt<bool> printStackTraceOnDiagnostic{
       "mlir-print-stacktrace-on-diagnostic",
BuiltinDialect(MLIRContext *context) : Dialect(/*name=*/"", context) {
     // TODO: These operations should be moved to a different dialect when they
     // have been fully decoupled from the core.
     addOperations<FuncOp, ModuleOp, ModuleTerminatorOp>();
   }
 };
 } // end anonymous namespace.
 
 //===----------------------------------------------------------------------===//
+// Locking Utilities
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Utility reader lock that takes a runtime flag that specifies if we really
+/// need to lock.
+struct ScopedReaderLock {
+  ScopedReaderLock(llvm::sys::SmartRWMutex<true> &mutexParam, bool shouldLock)
+      : mutex(shouldLock ? &mutexParam : nullptr) {
+    if (mutex)
+      mutex->lock_shared();
+  }
+  ~ScopedReaderLock() {
+    if (mutex)
+      mutex->unlock_shared();
+  }
+  llvm::sys::SmartRWMutex<true> *mutex;
+};
+/// Utility writer lock that takes a runtime flag that specifies if we really
+/// need to lock.
+struct ScopedWriterLock {
+  ScopedWriterLock(llvm::sys::SmartRWMutex<true> &mutexParam, bool shouldLock)
+      : mutex(shouldLock ? &mutexParam : nullptr) {
+    if (mutex)
+      mutex->lock();
+  }
+  ~ScopedWriterLock() {
+    if (mutex)
+      mutex->unlock();
+  }
+  llvm::sys::SmartRWMutex<true> *mutex;
+};
+} // end anonymous namespace.
+
+//===----------------------------------------------------------------------===//
 // AffineMap and IntegerSet hashing
 //===----------------------------------------------------------------------===//
 
 /// A utility function to safely get or create a uniqued instance within the
 /// given set container.
 template <typename ValueT, typename DenseInfoT, typename KeyT,
           typename ConstructorFn>
 static ValueT safeGetOrCreate(DenseSet<ValueT, DenseInfoT> &container,
                               KeyT &&key, llvm::sys::SmartRWMutex<true> &mutex,
+                              bool threadingIsEnabled,
                               ConstructorFn &&constructorFn) {
-  { // Check for an existing instance in read-only mode.
+  // Check for an existing instance in read-only mode.
+  if (threadingIsEnabled) {
     llvm::sys::SmartScopedReader<true> instanceLock(mutex);
     auto it = container.find_as(key);
     if (it != container.end())
       return *it;
   }
 
   // Acquire a writer-lock so that we can safely create the new instance.
-  llvm::sys::SmartScopedWriter<true> instanceLock(mutex);
+  ScopedWriterLock instanceLock(mutex, threadingIsEnabled);
 
   // Check for an existing instance again here, because another writer thread
-  // may have already created one.
+  // may have already created one. Otherwise, construct a new instance.
   auto existing = container.insert_as(ValueT(), key);
-  if (!existing.second)
-    return *existing.first;
-
-  // Otherwise, construct a new instance of the value.
+  if (existing.second)
     return *existing.first = constructorFn();
+  return *existing.first;
 }
 
 namespace {
 struct AffineMapKeyInfo : DenseMapInfo<AffineMap> {
   // Affine maps are uniqued based on their dim/symbol counts and affine
   // expressions.
   using KeyTy = std::tuple<unsigned, unsigned, ArrayRef<AffineExpr>>;
   using DenseMapInfo<AffineMap>::isEqual;
public:
   // Options
   //===--------------------------------------------------------------------===//
 
   /// In most cases, creating operation in unregistered dialect is not desired
   /// and indicate a misconfiguration of the compiler. This option enables to
   /// detect such use cases
   bool allowUnregisteredDialects = false;
 
+  /// Enable support for multi-threading within MLIR.
+  bool threadingIsEnabled = true;
+
   /// If the operation should be attached to diagnostics printed via the
   /// Operation::emit methods.
   bool printOpOnDiagnostic = true;
 
   /// If the current stack trace should be attached when emitting diagnostics.
   bool printStackTraceOnDiagnostic = false;
 
   //===--------------------------------------------------------------------===//
public:
   StorageUniquer attributeUniquer;
 
   /// Cached Attribute Instances.
   BoolAttr falseAttr, trueAttr;
   UnitAttr unitAttr;
   UnknownLoc unknownLocAttr;
 
 public:
-  MLIRContextImpl() : identifiers(identifierAllocator) {
-    // Initialize values based on the command line flags if they were provided.
-    if (clOptions.isConstructed()) {
-      printOpOnDiagnostic = clOptions->printOpOnDiagnostic;
-      printStackTraceOnDiagnostic = clOptions->printStackTraceOnDiagnostic;
-    }
-  }
+  MLIRContextImpl() : identifiers(identifierAllocator) {}
 };
 } // end namespace mlir
 
 MLIRContext::MLIRContext() : impl(new MLIRContextImpl()) {
+  // Initialize values based on the command line flags if they were provided.
+  if (clOptions.isConstructed()) {
+    disableMultithreading(clOptions->disableThreading);
+    printOpOnDiagnostic(clOptions->printOpOnDiagnostic);
+    printStackTraceOnDiagnostic(clOptions->printStackTraceOnDiagnostic);
+  }
+
+  // Register dialects with this context.
   new BuiltinDialect(this);
   registerAllDialects(this);
 
   // Initialize several common attributes and types to avoid the need to lock
   // the context when accessing them.
 
   //// Types.
   /// Floating-point Types.

 
 //===----------------------------------------------------------------------===//
 // Dialect and Operation Registration
 //===----------------------------------------------------------------------===//
 
 /// Return information about all registered IR dialects.
 std::vector<Dialect *> MLIRContext::getRegisteredDialects() {
   // Lock access to the context registry.
-  llvm::sys::SmartScopedReader<true> registryLock(getImpl().contextMutex);
-
+  ScopedReaderLock registryLock(impl->contextMutex, impl->threadingIsEnabled);
   std::vector<Dialect *> result;
-  result.reserve(getImpl().dialects.size());
-  for (auto &dialect : getImpl().dialects)
+  result.reserve(impl->dialects.size());
+  for (auto &dialect : impl->dialects)
     result.push_back(dialect.get());
   return result;
 }
 
 /// Get a registered IR dialect with the given namespace. If none is found,
 /// then return nullptr.
 Dialect *MLIRContext::getRegisteredDialect(StringRef name) {
   // Lock access to the context registry.
-  llvm::sys::SmartScopedReader<true> registryLock(getImpl().contextMutex);
-  for (auto &dialect : getImpl().dialects)
-    if (name == dialect->getNamespace())
-      return dialect.get();
-  return nullptr;
+  ScopedReaderLock registryLock(impl->contextMutex, impl->threadingIsEnabled);
+
+  // Dialects are sorted by name, so we can use binary search for lookup.
+  auto it = llvm::lower_bound(
+      impl->dialects, name,
+      [](const auto &lhs, StringRef rhs) { return lhs->getNamespace() < rhs; });
+  return (it != impl->dialects.end() && (*it)->getNamespace() == name)
+             ? (*it).get()
+             : nullptr;
 }
 
 /// Register this dialect object with the specified context.  The context
 /// takes ownership of the heap allocated dialect.
 void Dialect::registerDialect(MLIRContext *context) {
   auto &impl = context->getImpl();
   std::unique_ptr<Dialect> dialect(this);
 
   // Lock access to the context registry.
-  llvm::sys::SmartScopedWriter<true> registryLock(impl.contextMutex);
+  ScopedWriterLock registryLock(impl.contextMutex, impl.threadingIsEnabled);
 
   // Get the correct insertion position sorted by namespace.
-  auto insertPt =
-      llvm::lower_bound(impl.dialects, dialect,
-                        [](const std::unique_ptr<Dialect> &lhs,
-                           const std::unique_ptr<Dialect> &rhs) {
-                          return lhs->getNamespace() < rhs->getNamespace();
-                        });
+  auto insertPt = llvm::lower_bound(
+      impl.dialects, dialect, [](const auto &lhs, const auto &rhs) {
 
   // Abort if dialect with namespace has already been registered.
   if (insertPt != impl.dialects.end() &&
       (*insertPt)->getNamespace() == getNamespace()) {
     llvm::report_fatal_error("a dialect with namespace '" + getNamespace() +
                              "' has already been registered");
   }
   impl.dialects.insert(insertPt, std::move(dialect));
 }
 
 bool MLIRContext::allowsUnregisteredDialects() {
   return impl->allowUnregisteredDialects;
 }
 
 void MLIRContext::allowUnregisteredDialects(bool allowing) {
   impl->allowUnregisteredDialects = allowing;
 }
 
+/// Return true if multi-threading is disabled by the context.
+bool MLIRContext::isMultithreadingEnabled() {
+  return impl->threadingIsEnabled && llvm::llvm_is_multithreaded();
+}
+
+/// Set the flag specifying if multi-threading is disabled by the context.
+void MLIRContext::disableMultithreading(bool disable) {
+  impl->threadingIsEnabled = !disable;
+
+  // Update the threading mode for each of the uniquers.
+  impl->affineUniquer.disableMultithreading(disable);
+  impl->attributeUniquer.disableMultithreading(disable);
+  impl->typeUniquer.disableMultithreading(disable);
+}
+
 /// Return true if we should attach the operation to diagnostics emitted via
 /// Operation::emit.
 bool MLIRContext::shouldPrintOpOnDiagnostic() {
   return impl->printOpOnDiagnostic;
 }
 
 /// Set the flag specifying if we should attach the operation to diagnostics
 /// emitted via Operation::emit.

 
 /// Return information about all registered operations.  This isn't very
 /// efficient, typically you should ask the operations about their properties
 /// directly.
 std::vector<AbstractOperation *> MLIRContext::getRegisteredOperations() {
   std::vector<std::pair<StringRef, AbstractOperation *>> opsToSort;
 
   { // Lock access to the context registry.
-    llvm::sys::SmartScopedReader<true> registryLock(getImpl().contextMutex);
+    ScopedReaderLock registryLock(impl->contextMutex, impl->threadingIsEnabled);
 
     // We just have the operations in a non-deterministic hash table order. Dump
     // into a temporary array, then sort it by operation name to get a stable
     // ordering.
     llvm::StringMap<AbstractOperation> &registeredOps =
-        getImpl().registeredOperations;
+        impl->registeredOperations;
 
     opsToSort.reserve(registeredOps.size());
     for (auto &elt : registeredOps)
       opsToSort.push_back({elt.first(), &elt.second});
   }
 
   llvm::array_pod_sort(opsToSort.begin(), opsToSort.end());
 
   std::vector<AbstractOperation *> result;
   result.reserve(opsToSort.size());
   for (auto &elt : opsToSort)
     result.push_back(elt.second);
   return result;
 }
 
 void Dialect::addOperation(AbstractOperation opInfo) {
   assert((getNamespace().empty() ||
           opInfo.name.split('.').first == getNamespace()) &&
          "op name doesn't start with dialect namespace");
   assert(&opInfo.dialect == this && "Dialect object mismatch");
   auto &impl = context->getImpl();
 
   // Lock access to the context registry.
-  llvm::sys::SmartScopedWriter<true> registryLock(impl.contextMutex);
+  ScopedWriterLock registryLock(impl.contextMutex, impl.threadingIsEnabled);
   if (!impl.registeredOperations.insert({opInfo.name, opInfo}).second) {
     llvm::errs() << "error: operation named '" << opInfo.name
                  << "' is already registered.\n";
     abort();
   }
 }
 
 /// Register a dialect-specific symbol(e.g. type) with the current context.
 void Dialect::addSymbol(TypeID typeID) {
   auto &impl = context->getImpl();
 
   // Lock access to the context registry.
-  llvm::sys::SmartScopedWriter<true> registryLock(impl.contextMutex);
+  ScopedWriterLock registryLock(impl.contextMutex, impl.threadingIsEnabled);
   if (!impl.registeredDialectSymbols.insert({typeID, this}).second) {
     llvm::errs() << "error: dialect symbol already registered.\n";
     abort();
   }
 }
 
 /// Look up the specified operation in the operation set and return a pointer
 /// to it if present.  Otherwise, return a null pointer.
 const AbstractOperation *AbstractOperation::lookup(StringRef opName,
                                                    MLIRContext *context) {
   auto &impl = context->getImpl();
 
   // Lock access to the context registry.
-  llvm::sys::SmartScopedReader<true> registryLock(impl.contextMutex);
+  ScopedReaderLock registryLock(impl.contextMutex, impl.threadingIsEnabled);
   auto it = impl.registeredOperations.find(opName);
   if (it != impl.registeredOperations.end())
     return &it->second;
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Identifier uniquing
 //===----------------------------------------------------------------------===//
 
 /// Return an identifier for the specified string.
 Identifier Identifier::get(StringRef str, MLIRContext *context) {
   auto &impl = context->getImpl();
 
-  { // Check for an existing identifier in read-only mode.
+  // Check for an existing identifier in read-only mode.
+  if (context->isMultithreadingEnabled()) {
     llvm::sys::SmartScopedReader<true> contextLock(impl.identifierMutex);
     auto it = impl.identifiers.find(str);
     if (it != impl.identifiers.end())
       return Identifier(&*it);
   }
 
   // Check invariants after seeing if we already have something in the
   // identifier table - if we already had it in the table, then it already
   // passed invariant checks.
   assert(!str.empty() && "Cannot create an empty identifier");
   assert(str.find('\0') == StringRef::npos &&
          "Cannot create an identifier with a nul character");
 
   // Acquire a writer-lock so that we can safely create the new instance.
-  llvm::sys::SmartScopedWriter<true> contextLock(impl.identifierMutex);
+  ScopedWriterLock contextLock(impl.identifierMutex, impl.threadingIsEnabled);
   auto it = impl.identifiers.insert(str).first;
   return Identifier(&*it);
 }
 
 //===----------------------------------------------------------------------===//
 // Type uniquing
 //===----------------------------------------------------------------------===//
 

 
 AffineMap AffineMap::getImpl(unsigned dimCount, unsigned symbolCount,
                              ArrayRef<AffineExpr> results,
                              MLIRContext *context) {
   auto &impl = context->getImpl();
   auto key = std::make_tuple(dimCount, symbolCount, results);
 
   // Safely get or create an AffineMap instance.
-  return safeGetOrCreate(impl.affineMaps, key, impl.affineMutex, [&] {
+  return safeGetOrCreate(
+      impl.affineMaps, key, impl.affineMutex, impl.threadingIsEnabled, [&] {
         auto *res = impl.affineAllocator.Allocate<detail::AffineMapStorage>();
 
         // Copy the results into the bump pointer.
         results = copyArrayRefInto(impl.affineAllocator, results);
 
         // Initialize the memory using placement new.
-    new (res) detail::AffineMapStorage{dimCount, symbolCount, results, context};
+        new (res)
+            detail::AffineMapStorage{dimCount, symbolCount, results, context};
         return AffineMap(res);
       });
 }
 
 AffineMap AffineMap::get(MLIRContext *context) {
   return getImpl(/*dimCount=*/0, /*symbolCount=*/0, /*results=*/{}, context);
 }
 
 AffineMap AffineMap::get(unsigned dimCount, unsigned symbolCount,
                          MLIRContext *context) {
auto constructorFn = [&] {
     return IntegerSet(res);
   };
 
   // If this instance is uniqued, then we handle it separately so that multiple
   // threads may simultaneously access existing instances.
   if (constraints.size() < IntegerSet::kUniquingThreshold) {
     auto key = std::make_tuple(dimCount, symbolCount, constraints, eqFlags);
     return safeGetOrCreate(impl.integerSets, key, impl.affineMutex,
-                           constructorFn);
+                           impl.threadingIsEnabled, constructorFn);
   }
 
   // Otherwise, acquire a writer-lock so that we can safely create the new
   // instance.
-  llvm::sys::SmartScopedWriter<true> affineLock(impl.affineMutex);
+  ScopedWriterLock affineLock(impl.affineMutex, impl.threadingIsEnabled);
   return constructorFn();
 }
 
 //===----------------------------------------------------------------------===//
 // StorageUniquerSupport
 //===----------------------------------------------------------------------===//
 
 /// Utility method to generate a default location for use when checking the
 /// construction invariants of a storage object. This is defined out-of-line to
 /// avoid the need to include Location.h.
 const AttributeStorage *
 mlir::detail::generateUnknownStorageLocation(MLIRContext *ctx) {
   return reinterpret_cast<const AttributeStorage *>(
       ctx->getImpl().unknownLocAttr.getAsOpaquePointer());
 }

mlir/lib/Pass/IRPrinting.cpp

struct BasicIRPrinterConfig : public PassManager::IRPrinterConfig {
   /// The stream to output to.
   raw_ostream &out;
 };
 } // end anonymous namespace
 
 /// Add an instrumentation to print the IR before and after pass execution,
 /// using the provided configuration.
 void PassManager::enableIRPrinting(std::unique_ptr<IRPrinterConfig> config) {
-  if (config->shouldPrintAtModuleScope() && isMultithreadingEnabled())
+  if (config->shouldPrintAtModuleScope() &&
+      getContext()->isMultithreadingEnabled())
     llvm::report_fatal_error("IR printing can't be setup on a pass-manager "
                              "without disabling multi-threading first.");
   addInstrumentation(
       std::make_unique<IRPrinterInstrumentation>(std::move(config)));
 }
 
 /// Add an instrumentation to print the IR before and after pass execution.
 void PassManager::enableIRPrinting(
     std::function<bool(Pass *, Operation *)> shouldPrintBeforePass,
     std::function<bool(Pass *, Operation *)> shouldPrintAfterPass,
     bool printModuleScope, bool printAfterOnlyOnChange, raw_ostream &out) {
   enableIRPrinting(std::make_unique<BasicIRPrinterConfig>(
       std::move(shouldPrintBeforePass), std::move(shouldPrintAfterPass),
       printModuleScope, printAfterOnlyOnChange, out));
 }

mlir/lib/Pass/Pass.cpp

 
 //===----------------------------------------------------------------------===//
 // OpPassManagerImpl
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 struct OpPassManagerImpl {
-  OpPassManagerImpl(OperationName name, bool disableThreads, bool verifyPasses)
-      : name(name), disableThreads(disableThreads), verifyPasses(verifyPasses) {
-  }
+  OpPassManagerImpl(OperationName name, bool verifyPasses)
+      : name(name), verifyPasses(verifyPasses) {}
 
   /// Merge the passes of this pass manager into the one provided.
   void mergeInto(OpPassManagerImpl &rhs);
 
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
   OpPassManager &nest(const OperationName &nestedName);
   OpPassManager &nest(StringRef nestedName) {
struct OpPassManagerImpl {
   /// Return an instance of the context.
   MLIRContext *getContext() const {
     return name.getAbstractOperation()->dialect.getContext();
   }
 
   /// The name of the operation that passes of this pass manager operate on.
   OperationName name;
 
-  /// Flag to disable multi-threading of passes.
-  bool disableThreads : 1;
-
   /// Flag that specifies if the IR should be verified after each pass has run.
   bool verifyPasses : 1;
 
   /// The set of passes to run as part of this pass manager.
   std::vector<std::unique_ptr<Pass>> passes;
 };
 } // end namespace detail
 } // end namespace mlir
 
 void OpPassManagerImpl::mergeInto(OpPassManagerImpl &rhs) {
   assert(name == rhs.name && "merging unrelated pass managers");
   for (auto &pass : passes)
     rhs.passes.push_back(std::move(pass));
   passes.clear();
 }
 
 OpPassManager &OpPassManagerImpl::nest(const OperationName &nestedName) {
-  OpPassManager nested(nestedName, disableThreads, verifyPasses);
+  OpPassManager nested(nestedName, verifyPasses);
   auto *adaptor = new OpToOpPassAdaptor(std::move(nested));
   addPass(std::unique_ptr<Pass>(adaptor));
   return adaptor->getPassManagers().front();
 }
 
 void OpPassManagerImpl::addPass(std::unique_ptr<Pass> pass) {
   // If this pass runs on a different operation than this pass manager, then
   // implicitly nest a pass manager for this operation.
for (std::unique_ptr<Pass> &pass : oldPasses) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // OpPassManager
 //===----------------------------------------------------------------------===//
 
-OpPassManager::OpPassManager(OperationName name, bool disableThreads,
-                             bool verifyPasses)
-    : impl(new OpPassManagerImpl(name, disableThreads, verifyPasses)) {
+OpPassManager::OpPassManager(OperationName name, bool verifyPasses)
+    : impl(new OpPassManagerImpl(name, verifyPasses)) {
   assert(name.getAbstractOperation() &&
          "OpPassManager can only operate on registered operations");
   assert(name.getAbstractOperation()->hasProperty(
              OperationProperty::IsolatedFromAbove) &&
          "OpPassManager only supports operating on operations marked as "
          "'IsolatedFromAbove'");
 }
 OpPassManager::OpPassManager(OpPassManager &&rhs) : impl(std::move(rhs.impl)) {}
 OpPassManager::OpPassManager(const OpPassManager &rhs) { *this = rhs; }
 OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) {
-  impl.reset(new OpPassManagerImpl(rhs.impl->name, rhs.impl->disableThreads,
-                                   rhs.impl->verifyPasses));
+  impl.reset(new OpPassManagerImpl(rhs.impl->name, rhs.impl->verifyPasses));
   for (auto &pass : rhs.impl->passes)
     impl->passes.emplace_back(pass->clone());
   return *this;
 }
 
 OpPassManager::~OpPassManager() {}
 
 OpPassManager::pass_iterator OpPassManager::begin() {
llvm::interleaveComma(getPassManagers(), os, [&](OpPassManager &pm) {
     os << '\'' << pm.getOpName() << '\'';
   });
   os << ']';
   return os.str();
 }
 
 /// Run the held pipeline over all nested operations.
 void OpToOpPassAdaptor::runOnOperation() {
-  if (mgrs.front().getImpl().disableThreads || !llvm::llvm_is_multithreaded())
-    runOnOperationImpl();
-  else
+  if (getContext().isMultithreadingEnabled())
     runOnOperationAsyncImpl();
+  else
+    runOnOperationImpl();
 }
 
 /// Run this pass adaptor synchronously.
 void OpToOpPassAdaptor::runOnOperationImpl() {
   auto am = getAnalysisManager();
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         this};
   auto *instrumentor = am.getPassInstrumentor();
private:
   std::string pipeline;
 
   /// The MLIR module representing the IR before the crash.
   OwningModuleRef module;
 
   /// The filename to use when generating the reproducer.
   StringRef filename;
 
-  /// Various pass manager flags.
+  /// Various pass manager and context flags.
   bool disableThreads;
   bool verifyPasses;
 
   /// The current set of active reproducer contexts. This is used in the event
   /// of a crash. This is not thread_local as the pass manager may produce any
   /// number of child threads. This uses a set to allow for multiple MLIR pass
   /// managers to be running at the same time.
   static llvm::ManagedStatic<llvm::sys::SmartMutex<true>> reproducerMutex;
std::unique_ptr<llvm::ToolOutputFile> outputFile =
       mlir::openOutputFile(filename, &error);
   if (!outputFile)
     return failure();
   auto &outputOS = outputFile->os();
 
   // Output the current pass manager configuration.
   outputOS << "// configuration: -pass-pipeline='" << pipeline << "'";
   if (disableThreads)
-    outputOS << " -disable-pass-threading";
+    outputOS << " -mlir-disable-threading";
 
   // TODO: Should this also be configured with a pass manager flag?
   outputOS << "\n// note: verifyPasses=" << (verifyPasses ? "true" : "false")
            << "\n";
 
   // Output the .mlir module.
   module->print(outputOS);
   outputFile->keep();
LogicalResult PassManager::runWithCrashRecovery(ModuleOp module,
   return success();
 }
 
 /// Run the given passes with crash recover enabled.
 LogicalResult
 PassManager::runWithCrashRecovery(MutableArrayRef<std::unique_ptr<Pass>> passes,
                                   ModuleOp module, AnalysisManager am) {
   RecoveryReproducerContext context(passes, module, *crashReproducerFileName,
-                                    impl->disableThreads, impl->verifyPasses);
+                                    !getContext()->isMultithreadingEnabled(),
+                                    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)))

 }
 
 //===----------------------------------------------------------------------===//
 // PassManager
 //===----------------------------------------------------------------------===//
 
 PassManager::PassManager(MLIRContext *ctx, bool verifyPasses)
     : OpPassManager(OperationName(ModuleOp::getOperationName(), ctx),
-                    /*disableThreads=*/false, verifyPasses),
+                    verifyPasses),
       passTiming(false), localReproducer(false) {}
 
 PassManager::~PassManager() {}
 
 /// Run the passes within this manager on the provided module.
 LogicalResult PassManager::run(ModuleOp module) {
   // Before running, make sure to coalesce any adjacent pass adaptors in the
   // pipeline.
LogicalResult result = crashReproducerFileName
                              : OpPassManager::run(module, am);
 
   // Dump all of the pass statistics if necessary.
   if (passStatisticsMode)
     dumpStatistics();
   return result;
 }
 
-/// Disable support for multi-threading within the pass manager.
-void PassManager::disableMultithreading(bool disable) {
-  getImpl().disableThreads = disable;
-}
-
-bool PassManager::isMultithreadingEnabled() {
-  return !getImpl().disableThreads;
-}
-
 /// Enable support for the pass manager to generate a reproducer on the event
 /// of a crash or a pass failure. `outputFile` is a .mlir filename used to write
 /// the generated reproducer. If `genLocalReproducer` is true, the pass manager
 /// will attempt to generate a local reproducer that contains the smallest
 /// pipeline.
 void PassManager::enableCrashReproducerGeneration(StringRef outputFile,
                                                   bool genLocalReproducer) {
   crashReproducerFileName = std::string(outputFile);

mlir/lib/Pass/PassManagerOptions.cpp

llvm::cl::opt<std::string> reproducerFile{
                      " if the pass manager crashes or fails")};
   llvm::cl::opt<bool> localReproducer{
       "pass-pipeline-local-reproducer",
       llvm::cl::desc("When generating a crash reproducer, attempt to generated "
                      "a reproducer with the smallest pipeline."),
       llvm::cl::init(false)};
 
   //===--------------------------------------------------------------------===//
-  // Multi-threading
-  //===--------------------------------------------------------------------===//
-  llvm::cl::opt<bool> disableThreads{
-      "disable-pass-threading",
-      llvm::cl::desc("Disable multithreading in the pass manager"),
-      llvm::cl::init(false)};
-
-  //===--------------------------------------------------------------------===//
   // IR Printing
   //===--------------------------------------------------------------------===//
   PassPipelineCLParser printBefore{"print-ir-before",
                                    "Print IR before specified passes"};
   PassPipelineCLParser printAfter{"print-ir-after",
                                   "Print IR after specified passes"};
   llvm::cl::opt<bool> printBeforeAll{
       "print-ir-before-all", llvm::cl::desc("Print IR before each pass"),
void mlir::applyPassManagerCLOptions(PassManager &pm) {
   if (!options.isConstructed())
     return;
 
   // Generate a reproducer on crash/failure.
   if (options->reproducerFile.getNumOccurrences())
     pm.enableCrashReproducerGeneration(options->reproducerFile,
                                        options->localReproducer);
 
-  // Disable multi-threading.
-  if (options->disableThreads)
-    pm.disableMultithreading();
-
   // Enable statistics dumping.
   if (options->passStatistics)
     pm.enableStatistics(options->passStatisticsDisplayMode);
 
   // Add the IR printing instrumentation.
   options->addPrinterInstrumentation(pm);
 
   // Note: The pass timing instrumentation should be added last to avoid any
   // potential "ghost" timing from other instrumentations being unintentionally
   // included in the timing results.
   options->addTimingInstrumentation(pm);
 }

mlir/lib/Support/StorageUniquer.cpp

struct StorageUniquerImpl {
   };
 
   /// Get or create an instance of a complex derived type.
   BaseStorage *
   getOrCreate(unsigned kind, unsigned hashValue,
               function_ref<bool(const BaseStorage *)> isEqual,
               function_ref<BaseStorage *(StorageAllocator &)> ctorFn) {
     LookupKey lookupKey{kind, hashValue, isEqual};
+    if (!threadingIsEnabled)
+      return getOrCreateUnsafe(kind, hashValue, lookupKey, ctorFn);
 
     // Check for an existing instance in read-only mode.
     {
       llvm::sys::SmartScopedReader<true> typeLock(mutex);
       auto it = storageTypes.find_as(lookupKey);
       if (it != storageTypes.end())
         return it->storage;
     }
 
     // Acquire a writer-lock so that we can safely create the new type instance.
     llvm::sys::SmartScopedWriter<true> typeLock(mutex);
-
-    // Check for an existing instance again here, because another writer thread
-    // may have already created one.
+    return getOrCreateUnsafe(kind, hashValue, lookupKey, ctorFn);
+  }
+  /// Get or create an instance of a complex derived type in an unsafe fashion.
+  BaseStorage *
+  getOrCreateUnsafe(unsigned kind, unsigned hashValue, LookupKey &lookupKey,
+                    function_ref<BaseStorage *(StorageAllocator &)> ctorFn) {
     auto existing = storageTypes.insert_as({}, lookupKey);
     if (!existing.second)
       return existing.first->storage;
 
     // Otherwise, construct and initialize the derived storage for this type
     // instance.
     BaseStorage *storage = initializeStorage(kind, ctorFn);
     *existing.first = HashedStorage{hashValue, storage};
     return storage;
   }
 
   /// Get or create an instance of a simple derived type.
   BaseStorage *
   getOrCreate(unsigned kind,
               function_ref<BaseStorage *(StorageAllocator &)> ctorFn) {
+    if (!threadingIsEnabled)
+      return getOrCreateUnsafe(kind, ctorFn);
+
     // Check for an existing instance in read-only mode.
     {
       llvm::sys::SmartScopedReader<true> typeLock(mutex);
       auto it = simpleTypes.find(kind);
       if (it != simpleTypes.end())
         return it->second;
     }
 
     // Acquire a writer-lock so that we can safely create the new type instance.
     llvm::sys::SmartScopedWriter<true> typeLock(mutex);
-
-    // Check for an existing instance again here, because another writer thread
-    // may have already created one.
+    return getOrCreateUnsafe(kind, ctorFn);
+  }
+  /// Get or create an instance of a simple derived type in an unsafe fashion.
+  BaseStorage *
+  getOrCreateUnsafe(unsigned kind,
+                    function_ref<BaseStorage *(StorageAllocator &)> ctorFn) {
     auto &result = simpleTypes[kind];
     if (result)
       return result;
 
     // Otherwise, create and return a new storage instance.
     return result = initializeStorage(kind, ctorFn);
   }
 
static bool isEqual(const LookupKey &lhs, const HashedStorage &rhs) {
       if (isEqual(rhs, getEmptyKey()) || isEqual(rhs, getTombstoneKey()))
         return false;
       // If the lookup kind matches the kind of the storage, then invoke the
       // equality function on the lookup key.
       return lhs.kind == rhs.storage->getKind() && lhs.isEqual(rhs.storage);
     }
   };
 
-  // Unique types with specific hashing or storage constraints.
+  /// Unique types with specific hashing or storage constraints.
   using StorageTypeSet = DenseSet<HashedStorage, StorageKeyInfo>;
   StorageTypeSet storageTypes;
 
-  // Unique types with just the kind.
+  /// Unique types with just the kind.
   DenseMap<unsigned, BaseStorage *> simpleTypes;
 
-  // Allocator to use when constructing derived type instances.
+  /// Allocator to use when constructing derived type instances.
   StorageUniquer::StorageAllocator allocator;
 
-  // A mutex to keep type uniquing thread-safe.
+  /// A mutex to keep type uniquing thread-safe.
   llvm::sys::SmartRWMutex<true> mutex;
+
+  /// Flag specifying if multi-threading is enabled within the uniquer.
+  bool threadingIsEnabled = true;
 };
 } // end namespace detail
 } // namespace mlir
 
 StorageUniquer::StorageUniquer() : impl(new StorageUniquerImpl()) {}
 StorageUniquer::~StorageUniquer() {}
 
+/// Set the flag specifying if multi-threading is disabled within the uniquer.
+void StorageUniquer::disableMultithreading(bool disable) {
+  impl->threadingIsEnabled = !disable;
+}
+
 /// Implementation for getting/creating an instance of a derived type with
 /// complex storage.
 auto StorageUniquer::getImpl(
     unsigned kind, unsigned hashValue,
     function_ref<bool(const BaseStorage *)> isEqual,
     function_ref<BaseStorage *(StorageAllocator &)> ctorFn) -> BaseStorage * {
   return impl->getOrCreate(kind, hashValue, isEqual, ctorFn);
 }

mlir/lib/Transforms/Inliner.cpp

static void canonicalizeSCC(CallGraph &cg, CGUseList &useList,
   }
   if (nodesToCanonicalize.empty())
     return;
 
   // Canonicalize each of the nodes within the SCC in parallel.
   // NOTE: This is simple now, because we don't enable canonicalizing nodes
   // within children. When we remove this restriction, this logic will need to
   // be reworked.
+  if (context->isMultithreadingEnabled()) {
     ParallelDiagnosticHandler canonicalizationHandler(context);
     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];
-        applyPatternsAndFoldGreedily(*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();
         });
+  } else {
+    for (CallGraphNode *node : nodesToCanonicalize)
+      applyPatternsAndFoldGreedily(*node->getCallableRegion(), canonPatterns);
+  }
 
   // Recompute the uses held by each of the nodes.
   for (CallGraphNode *node : nodesToCanonicalize)
     useList.recomputeUses(node, cg);
 }
 
 //===----------------------------------------------------------------------===//
 // InlinerPass

mlir/test/Dialect/SPIRV/availability.mlir

-// RUN: mlir-opt -disable-pass-threading -test-spirv-op-availability %s | FileCheck %s
+// RUN: mlir-opt -mlir-disable-threading -test-spirv-op-availability %s | FileCheck %s
 
 // CHECK-LABEL: iadd
 func @iadd(%arg: i32) -> i32 {
   // CHECK: min version: v1.0
   // CHECK: max version: v1.5
   // CHECK: extensions: [ ]
   // CHECK: capabilities: [ ]
   %0 = spv.IAdd %arg, %arg: i32

mlir/test/Dialect/SPIRV/target-env.mlir

-// RUN: mlir-opt -disable-pass-threading -test-spirv-target-env %s | FileCheck %s
+// RUN: mlir-opt -mlir-disable-threading -test-spirv-target-env %s | FileCheck %s
 
 // Note: The following tests check that a spv.target_env can properly control
 // the conversion target and filter unavailable ops during the conversion.
 // We don't care about the op argument consistency too much; so certain enum
 // values for enum attributes may not make much sense for the test op.
 
 // spv.AtomicCompareExchangeWeak is available from SPIR-V 1.0 to 1.3 under
 // Kernel capability.

mlir/test/IR/test-matchers.mlir

-// RUN: mlir-opt %s -disable-pass-threading=true -test-matchers -o /dev/null 2>&1 | FileCheck %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -test-matchers -o /dev/null 2>&1 | FileCheck %s
 
 func @test1(%a: f32, %b: f32, %c: f32) {
   %0 = addf %a, %b: f32
   %1 = addf %a, %c: f32
   %2 = addf %c, %b: f32
   %3 = mulf %a, %2: f32
   %4 = mulf %3, %1: f32
   %5 = mulf %4, %4: f32

mlir/test/Pass/ir-printing.mlir

-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse  -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
-// RUN: mlir-opt %s -disable-pass-threading=true -pass-pipeline='func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse  -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
 
 func @foo() {
   %0 = constant 0 : i32
   return
 }
 
 func @bar() {
   return

mlir/test/Pass/pass-timing.mlir

-// RUN: mlir-opt %s -disable-pass-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s
-// RUN: mlir-opt %s -disable-pass-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
-// RUN: mlir-opt %s -disable-pass-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s
-// RUN: mlir-opt %s -disable-pass-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s
-// RUN: mlir-opt %s -disable-pass-threading=false -verify-each=false -test-pm-nested-pipeline -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=NESTED_MT_PIPELINE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
+// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s
+// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s
+// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=false -test-pm-nested-pipeline -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=NESTED_MT_PIPELINE %s
 
 // LIST: Pass execution timing report
 // LIST: Total Execution Time:
 // LIST: Name
 // LIST-DAG: Canonicalizer
 // LIST-DAG: Verifier
 // LIST-DAG: CSE
 // LIST-DAG: DominanceInfo