[mlir] AsyncRuntime: disable threading until test flakiness is fixed

[ezhulenev]

Summary

ExecutionEngine/LLJIT do not run globals destructors in loaded dynamic libraries when destroyed, and threads managed by ThreadPool can race with program termination, and it leads to segfaults.

TODO: Re-enable threading after fixing a problem with destructors, or removing static globals from dynamic library.

[mehdi_amini]

Since it surfaced on our radar again, any updated on the global destructors removal?

[ezhulenev]

In D92368#2473858, @mehdi_amini wrote:

Since it surfaced on our radar again, any updated on the global destructors removal?

The PR comment is a bit incorrect, it's not ExecutionEngine/LLJIT problem, it is the dlcose behavior and when it runs global destructors. One potential fix is to link async runtime with mlir-cpu-runner and let the runner to manage thread pool lifetime, but it will make it an exception from every other support library loaded at runtime.

[mehdi_amini]

Can we change the way mlir-cpu-runner loads dynamic libraries so that it expects known entry points in the library to initialize/register/deinitialize?
We could then also dlopen them in private mode instead of injecting symbols in the namespace.

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

 #include <cassert>
 #include <condition_variable>
 #include <functional>
 #include <iostream>
 #include <mutex>
 #include <thread>
 #include <vector>
 
-#include "llvm/Support/ThreadPool.h"
-
 //===----------------------------------------------------------------------===//
 // Async runtime API.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 // Forward declare class defined below.
 class RefCounted;
 
 // -------------------------------------------------------------------------- //
 // AsyncRuntime orchestrates all async operations and Async runtime API is built
 // on top of the default runtime instance.
 // -------------------------------------------------------------------------- //
 
 class AsyncRuntime {
 public:
   AsyncRuntime() : numRefCountedObjects(0) {}
 
   ~AsyncRuntime() {
-    threadPool.wait(); // wait for the completion of all async tasks
     assert(getNumRefCountedObjects() == 0 &&
            "all ref counted objects must be destroyed");
   }
 
   int32_t getNumRefCountedObjects() {
     return numRefCountedObjects.load(std::memory_order_relaxed);
   }
 
-  llvm::ThreadPool &getThreadPool() { return threadPool; }
-
 private:
   friend class RefCounted;
 
   // Count the total number of reference counted objects in this instance
   // of an AsyncRuntime. For debugging purposes only.
   void addNumRefCountedObjects() {
     numRefCountedObjects.fetch_add(1, std::memory_order_relaxed);
   }
   void dropNumRefCountedObjects() {
     numRefCountedObjects.fetch_sub(1, std::memory_order_relaxed);
   }
 
   std::atomic<int32_t> numRefCountedObjects;
-
-  llvm::ThreadPool threadPool;
 };
 
 // Returns the default per-process instance of an async runtime.
 AsyncRuntime *getDefaultAsyncRuntimeInstance() {
   static auto runtime = std::make_unique<AsyncRuntime>();
   return runtime.get();
 }
 

 
 extern "C" void mlirAsyncRuntimeAwaitAllInGroup(AsyncGroup *group) {
   std::unique_lock<std::mutex> lock(group->mu);
   if (group->pendingTokens != 0)
     group->cv.wait(lock, [group] { return group->pendingTokens == 0; });
 }
 
 extern "C" void mlirAsyncRuntimeExecute(CoroHandle handle, CoroResume resume) {
-  auto *runtime = getDefaultAsyncRuntimeInstance();
-  runtime->getThreadPool().async([handle, resume]() { (*resume)(handle); });
+  (*resume)(handle);
 }
 
 extern "C" void mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *token,
                                                      CoroHandle handle,
                                                      CoroResume resume) {
   std::unique_lock<std::mutex> lock(token->mu);
   auto execute = [handle, resume]() { (*resume)(handle); };
   if (token->ready)