Add (untested) event Qt thread pool.

Author: Mysticial

Common/Qt/QtThreadPool.cpp

@@ -124,4 +124,64 @@ void QtWorkerThreadPool::run_and_wait(std::function<void()> lambda){
 
 
 
+
+
+
+
+
+
+QtEventThreadPool::~QtEventThreadPool(){
+    stop();
+}
+void QtEventThreadPool::stop(){
+    m_threads.clear();
+    m_available_threads.clear();
+}
+
+
+
+
+
+
+QObject* QtEventThreadPool::add_object(std::function<std::unique_ptr<QObject>()> factory){
+    QtEventThread& thread = get_thread();
+    QObject* ret = thread.add_object(std::move(factory));
+    try{
+        m_objects[ret] = &thread;
+    }catch (...){
+        thread.remove_object();
+        std::lock_guard<Mutex> lg(m_lock);
+        m_available_threads.emplace_back(&thread);
+        throw;
+    }
+    return ret;
+}
+void QtEventThreadPool::remove_object(QObject* object) noexcept{
+    std::lock_guard<Mutex> lg(m_lock);
+    auto iter = m_objects.find(object);
+    if (iter == m_objects.end()){
+        return;
+    }
+    iter->second->remove_object();
+    m_available_threads.emplace_back(iter->second);
+    m_objects.erase(iter);
+}
+
+QtEventThread& QtEventThreadPool::get_thread(){
+    std::lock_guard<Mutex> lg(m_lock);
+    if (m_available_threads.empty()){
+        m_available_threads.reserve(m_threads.size() + 1);
+        auto& new_thread = m_threads.emplace_back();
+        m_available_threads.emplace_back(&new_thread);
+    }
+    QtEventThread* ret = m_available_threads.back();
+    m_available_threads.pop_back();
+    return *ret;
+}
+
+
+
+
+
+
 }

Common/Qt/QtThreadPool.h

@@ -8,6 +8,8 @@
 #define PokemonAutomation_QtThreadPool_H
 
 #include <vector>
+#include <deque>
+#include <map>
 #include <QThread>
 #include "Common/Cpp/Concurrency/Mutex.h"
 #include "Common/Cpp/Concurrency/ConditionVariable.h"
@@ -16,6 +18,7 @@ namespace PokemonAutomation{
 
 
 class QtWorkerThread;
+class QtEventThread;
 
 
 
@@ -42,6 +45,72 @@ class QtWorkerThreadPool{
 
 
 
+class QtEventThread : public QThread{
+    Q_OBJECT
+
+public:
+    QtEventThread(){
+        start();
+    }
+    ~QtEventThread(){
+        quit();
+        wait();
+    }
+
+    QObject* add_object(std::function<std::unique_ptr<QObject>()> factory){
+        m_pending_factory = std::move(factory);
+        emit add_object_internal();
+        std::unique_lock<Mutex> lg(m_lock);
+        m_cv.wait(lg, [this]{ return m_pending_factory == nullptr; });
+        return m_object.get();
+    }
+    void remove_object(){
+        emit remove_object_internal();
+        std::unique_lock<Mutex> lg(m_lock);
+        m_cv.wait(lg, [this]{ return m_object == nullptr; });
+    }
+
+public slots:
+    void add_object_internal(){
+        m_object = m_pending_factory();
+    }
+    void remove_object_internal(){
+        m_object.reset();
+    }
+
+private:
+    Mutex m_lock;
+    ConditionVariable m_cv;
+
+    std::function<std::unique_ptr<QObject>()> m_pending_factory;
+    std::unique_ptr<QObject> m_object;
+};
+
+
+
+class QtEventThreadPool : public QObject{
+public:
+    ~QtEventThreadPool();
+    void stop();
+
+    QObject* add_object(std::function<std::unique_ptr<QObject>()> factory);
+    void remove_object(QObject* object) noexcept;
+
+
+private:
+    QtEventThread& get_thread();
+
+
+private:
+    std::map<QObject*, QtEventThread*> m_objects;
+
+    Mutex m_lock;
+
+    bool m_stopping = false;
+    std::deque<QtEventThread> m_threads;
+    std::vector<QtEventThread*> m_available_threads;
+};
+
 
 
 

SerialPrograms/Source/CommonFramework/AudioPipeline/Backends/AudioPassthroughPairQt.h

@@ -8,7 +8,7 @@
 #define PokemonAutomation_AudioPipeline_AudioPassthroughPairQt_H
 
 #include <memory>
-#include <set>
+//#include <set>
 #include <QObject>
 #include "Common/Cpp/ListenerSet.h"
 #include "Common/Cpp/LifetimeSanitizer.h"

SerialPrograms/Source/CommonFramework/Main.cpp

@@ -106,10 +106,18 @@ int run_program(int argc, char *argv[]){
     QDir().mkpath(QString::fromStdString(SETTINGS_PATH()));
     QDir().mkpath(QString::fromStdString(SCREENSHOTS_PATH()));
 
+
+
     //  Preload all the cameras now so we don't hang the UI later on.
-    ScopeExit cameras([]{ GlobalMediaServices::instance().stop(); });
+    ScopeExit cameras([]{
+        GlobalMediaServices::instance().stop();
+    });
     get_all_cameras();
 
+    //  Force all the Qt thread pools to be constructed now on the main thread.
+    GlobalThreadPools::qt_worker_threadpool();
+    GlobalThreadPools::qt_event_threadpool();
+
     //  Several novice developers struggled to build and run the program due to missing Resources folder.
     //  Add this check to pop a message box when Resources folder is missing.
     if (!check_resource_folder(logger)){
@@ -226,15 +234,20 @@ int main(int argc, char *argv[]){
     global_watchdog().stop();
     static_cast<FileWindowLogger&>(global_logger_raw()).stop();
 
+    //  When we actually migrate to Qt 6.9+, we may need to move the exit(0)
+    //  call here since joining *any* threads may hang.
+
     //  Force stop the thread pools.
+    //  This is where all the threads in the program are joined.
     PokemonAutomation::GlobalThreadPools::computation_realtime().stop();
     PokemonAutomation::GlobalThreadPools::computation_normal().stop();
     PokemonAutomation::GlobalThreadPools::unlimited_realtime().stop();
     PokemonAutomation::GlobalThreadPools::unlimited_normal().stop();
-    GlobalThreadPools::qt_worker_threadpool().stop();
-
     PokemonAutomation::global_dispatcher.stop();
 
+    GlobalThreadPools::qt_worker_threadpool().stop();
+    GlobalThreadPools::qt_event_threadpool().stop();
+
     cout << "Exiting main()..." << endl;
 
 

SerialPrograms/Source/CommonFramework/Tools/GlobalThreadPoolsQt.cpp

@@ -17,6 +17,12 @@ QtWorkerThreadPool& qt_worker_threadpool(){
 }
 
 
+QtEventThreadPool& qt_event_threadpool(){
+    static QtEventThreadPool pool;
+    return pool;
+}
+
+
 
 }
 }

SerialPrograms/Source/CommonFramework/Tools/GlobalThreadPoolsQt.h

@@ -18,10 +18,14 @@ namespace PokemonAutomation{
 namespace GlobalThreadPools{
 
 
-
+//  Temporary and only used for audio template loading.
+//  Hopefully we can remove this in the near future.
 QtWorkerThreadPool& qt_worker_threadpool();
 
 
+QtEventThreadPool& qt_event_threadpool();
+
+
 
 }
 }