Add more operation analysis, combine with deletes and inserts variables.

And Using the preprocessor to decide the analysis being set or not.

The following are the new varialbes to record the opreations:

rtry is the number of retries in the __list_find function.
cons is the number of wait-free contains in the __list_find function that curr pointer pointed.
trav is the number of list element traversal in the __list_find function.
fail is the number of CAS() failures.
del  is the number of list_delete operation failed and restart again.
ins  is the number of list_insert operation failed and restart again.

Author: linD026

hp_list/Makefile

@@ -1,6 +1,11 @@
 all:
 	$(CC) -Wall -o list main.c -lpthread -g -fsanitize=thread
 
+# The RUNTIME_STAT allow to show the runtime operation state,
+# such as "rtry" is the number of retries in the __list_find function.
+analysis:
+	$(CC) -Wall -D RUNTIME_STAT -o list main.c -lpthread -g -fsanitize=thread
+
 indent:
 	clang-format -i *.[ch]
 

hp_list/main.c

@@ -14,6 +14,110 @@
 #include <string.h>
 #include <threads.h>
 
+#ifdef RUNTIME_STAT
+/*
+ * "rtry" the number of retries in the __list_find function.
+ * "cons" the number of wait-free contains in the __list_find function that curr
+ * pointer pointed.
+ * "trav" the number of list element traversal in the __list_find function.
+ * "fail" the number of CAS() failures.
+ * "del" the number of list_delete operation failed and restart again.
+ * "ins" the number of list_insert operation failed and restart again.
+ */
+static atomic_uint_fast64_t rtry = 0, cons = 0, trav = 0, fail = 0;
+static atomic_uint_fast64_t del = 0, ins = 0;
+static atomic_uint_fast64_t deletes = 0, inserts = 0;
+
+#define TRACE_GOTO_TRY_AGAIN        \
+    do {                            \
+        atomic_fetch_add(&rtry, 1); \
+        goto try_again;             \
+    } while (0)
+#define TRACE_WAIT_FREE_CONS        \
+    do {                            \
+        atomic_fetch_add(&cons, 1); \
+    } while (0)
+#define TRACE_TRAVERSAL             \
+    do {                            \
+        atomic_fetch_add(&trav, 1); \
+    } while (0)
+#define CAS(obj, expected, desired)                             \
+    ({                                                          \
+        atomic_fetch_add(&fail, 1);                             \
+        atomic_compare_exchange_strong(obj, expected, desired); \
+    })
+#define TRACE_DEL                  \
+    do {                           \
+        atomic_fetch_add(&del, 1); \
+    } while (0)
+#define TRACE_INS                  \
+    do {                           \
+        atomic_fetch_add(&ins, 1); \
+    } while (0)
+#define TRACE_DELETES                  \
+    do {                               \
+        atomic_fetch_add(&deletes, 1); \
+    } while (0)
+#define TRACE_INSERTS                  \
+    do {                               \
+        atomic_fetch_add(&inserts, 1); \
+    } while (0)
+
+void analysis_func(void)
+{
+    printf("\"rtry\" is the number of retries in the __list_find function.\n");
+    printf(
+        "\"cons\" is the number of wait-free contains in the __list_find "
+        "function that curr pointer pointed.\n");
+    printf(
+        "\"trav\" is the number of list element traversal in the __list_find "
+        "function.\n");
+    printf("\"fail\" is the number of CAS() failures.\n");
+    printf(
+        "\"del\"  is the number of list_delete operation failed and restart "
+        "again.\n");
+    printf(
+        "\"ins\"  is the number of list_insert operation failed and restart "
+        "again.\n");
+    printf("\"deletes\" is the number of linked list elements deleted.\n");
+    printf("\"inserts\" is the number of linked list elements created.\n");
+    printf("\n%10s %10s %10s %10s %10s %10s %10s %10s\n", "rtry", "cons",
+           "trav", "fail", "del", "ins", "deletes", "inserts");
+    for (int i = 0; i < 87; i++)
+        printf("-");
+    printf("\n%10ld %10ld %10ld %10ld %10ld %10ld %10ld %10ld\n", rtry, cons,
+           trav, fail, del, ins, deletes, inserts);
+}
+
+#else
+
+#define TRACE_GOTO_TRY_AGAIN \
+    do {                     \
+        goto try_again;      \
+    } while (0)
+#define TRACE_WAIT_FREE_CONS \
+    do {                     \
+    } while (0)
+#define TRACE_TRAVERSAL \
+    do {                \
+    } while (0)
+#define CAS(obj, expected, desired) \
+    ({ atomic_compare_exchange_strong(obj, expected, desired); })
+#define TRACE_DEL \
+    do {          \
+    } while (0)
+#define TRACE_INS \
+    do {          \
+    } while (0)
+#define TRACE_DELETES \
+    do {              \
+    } while (0)
+#define TRACE_INSERTS \
+    do {              \
+    } while (0)
+
+#endif
+
 #define HP_MAX_THREADS 128
 #define HP_MAX_HPS 5 /* This is named 'K' in the HP paper */
 #define CLPAD (128 / sizeof(uintptr_t))
@@ -162,8 +266,6 @@ void list_hp_retire(list_hp_t *hp, uintptr_t ptr)
 #define N_THREADS (128 / 2)
 #define MAX_THREADS 128
 
-static atomic_uint_fast32_t deletes = 0, inserts = 0;
-
 enum { HP_NEXT = 0, HP_CURR = 1, HP_PREV };
 
 #define is_marked(p) (bool) ((uintptr_t)(p) &0x01)
@@ -195,7 +297,7 @@ list_node_t *list_node_new(list_key_t key)
     list_node_t *node = aligned_alloc(128, sizeof(*node));
     assert(node);
     *node = (list_node_t){.magic = LIST_MAGIC, .key = key};
-    (void) atomic_fetch_add(&inserts, 1);
+    TRACE_INSERTS;
     return node;
 }
 
@@ -205,7 +307,7 @@ void list_node_destroy(list_node_t *node)
         return;
     assert(node->magic == LIST_MAGIC);
     free(node);
-    (void) atomic_fetch_add(&deletes, 1);
+    TRACE_DELETES;
 }
 
 static void __list_node_delete(void *arg)
@@ -228,18 +330,22 @@ static bool __list_find(list_t *list,
     curr = (list_node_t *) atomic_load(prev);
     (void) list_hp_protect_ptr(list->hp, HP_CURR, (uintptr_t) curr);
     if (atomic_load(prev) != get_unmarked(curr))
-        goto try_again;
+        TRACE_GOTO_TRY_AGAIN;
     while (true) {
+#ifdef RUNTIME_STAT
+        if (is_marked(curr))
+            TRACE_WAIT_FREE_CONS;
+#endif
         next = (list_node_t *) atomic_load(&get_unmarked_node(curr)->next);
         (void) list_hp_protect_ptr(list->hp, HP_NEXT, get_unmarked(next));
         /* On a CAS failure, the search function, "__list_find," will simply
          * have to go backwards in the list until an unmarked element is found
          * from which the search in increasing key order can be started.
          */
         if (atomic_load(&get_unmarked_node(curr)->next) != (uintptr_t) next)
-            goto try_again;
+            TRACE_GOTO_TRY_AGAIN;
         if (atomic_load(prev) != get_unmarked(curr))
-            goto try_again;
+            TRACE_GOTO_TRY_AGAIN;
         if (get_unmarked_node(next) == next) {
             if (!(get_unmarked_node(curr)->key < *key)) {
                 *par_curr = curr;
@@ -252,12 +358,13 @@ static bool __list_find(list_t *list,
                                            get_unmarked(curr));
         } else {
             uintptr_t tmp = get_unmarked(curr);
-            if (!atomic_compare_exchange_strong(prev, &tmp, get_unmarked(next)))
-                goto try_again;
+            if (!CAS(prev, &tmp, get_unmarked(next)))
+                TRACE_GOTO_TRY_AGAIN;
             list_hp_retire(list->hp, get_unmarked(curr));
         }
         curr = next;
         (void) list_hp_protect_release(list->hp, HP_CURR, get_unmarked(next));
+        TRACE_TRAVERSAL;
     }
 }
 
@@ -277,10 +384,11 @@ bool list_insert(list_t *list, list_key_t key)
         atomic_store_explicit(&node->next, (uintptr_t) curr,
                               memory_order_relaxed);
         uintptr_t tmp = get_unmarked(curr);
-        if (atomic_compare_exchange_strong(prev, &tmp, (uintptr_t) node)) {
+        if (CAS(prev, &tmp, (uintptr_t) node)) {
             list_hp_clear(list->hp);
             return true;
         }
+        TRACE_INS;
     }
 }
 
@@ -296,12 +404,13 @@ bool list_delete(list_t *list, list_key_t key)
 
         uintptr_t tmp = get_unmarked(next);
 
-        if (!atomic_compare_exchange_strong(&curr->next, &tmp,
-                                            get_marked(next)))
+        if (!CAS(&curr->next, &tmp, get_marked(next))) {
+            TRACE_DEL;
             continue;
+        }
 
         tmp = get_unmarked(curr);
-        if (atomic_compare_exchange_strong(prev, &tmp, get_unmarked(next))) {
+        if (CAS(prev, &tmp, get_unmarked(next))) {
             list_hp_clear(list->hp);
             list_hp_retire(list->hp, get_unmarked(curr));
         } else {
@@ -382,8 +491,8 @@ int main(void)
 
     list_destroy(list);
 
-    fprintf(stderr, "inserts = %zu, deletes = %zu\n", atomic_load(&inserts),
-            atomic_load(&deletes));
-
+#ifdef RUNTIME_STAT
+    analysis_func();
+#endif
     return 0;
 }