Task execution mechanism moved task state field from volatile to atomic

Author: sadko4u

CHANGELOG

@@ -3,6 +3,7 @@
 *******************************************************************************
 
 === 1.0.31 ===
+* Task execution mechanism moved task state field from volatile to atomic.
 * Updated LLTL hashing specifications.
 * Fixed $XDG_CONFIG_HOME being ignored.
 

include/lsp-plug.in/ipc/IExecutor.h

@@ -33,9 +33,14 @@ namespace lsp
         class IExecutor
         {
             protected:
-                static inline void change_task_state(ITask *task, ITask::task_state_t state)
+                static inline void set_task_state(ITask *task, ITask::task_state_t state)
                 {
-                    task->nState    = state;
+                    atomic_store(&task->nState, state);
+                }
+
+                static inline bool change_task_state(ITask *task, ITask::task_state_t old_state, ITask::task_state_t new_state)
+                {
+                    return atomic_cas(&task->nState, old_state, new_state);
                 }
 
                 static inline void link_task(ITask *tail, ITask *link)

include/lsp-plug.in/ipc/ITask.h

@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2024 Linux Studio Plugins Project <https://lsp-plug.in/>
- *           (C) 2024 Vladimir Sadovnikov <sadko4u@gmail.com>
+ * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
+ *           (C) 2025 Vladimir Sadovnikov <sadko4u@gmail.com>
  *
  * This file is part of lsp-runtime-lib
  * Created on: 27 янв. 2016 г.
@@ -23,6 +23,7 @@
 #define LSP_PLUG_IN_IPC_ITASK_H_
 
 #include <lsp-plug.in/runtime/version.h>
+#include <lsp-plug.in/common/atomic.h>
 #include <lsp-plug.in/common/status.h>
 #include <lsp-plug.in/ipc/IRunnable.h>
 
@@ -50,7 +51,7 @@ namespace lsp
                 ITask                  *pNext;          // Pointer to next task queue
                 ipc::IExecutor         *pExecutor;      // Nested executor if present
                 int                     nCode;          // Execution code
-                volatile task_state_t   nState;         // Task state
+                int                     nState;         // Task state
 
             protected:
                 // Executor service
@@ -62,67 +63,65 @@ namespace lsp
                 ITask();
                 ITask(const ITask &) = delete;
                 ITask(ITask &&) = delete;
-                virtual ~ITask();
+                virtual ~ITask() override;
 
                 ITask & operator = (const ITask &) = delete;
                 ITask & operator = (ITask &&) = delete;
 
             public:
-                virtual status_t run();
+                virtual status_t run() override;
 
             public:
+                /** Get current state of task
+                 *
+                 * @return current task state
+                 */
+                inline task_state_t state() const   { return task_state_t(atomic_load(&nState));    }
+
                 /** Check that task status is idle
                  *
                  * @return true if task status is idle
                  */
-                inline bool idle() const        { return nState == TS_IDLE;         };
+                inline bool idle() const            { return state() == TS_IDLE;        }
 
                 /** Check that task status is submitted
                  *
                  * @return true if task status is submitted
                  */
-                inline bool submitted() const   { return nState == TS_SUBMITTED;    };
+                inline bool submitted() const       { return state() == TS_SUBMITTED;   }
 
                 /** Check that task status is running
                  *
                  * @return true if task status is running
                  */
-                inline bool running() const     { return nState == TS_RUNNING;      };
+                inline bool running() const         { return state() == TS_RUNNING;     }
 
                 /** Check that task status is completed
                  *
                  * @return true if task status is completed
                  */
-                inline bool completed() const   { return nState == TS_COMPLETED;    };
+                inline bool completed() const       { return state() == TS_COMPLETED;   }
 
                 /** Check that execution was successful
                  *
                  * @return true if execution was successful;
                  */
-                inline bool successful() const  { return successful(nCode);         };
+                inline bool successful() const      { return successful(nCode);         }
 
                 /** Get last execution code
                  *
                  * @return last execution code
                  */
-                inline int code() const         { return nCode;                     };
-
-                /** Get current state of task
-                 *
-                 * @return current task state
-                 */
-                inline task_state_t state() const {return nState;                   };
+                inline int code() const             { return nCode;                     }
 
-                /** Reset task state
+                /**
+                 * Reset task state. The state can be reset only if task is in completed state.
                  *
-                 * @return task state
+                 * @return true if task has been reset
                  */
                 inline bool reset()
                 {
-                    if (nState != TS_COMPLETED)
-                        return false;
-                    nState      = TS_IDLE;
-                    return true;
+                    return atomic_cas(&nState, TS_COMPLETED, TS_IDLE);
                 }
         };
 

src/main/ipc/IExecutor.cpp

@@ -36,10 +36,12 @@ namespace lsp
 
         void IExecutor::run_task(ITask *task)
         {
-            task->nState    = ITask::TS_RUNNING;
+            atomic_store(&task->nState, ITask::TS_RUNNING);
             task->nCode     = 0;
+
             task->nCode     = task->run();
-            task->nState    = ITask::TS_COMPLETED;
+
+            atomic_store(&task->nState, ITask::TS_COMPLETED);
 
             // Run callback method
             task_finished(task);

src/main/ipc/ITask.cpp

@@ -31,7 +31,8 @@ namespace lsp
             pNext       = NULL;
             pExecutor   = NULL;
             nCode       = 0;
-            nState      = TS_IDLE;
+
+            atomic_store(&nState, TS_IDLE);
         }
 
         ITask::~ITask()

src/main/ipc/NativeExecutor.cpp

@@ -49,16 +49,18 @@ namespace lsp
         bool NativeExecutor::submit(ITask *task)
         {
             lsp_trace("submit task=%p", task);
-            // Check task state
-            if (!task->idle())
+
+            // Update task state to SUBMITTED
+            if (!change_task_state(task, ITask::TS_IDLE, ITask::TS_SUBMITTED))
                 return false;
 
             // Try to acquire critical section
             if (!atomic_trylock(nLock))
+            {
+                set_task_state(task, ITask::TS_IDLE);
                 return false;
-
-            // Update task state to SUBMITTED
-            change_task_state(task, ITask::TS_SUBMITTED);
+            }
+            lsp_finally { atomic_unlock(nLock); };
 
             // Critical section acquired, bind new task
             // Check that queue is empty
@@ -68,8 +70,6 @@ namespace lsp
                 pHead   = task;
             pTail   = task;
 
-            // Release critical section
-            atomic_unlock(nLock);
             return true;
         }
 
@@ -151,8 +151,8 @@ namespace lsp
 
         status_t NativeExecutor::execute(void *params)
         {
-            NativeExecutor *_this = reinterpret_cast<NativeExecutor *>(params);
-            _this->run();
+            NativeExecutor *self = reinterpret_cast<NativeExecutor *>(params);
+            self->run();
             return STATUS_OK;
         }