Sanitize initialization and finalization

include/proteus/Frontend/Dispatcher.h

@@ -76,7 +76,7 @@ struct DispatchResult;
 class Dispatcher {
 protected:
   TargetModelType TargetModel;
-  ObjectCacheChain *ObjectCache = nullptr;
+  std::unique_ptr<ObjectCacheChain> ObjectCache;
 
   Dispatcher(const std::string &Name, TargetModelType TM);
 

include/proteus/Init.h

@@ -11,11 +11,11 @@
 
 namespace proteus {
 
-bool &proteusIsInitialized();
-void ensureProteusInitialized();
-
+[[deprecated("it is a no-op and will be removed in a future version.")]]
 void init();
+[[deprecated("it is a no-op and will be removed in a future version.")]]
 void finalize();
+
 void enable();
 void disable();
 

src/include/proteus/impl/Caching/MPISharedStorageCache.h

@@ -15,7 +15,7 @@
 #include "proteus/impl/CompiledLibrary.h"
 #include "proteus/impl/Hashing.h"
 
 #include <mpi.h>
 
 #include <atomic>
 #include <chrono>
@@ -40,28 +40,21 @@
   CommThreadHandle &operator=(const CommThreadHandle &) = delete;
 
   template <typename Callable> void start(Callable &&ThreadFunc) {
-    if (Running.load())
+    if (isRunning())
       return;
 
-    ShutdownFlag.store(false, std::memory_order_release);
     Thread = std::make_unique<std::thread>(std::forward<Callable>(ThreadFunc));
-    Running.store(true, std::memory_order_release);
+    Running = true;
   }
 
-  void stop();
+  void join();
 
   bool isRunning() const;
 
-  bool shutdownRequested() const;
-
-  bool waitOrShutdown(std::chrono::milliseconds Timeout);
-
 private:
   std::unique_ptr<std::thread> Thread;
   mutable std::mutex Mutex;
-  std::condition_variable CondVar;
-  std::atomic<bool> ShutdownFlag{false};
-  std::atomic<bool> Running{false};
+  bool Running = false;
 };
 
 class MPICommHandle {
@@ -131,6 +124,7 @@
   const std::string StorageDirectory;
   const std::string Label;
   const int Tag;
+  const int ShutdownTag;
   MPICommHandle CommHandle;
   CommThreadHandle CommThread;
   bool Finalized = false;

src/include/proteus/impl/CompilerAsync.h

@@ -46,11 +46,6 @@ class CompilationResult {
 
 class CompilerAsync {
 public:
-  static CompilerAsync &instance(int NumThreads) {
-    static CompilerAsync Singleton{NumThreads};
-    return Singleton;
-  }
-
   void compile(CompilationTask &&CT) {
     std::unique_lock Lock{Mutex};
     // Get HashValue before the move of CT.
@@ -76,6 +71,13 @@ class CompilerAsync {
 
       Count++;
       std::unique_ptr<MemoryBuffer> ObjBuf = CT.compile();
+
+      // Ensure threads are joined before static objects are destroyed during
+      // program exit. This static is initialized after COMGR's own statics
+      // (triggered by compile() above), so C++ reverse destruction order
+      // guarantees ~ShutdownGuard runs first.
+      static ShutdownGuard Guard{this};
+
       Lock.lock();
       CompilationResultMap.at(CT.getHashValue())->set(std::move(ObjBuf));
       Lock.unlock();
@@ -97,7 +99,8 @@ class CompilerAsync {
     CondVar.notify_all();
 
     for (auto &Thread : Threads)
-      Thread.join();
+      if (Thread.joinable())
+        Thread.join();
 
     Threads.clear();
   }
@@ -138,22 +141,33 @@ class CompilerAsync {
     return ObjBuf;
   }
 
+  CompilerAsync(int NumThreads) {
+    Active = true;
+    for (int I = 0; I < NumThreads; ++I)
+      Threads.emplace_back(&CompilerAsync::run, this);
+  }
+
+  ~CompilerAsync() { joinAllThreads(); }
+
 private:
+  // Joins threads before static objects are destroyed at exit (e.g.,
+  // COMGR/HIPRTC). Must be constructed after the first compile()) so that
+  // reverse destruction order ensures this runs first.
+  struct ShutdownGuard {
+    CompilerAsync *CA;
+    ~ShutdownGuard() {
+      if (CA)
+        CA->joinAllThreads();
+    }
+  };
+
   bool Active;
   std::mutex Mutex;
   std::condition_variable CondVar;
   std::unordered_map<HashT, std::unique_ptr<CompilationResult>>
       CompilationResultMap;
   std::deque<CompilationTask> Worklist;
   std::vector<std::thread> Threads;
-
-  CompilerAsync(int NumThreads) {
-    Active = true;
-    for (int I = 0; I < NumThreads; ++I)
-      Threads.emplace_back(&CompilerAsync::run, this);
-  }
-
-  ~CompilerAsync() { joinAllThreads(); }
 };
 
 } // namespace proteus