rculfhash: Move "struct rcu_head head" out of "struct cds_lfht_node"

[urcu.git] / tests / test_urcu_hash.c

diff --git a/tests/test_urcu_hash.c b/tests/test_urcu_hash.c
index 8f850ac75a9e478a6811a88600d064d0c821ecc7..e28c14afc750c7ffe09ec879b44f05488f76dc44 100644 (file)
--- a/tests/test_urcu_hash.c
+++ b/tests/test_urcu_hash.c
@@ -105,6 +105,31 @@ struct test_data {
        int b;
 };
 
+struct lfht_test_node {
+       struct cds_lfht_node node;
+       /* cache-cold for iteration */
+       struct rcu_head head;
+};
+
+static inline struct lfht_test_node *
+to_test_node(struct cds_lfht_node *node)
+{
+       return caa_container_of(node, struct lfht_test_node, node);
+}
+
+static inline
+void lfht_test_node_init(struct lfht_test_node *node, void *key,
+                       size_t key_len)
+{
+       cds_lfht_node_init(&node->node, key, key_len);
+}
+
+static inline struct lfht_test_node *
+cds_lfht_iter_get_test_node(struct cds_lfht_iter *iter)
+{
+       return to_test_node(cds_lfht_iter_get_node(iter));
+}
+
 static volatile int test_go, test_stop;
 
 static unsigned long wdelay;
@@ -385,7 +410,7 @@ static
 unsigned long test_compare(void *key1, size_t key1_len,
                            void *key2, size_t key2_len)
 {
-       if (unlikely(key1_len != key2_len))
+       if (caa_unlikely(key1_len != key2_len))
                return -1;
        assert(key1_len == sizeof(unsigned long));
        if (key1 == key2)
@@ -410,7 +435,7 @@ void *thr_count(void *arg)
                rcu_thread_offline();
                len = read(count_pipe[0], buf, 1);
                rcu_thread_online();
-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))
                        break;
                if (len != 1)
                        continue;
@@ -437,7 +462,7 @@ void *thr_count(void *arg)
 void *thr_reader(void *_count)
 {
        unsigned long long *count = _count;
-       struct cds_lfht_node *node;
+       struct lfht_test_node *node;
        struct cds_lfht_iter iter;
 
        printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
@@ -457,7 +482,7 @@ void *thr_reader(void *_count)
                cds_lfht_lookup(test_ht,
                        (void *)(((unsigned long) rand_r(&rand_lookup) % lookup_pool_size) + lookup_pool_offset),
                        sizeof(void *), &iter);
-               node = cds_lfht_iter_get_node(&iter);
+               node = cds_lfht_iter_get_test_node(&iter);
                if (node == NULL) {
                        if (validate_lookup) {
                                printf("[ERROR] Lookup cannot find initial node.\n");
@@ -468,13 +493,13 @@ void *thr_reader(void *_count)
                        lookup_ok++;
                }
                debug_yield_read();
-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))
                        break;
-               if (unlikely((nr_reads & ((1 << 10) - 1)) == 0))
+               if (caa_unlikely((nr_reads & ((1 << 10) - 1)) == 0))
                        rcu_quiescent_state();
        }
 
@@ -492,14 +517,15 @@ void *thr_reader(void *_count)
 static
 void free_node_cb(struct rcu_head *head)
 {
-       struct cds_lfht_node *node =
-               caa_container_of(head, struct cds_lfht_node, head);
+       struct lfht_test_node *node =
+               caa_container_of(head, struct lfht_test_node, head);
        free(node);
 }
 
 void *thr_writer(void *_count)
 {
-       struct cds_lfht_node *node, *ret_node;
+       struct lfht_test_node *node;
+       struct cds_lfht_node *ret_node;
        struct cds_lfht_iter iter;
        struct wr_count *count = _count;
        int ret;
@@ -519,26 +545,27 @@ void *thr_writer(void *_count)
        for (;;) {
                if ((addremove == AR_ADD || add_only)
                                || (addremove == AR_RANDOM && rand_r(&rand_lookup) & 1)) {
-                       node = malloc(sizeof(struct cds_lfht_node));
-                       cds_lfht_node_init(node,
+                       node = malloc(sizeof(struct lfht_test_node));
+                       lfht_test_node_init(node,
                                (void *)(((unsigned long) rand_r(&rand_lookup) % write_pool_size) + write_pool_offset),
                                sizeof(void *));
                        rcu_read_lock();
                        if (add_unique) {
-                               ret_node = cds_lfht_add_unique(test_ht, node);
+                               ret_node = cds_lfht_add_unique(test_ht, &node->node);
                        } else {
                                if (add_replace)
-                                       ret_node = cds_lfht_add_replace(test_ht, node);
+                                       ret_node = cds_lfht_add_replace(test_ht, &node->node);
                                else
-                                       cds_lfht_add(test_ht, node);
+                                       cds_lfht_add(test_ht, &node->node);
                        }
                        rcu_read_unlock();
-                       if (add_unique && ret_node != node) {
+                       if (add_unique && ret_node != &node->node) {
                                free(node);
                                nr_addexist++;
                        } else {
                                if (add_replace && ret_node) {
-                                       call_rcu(&ret_node->head, free_node_cb);
+                                       call_rcu(&to_test_node(ret_node)->head,
+                                                       free_node_cb);
                                        nr_addexist++;
                                } else {
                                        nr_add++;
@@ -553,7 +580,7 @@ void *thr_writer(void *_count)
                        ret = cds_lfht_del(test_ht, &iter);
                        rcu_read_unlock();
                        if (ret == 0) {
-                               node = cds_lfht_iter_get_node(&iter);
+                               node = cds_lfht_iter_get_test_node(&iter);
                                call_rcu(&node->head, free_node_cb);
                                nr_del++;
                        } else
@@ -572,11 +599,11 @@ void *thr_writer(void *_count)
                }
 #endif //0
                nr_writes++;
-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))
                        break;
-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))
                        loop_sleep(wdelay);
-               if (unlikely((nr_writes & ((1 << 10) - 1)) == 0))
+               if (caa_unlikely((nr_writes & ((1 << 10) - 1)) == 0))
                        rcu_quiescent_state();
        }
 
@@ -596,7 +623,8 @@ void *thr_writer(void *_count)
 
 static int populate_hash(void)
 {
-       struct cds_lfht_node *node, *ret_node;
+       struct lfht_test_node *node;
+       struct cds_lfht_node *ret_node;
 
        if (!init_populate)
                return 0;
@@ -608,26 +636,26 @@ static int populate_hash(void)
        }
 
        while (nr_add < init_populate) {
-               node = malloc(sizeof(struct cds_lfht_node));
-               cds_lfht_node_init(node,
+               node = malloc(sizeof(struct lfht_test_node));
+               lfht_test_node_init(node,
                        (void *)(((unsigned long) rand_r(&rand_lookup) % init_pool_size) + init_pool_offset),
                        sizeof(void *));
                rcu_read_lock();
                if (add_unique) {
-                       ret_node = cds_lfht_add_unique(test_ht, node);
+                       ret_node = cds_lfht_add_unique(test_ht, &node->node);
                } else {
                        if (add_replace)
-                               ret_node = cds_lfht_add_replace(test_ht, node);
+                               ret_node = cds_lfht_add_replace(test_ht, &node->node);
                        else
-                               cds_lfht_add(test_ht, node);
+                               cds_lfht_add(test_ht, &node->node);
                }
                rcu_read_unlock();
-               if (add_unique && ret_node != node) {
+               if (add_unique && ret_node != &node->node) {
                        free(node);
                        nr_addexist++;
                } else {
                        if (add_replace && ret_node) {
-                               call_rcu(&ret_node->head, free_node_cb);
+                               call_rcu(&to_test_node(ret_node)->head, free_node_cb);
                                nr_addexist++;
                        } else {
                                nr_add++;
@@ -642,11 +670,11 @@ static
 void test_delete_all_nodes(struct cds_lfht *ht)
 {
        struct cds_lfht_iter iter;
-       struct cds_lfht_node *node;
+       struct lfht_test_node *node;
        unsigned long count = 0;
 
        cds_lfht_first(ht, &iter);
-       while ((node = cds_lfht_iter_get_node(&iter)) != NULL) {
+       while ((node = cds_lfht_iter_get_test_node(&iter)) != NULL) {
                int ret;
 
                ret = cds_lfht_del(test_ht, &iter);