Update makefile to compiler for 32-bit architectures on x86_64

[urcu.git] / urcu-qsbr.c

diff --git a/urcu-qsbr.c b/urcu-qsbr.c
index 6ba03642f852763057781dcf14bf2ff4a01dc5b9..ba6e02af27f3a18b60f26d56779bb5d4f869524e 100644 (file)
--- a/urcu-qsbr.c
+++ b/urcu-qsbr.c
@@ -1,7 +1,7 @@
 /*
- * urcu.c
+ * urcu-qsbr.c
  *
- * Userspace RCU library
+ * Userspace RCU QSBR library
  *
  * Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
  * Copyright (c) 2009 Paul E. McKenney, IBM Corporation.
@@ -32,30 +32,30 @@
 #include <errno.h>
 #include <poll.h>
 
-#include "urcu-qsbr.h"
+#define BUILD_QSBR_LIB
+#include "urcu-qsbr-static.h"
 /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */
-//#include "urcu.h"
+#include "urcu-qsbr.h"
 
 pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 /*
  * Global grace period counter.
  */
-long urcu_gp_ctr = 0;
+unsigned long urcu_gp_ctr = RCU_GP_ONLINE;
 
 /*
  * Written to only by each individual reader. Read by both the reader and the
  * writers.
  */
-long __thread rcu_reader_qs_gp;
+unsigned long __thread rcu_reader_qs_gp;
 
 /* Thread IDs of registered readers */
 #define INIT_NUM_THREADS 4
 
 struct reader_registry {
        pthread_t tid;
-       long *rcu_reader_qs_gp;
-       char *need_mb;
+       unsigned long *rcu_reader_qs_gp;
 };
 
 #ifdef DEBUG_YIELD
@@ -64,10 +64,9 @@ unsigned int __thread rand_yield;
 #endif
 
 static struct reader_registry *registry;
-static char __thread need_mb;
 static int num_readers, alloc_readers;
 
-void internal_urcu_lock(void)
+static void internal_urcu_lock(void)
 {
        int ret;
 
@@ -84,17 +83,12 @@ void internal_urcu_lock(void)
                        perror("Error in pthread mutex lock");
                        exit(-1);
                }
-               if (need_mb) {
-                       smp_mb();
-                       need_mb = 0;
-                       smp_mb();
-               }
                poll(NULL,0,10);
        }
 #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
 }
 
-void internal_urcu_unlock(void)
+static void internal_urcu_unlock(void)
 {
        int ret;
 
@@ -112,12 +106,7 @@ static void force_mb_single_thread(struct reader_registry *index)
 }
 #endif /* #ifdef HAS_INCOHERENT_CACHES */
 
-static void force_mb_all_threads(void)
-{
-       smp_mb();
-}
-
-void wait_for_quiescent_state(void)
+static void wait_for_quiescent_state(void)
 {
        struct reader_registry *index;
 
@@ -128,8 +117,7 @@ void wait_for_quiescent_state(void)
         */
        for (index = registry; index < registry + num_readers; index++) {
 #ifndef HAS_INCOHERENT_CACHES
-               while (rcu_gp_ongoing(index->rcu_reader_qs_gp) &&
-                      (*index->rcu_reader_qs_gp - urcu_gp_ctr < 0))
+               while (rcu_gp_ongoing(index->rcu_reader_qs_gp))
                        cpu_relax();
 #else /* #ifndef HAS_INCOHERENT_CACHES */
                int wait_loops = 0;
@@ -137,8 +125,7 @@ void wait_for_quiescent_state(void)
                 * BUSY-LOOP. Force the reader thread to commit its
                 * rcu_reader_qs_gp update to memory if we wait for too long.
                 */
-               while (rcu_gp_ongoing(index->rcu_reader_qs_gp) &&
-                      (*index->rcu_reader_qs_gp - urcu_gp_ctr < 0)) {
+               while (rcu_gp_ongoing(index->rcu_reader_qs_gp)) {
                        if (wait_loops++ == KICK_READER_LOOPS) {
                                force_mb_single_thread(index);
                                wait_loops = 0;
@@ -152,12 +139,27 @@ void wait_for_quiescent_state(void)
 
 void synchronize_rcu(void)
 {
+       unsigned long was_online;
+
+       was_online = rcu_reader_qs_gp;
+
+       /*
+        * Mark the writer thread offline to make sure we don't wait for
+        * our own quiescent state. This allows using synchronize_rcu() in
+        * threads registered as readers.
+        */
+       smp_mb();
+       if (was_online)
+               STORE_SHARED(rcu_reader_qs_gp, 0);
+
        internal_urcu_lock();
-       force_mb_all_threads();
-       urcu_gp_ctr += 2;
+       STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr + RCU_GP_CTR);
        wait_for_quiescent_state();
-       force_mb_all_threads();
        internal_urcu_unlock();
+
+       if (was_online)
+               _STORE_SHARED(rcu_reader_qs_gp, LOAD_SHARED(urcu_gp_ctr));
+       smp_mb();
 }
 
 /*
@@ -200,6 +202,21 @@ void *rcu_publish_content_sym(void **p, void *v)
        return oldptr;
 }
 
+void rcu_quiescent_state(void)
+{
+       _rcu_quiescent_state();
+}
+
+void rcu_thread_offline(void)
+{
+       _rcu_thread_offline();
+}
+
+void rcu_thread_online(void)
+{
+       _rcu_thread_online();
+}
+
 static void rcu_add_reader(pthread_t id)
 {
        struct reader_registry *oldarray;
@@ -222,7 +239,6 @@ static void rcu_add_reader(pthread_t id)
        registry[num_readers].tid = id;
        /* reference to the TLS of _this_ reader thread. */
        registry[num_readers].rcu_reader_qs_gp = &rcu_reader_qs_gp;
-       registry[num_readers].need_mb = &need_mb;
        num_readers++;
 }
 
@@ -254,10 +270,16 @@ void rcu_register_thread(void)
        internal_urcu_lock();
        rcu_add_reader(pthread_self());
        internal_urcu_unlock();
+       _rcu_thread_online();
 }
 
 void rcu_unregister_thread(void)
 {
+       /*
+        * We have to make the thread offline otherwise we end up dealocking
+        * with a waiting writer.
+        */
+       _rcu_thread_offline();
        internal_urcu_lock();
        rcu_remove_reader(pthread_self());
        internal_urcu_unlock();