rculfhash: rename likely/unlikely (add caa_ prefix)

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/rculfhash.c b/rculfhash.c
index f4187e7993ca9ea53a6915ede1edb6673388db48..d1a17669f9fa176660b9552241808f2760f6bdcc 100644 (file)
--- a/rculfhash.c
+++ b/rculfhash.c
@@ -604,7 +604,7 @@ int ht_get_split_count_index(unsigned long hash)
 
        assert(split_count_mask >= 0);
        cpu = sched_getcpu();
-       if (unlikely(cpu < 0))
+       if (caa_unlikely(cpu < 0))
                return hash & split_count_mask;
        else
                return cpu & split_count_mask;
@@ -623,11 +623,11 @@ void ht_count_add(struct cds_lfht *ht, unsigned long size, unsigned long hash)
        unsigned long split_count;
        int index;
 
-       if (unlikely(!ht->split_count))
+       if (caa_unlikely(!ht->split_count))
                return;
        index = ht_get_split_count_index(hash);
        split_count = uatomic_add_return(&ht->split_count[index].add, 1);
-       if (unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
+       if (caa_unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
                long count;
 
                dbg_printf("add split count %lu\n", split_count);
@@ -650,11 +650,11 @@ void ht_count_del(struct cds_lfht *ht, unsigned long size, unsigned long hash)
        unsigned long split_count;
        int index;
 
-       if (unlikely(!ht->split_count))
+       if (caa_unlikely(!ht->split_count))
                return;
        index = ht_get_split_count_index(hash);
        split_count = uatomic_add_return(&ht->split_count[index].del, 1);
-       if (unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
+       if (caa_unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
                long count;
 
                dbg_printf("del split count %lu\n", split_count);
@@ -806,12 +806,12 @@ void _cds_lfht_gc_bucket(struct cds_lfht_node *dummy, struct cds_lfht_node *node
                 */
                assert(dummy != node);
                for (;;) {
-                       if (unlikely(is_end(iter)))
+                       if (caa_unlikely(is_end(iter)))
                                return;
-                       if (likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
+                       if (caa_likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
                                return;
                        next = rcu_dereference(clear_flag(iter)->p.next);
-                       if (likely(is_removed(next)))
+                       if (caa_likely(is_removed(next)))
                                break;
                        iter_prev = clear_flag(iter);
                        iter = next;
@@ -915,9 +915,9 @@ void _cds_lfht_add(struct cds_lfht *ht,
                iter = rcu_dereference(iter_prev->p.next);
                assert(iter_prev->p.reverse_hash <= node->p.reverse_hash);
                for (;;) {
-                       if (unlikely(is_end(iter)))
+                       if (caa_unlikely(is_end(iter)))
                                goto insert;
-                       if (likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
+                       if (caa_likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
                                goto insert;
 
                        /* dummy node is the first node of the identical-hash-value chain */
@@ -925,7 +925,7 @@ void _cds_lfht_add(struct cds_lfht *ht,
                                goto insert;
 
                        next = rcu_dereference(clear_flag(iter)->p.next);
-                       if (unlikely(is_removed(next)))
+                       if (caa_unlikely(is_removed(next)))
                                goto gc_node;
 
                        /* uniquely add */
@@ -1015,7 +1015,7 @@ int _cds_lfht_del(struct cds_lfht *ht, unsigned long size,
                struct cds_lfht_node *new_next;
 
                next = old;
-               if (unlikely(is_removed(next)))
+               if (caa_unlikely(is_removed(next)))
                        return -ENOENT;
                if (dummy_removal)
                        assert(is_dummy(next));
@@ -1408,20 +1408,20 @@ void cds_lfht_lookup(struct cds_lfht *ht, void *key, size_t key_len,
        node = rcu_dereference(dummy_node->p.next);
        node = clear_flag(node);
        for (;;) {
-               if (unlikely(is_end(node))) {
+               if (caa_unlikely(is_end(node))) {
                        node = next = NULL;
                        break;
                }
-               if (unlikely(node->p.reverse_hash > reverse_hash)) {
+               if (caa_unlikely(node->p.reverse_hash > reverse_hash)) {
                        node = next = NULL;
                        break;
                }
                next = rcu_dereference(node->p.next);
                assert(node == clear_flag(node));
-               if (likely(!is_removed(next))
+               if (caa_likely(!is_removed(next))
                    && !is_dummy(next)
                    && node->p.reverse_hash == reverse_hash
-                   && likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
+                   && caa_likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
                                break;
                }
                node = clear_flag(next);
@@ -1446,18 +1446,18 @@ void cds_lfht_next_duplicate(struct cds_lfht *ht, struct cds_lfht_iter *iter)
        node = clear_flag(next);
 
        for (;;) {
-               if (unlikely(is_end(node))) {
+               if (caa_unlikely(is_end(node))) {
                        node = next = NULL;
                        break;
                }
-               if (unlikely(node->p.reverse_hash > reverse_hash)) {
+               if (caa_unlikely(node->p.reverse_hash > reverse_hash)) {
                        node = next = NULL;
                        break;
                }
                next = rcu_dereference(node->p.next);
-               if (likely(!is_removed(next))
+               if (caa_likely(!is_removed(next))
                    && !is_dummy(next)
-                   && likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
+                   && caa_likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
                                break;
                }
                node = clear_flag(next);
@@ -1473,12 +1473,12 @@ void cds_lfht_next(struct cds_lfht *ht, struct cds_lfht_iter *iter)
 
        node = clear_flag(iter->next);
        for (;;) {
-               if (unlikely(is_end(node))) {
+               if (caa_unlikely(is_end(node))) {
                        node = next = NULL;
                        break;
                }
                next = rcu_dereference(node->p.next);
-               if (likely(!is_removed(next))
+               if (caa_likely(!is_removed(next))
                    && !is_dummy(next)) {
                                break;
                }

diff --git a/tests/test_urcu_hash.c b/tests/test_urcu_hash.c
index 8f850ac75a9e478a6811a88600d064d0c821ecc7..25f872f7319a03f3a1c1847aee7e7efcf9d8dcf0 100644 (file)
--- a/tests/test_urcu_hash.c
+++ b/tests/test_urcu_hash.c
@@ -385,7 +385,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 +410,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;
@@ -468,13 +468,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();
        }
 
@@ -572,11 +572,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();
        }