X-Git-Url: https://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu.c;h=b4346551b2403127da9822f08223f875c991e4ca;hp=b4a5a7db948b8d57a03960747c5257d9631b1c7c;hb=541d828d3101283ccdb1e25fa5a885e1d1743c1a;hpb=06f22bdbb0c4c4d5db42a2e2dc35818aa61415be diff --git a/urcu.c b/urcu.c index b4a5a7d..b434655 100644 --- a/urcu.c +++ b/urcu.c @@ -24,18 +24,39 @@ */ #define _BSD_SOURCE +#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include #include #include +#include #include #include #include -#include "urcu-static.h" +#include "urcu/wfqueue.h" +#include "urcu/map/urcu.h" +#include "urcu/static/urcu.h" +#include "urcu-pointer.h" + /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ +#undef _LGPL_SOURCE #include "urcu.h" +#define _LGPL_SOURCE + +/* + * If a reader is really non-cooperative and refuses to commit its + * rcu_active_readers count to memory (there is no barrier in the reader + * per-se), kick it after a few loops waiting for it. + */ +#define KICK_READER_LOOPS 10000 + +/* + * Active attempts to check for reader Q.S. before calling futex(). + */ +#define RCU_QS_ACTIVE_ATTEMPTS 100 #ifdef RCU_MEMBARRIER static int init_done; @@ -59,7 +80,7 @@ void __attribute__((destructor)) rcu_exit(void); static pthread_mutex_t rcu_gp_lock = PTHREAD_MUTEX_INITIALIZER; -int gp_futex; +int32_t gp_futex; /* * Global grace period counter. @@ -80,7 +101,7 @@ unsigned int yield_active; unsigned int __thread rand_yield; #endif -static LIST_HEAD(registry); +static CDS_LIST_HEAD(registry); static void mutex_lock(pthread_mutex_t *mutex) { @@ -99,9 +120,9 @@ static void mutex_lock(pthread_mutex_t *mutex) perror("Error in pthread mutex lock"); exit(-1); } - if (CAA_LOAD_SHARED(rcu_reader.need_mb)) { + if (CMM_LOAD_SHARED(rcu_reader.need_mb)) { cmm_smp_mb(); - _CAA_STORE_SHARED(rcu_reader.need_mb, 0); + _CMM_STORE_SHARED(rcu_reader.need_mb, 0); cmm_smp_mb(); } poll(NULL,0,10); @@ -123,7 +144,7 @@ static void mutex_unlock(pthread_mutex_t *mutex) #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(); @@ -146,7 +167,7 @@ static void force_mb_all_readers(void) * Ask for each threads to execute a cmm_smp_mb() so we can consider the * compiler barriers around rcu read lock as real memory barriers. */ - if (list_empty(®istry)) + if (cds_list_empty(®istry)) return; /* * pthread_kill has a cmm_smp_mb(). But beware, we assume it performs @@ -154,8 +175,8 @@ static void force_mb_all_readers(void) * safe and don't assume anything : we use cmm_smp_mc() to make sure the * cache flush is enforced. */ - list_for_each_entry(index, ®istry, node) { - CAA_STORE_SHARED(index->need_mb, 1); + cds_list_for_each_entry(index, ®istry, node) { + CMM_STORE_SHARED(index->need_mb, 1); pthread_kill(index->tid, SIGRCU); } /* @@ -171,8 +192,8 @@ static void force_mb_all_readers(void) * relevant bug report. For Linux kernels, we recommend getting * the Linux Test Project (LTP). */ - list_for_each_entry(index, ®istry, node) { - while (CAA_LOAD_SHARED(index->need_mb)) { + cds_list_for_each_entry(index, ®istry, node) { + while (CMM_LOAD_SHARED(index->need_mb)) { pthread_kill(index->tid, SIGRCU); poll(NULL, 0, 1); } @@ -200,12 +221,12 @@ static void wait_gp(void) void update_counter_and_wait(void) { - LIST_HEAD(qsreaders); + CDS_LIST_HEAD(qsreaders); int wait_loops = 0; struct rcu_reader *index, *tmp; /* Switch parity: 0 -> 1, 1 -> 0 */ - CAA_STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr ^ RCU_GP_CTR_PHASE); + CMM_STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr ^ RCU_GP_CTR_PHASE); /* * Must commit rcu_gp_ctr update to memory before waiting for quiescent @@ -234,13 +255,13 @@ void update_counter_and_wait(void) smp_mb_master(RCU_MB_GROUP); } - list_for_each_entry_safe(index, tmp, ®istry, node) { + cds_list_for_each_entry_safe(index, tmp, ®istry, node) { if (!rcu_gp_ongoing(&index->ctr)) - list_move(&index->node, &qsreaders); + cds_list_move(&index->node, &qsreaders); } #ifndef HAS_INCOHERENT_CACHES - if (list_empty(®istry)) { + if (cds_list_empty(®istry)) { if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS) { /* Read reader_gp before write futex */ smp_mb_master(RCU_MB_GROUP); @@ -258,7 +279,7 @@ void update_counter_and_wait(void) * BUSY-LOOP. Force the reader thread to commit its * rcu_reader.ctr update to memory if we wait for too long. */ - if (list_empty(®istry)) { + if (cds_list_empty(®istry)) { if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS) { /* Read reader_gp before write futex */ smp_mb_master(RCU_MB_GROUP); @@ -281,14 +302,14 @@ void update_counter_and_wait(void) #endif /* #else #ifndef HAS_INCOHERENT_CACHES */ } /* put back the reader list in the registry */ - list_splice(&qsreaders, ®istry); + cds_list_splice(&qsreaders, ®istry); } void synchronize_rcu(void) { mutex_lock(&rcu_gp_lock); - if (list_empty(®istry)) + if (cds_list_empty(®istry)) goto out; /* All threads should read qparity before accessing data structure @@ -353,14 +374,14 @@ void rcu_register_thread(void) mutex_lock(&rcu_gp_lock); rcu_init(); /* In case gcc does not support constructor attribute */ - list_add(&rcu_reader.node, ®istry); + cds_list_add(&rcu_reader.node, ®istry); mutex_unlock(&rcu_gp_lock); } void rcu_unregister_thread(void) { mutex_lock(&rcu_gp_lock); - list_del(&rcu_reader.node); + cds_list_del(&rcu_reader.node); mutex_unlock(&rcu_gp_lock); } @@ -384,7 +405,7 @@ static void sigrcu_handler(int signo, siginfo_t *siginfo, void *context) * executed on. */ cmm_smp_mb(); - _CAA_STORE_SHARED(rcu_reader.need_mb, 0); + _CMM_STORE_SHARED(rcu_reader.need_mb, 0); cmm_smp_mb(); } @@ -426,6 +447,12 @@ void rcu_exit(void) exit(-1); } assert(act.sa_sigaction == sigrcu_handler); - assert(list_empty(®istry)); + assert(cds_list_empty(®istry)); } + #endif /* #ifdef RCU_SIGNAL */ + +DEFINE_RCU_FLAVOR() + +#include "urcu-call-rcu-impl.h" +#include "urcu-defer-impl.h"