name change

Author: David-Haim

include/concurrencpp/executors/worker_thread_executor.h

@@ -19,7 +19,7 @@ namespace concurrencpp {
         alignas(CRCPP_CACHE_LINE_ALIGNMENT) std::mutex m_lock;
         std::deque<task> m_public_queue;
         bool m_abort;
-        std::atomic<details::queue_status> m_status;
+        std::atomic<details::queue_status> m_public_queue_status;
         details::thread m_thread;
         const std::function<void(std::string_view)> m_thread_started_callback;
         const std::function<void(std::string_view)> m_thread_terminated_callback;

source/executors/worker_thread_executor.cpp

@@ -12,17 +12,17 @@ using concurrencpp::worker_thread_executor;
 worker_thread_executor::worker_thread_executor(const std::function<void(std::string_view thread_name)>& thread_started_callback,
                                                const std::function<void(std::string_view thread_name)>& thread_terminated_callback) :
     derivable_executor<concurrencpp::worker_thread_executor>(details::consts::k_worker_thread_executor_name),
-    m_private_atomic_abort(false), m_abort(false), m_status(details::queue_status::empty), m_thread_started_callback(thread_started_callback),
+    m_private_atomic_abort(false), m_abort(false), m_public_queue_status(details::queue_status::empty), m_thread_started_callback(thread_started_callback),
     m_thread_terminated_callback(thread_terminated_callback) {}
 
 void worker_thread_executor::notify_task_exists() noexcept {
     auto expected = details::queue_status::empty;
-    const auto swapped = m_status.compare_exchange_strong(expected,
+    const auto swapped = m_public_queue_status.compare_exchange_strong(expected,
                                                           details::queue_status::task_available,
                                                           std::memory_order_relaxed,
                                                           std::memory_order_relaxed);
     if (swapped) {
-        details::atomic_notify_one(m_status);
+        details::atomic_notify_one(m_public_queue_status);
     }
 }
 
@@ -56,7 +56,7 @@ void worker_thread_executor::work_loop() {
 
     auto yield_fn = [this]() noexcept -> bool {
         for (size_t i = 0; i < 2 * 1024; i++) {
-            const auto status = m_status.load(std::memory_order_relaxed);
+            const auto status = m_public_queue_status.load(std::memory_order_relaxed);
             if (status != details::queue_status::empty) {
                 return true;
             }
@@ -70,13 +70,13 @@ void worker_thread_executor::work_loop() {
     while (true) {
         assert(m_private_queue.empty());
 
-        auto status = m_status.load(std::memory_order_relaxed);
+        auto status = m_public_queue_status.load(std::memory_order_relaxed);
         if (status == details::queue_status::abort) {
             return;
         }
 
         if (status == details::queue_status::task_available) {
-            const auto swapped = m_status.compare_exchange_strong(status,
+            const auto swapped = m_public_queue_status.compare_exchange_strong(status,
                                                                   details::queue_status::empty,
                                                                   std::memory_order_relaxed,
                                                                   std::memory_order_relaxed);
@@ -103,7 +103,7 @@ void worker_thread_executor::work_loop() {
         }
 
         assert(status == details::queue_status::empty);
-        details::atomic_wait(m_status, details::queue_status::empty, std::memory_order_relaxed);
+        details::atomic_wait(m_public_queue_status, details::queue_status::empty, std::memory_order_relaxed);
     }
 }
 
@@ -124,7 +124,7 @@ void worker_thread_executor::enqueue_local(std::span<concurrencpp::task> tasks)
 }
 
 void worker_thread_executor::enqueue_foreign(concurrencpp::task& task) {
-    if (m_status.load(std::memory_order_relaxed) == details::queue_status::abort) {
+    if (m_public_queue_status.load(std::memory_order_relaxed) == details::queue_status::abort) {
         details::throw_runtime_shutdown_exception(name);
     }
 
@@ -145,7 +145,7 @@ void worker_thread_executor::enqueue_foreign(concurrencpp::task& task) {
 }
 
 void worker_thread_executor::enqueue_foreign(std::span<concurrencpp::task> tasks) {
-    if (m_status.load(std::memory_order_relaxed) == details::queue_status::abort) {
+    if (m_public_queue_status.load(std::memory_order_relaxed) == details::queue_status::abort) {
         details::throw_runtime_shutdown_exception(name);
     }
 
@@ -186,18 +186,18 @@ int worker_thread_executor::max_concurrency_level() const noexcept {
 }
 
 bool worker_thread_executor::shutdown_requested() const {
-    return m_status.load(std::memory_order_relaxed) == details::queue_status::abort;
+    return m_public_queue_status.load(std::memory_order_relaxed) == details::queue_status::abort;
 }
 
 void worker_thread_executor::shutdown() {
-    const auto status = m_status.exchange(details::queue_status::abort, std::memory_order_relaxed);
+    const auto status = m_public_queue_status.exchange(details::queue_status::abort, std::memory_order_relaxed);
     if (status == details::queue_status::abort) {
         return;  // shutdown had been called before.
     }
 
     m_private_atomic_abort.store(true, std::memory_order_relaxed);
 
-    details::atomic_notify_one(m_status);
+    details::atomic_notify_one(m_public_queue_status);
 
     decltype(m_thread) worker;
     {