Made keep alive a runtime setting instead

Author: markoostveen

JobSystem/Src/CMakeLists.txt

@@ -19,9 +19,6 @@ set(JobSystemHeaderDirectory "${CMAKE_CURRENT_SOURCE_DIR}/")
 find_package(Threads REQUIRED)
 
 add_library (JobSystem STATIC ${JobSystemSources})
-if(${JOBSYSTEM_KEEP_ALIVE})
-  target_compile_definitions(JobSystem PUBLIC JBSYSTEM_KEEP_ALIVE)
-endif()
 target_include_directories(JobSystem PUBLIC ${JobSystemHeaderDirectory})
 set_property(TARGET JobSystem PROPERTY CXX_STANDARD 23)
 

JobSystem/Src/JobSystem/JobSystem.cpp

@@ -86,7 +86,7 @@ namespace JbSystem
         return false;
     }
 
-    JobSystem::JobSystem(unsigned int threadCount, WorkerThreadLoop workerLoop) : _showStats(true)
+    JobSystem::JobSystem(unsigned int threadCount, WorkerThreadLoop workerLoop) : _showStats(true), _keepAlive(false)
     {
         if (threadCount < _minimumActiveWorkers)
         {
@@ -255,6 +255,16 @@ namespace JbSystem
         return remainingJobs;
     }
 
+    void JobSystem::SetKeepAlive(bool option)
+    {
+        _keepAlive.store(option);
+    }
+
+    bool JobSystem::IsKeepAliveEnabled() const
+    {
+        return _keepAlive.load(std::memory_order_relaxed);
+    }
+
     void JobSystem::WaitForAllJobs()
     {
         bool wasActive = false;

JobSystem/Src/JobSystem/JobSystem.h

@@ -184,6 +184,10 @@ namespace JbSystem
         void OptimizePerformance();
         void MaybeOptimize();
 
+        void SetKeepAlive(bool option);
+
+        bool IsKeepAliveEnabled() const;
+
         /// <summary>
         /// is the job system active or not
         /// </summary>
@@ -261,6 +265,8 @@ namespace JbSystem
         // Deadlock prevention
         JbSystem::Mutex _spawnedThreadsMutex;
         std::unordered_map<std::thread::id, std::thread> _spawnedThreadsExecutingIgnoredJobs;
+
+        std::atomic<bool> _keepAlive;
     };
 
     template <typename... Args>

JobSystem/Src/JobSystem/WorkerThread.cpp

@@ -112,11 +112,14 @@ namespace JbSystem
         {
             _jobsystem->WorkerLoop(this);
 
-#ifdef JBSYSTEM_KEEP_ALIVE
-            std::this_thread::yield();
-#else
-            break;
-#endif
+            if (_jobsystem->IsKeepAliveEnabled())
+            {
+                std::this_thread::yield();
+            }
+            else
+            {
+                break;
+            }
         }
     }
 
@@ -198,46 +201,28 @@ namespace JbSystem
 
         _modifyingThread.lock();
 
-#ifndef JBSYSTEM_KEEP_ALIVE
-        if (IsActive() || _shutdownRequested.load())
-        {
-            _modifyingThread.unlock();
-            return;
-        }
-
-        if (_worker.get_id() != std::thread::id())
+        if (_jobsystem->IsKeepAliveEnabled())
         {
-            if (_worker.joinable())
-                _worker.join();
-            else
-                _worker.detach();
-        }
-
-        _shutdownRequested.store(false);
-        Active.store(true);
-        _worker = std::thread(
-            [this](JobSystemWorker* worker)
+            if (IsActive() || _shutdownRequested.load())
             {
-                std::unique_lock ul(_isRunningMutex);
-                _isRunning.store(true);
-
-                worker->KeepAliveLoop();
-                _isRunning.store(false);
-                Active.store(false);
-            },
-            this);
-#else
-        if (!_shutdownRequested.load())
-        {
-            Active.store(true);
-            if (_worker.joinable())
+                _modifyingThread.unlock();
+                return;
+            }
+
+            if (_worker.get_id() != std::thread::id())
             {
-                _worker.join();
+                if (_worker.joinable())
+                    _worker.join();
+                else
+                    _worker.detach();
             }
+
+            _shutdownRequested.store(false);
+            Active.store(true);
             _worker = std::thread(
                 [this](JobSystemWorker* worker)
                 {
-                    const std::unique_lock ul(_isRunningMutex);
+                    std::unique_lock ul(_isRunningMutex);
                     _isRunning.store(true);
 
                     worker->KeepAliveLoop();
@@ -246,7 +231,28 @@ namespace JbSystem
                 },
                 this);
         }
-#endif
+        else
+        {
+            if (!_shutdownRequested.load())
+            {
+                Active.store(true);
+                if (_worker.joinable())
+                {
+                    _worker.detach();
+                }
+                _worker = std::thread(
+                    [this](JobSystemWorker* worker)
+                    {
+                        const std::unique_lock ul(_isRunningMutex);
+                        _isRunning.store(true);
+
+                        worker->KeepAliveLoop();
+                        _isRunning.store(false);
+                        Active.store(false);
+                    },
+                    this);
+            }
+        }
 
         _modifyingThread.unlock();
         _jobsystem->OptimizePerformance(); // Determin best scaling options