API prefix standardization: urcu_ -> rcu_

[urcu.git] / urcu-qsbr.c

diff --git a/urcu-qsbr.c b/urcu-qsbr.c
index f002c345dcb7325d7bb6fb0221518587d35c4fc1..3d576b57441eac3c318f6af6fea2fab7d362ef7d 100644 (file)
--- a/urcu-qsbr.c
+++ b/urcu-qsbr.c
@@ -39,20 +39,20 @@
 
 void __attribute__((destructor)) rcu_exit(void);
 
-static pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t rcu_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 int gp_futex;
 
 /*
  * Global grace period counter.
  */
-unsigned long urcu_gp_ctr = RCU_GP_ONLINE;
+unsigned long rcu_gp_ctr = RCU_GP_ONLINE;
 
 /*
  * Written to only by each individual reader. Read by both the reader and the
  * writers.
  */
-struct urcu_reader __thread urcu_reader;
+struct rcu_reader __thread rcu_reader;
 
 #ifdef DEBUG_YIELD
 unsigned int yield_active;
@@ -61,18 +61,18 @@ unsigned int __thread rand_yield;
 
 static LIST_HEAD(registry);
 
-static void internal_urcu_lock(void)
+static void internal_rcu_lock(void)
 {
        int ret;
 
 #ifndef DISTRUST_SIGNALS_EXTREME
-       ret = pthread_mutex_lock(&urcu_mutex);
+       ret = pthread_mutex_lock(&rcu_mutex);
        if (ret) {
                perror("Error in pthread mutex lock");
                exit(-1);
        }
 #else /* #ifndef DISTRUST_SIGNALS_EXTREME */
-       while ((ret = pthread_mutex_trylock(&urcu_mutex)) != 0) {
+       while ((ret = pthread_mutex_trylock(&rcu_mutex)) != 0) {
                if (ret != EBUSY && ret != EINTR) {
                        printf("ret = %d, errno = %d\n", ret, errno);
                        perror("Error in pthread mutex lock");
@@ -83,11 +83,11 @@ static void internal_urcu_lock(void)
 #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
 }
 
-static void internal_urcu_unlock(void)
+static void internal_rcu_unlock(void)
 {
        int ret;
 
-       ret = pthread_mutex_unlock(&urcu_mutex);
+       ret = pthread_mutex_unlock(&rcu_mutex);
        if (ret) {
                perror("Error in pthread mutex unlock");
                exit(-1);
@@ -102,7 +102,7 @@ static void wait_gp(void)
        /* Read reader_gp before read futex */
        smp_rmb();
        if (uatomic_read(&gp_futex) == -1)
-               futex(&gp_futex, FUTEX_WAIT, -1,
+               futex_noasync(&gp_futex, FUTEX_WAIT, -1,
                      NULL, NULL, 0);
 }
 
@@ -110,7 +110,7 @@ static void wait_for_quiescent_state(void)
 {
        LIST_HEAD(qsreaders);
        int wait_loops = 0;
-       struct urcu_reader *index, *tmp;
+       struct rcu_reader *index, *tmp;
 
        if (list_empty(&registry))
                return;
@@ -160,18 +160,18 @@ static void wait_for_quiescent_state(void)
 
 #if (BITS_PER_LONG < 64)
 /*
- * called with urcu_mutex held.
+ * called with rcu_mutex held.
  */
-static void switch_next_urcu_qparity(void)
+static void switch_next_rcu_qparity(void)
 {
-       STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_CTR);
+       STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr ^ RCU_GP_CTR);
 }
 
 void synchronize_rcu(void)
 {
        unsigned long was_online;
 
-       was_online = urcu_reader.ctr;
+       was_online = rcu_reader.ctr;
 
        /* All threads should read qparity before accessing data structure
         * where new ptr points to.
@@ -185,11 +185,11 @@ void synchronize_rcu(void)
         * threads registered as readers.
         */
        if (was_online)
-               STORE_SHARED(urcu_reader.ctr, 0);
+               STORE_SHARED(rcu_reader.ctr, 0);
 
-       internal_urcu_lock();
+       internal_rcu_lock();
 
-       switch_next_urcu_qparity();     /* 0 -> 1 */
+       switch_next_rcu_qparity();      /* 0 -> 1 */
 
        /*
         * Must commit qparity update to memory before waiting for parity
@@ -212,7 +212,7 @@ void synchronize_rcu(void)
         * Ensured by STORE_SHARED and LOAD_SHARED.
         */
 
-       switch_next_urcu_qparity();     /* 1 -> 0 */
+       switch_next_rcu_qparity();      /* 1 -> 0 */
 
        /*
         * Must commit qparity update to memory before waiting for parity
@@ -227,14 +227,14 @@ void synchronize_rcu(void)
         */
        wait_for_quiescent_state();     /* Wait readers in parity 1 */
 
-       internal_urcu_unlock();
+       internal_rcu_unlock();
 
        /*
         * Finish waiting for reader threads before letting the old ptr being
         * freed.
         */
        if (was_online)
-               _STORE_SHARED(urcu_reader.ctr, LOAD_SHARED(urcu_gp_ctr));
+               _STORE_SHARED(rcu_reader.ctr, LOAD_SHARED(rcu_gp_ctr));
        smp_mb();
 }
 #else /* !(BITS_PER_LONG < 64) */
@@ -242,7 +242,7 @@ void synchronize_rcu(void)
 {
        unsigned long was_online;
 
-       was_online = urcu_reader.ctr;
+       was_online = rcu_reader.ctr;
 
        /*
         * Mark the writer thread offline to make sure we don't wait for
@@ -251,15 +251,15 @@ void synchronize_rcu(void)
         */
        smp_mb();
        if (was_online)
-               STORE_SHARED(urcu_reader.ctr, 0);
+               STORE_SHARED(rcu_reader.ctr, 0);
 
-       internal_urcu_lock();
-       STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr + RCU_GP_CTR);
+       internal_rcu_lock();
+       STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr + RCU_GP_CTR);
        wait_for_quiescent_state();
-       internal_urcu_unlock();
+       internal_rcu_unlock();
 
        if (was_online)
-               _STORE_SHARED(urcu_reader.ctr, LOAD_SHARED(urcu_gp_ctr));
+               _STORE_SHARED(rcu_reader.ctr, LOAD_SHARED(rcu_gp_ctr));
        smp_mb();
 }
 #endif  /* !(BITS_PER_LONG < 64) */
@@ -278,38 +278,6 @@ void rcu_read_unlock(void)
        _rcu_read_unlock();
 }
 
-void *rcu_dereference(void *p)
-{
-       return _rcu_dereference(p);
-}
-
-void *rcu_assign_pointer_sym(void **p, void *v)
-{
-       wmb();
-       return STORE_SHARED(p, v);
-}
-
-void *rcu_cmpxchg_pointer_sym(void **p, void *old, void *_new)
-{
-       wmb();
-       return uatomic_cmpxchg(p, old, _new);
-}
-
-void *rcu_xchg_pointer_sym(void **p, void *v)
-{
-       wmb();
-       return uatomic_xchg(p, v);
-}
-
-void *rcu_publish_content_sym(void **p, void *v)
-{
-       void *oldptr;
-
-       oldptr = _rcu_xchg_pointer(p, v);
-       synchronize_rcu();
-       return oldptr;
-}
-
 void rcu_quiescent_state(void)
 {
        _rcu_quiescent_state();
@@ -327,12 +295,12 @@ void rcu_thread_online(void)
 
 void rcu_register_thread(void)
 {
-       urcu_reader.tid = pthread_self();
-       assert(urcu_reader.ctr == 0);
+       rcu_reader.tid = pthread_self();
+       assert(rcu_reader.ctr == 0);
 
-       internal_urcu_lock();
-       list_add(&urcu_reader.head, &registry);
-       internal_urcu_unlock();
+       internal_rcu_lock();
+       list_add(&rcu_reader.head, &registry);
+       internal_rcu_unlock();
        _rcu_thread_online();
 }
 
@@ -343,9 +311,9 @@ void rcu_unregister_thread(void)
         * with a waiting writer.
         */
        _rcu_thread_offline();
-       internal_urcu_lock();
-       list_del(&urcu_reader.head);
-       internal_urcu_unlock();
+       internal_rcu_lock();
+       list_del(&rcu_reader.head);
+       internal_rcu_unlock();
 }
 
 void rcu_exit(void)