Rename likely/unlikely to caa_likely/caa_unlikely

This fixes namespace conflicts.

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

diff --git a/tests/test_mutex.c b/tests/test_mutex.c
index 1194b0298a68bffd75bb382bbe5c601d123da7ec..3f84bbfa06fa6c280a0896e4072bdf9ce41b4a6f 100644 (file)
--- a/tests/test_mutex.c
+++ b/tests/test_mutex.c
@@ -205,11 +205,11 @@ void *thr_reader(void *data)
        for (;;) {
                pthread_mutex_lock(&lock);
                assert(test_array.a == 8);
        for (;;) {
                pthread_mutex_lock(&lock);
                assert(test_array.a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                pthread_mutex_unlock(&lock);
                nr_reads++;
                        loop_sleep(rduration);
                pthread_mutex_unlock(&lock);
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -238,13 +238,13 @@ void *thr_writer(void *data)
                pthread_mutex_lock(&lock);
                test_array.a = 0;
                test_array.a = 8;
                pthread_mutex_lock(&lock);
                test_array.a = 0;
                test_array.a = 8;

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                pthread_mutex_unlock(&lock);
                nr_writes++;
                        loop_sleep(wduration);
                pthread_mutex_unlock(&lock);
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_perthreadlock.c b/tests/test_perthreadlock.c
index 6c7114ca059096f98340ce7f815a7b7a8fa40bca..fa9c89a5e560e452f9768ef90fffbd795f16cb84 100644 (file)
--- a/tests/test_perthreadlock.c
+++ b/tests/test_perthreadlock.c
@@ -209,11 +209,11 @@ void *thr_reader(void *data)
        for (;;) {
                pthread_mutex_lock(&per_thread_lock[tidx].lock);
                assert(test_array.a == 8);
        for (;;) {
                pthread_mutex_lock(&per_thread_lock[tidx].lock);
                assert(test_array.a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                pthread_mutex_unlock(&per_thread_lock[tidx].lock);
                nr_reads++;
                        loop_sleep(rduration);
                pthread_mutex_unlock(&per_thread_lock[tidx].lock);
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -245,15 +245,15 @@ void *thr_writer(void *data)
                }
                test_array.a = 0;
                test_array.a = 8;
                }
                test_array.a = 0;
                test_array.a = 8;

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                for (tidx = (long)nr_readers - 1; tidx >= 0; tidx--) {
                        pthread_mutex_unlock(&per_thread_lock[tidx].lock);
                }
                nr_writes++;
                        loop_sleep(wduration);
                for (tidx = (long)nr_readers - 1; tidx >= 0; tidx--) {
                        pthread_mutex_unlock(&per_thread_lock[tidx].lock);
                }
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_rwlock.c b/tests/test_rwlock.c
index 9c8f97e39cf2232be5f461a655102ba1c3feac07..34d8c0727b271aab00241173154c9c8f825fc4a1 100644 (file)
--- a/tests/test_rwlock.c
+++ b/tests/test_rwlock.c
@@ -201,11 +201,11 @@ void *thr_reader(void *_count)
        for (;;) {
                pthread_rwlock_rdlock(&lock);
                assert(test_array.a == 8);
        for (;;) {
                pthread_rwlock_rdlock(&lock);
                assert(test_array.a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                pthread_rwlock_unlock(&lock);
                nr_reads++;
                        loop_sleep(rduration);
                pthread_rwlock_unlock(&lock);
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -234,13 +234,13 @@ void *thr_writer(void *_count)
                pthread_rwlock_wrlock(&lock);
                test_array.a = 0;
                test_array.a = 8;
                pthread_rwlock_wrlock(&lock);
                test_array.a = 0;
                test_array.a = 8;

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                pthread_rwlock_unlock(&lock);
                nr_writes++;
                        loop_sleep(wduration);
                pthread_rwlock_unlock(&lock);
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu.c b/tests/test_urcu.c
index 884d77c472ae28b3a79059d303559932f544b41d..870f133ab75f82b03f997cea1518f9e1979e4403 100644 (file)
--- a/tests/test_urcu.c
+++ b/tests/test_urcu.c
@@ -239,11 +239,11 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -280,7 +280,7 @@ void *thr_writer(void *_count)
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)
                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)


@@ -288,9 +288,9 @@ void *thr_writer(void *_count)
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_assign.c b/tests/test_urcu_assign.c
index 0d9ef853db8eb88b7b0fbe1650c6fc09201fec50..42d70c26ce8b15ef0ae074e83ca3c9632bc0dc00 100644 (file)
--- a/tests/test_urcu_assign.c
+++ b/tests/test_urcu_assign.c
@@ -239,11 +239,11 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -277,7 +277,7 @@ void *thr_writer(void *_count)
                new->a = 8;
                old = test_rcu_pointer;
                rcu_assign_pointer(test_rcu_pointer, new);
                new->a = 8;
                old = test_rcu_pointer;
                rcu_assign_pointer(test_rcu_pointer, new);

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)
                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)


@@ -285,9 +285,9 @@ void *thr_writer(void *_count)
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_bp.c b/tests/test_urcu_bp.c
index ba80ae60f5129bd172960007b2f019e0ce9c1b7a..857913f83413e89722ce17f9b00182dc1254bea1 100644 (file)
--- a/tests/test_urcu_bp.c
+++ b/tests/test_urcu_bp.c
@@ -239,11 +239,11 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -276,7 +276,7 @@ void *thr_writer(void *_count)
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)
                        loop_sleep(wduration);
                synchronize_rcu();
                if (old)


@@ -284,9 +284,9 @@ void *thr_writer(void *_count)
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_defer.c b/tests/test_urcu_defer.c
index 7d71f1029f45f0d97d933e6d85a97ded23dd85ef..1575e9c3523a45e07d96e4eae59af99acad54d63 100644 (file)
--- a/tests/test_urcu_defer.c
+++ b/tests/test_urcu_defer.c
@@ -210,11 +210,11 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -261,7 +261,7 @@ void *thr_writer(void *data)
                new = malloc(sizeof(*new));
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
                new = malloc(sizeof(*new));
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                defer_rcu(free, old);
                defer_rcu(test_cb1, old);
                        loop_sleep(wduration);
                defer_rcu(free, old);
                defer_rcu(test_cb1, old);


@@ -272,9 +272,9 @@ void *thr_writer(void *data)
                defer_rcu(test_cb2, (void *)-4L);
                defer_rcu(test_cb2, (void *)-2L);
                nr_writes++;
                defer_rcu(test_cb2, (void *)-4L);
                defer_rcu(test_cb2, (void *)-2L);
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_gc.c b/tests/test_urcu_gc.c
index 4eaa61b777d0dd6460b4f0ae196bb5ca0d833c28..21c5d5608d37e79eba0d21b3261ee908ac12d366 100644 (file)
--- a/tests/test_urcu_gc.c
+++ b/tests/test_urcu_gc.c
@@ -218,11 +218,11 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -259,7 +259,7 @@ static void rcu_gc_reclaim(unsigned long wtidx, void *old)
        *pending_reclaims[wtidx].head = old;
        pending_reclaims[wtidx].head++;
 
        *pending_reclaims[wtidx].head = old;
        pending_reclaims[wtidx].head++;
 

-       if (likely(pending_reclaims[wtidx].head - pending_reclaims[wtidx].queue
+       if (caa_likely(pending_reclaims[wtidx].head - pending_reclaims[wtidx].queue

                        < reclaim_batch))
                return;
 
                        < reclaim_batch))
                return;
 


@@ -291,13 +291,13 @@ void *thr_writer(void *data)
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
 #endif
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
 #endif

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                rcu_gc_reclaim(wtidx, old);
                nr_writes++;
                        loop_sleep(wduration);
                rcu_gc_reclaim(wtidx, old);
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_lfq.c b/tests/test_urcu_lfq.c
index 5292ebd4c4f35e673b7e52588cc526c326fcb6be..11e7eb37b265c43a404d26c1d017e58cbfbc9fb1 100644 (file)
--- a/tests/test_urcu_lfq.c
+++ b/tests/test_urcu_lfq.c
@@ -190,11 +190,11 @@ void *thr_enqueuer(void *_count)
                rcu_read_unlock();
                nr_successful_enqueues++;
 
                rcu_read_unlock();
                nr_successful_enqueues++;
 

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;
                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;

-               if (unlikely(!test_duration_enqueue()))
+               if (caa_unlikely(!test_duration_enqueue()))

                        break;
        }
 
                        break;
        }
 


@@ -255,9 +255,9 @@ void *thr_dequeuer(void *_count)
                }
 
                nr_dequeues++;
                }
 
                nr_dequeues++;

-               if (unlikely(!test_duration_dequeue()))
+               if (caa_unlikely(!test_duration_dequeue()))

                        break;
                        break;

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
        }
 
                        loop_sleep(rduration);
        }
 

diff --git a/tests/test_urcu_lfs.c b/tests/test_urcu_lfs.c
index c85fa447c37afd7eb48da32f1c10811e57fd9d85..883fd0c18add12ad4b97b4063f92c88dfa77732b 100644 (file)
--- a/tests/test_urcu_lfs.c
+++ b/tests/test_urcu_lfs.c
@@ -189,11 +189,11 @@ void *thr_enqueuer(void *_count)
                cds_lfs_push_rcu(&s, &node->list);
                nr_successful_enqueues++;
 
                cds_lfs_push_rcu(&s, &node->list);
                nr_successful_enqueues++;
 

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;
                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;

-               if (unlikely(!test_duration_enqueue()))
+               if (caa_unlikely(!test_duration_enqueue()))

                        break;
        }
 
                        break;
        }
 


@@ -252,9 +252,9 @@ void *thr_dequeuer(void *_count)
                        nr_successful_dequeues++;
                }
                nr_dequeues++;
                        nr_successful_dequeues++;
                }
                nr_dequeues++;

-               if (unlikely(!test_duration_dequeue()))
+               if (caa_unlikely(!test_duration_dequeue()))

                        break;
                        break;

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
        }
 
                        loop_sleep(rduration);
        }
 

diff --git a/tests/test_urcu_qsbr.c b/tests/test_urcu_qsbr.c
index 1c5a696c03491db909c4c2a23f42df9a0fe4b4b0..b986fd825fabc4d8663ab395f95d875631453133 100644 (file)
--- a/tests/test_urcu_qsbr.c
+++ b/tests/test_urcu_qsbr.c
@@ -238,14 +238,14 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                /* QS each 1024 reads */
                        loop_sleep(rduration);
                rcu_read_unlock();
                nr_reads++;
                /* QS each 1024 reads */

-               if (unlikely((nr_reads & ((1 << 10) - 1)) == 0))
+               if (caa_unlikely((nr_reads & ((1 << 10) - 1)) == 0))

                        rcu_quiescent_state();
                        rcu_quiescent_state();

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -282,7 +282,7 @@ void *thr_writer(void *_count)
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);
                new = test_array_alloc();
                new->a = 8;
                old = rcu_xchg_pointer(&test_rcu_pointer, new);

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                synchronize_rcu();
                /* can be done after unlock */
                        loop_sleep(wduration);
                synchronize_rcu();
                /* can be done after unlock */


@@ -291,9 +291,9 @@ void *thr_writer(void *_count)
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;
                test_array_free(old);
                rcu_copy_mutex_unlock();
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_qsbr_gc.c b/tests/test_urcu_qsbr_gc.c
index 0c1c124ae6773e07c203d6e4b219272b8589de39..9deb0aa2044c1e8ec34d3f8a3736f90668b2c828 100644 (file)
--- a/tests/test_urcu_qsbr_gc.c
+++ b/tests/test_urcu_qsbr_gc.c
@@ -214,14 +214,14 @@ void *thr_reader(void *_count)
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);
                debug_yield_read();
                if (local_ptr)
                        assert(local_ptr->a == 8);

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
                _rcu_read_unlock();
                nr_reads++;
                /* QS each 1024 reads */
                        loop_sleep(rduration);
                _rcu_read_unlock();
                nr_reads++;
                /* QS each 1024 reads */

-               if (unlikely((nr_reads & ((1 << 10) - 1)) == 0))
+               if (caa_unlikely((nr_reads & ((1 << 10) - 1)) == 0))

                        _rcu_quiescent_state();
                        _rcu_quiescent_state();

-               if (unlikely(!test_duration_read()))
+               if (caa_unlikely(!test_duration_read()))

                        break;
        }
 
                        break;
        }
 


@@ -258,7 +258,7 @@ static void rcu_gc_reclaim(unsigned long wtidx, void *old)
        *pending_reclaims[wtidx].head = old;
        pending_reclaims[wtidx].head++;
 
        *pending_reclaims[wtidx].head = old;
        pending_reclaims[wtidx].head++;
 

-       if (likely(pending_reclaims[wtidx].head - pending_reclaims[wtidx].queue
+       if (caa_likely(pending_reclaims[wtidx].head - pending_reclaims[wtidx].queue

                        < reclaim_batch))
                return;
 
                        < reclaim_batch))
                return;
 


@@ -290,13 +290,13 @@ void *thr_writer(void *data)
                new->a = 8;
                old = _rcu_xchg_pointer(&test_rcu_pointer, new);
 #endif
                new->a = 8;
                old = _rcu_xchg_pointer(&test_rcu_pointer, new);
 #endif

-               if (unlikely(wduration))
+               if (caa_unlikely(wduration))

                        loop_sleep(wduration);
                rcu_gc_reclaim(wtidx, old);
                nr_writes++;
                        loop_sleep(wduration);
                rcu_gc_reclaim(wtidx, old);
                nr_writes++;

-               if (unlikely(!test_duration_write()))
+               if (caa_unlikely(!test_duration_write()))

                        break;
                        break;

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
        }
 
                        loop_sleep(wdelay);
        }
 

diff --git a/tests/test_urcu_wfq.c b/tests/test_urcu_wfq.c
index e042f5ec115eff39758af279f4d6049761b5d93e..83ec6359f2c40710dc9ceb05ef2f39cbbb45868c 100644 (file)
--- a/tests/test_urcu_wfq.c
+++ b/tests/test_urcu_wfq.c
@@ -180,11 +180,11 @@ void *thr_enqueuer(void *_count)
                cds_wfq_enqueue(&q, node);
                nr_successful_enqueues++;
 
                cds_wfq_enqueue(&q, node);
                nr_successful_enqueues++;
 

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;
                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;

-               if (unlikely(!test_duration_enqueue()))
+               if (caa_unlikely(!test_duration_enqueue()))

                        break;
        }
 
                        break;
        }
 


@@ -221,9 +221,9 @@ void *thr_dequeuer(void *_count)
                }
 
                nr_dequeues++;
                }
 
                nr_dequeues++;

-               if (unlikely(!test_duration_dequeue()))
+               if (caa_unlikely(!test_duration_dequeue()))

                        break;
                        break;

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
        }
 
                        loop_sleep(rduration);
        }
 

diff --git a/tests/test_urcu_wfs.c b/tests/test_urcu_wfs.c
index 6d419ca189d404bae46443a2afc088e7e2365a65..7746a1d17447e332c1e88b6cf18523c49c57f439 100644 (file)
--- a/tests/test_urcu_wfs.c
+++ b/tests/test_urcu_wfs.c
@@ -180,11 +180,11 @@ void *thr_enqueuer(void *_count)
                cds_wfs_push(&s, node);
                nr_successful_enqueues++;
 
                cds_wfs_push(&s, node);
                nr_successful_enqueues++;
 

-               if (unlikely(wdelay))
+               if (caa_unlikely(wdelay))

                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;
                        loop_sleep(wdelay);
 fail:
                nr_enqueues++;

-               if (unlikely(!test_duration_enqueue()))
+               if (caa_unlikely(!test_duration_enqueue()))

                        break;
        }
 
                        break;
        }
 


@@ -221,9 +221,9 @@ void *thr_dequeuer(void *_count)
                }
 
                nr_dequeues++;
                }
 
                nr_dequeues++;

-               if (unlikely(!test_duration_dequeue()))
+               if (caa_unlikely(!test_duration_dequeue()))

                        break;
                        break;

-               if (unlikely(rduration))
+               if (caa_unlikely(rduration))

                        loop_sleep(rduration);
        }
 
                        loop_sleep(rduration);
        }
 

diff --git a/urcu-call-rcu-impl.h b/urcu-call-rcu-impl.h
index 182e9b15bd96552ed5e4fb8125bee02da04a8715..36e3cf4b93a5904b5fc1e3d0ee84eccd1cc3d9ea 100644 (file)
--- a/urcu-call-rcu-impl.h
+++ b/urcu-call-rcu-impl.h
@@ -204,7 +204,7 @@ static void call_rcu_wake_up(struct call_rcu_data *crdp)
 {
        /* Write to call_rcu list before reading/writing futex */
        cmm_smp_mb();
 {
        /* Write to call_rcu list before reading/writing futex */
        cmm_smp_mb();

-       if (unlikely(uatomic_read(&crdp->futex) == -1)) {
+       if (caa_unlikely(uatomic_read(&crdp->futex) == -1)) {

                uatomic_set(&crdp->futex, 0);
                futex_async(&crdp->futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);
                uatomic_set(&crdp->futex, 0);
                futex_async(&crdp->futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);

diff --git a/urcu-defer-impl.h b/urcu-defer-impl.h
index 34d99c92997641323175c909f13f793fa27df33d..4d1ca5e4e63085f4dbe24f7284361e9879e46e4b 100644 (file)
--- a/urcu-defer-impl.h
+++ b/urcu-defer-impl.h
@@ -161,7 +161,7 @@ static void mutex_lock_defer(pthread_mutex_t *mutex)
  */
 static void wake_up_defer(void)
 {
  */
 static void wake_up_defer(void)
 {

-       if (unlikely(uatomic_read(&defer_thread_futex) == -1)) {
+       if (caa_unlikely(uatomic_read(&defer_thread_futex) == -1)) {

                uatomic_set(&defer_thread_futex, 0);
                futex_noasync(&defer_thread_futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);
                uatomic_set(&defer_thread_futex, 0);
                futex_noasync(&defer_thread_futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);


@@ -225,11 +225,11 @@ static void rcu_defer_barrier_queue(struct defer_queue *queue,
        for (i = queue->tail; i != head;) {
                cmm_smp_rmb();       /* read head before q[]. */
                p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
        for (i = queue->tail; i != head;) {
                cmm_smp_rmb();       /* read head before q[]. */
                p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);

-               if (unlikely(DQ_IS_FCT_BIT(p))) {
+               if (caa_unlikely(DQ_IS_FCT_BIT(p))) {

                        DQ_CLEAR_FCT_BIT(p);
                        queue->last_fct_out = p;
                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
                        DQ_CLEAR_FCT_BIT(p);
                        queue->last_fct_out = p;
                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);

-               } else if (unlikely(p == DQ_FCT_MARK)) {
+               } else if (caa_unlikely(p == DQ_FCT_MARK)) {

                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
                        queue->last_fct_out = p;
                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
                        queue->last_fct_out = p;
                        p = CMM_LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);


@@ -247,7 +247,7 @@ static void _rcu_defer_barrier_thread(void)
 
        head = defer_queue.head;
        num_items = head - defer_queue.tail;
 
        head = defer_queue.head;
        num_items = head - defer_queue.tail;

-       if (unlikely(!num_items))
+       if (caa_unlikely(!num_items))

                return;
        synchronize_rcu();
        rcu_defer_barrier_queue(&defer_queue, head);
                return;
        synchronize_rcu();
        rcu_defer_barrier_queue(&defer_queue, head);


@@ -286,7 +286,7 @@ void rcu_defer_barrier(void)
                index->last_head = CMM_LOAD_SHARED(index->head);
                num_items += index->last_head - index->tail;
        }
                index->last_head = CMM_LOAD_SHARED(index->head);
                num_items += index->last_head - index->tail;
        }

-       if (likely(!num_items)) {
+       if (caa_likely(!num_items)) {

                /*
                 * We skip the grace period because there are no queued
                 * callbacks to execute.
                /*
                 * We skip the grace period because there are no queued
                 * callbacks to execute.


@@ -318,7 +318,7 @@ void _defer_rcu(void (*fct)(void *p), void *p)
         * If queue is full, or reached threshold. Empty queue ourself.
         * Worse-case: must allow 2 supplementary entries for fct pointer.
         */
         * If queue is full, or reached threshold. Empty queue ourself.
         * Worse-case: must allow 2 supplementary entries for fct pointer.
         */

-       if (unlikely(head - tail >= DEFER_QUEUE_SIZE - 2)) {
+       if (caa_unlikely(head - tail >= DEFER_QUEUE_SIZE - 2)) {

                assert(head - tail <= DEFER_QUEUE_SIZE);
                rcu_defer_barrier_thread();
                assert(head - CMM_LOAD_SHARED(defer_queue.tail) == 0);
                assert(head - tail <= DEFER_QUEUE_SIZE);
                rcu_defer_barrier_thread();
                assert(head - CMM_LOAD_SHARED(defer_queue.tail) == 0);


@@ -340,11 +340,11 @@ void _defer_rcu(void (*fct)(void *p), void *p)
         * Decode: see the comments before 'struct defer_queue'
         *         or the code in rcu_defer_barrier_queue().
         */
         * Decode: see the comments before 'struct defer_queue'
         *         or the code in rcu_defer_barrier_queue().
         */

-       if (unlikely(defer_queue.last_fct_in != fct
+       if (caa_unlikely(defer_queue.last_fct_in != fct

                        || DQ_IS_FCT_BIT(p)
                        || p == DQ_FCT_MARK)) {
                defer_queue.last_fct_in = fct;
                        || DQ_IS_FCT_BIT(p)
                        || p == DQ_FCT_MARK)) {
                defer_queue.last_fct_in = fct;

-               if (unlikely(DQ_IS_FCT_BIT(fct) || fct == DQ_FCT_MARK)) {
+               if (caa_unlikely(DQ_IS_FCT_BIT(fct) || fct == DQ_FCT_MARK)) {

                        _CMM_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
                                      DQ_FCT_MARK);
                        _CMM_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
                        _CMM_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
                                      DQ_FCT_MARK);
                        _CMM_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],

diff --git a/urcu.c b/urcu.c
index 77f6888f0ec547647fe8ced21e04d19e4de73105..ba013d990b6f052da8e85f69af7192de72a4b799 100644 (file)
--- a/urcu.c
+++ b/urcu.c
@@ -144,7 +144,7 @@ static void mutex_unlock(pthread_mutex_t *mutex)
 #ifdef RCU_MEMBARRIER
 static void smp_mb_master(int group)
 {
 #ifdef RCU_MEMBARRIER
 static void smp_mb_master(int group)
 {

-       if (likely(has_sys_membarrier))
+       if (caa_likely(has_sys_membarrier))

                membarrier(MEMBARRIER_EXPEDITED);
        else
                cmm_smp_mb();
                membarrier(MEMBARRIER_EXPEDITED);
        else
                cmm_smp_mb();

diff --git a/urcu/compiler.h b/urcu/compiler.h
index 6db803e9319845a38d847f6ccc339c2230f55c91..f977b95fdc60f73b6ef6c9ab2b96c4c30a884de2 100644 (file)
--- a/urcu/compiler.h
+++ b/urcu/compiler.h
@@ -20,8 +20,8 @@
 
 #include <stddef.h>    /* for offsetof */
 
 
 #include <stddef.h>    /* for offsetof */
 

-#define likely(x)      __builtin_expect(!!(x), 1)
-#define unlikely(x)    __builtin_expect(!!(x), 0)
+#define caa_likely(x)  __builtin_expect(!!(x), 1)
+#define caa_unlikely(x)        __builtin_expect(!!(x), 0)

 
 #define        cmm_barrier()   asm volatile("" : : : "memory")
 
 
 #define        cmm_barrier()   asm volatile("" : : : "memory")
 

diff --git a/urcu/static/urcu-bp.h b/urcu/static/urcu-bp.h
index 832ba0fe2b238293558761fa94b3bbdd9ba05e14..8d221637a2756890d718faf55d7ca0a5a4a5ac23 100644 (file)
--- a/urcu/static/urcu-bp.h
+++ b/urcu/static/urcu-bp.h
@@ -166,7 +166,7 @@ static inline void _rcu_read_lock(void)
        long tmp;
 
        /* Check if registered */
        long tmp;
 
        /* Check if registered */

-       if (unlikely(!rcu_reader))
+       if (caa_unlikely(!rcu_reader))

                rcu_bp_register();
 
        cmm_barrier();  /* Ensure the compiler does not reorder us with mutex */
                rcu_bp_register();
 
        cmm_barrier();  /* Ensure the compiler does not reorder us with mutex */


@@ -175,7 +175,7 @@ static inline void _rcu_read_lock(void)
         * rcu_gp_ctr is
         *   RCU_GP_COUNT | (~RCU_GP_CTR_PHASE or RCU_GP_CTR_PHASE)
         */
         * rcu_gp_ctr is
         *   RCU_GP_COUNT | (~RCU_GP_CTR_PHASE or RCU_GP_CTR_PHASE)
         */

-       if (likely(!(tmp & RCU_GP_CTR_NEST_MASK))) {
+       if (caa_likely(!(tmp & RCU_GP_CTR_NEST_MASK))) {

                _CMM_STORE_SHARED(rcu_reader->ctr, _CMM_LOAD_SHARED(rcu_gp_ctr));
                /*
                 * Set active readers count for outermost nesting level before
                _CMM_STORE_SHARED(rcu_reader->ctr, _CMM_LOAD_SHARED(rcu_gp_ctr));
                /*
                 * Set active readers count for outermost nesting level before

diff --git a/urcu/static/urcu-qsbr.h b/urcu/static/urcu-qsbr.h
index 489abb0c399cc1026b387f37960530dfb9400bdf..68bfc31f540ee07adbb0701251adac9ccb0434b5 100644 (file)
--- a/urcu/static/urcu-qsbr.h
+++ b/urcu/static/urcu-qsbr.h
@@ -137,7 +137,7 @@ extern int32_t gp_futex;
  */
 static inline void wake_up_gp(void)
 {
  */
 static inline void wake_up_gp(void)
 {

-       if (unlikely(_CMM_LOAD_SHARED(rcu_reader.waiting))) {
+       if (caa_unlikely(_CMM_LOAD_SHARED(rcu_reader.waiting))) {

                _CMM_STORE_SHARED(rcu_reader.waiting, 0);
                cmm_smp_mb();
                if (uatomic_read(&gp_futex) != -1)
                _CMM_STORE_SHARED(rcu_reader.waiting, 0);
                cmm_smp_mb();
                if (uatomic_read(&gp_futex) != -1)

diff --git a/urcu/static/urcu.h b/urcu/static/urcu.h
index b9933754e26fed2e7ddb823a25a389681d8506a2..7ae018596ec89c9bbcf56b22340d100f0998357b 100644 (file)
--- a/urcu/static/urcu.h
+++ b/urcu/static/urcu.h
@@ -176,7 +176,7 @@ extern int has_sys_membarrier;
 
 static inline void smp_mb_slave(int group)
 {
 
 static inline void smp_mb_slave(int group)
 {

-       if (likely(has_sys_membarrier))
+       if (caa_likely(has_sys_membarrier))

                cmm_barrier();
        else
                cmm_smp_mb();
                cmm_barrier();
        else
                cmm_smp_mb();


@@ -231,7 +231,7 @@ extern int32_t gp_futex;
  */
 static inline void wake_up_gp(void)
 {
  */
 static inline void wake_up_gp(void)
 {

-       if (unlikely(uatomic_read(&gp_futex) == -1)) {
+       if (caa_unlikely(uatomic_read(&gp_futex) == -1)) {

                uatomic_set(&gp_futex, 0);
                futex_async(&gp_futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);
                uatomic_set(&gp_futex, 0);
                futex_async(&gp_futex, FUTEX_WAKE, 1,
                      NULL, NULL, 0);


@@ -261,7 +261,7 @@ static inline void _rcu_read_lock(void)
         * rcu_gp_ctr is
         *   RCU_GP_COUNT | (~RCU_GP_CTR_PHASE or RCU_GP_CTR_PHASE)
         */
         * rcu_gp_ctr is
         *   RCU_GP_COUNT | (~RCU_GP_CTR_PHASE or RCU_GP_CTR_PHASE)
         */

-       if (likely(!(tmp & RCU_GP_CTR_NEST_MASK))) {
+       if (caa_likely(!(tmp & RCU_GP_CTR_NEST_MASK))) {

                _CMM_STORE_SHARED(rcu_reader.ctr, _CMM_LOAD_SHARED(rcu_gp_ctr));
                /*
                 * Set active readers count for outermost nesting level before
                _CMM_STORE_SHARED(rcu_reader.ctr, _CMM_LOAD_SHARED(rcu_gp_ctr));
                /*
                 * Set active readers count for outermost nesting level before


@@ -282,7 +282,7 @@ static inline void _rcu_read_unlock(void)
         * Finish using rcu before decrementing the pointer.
         * See smp_mb_master().
         */
         * Finish using rcu before decrementing the pointer.
         * See smp_mb_master().
         */

-       if (likely((tmp & RCU_GP_CTR_NEST_MASK) == RCU_GP_COUNT)) {
+       if (caa_likely((tmp & RCU_GP_CTR_NEST_MASK) == RCU_GP_COUNT)) {

                smp_mb_slave(RCU_MB_GROUP);
                _CMM_STORE_SHARED(rcu_reader.ctr, rcu_reader.ctr - RCU_GP_COUNT);
                /* write rcu_reader.ctr before read futex */
                smp_mb_slave(RCU_MB_GROUP);
                _CMM_STORE_SHARED(rcu_reader.ctr, rcu_reader.ctr - RCU_GP_COUNT);
                /* write rcu_reader.ctr before read futex */

diff --git a/urcu/uatomic/x86.h b/urcu/uatomic/x86.h
index e064b9ebd6e1bc798c85a0d464d42940cacf2d3e..9b67f1608d365830bd951382781ada35f91b6150 100644 (file)
--- a/urcu/uatomic/x86.h
+++ b/urcu/uatomic/x86.h
@@ -505,9 +505,9 @@ extern int __rcu_cas_avail;
 extern int __rcu_cas_init(void);
 
 #define UATOMIC_COMPAT(insn)                                                   \
 extern int __rcu_cas_init(void);
 
 #define UATOMIC_COMPAT(insn)                                                   \

-       ((likely(__rcu_cas_avail > 0))                                          \
+       ((caa_likely(__rcu_cas_avail > 0))                                              \

        ? (_uatomic_##insn)                                                     \
        ? (_uatomic_##insn)                                                     \

-               : ((unlikely(__rcu_cas_avail < 0)                               \
+               : ((caa_unlikely(__rcu_cas_avail < 0)                           \

                        ? ((__rcu_cas_init() > 0)                               \
                                ? (_uatomic_##insn)                             \
                                : (compat_uatomic_##insn))                      \
                        ? ((__rcu_cas_init() > 0)                               \
                                ? (_uatomic_##insn)                             \
                                : (compat_uatomic_##insn))                      \