Expose Threadpool Stopping and Manual Threadpool cleanup in main function

Common/Cpp/Concurrency/ComputationThreadPool.cpp

@@ -64,7 +64,10 @@ void ComputationThreadPool::run_in_parallel(
 ){
     m_core->run_in_parallel(func, start, end, block_size);
 }
-
+void ComputationThreadPool::stop() {
+    // force call stop in computation thread pool
+    m_core->stop();
+}
 
 
 

Common/Cpp/Concurrency/ComputationThreadPool.h

@@ -41,6 +41,8 @@ class ComputationThreadPool final{
 
     void ensure_threads(size_t threads);
 
+    void stop();
+
 //    void wait_for_everything();
 
 

Common/Cpp/Concurrency/ComputationThreadPoolCore.cpp

@@ -31,21 +31,40 @@ ComputationThreadPoolCore::ComputationThreadPoolCore(
         spawn_thread();
     }
 }
-ComputationThreadPoolCore::~ComputationThreadPoolCore(){
+
+void ComputationThreadPoolCore::stop() {
     {
         std::lock_guard<std::mutex> lg(m_lock);
+        if (m_stopping) return;
         m_stopping = true;
         m_thread_cv.notify_all();
 //        m_dispatch_cv.notify_all();
     }
     for (ThreadData& thread : m_threads){
-        thread.thread.join();
+        if (thread.thread.joinable()) {
+            thread.thread.join();
+        }
     }
+
+    // DO NOT JOIN AGAIN IN DESTRUCTOR
+    m_threads.clear();
+
     for (auto& task : m_queue){
         task->report_cancelled();
     }
+
+    // DO NOT CLEAR AGAIN IN DESTRUCTOR
+    m_queue.clear();
+
 }
 
+ComputationThreadPoolCore::~ComputationThreadPoolCore(){
+    stop();
+}
+
+
+
+
 WallDuration ComputationThreadPoolCore::cpu_time() const{
     //  TODO: Don't lock the entire queue.
     WallDuration ret = WallDuration::zero();

Common/Cpp/Concurrency/ComputationThreadPoolCore.h

@@ -47,6 +47,8 @@ class ComputationThreadPoolCore final{
     WallDuration cpu_time() const;
 
     void ensure_threads(size_t threads);
+
+    void stop();
 //    void wait_for_everything();
 
 

Common/Cpp/Concurrency/FireForgetDispatcher.cpp

@@ -22,14 +22,22 @@ FireForgetDispatcher global_dispatcher;
 FireForgetDispatcher::FireForgetDispatcher()
     : m_stopping(false)
 {}
-FireForgetDispatcher::~FireForgetDispatcher(){
+
+void FireForgetDispatcher::stop() {
     {
         std::lock_guard<std::mutex> lg(m_lock);
+        // like with the other thread option, make sure we're not double stopping
+        if (m_stopping) return;
         m_stopping = true;
         m_cv.notify_all();
     }
     m_thread.join();
 }
+
+FireForgetDispatcher::~FireForgetDispatcher(){
+    stop();
+}
+
 void FireForgetDispatcher::dispatch(std::function<void()>&& func){
     std::lock_guard<std::mutex> lg(m_lock);
     m_queue.emplace_back(std::move(func));

Common/Cpp/Concurrency/FireForgetDispatcher.h

@@ -25,6 +25,8 @@ class FireForgetDispatcher{
     //  Call "handle->wait()" to wait for the task to finish.
     void dispatch(std::function<void()>&& func);
 
+    void stop();
+
 
 private:
     void thread_loop();

Common/Cpp/Concurrency/Thread.cpp

@@ -82,6 +82,10 @@ void Thread::join(){
 }
 
 
+bool Thread::joinable() const{
+    return m_data && m_data->m_thread.joinable();
+}
+
 
 
 }

Common/Cpp/Concurrency/Thread.h

@@ -35,6 +35,7 @@ class Thread{
         return m_data;
     }
     void join();
+    bool joinable() const;
 
 private:
     enum class State;

SerialPrograms/Source/CommonFramework/Main.cpp

@@ -5,8 +5,10 @@
 //#include <QTextStream>
 #include <QMessageBox>
 #include "Common/Cpp/Concurrency/AsyncTask.h"
+#include "Common/Cpp/Concurrency/FireForgetDispatcher.h"
 #include "Common/Cpp/Exceptions.h"
 #include "Common/Cpp/ImageResolution.h"
+#include "CommonFramework/Tools/GlobalThreadPools.h"
 #include "Globals.h"
 #include "GlobalSettingsPanel.h"
 #include "PersistentSettings.h"
@@ -149,6 +151,12 @@ int main(int argc, char *argv[]){
     Integration::DppClient::Client::instance().disconnect();
 #endif
 
+    // Force stop the thread pool
+    PokemonAutomation::GlobalThreadPools::realtime_inference().stop();
+    PokemonAutomation::GlobalThreadPools::normal_inference().stop();
+
+    PokemonAutomation::global_dispatcher.stop();
+
     //  We must clear the OCR cache or it will crash on Linux when the library
     //  unloads before the cache is destructed from static memory.
     OCR::clear_cache();