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

And Using the preprocessor to decide the analysis being set or not.
Rename the variable which is the number of linked list element created from "inserts" to
"creates". The origin one may mixed up with the list_insert operation.

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.
load  is the number of atomic_load operation in list_delete, list_insert and __list_find.
store is the number of atomic_store operation in list_delete, list_insert and __list_find.

Author: linD026

hp_list/Makefile

@@ -12,8 +12,13 @@ $(BIN): main.c
 all: CFLAGS += -O2
 all: $(BIN)
 
+# The RUNTIME_STAT allow to show the runtime operation state,
+# such as "rtry" is the number of retries in the __list_find function.
+analyze: CFLAGS +=-D RUNTIME_STAT
+analyze: $(BIN)
+
 indent:
 	clang-format -i *.[ch]
 
 clean:
-	rm -f $(BIN)
+	rm -f list

hp_list/main.c

@@ -14,6 +14,92 @@
 #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.
+ * "load"  is the number of atomic_load operation in list_delete, list_insert
+ * and __list_find.
+ * "store" is the number of atomic_store operation in list_delete, list_insert
+ * and __list_find.
+ */
+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 load = 0, store = 0;
+static atomic_uint_fast64_t deletes = 0, creates = 0;
+
+#define CAS(obj, expected, desired)                                          \
+    ({                                                                       \
+        bool __ret = atomic_compare_exchange_strong(obj, expected, desired); \
+        if (!__ret)                                                          \
+            atomic_fetch_add(&fail, 1);                                      \
+        __ret;                                                               \
+    })
+#define ATOMIC_LOAD(obj)            \
+    ({                              \
+        atomic_fetch_add(&load, 1); \
+        atomic_load(obj);           \
+    })
+#define ATOMIC_STORE_EXPLICIT(obj, desired, order)  \
+    do {                                            \
+        atomic_fetch_add(&store, 1);                \
+        atomic_store_explicit(obj, desired, order); \
+    } while (0)
+#define ATOMIC_FETCH_ADD(obj, arg, ops) ({ atomic_fetch_add(obj, 1); })
+
+void do_analysis(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("\"creates\" is the number of linked list elements created.\n");
+    printf(
+        "\"load\"    is the number of atomic_load operation in list_delete, "
+        "list_insert and __list_find.\n");
+    printf(
+        "\"store\"   is the number of atomic_store operation in list_delete, "
+        "list_insert and __list_find.\n");
+    printf("\n%10s %10s %10s %10s %10s %10s %10s %10s %10s %10s\n", "rtry",
+           "cons", "trav", "fail", "del", "ins", "load", "store", "deletes",
+           "creates");
+    for (int i = 0; i < 109; i++)
+        printf("-");
+    printf("\n%10ld %10ld %10ld %10ld %10ld %10ld %10ld %10ld %10ld %10ld\n",
+           rtry, cons, trav, fail, del, ins, load, store, deletes, creates);
+}
+
+#else
+
+#define CAS(obj, expected, desired) \
+    ({ atomic_compare_exchange_strong(obj, expected, desired); })
+#define ATOMIC_LOAD(obj) ({ atomic_load(obj); })
+#define ATOMIC_STORE_EXPLICIT(obj, desired, order)  \
+    do {                                            \
+        atomic_store_explicit(obj, desired, order); \
+    } while (0)
+#define ATOMIC_FETCH_ADD(obj, arg, ops) \
+    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 +248,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 +279,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);
+    ATOMIC_FETCH_ADD(&creates, 1, TRACE_CREATES);
     return node;
 }
 
@@ -205,7 +289,7 @@ void list_node_destroy(list_node_t *node)
         return;
     assert(node->magic == LIST_MAGIC);
     free(node);
-    (void) atomic_fetch_add(&deletes, 1);
+    ATOMIC_FETCH_ADD(&deletes, 1, TRACE_DELETES);
 }
 
 static void __list_node_delete(void *arg)
@@ -225,21 +309,31 @@ static bool __list_find(list_t *list,
 
 try_again:
     prev = &list->head;
-    curr = (list_node_t *) atomic_load(prev);
+    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))
+    if (ATOMIC_LOAD(prev) != get_unmarked(curr)) {
+        ATOMIC_FETCH_ADD(&rtry, 1, TRACE_TRIES);
         goto try_again;
+    }
     while (true) {
-        next = (list_node_t *) atomic_load(&get_unmarked_node(curr)->next);
+#ifdef RUNTIME_STAT
+        if (is_marked(curr))
+            ATOMIC_FETCH_ADD(&cons, 1, 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)
+        if (ATOMIC_LOAD(&get_unmarked_node(curr)->next) != (uintptr_t) next) {
+            ATOMIC_FETCH_ADD(&rtry, 1, TRACE_TRIES);
             goto try_again;
-        if (atomic_load(prev) != get_unmarked(curr))
+        }
+        if (ATOMIC_LOAD(prev) != get_unmarked(curr)) {
+            ATOMIC_FETCH_ADD(&rtry, 1, TRACE_TRIES);
             goto try_again;
+        }
         if (get_unmarked_node(next) == next) {
             if (!(get_unmarked_node(curr)->key < *key)) {
                 *par_curr = curr;
@@ -252,12 +346,15 @@ 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)))
+            if (!CAS(prev, &tmp, get_unmarked(next))) {
+                ATOMIC_FETCH_ADD(&rtry, 1, TRACE_TRIES);
                 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));
+        ATOMIC_FETCH_ADD(&trav, 1, TRACE_TRAVERSAL);
     }
 }
 
@@ -274,13 +371,14 @@ bool list_insert(list_t *list, list_key_t key)
             list_hp_clear(list->hp);
             return false;
         }
-        atomic_store_explicit(&node->next, (uintptr_t) curr,
+        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;
         }
+        ATOMIC_FETCH_ADD(&ins, 1, TRACE_INS);
     }
 }
 
@@ -296,12 +394,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))) {
+            ATOMIC_FETCH_ADD(&del, 1, 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 +481,8 @@ int main(void)
 
     list_destroy(list);
 
-    fprintf(stderr, "inserts = %zu, deletes = %zu\n", atomic_load(&inserts),
-            atomic_load(&deletes));
-
+#ifdef RUNTIME_STAT
+    do_analysis();
+#endif
     return 0;
 }