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 @@
+CFLAG=-D ANALYSIS_OPS
+
 all:
 	$(CC) -Wall -o list main.c -lpthread -g -fsanitize=thread
 
+analysis:
+	$(CC) -Wall $(CFLAG) -o list main.c -lpthread -g -fsanitize=thread
+
 indent:
 	clang-format -i *.[ch]
 

hp_list/main.c

@@ -14,6 +14,93 @@
 #include <string.h>
 #include <threads.h>
 
+#ifdef ANALYSIS_OPS
+/*
+ * 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 goto_try_again              \
+    do {                            \
+        atomic_fetch_add(&rtry, 1); \
+        goto try_again;             \
+    } while (0)
+#define cons_inc                    \
+    do {                            \
+        atomic_fetch_add(&cons, 1); \
+    } while (0)
+#define trav_inc                    \
+    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 del_inc                    \
+    do {                           \
+        atomic_fetch_add(&del, 1); \
+    } while (0)
+#define ins_inc                    \
+    do {                           \
+        atomic_fetch_add(&ins, 1); \
+    } while (0)
+#define deletes_inc                    \
+    do {                               \
+        atomic_fetch_add(&deletes, 1); \
+    } while (0)
+#define inserts_inc                    \
+    do {                               \
+        atomic_fetch_add(&inserts, 1); \
+    } while (0)
+
+void analysis_func(void)
+{
+    printf("%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 goto_try_again  \
+    do {                \
+        goto try_again; \
+    } while (0)
+#define cons_inc \
+    do {         \
+    } while (0)
+#define trav_inc \
+    do {         \
+    } while (0)
+#define CAS(obj, expected, desired) \
+    ({ atomic_compare_exchange_strong(obj, expected, desired); })
+#define del_inc \
+    do {        \
+    } while (0)
+#define ins_inc \
+    do {        \
+    } while (0)
+#define deletes_inc \
+    do {            \
+    } while (0)
+#define inserts_inc \
+    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 +249,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 +280,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);
+    inserts_inc;
     return node;
 }
 
@@ -205,7 +290,7 @@ void list_node_destroy(list_node_t *node)
         return;
     assert(node->magic == LIST_MAGIC);
     free(node);
-    (void) atomic_fetch_add(&deletes, 1);
+    deletes_inc;
 }
 
 static void __list_node_delete(void *arg)
@@ -228,18 +313,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;
+        goto_try_again;
     while (true) {
+#ifdef ANALYSIS_OPS
+        if (is_marked(curr))
+            cons_inc;
+#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;
+            goto_try_again;
         if (atomic_load(prev) != get_unmarked(curr))
-            goto try_again;
+            goto_try_again;
         if (get_unmarked_node(next) == next) {
             if (!(get_unmarked_node(curr)->key < *key)) {
                 *par_curr = curr;
@@ -252,12 +341,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)))
+                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));
+        trav_inc;
     }
 }
 
@@ -277,10 +367,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;
         }
+        ins_inc;
     }
 }
 
@@ -296,12 +387,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))) {
+            del_inc;
             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 +474,8 @@ int main(void)
 
     list_destroy(list);
 
-    fprintf(stderr, "inserts = %zu, deletes = %zu\n", atomic_load(&inserts),
-            atomic_load(&deletes));
-
+#ifdef ANALYSIS_OPS
+    analysis_func();
+#endif
     return 0;
 }