/* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */
#include "urcu.h"
-#ifndef DEBUG_FULL_MB
+#ifndef URCU_MB
+static int init_done;
+
void __attribute__((constructor)) urcu_init(void);
void __attribute__((destructor)) urcu_exit(void);
#else
-static inline void urcu_init(void)
+void urcu_init(void)
{
}
#endif
-int init_done;
-
-pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
/*
* Global grace period counter.
* Contains the current RCU_GP_CTR_BIT.
- * Also has a RCU_GP_CTR_BIT of 1, to accelerate the reader fast path.
+ * Also has a RCU_GP_COUNT of 1, to accelerate the reader fast path.
* Written to only by writer with mutex taken. Read by both writer and readers.
*/
long urcu_gp_ctr = RCU_GP_COUNT;
* Written to only by each individual reader. Read by both the reader and the
* writers.
*/
-long __thread urcu_active_readers;
+struct urcu_reader_status __thread urcu_reader_status;
/* Thread IDs of registered readers */
#define INIT_NUM_THREADS 4
struct reader_registry {
pthread_t tid;
- long *urcu_active_readers;
+ struct urcu_reader_status *urcu_reader_status;
char *need_mb;
};
static char __thread need_mb;
static int num_readers, alloc_readers;
-void internal_urcu_lock(void)
+static void internal_urcu_lock(void)
{
int ret;
#endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
}
-void internal_urcu_unlock(void)
+static void internal_urcu_unlock(void)
{
int ret;
STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_CTR_BIT);
}
-#ifdef DEBUG_FULL_MB
+#ifdef URCU_MB
#ifdef HAS_INCOHERENT_CACHES
static void force_mb_single_thread(struct reader_registry *index)
{
{
smp_mb();
}
-#else /* #ifdef DEBUG_FULL_MB */
+#else /* #ifdef URCU_MB */
#ifdef HAS_INCOHERENT_CACHES
static void force_mb_single_thread(struct reader_registry *index)
{
}
smp_mb(); /* read ->need_mb before ending the barrier */
}
-#endif /* #else #ifdef DEBUG_FULL_MB */
+#endif /* #else #ifdef URCU_MB */
void wait_for_quiescent_state(void)
{
if (!registry)
return;
/*
- * Wait for each thread urcu_active_readers count to become 0.
+ * Wait for each thread active_readers count to become 0.
*/
for (index = registry; index < registry + num_readers; index++) {
+ int wait_loops = 0;
+
+ if (likely(!rcu_old_gp_ongoing(
+ &index->urcu_reader_status->active_readers)))
+ continue;
+
+ index->urcu_reader_status->gp_waiting = 1;
#ifndef HAS_INCOHERENT_CACHES
- while (rcu_old_gp_ongoing(index->urcu_active_readers))
- cpu_relax();
+ while (rcu_old_gp_ongoing(
+ &index->urcu_reader_status->active_readers)) {
+ if (wait_loops++ == RCU_QS_ACTIVE_ATTEMPTS) {
+ sched_yield(); /* ideally sched_yield_to() */
+ } else {
+ cpu_relax();
+ }
+ }
#else /* #ifndef HAS_INCOHERENT_CACHES */
- int wait_loops = 0;
/*
* BUSY-LOOP. Force the reader thread to commit its
- * urcu_active_readers update to memory if we wait for too long.
+ * active_readers update to memory if we wait for too long.
*/
- while (rcu_old_gp_ongoing(index->urcu_active_readers)) {
- if (wait_loops++ == KICK_READER_LOOPS) {
+ while (rcu_old_gp_ongoing(
+ &index->urcu_reader_status->active_readers)) {
+ switch (wait_loops++) {
+ case RCU_QS_ACTIVE_ATTEMPTS:
+ sched_yield(); /* ideally sched_yield_to() */
+ break;
+ case KICK_READER_LOOPS:
force_mb_single_thread(index);
wait_loops = 0;
- } else {
+ break;
+ default:
cpu_relax();
}
}
#endif /* #else #ifndef HAS_INCOHERENT_CACHES */
+ index->urcu_reader_status->gp_waiting = 0;
}
}
/* Write new ptr before changing the qparity */
force_mb_all_threads();
+ STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_ONGOING);
+
switch_next_urcu_qparity(); /* 0 -> 1 */
/*
*/
wait_for_quiescent_state(); /* Wait readers in parity 1 */
+ STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_ONGOING);
+
/* Finish waiting for reader threads before letting the old ptr being
* freed. Must be done within internal_urcu_lock because it iterates on
* reader threads. */
return xchg(p, v);
}
+void *rcu_cmpxchg_pointer_sym(void **p, void *old, void *_new)
+{
+ wmb();
+ return cmpxchg(p, old, _new);
+}
+
void *rcu_publish_content_sym(void **p, void *v)
{
void *oldptr;
}
registry[num_readers].tid = id;
/* reference to the TLS of _this_ reader thread. */
- registry[num_readers].urcu_active_readers = &urcu_active_readers;
+ registry[num_readers].urcu_reader_status = &urcu_reader_status;
registry[num_readers].need_mb = &need_mb;
num_readers++;
}
memcpy(index, ®istry[num_readers - 1],
sizeof(struct reader_registry));
registry[num_readers - 1].tid = 0;
- registry[num_readers - 1].urcu_active_readers = NULL;
+ registry[num_readers - 1].urcu_reader_status = NULL;
num_readers--;
return;
}
internal_urcu_unlock();
}
-#ifndef DEBUG_FULL_MB
+#ifndef URCU_MB
static void sigurcu_handler(int signo, siginfo_t *siginfo, void *context)
{
/*
init_done = 1;
act.sa_sigaction = sigurcu_handler;
- act.sa_flags = SA_SIGINFO;
+ act.sa_flags = SA_SIGINFO | SA_RESTART;
sigemptyset(&act.sa_mask);
ret = sigaction(SIGURCU, &act, NULL);
if (ret) {
assert(act.sa_sigaction == sigurcu_handler);
free(registry);
}
-#endif /* #ifndef DEBUG_FULL_MB */
+#endif /* #ifndef URCU_MB */