Rewrite rcu-list for built-in tracer

Known issue: fail to pass thread sanitizer

Author: jserv

README.md

@@ -29,7 +29,7 @@ purpose of these programs is to be illustrative and educational.
     - [lf-timer](lf-timer/): A lock-free timer.
 * [Synchronization](https://en.wikipedia.org/wiki/Synchronization_(computer_science))
     - [hp\_list](hp_list): A concurrent linked list utilizing Hazard Pointers.
-    - [rcu\_list](rcu_list/): A concurrent linked list utilizing the simplified RCU algorithm.
+    - [rcu-list](rcu-list/): A concurrent linked list utilizing the simplified RCU algorithm.
     - [qsbr](qsbr/): An implementation of Quiescent state based reclamation (QSBR).
     - [list-move](list-move/): Evaluation of two concurrent linked lists: QSBR and lock-based.
     - [rcu\_queue](rcu_queue/): An efficient concurrent queue based on QSBR.

rcu-list/Makefile

@@ -0,0 +1,21 @@
+CC ?= gcc
+CFLAGS = -g
+CFLAGS += -Wall
+LDFLAGS += -lpthread
+CFLAGS += -std=c99
+# CFLAGS += -fsanitize=thread
+
+READER_NUM = 10
+UPDATER_NUM = 1
+TRACE_LOOP = 1000
+
+CFLAGS += -D'READER_NUM=$(READER_NUM)'
+CFLAGS += -D'UPDATER_NUM=$(UPDATER_NUM)'
+CFLAGS += -D'TRACE_LOOP=$(TRACE_LOOP)'
+CFLAGS += -D'CONFIG_TRACE_TIME'
+
+all:
+	$(CC) -o test test.c $(CFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f test

rcu-list/rculist.h

@@ -0,0 +1,72 @@
+/* concurrency linked list */
+
+#pragma once
+
+#include <stddef.h>
+
+#include "thread-rcu.h"
+
+#define container_of(ptr, type, member)                         \
+    __extension__({                                             \
+        const __typeof__(((type *) 0)->member) *__mptr = (ptr); \
+        (type *) ((char *) __mptr - offsetof(type, member));    \
+    })
+#define list_entry_rcu(ptr, type, member) \
+    container_of(READ_ONCE(ptr), type, member)
+
+#define list_next_rcu(n) (*((struct list_head __rcu **) (&(n)->next)))
+
+struct list_head {
+    struct list_head *next, *prev;
+};
+
+static inline void list_init_rcu(struct list_head *node)
+{
+    node->next = node;
+    barrier();
+    node->prev = node;
+}
+
+static inline void __list_add_rcu(struct list_head *new,
+                                  struct list_head *prev,
+                                  struct list_head *next)
+{
+    next->prev = new;
+    new->next = next;
+    new->prev = prev;
+    barrier();
+    rcu_assign_pointer(list_next_rcu(prev), new);
+}
+
+static inline void list_add_rcu(struct list_head *new, struct list_head *head)
+{
+    __list_add_rcu(new, head, head->next);
+}
+
+static inline void list_add_tail_rcu(struct list_head *new,
+                                     struct list_head *head)
+{
+    __list_add_rcu(new, head->prev, head);
+}
+
+static inline void __list_del_rcu(struct list_head *prev,
+                                  struct list_head *next)
+{
+    next->prev = prev;
+    barrier();
+    rcu_assign_pointer(list_next_rcu(prev), next);
+}
+
+static inline void list_del_rcu(struct list_head *node)
+{
+    __list_del_rcu(node->prev, node->next);
+    list_init_rcu(node);
+}
+
+#define list_for_each(n, head) for (n = (head)->next; n != (head); n = n->next)
+
+#define list_for_each_from(pos, head) for (; pos != (head); pos = pos->next)
+
+#define list_for_each_safe(pos, n, head)                   \
+    for (pos = (head)->next, n = pos->next; pos != (head); \
+         pos = n, n = pos->next)

rcu-list/test.c

@@ -0,0 +1,100 @@
+/* A benchmark of thread-rcu linked list */
+
+#define _GNU_SOURCE
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "rculist.h"
+
+struct test {
+    int count;
+    struct list_head node;
+};
+
+static struct list_head head;
+
+static struct test *test_alloc(int val)
+{
+    struct test *new = (struct test *) malloc(sizeof(struct test));
+    if (!new) {
+        fprintf(stderr, "test_alloc failed\n");
+        abort();
+    }
+
+    new->count = val;
+    list_init_rcu(&new->node);
+
+    return new;
+}
+
+static void *reader_side(void *argv)
+{
+    struct test __allow_unused *tmp;
+    struct list_head *node;
+
+    rcu_init();
+
+    rcu_read_lock();
+
+    list_for_each (node, &head) {
+        tmp = list_entry_rcu(node, struct test, node);
+    }
+
+    rcu_read_unlock();
+
+    pthread_exit(NULL);
+}
+
+static void *updater_side(void *argv)
+{
+    struct test *newval = test_alloc(current_tid());
+
+    list_add_tail_rcu(&newval->node, &head);
+    synchronize_rcu();
+
+    pthread_exit(NULL);
+}
+
+static inline void benchmark(void)
+{
+    pthread_t reader[READER_NUM];
+    pthread_t updater[UPDATER_NUM];
+    struct list_head *node, *pos;
+    struct test *tmp;
+    int i;
+    list_init_rcu(&head);
+
+    for (i = 0; i < READER_NUM / 2; i++)
+        pthread_create(&reader[i], NULL, reader_side, NULL);
+
+    for (i = 0; i < UPDATER_NUM; i++)
+        pthread_create(&updater[i], NULL, updater_side, NULL);
+
+    for (i = READER_NUM / 2; i < READER_NUM; i++)
+        pthread_create(&reader[i], NULL, reader_side, NULL);
+
+    for (i = 0; i < READER_NUM; i++)
+        pthread_join(reader[i], NULL);
+
+    for (i = 0; i < UPDATER_NUM; i++)
+        pthread_join(updater[i], NULL);
+
+    list_for_each_safe (pos, node, &head) {
+        tmp = container_of(pos, struct test, node);
+        free(tmp);
+    }
+    list_init_rcu(&head);
+
+    rcu_clean();
+}
+
+#include "tracer.h"
+
+int main(int argc, char *argv[])
+{
+    time_check_loop(benchmark(), TRACE_LOOP);
+    return 0;
+}