Simplify the operation of test and set

1. When creating the future, set the future's flag, which is akin to
assigning the job. Afterward, transfer the ownership to the worker.
Once the worker completes the job, clear the flag and return the
ownership, which is akin to submitting a job. Then, the main thread
can regain ownership. By doing this, the main thread can wait directly
for the result through test and set without checking if the result is
NULL. This avoids the situation where the flag could be set to true by
the main thread before the worker starts the job. Additionally, the
worker does not need to check with test and set before performing the
job.

2. Drop the `atomic_flag_clear` in `tpool_future_wait` function and then
directly free the pointer of future and its result in
`tpool_future_destroy` function.

3. Rename the variable 'lock' in the future structure to 'flag'. Rename
the function name `tpool_future_get` to `tpool_future_wait`.

Co-authored-by: Chih-Wei Chien <[email protected]>
Signed-off-by: Wei-Hsin Yeh <[email protected]>

Author: weihsinyeh

examples/rmw_example.c

@@ -6,7 +6,6 @@
 #include <assert.h>
 
 #include <math.h>
-#include <stddef.h>
 
 #define PRECISION 100 /* upper bound in BPP sum */
 
@@ -15,7 +14,7 @@
 
 struct tpool_future {
     void *result;
-    atomic_flag lock;
+    atomic_flag flag;
 };
 
 typedef struct job {
@@ -48,32 +47,22 @@ static struct tpool_future *tpool_future_create(void)
     struct tpool_future *future = malloc(sizeof(struct tpool_future));
     if (future) {
         future->result = NULL;
-        atomic_flag_clear(&future->lock);
+        atomic_flag_clear(&future->flag);
+        atomic_flag_test_and_set(&future->flag);
     }
     return future;
 }
 
-void tpool_future_get(struct tpool_future *future)
+void tpool_future_wait(struct tpool_future *future)
 {
-    while (future->result == NULL)
+    while (atomic_flag_test_and_set(&future->flag))
         ;
-    while (atomic_flag_test_and_set(&future->lock))
-        ;
-    atomic_flag_clear(&future->lock);
 }
 
-int tpool_future_destroy(struct tpool_future *future)
+void tpool_future_destroy(struct tpool_future *future)
 {
-    if (future) {
-        while (atomic_flag_test_and_set(&future->lock))
-            ;
-        if (future->result != NULL) {
-            free(future);
-        } else {
-            atomic_flag_clear(&future->lock);
-        }
-    }
-    return 0;
+    free(future->result);
+    free(future);
 }
 
 static int worker(void *args)
@@ -95,12 +84,8 @@ static int worker(void *args)
                 atomic_store(&thrd_pool->state, idle);
             } else {
                 void *ret_value = job->func(job->args);
-
-                while (atomic_flag_test_and_set(&job->future->lock))
-                    ;
                 job->future->result = ret_value;
-
-                atomic_flag_clear(&job->future->lock);
+                atomic_flag_clear(&job->future->flag);
                 free(job->args);
                 free(job);
             }
@@ -243,7 +228,7 @@ int main()
         add_job(&thrd_pool, bbp, id);
     }
     for (int i = 0; i <= PRECISION; i++) {
-        tpool_future_get(futures[i]);
+        tpool_future_wait(futures[i]);
         bbp_sum += *(double *)(futures[i]->result);
         tpool_future_destroy(futures[i]);
     }