X-Git-Url: https://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu-bp.c;h=1b0bd6950da04533c35bf00a5c131ac4da3e470b;hp=9c3dbe7e15ef210b5da7c9d7638796207ad041c7;hb=ee39cfb61d2a389db3342751762412f332a3e851;hpb=0617bf4c03c86fb9653c0887cde8ddbdb3b95658 diff --git a/urcu-bp.c b/urcu-bp.c index 9c3dbe7..1b0bd69 100644 --- a/urcu-bp.c +++ b/urcu-bp.c @@ -43,9 +43,9 @@ #define RCU_SLEEP_DELAY 1000 #define ARENA_INIT_ALLOC 16 -void __attribute__((destructor)) urcu_bp_exit(void); +void __attribute__((destructor)) rcu_bp_exit(void); -static pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t rcu_gp_lock = PTHREAD_MUTEX_INITIALIZER; #ifdef DEBUG_YIELD unsigned int yield_active; @@ -54,17 +54,17 @@ unsigned int __thread rand_yield; /* * Global grace period counter. - * Contains the current RCU_GP_CTR_BIT. + * Contains the current RCU_GP_CTR_PHASE. * 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; +long rcu_gp_ctr = RCU_GP_COUNT; /* * Pointer to registry elements. 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; static LIST_HEAD(registry); @@ -78,26 +78,26 @@ static struct registry_arena registry_arena; static void rcu_gc_registry(void); -static void internal_urcu_lock(void) +static void mutex_lock(pthread_mutex_t *mutex) { int ret; #ifndef DISTRUST_SIGNALS_EXTREME - ret = pthread_mutex_lock(&urcu_mutex); + ret = pthread_mutex_lock(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(mutex)) != 0) { if (ret != EBUSY && ret != EINTR) { printf("ret = %d, errno = %d\n", ret, errno); perror("Error in pthread mutex lock"); exit(-1); } - if (urcu_reader.need_mb) { + if (rcu_reader.need_mb) { smp_mb(); - urcu_reader.need_mb = 0; + rcu_reader.need_mb = 0; smp_mb(); } poll(NULL,0,10); @@ -105,35 +105,42 @@ static void internal_urcu_lock(void) #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */ } -static void internal_urcu_unlock(void) +static void mutex_unlock(pthread_mutex_t *mutex) { int ret; - ret = pthread_mutex_unlock(&urcu_mutex); + ret = pthread_mutex_unlock(mutex); if (ret) { perror("Error in pthread mutex unlock"); exit(-1); } } -/* - * called with urcu_mutex held. - */ -static void switch_next_urcu_qparity(void) -{ - STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_CTR_BIT); -} - -void wait_for_quiescent_state(void) +void update_counter_and_wait(void) { LIST_HEAD(qsreaders); int wait_loops = 0; - struct urcu_reader *index, *tmp; + struct rcu_reader *index, *tmp; + + /* Switch parity: 0 -> 1, 1 -> 0 */ + STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr ^ RCU_GP_CTR_PHASE); + + /* + * Must commit qparity update to memory before waiting for other parity + * quiescent state. Failure to do so could result in the writer waiting + * forever while new readers are always accessing data (no progress). + * Ensured by STORE_SHARED and LOAD_SHARED. + */ + + /* + * Adding a smp_mb() which is _not_ formally required, but makes the + * model easier to understand. It does not have a big performance impact + * anyway, given this is the write-side. + */ + smp_mb(); - if (list_empty(®istry)) - return; /* - * Wait for each thread urcu_reader.ctr count to become 0. + * Wait for each thread rcu_reader.ctr count to become 0. */ for (;;) { wait_loops++; @@ -165,46 +172,23 @@ void synchronize_rcu(void) ret = pthread_sigmask(SIG_SETMASK, &newmask, &oldmask); assert(!ret); - internal_urcu_lock(); + mutex_lock(&rcu_gp_lock); - /* Remove old registry elements */ - rcu_gc_registry(); + if (list_empty(®istry)) + goto out; /* All threads should read qparity before accessing data structure - * where new ptr points to. Must be done within internal_urcu_lock - * because it iterates on reader threads.*/ + * where new ptr points to. */ /* Write new ptr before changing the qparity */ smp_mb(); - switch_next_urcu_qparity(); /* 0 -> 1 */ - - /* - * Must commit qparity update to memory before waiting for parity - * 0 quiescent state. Failure to do so could result in the writer - * waiting forever while new readers are always accessing data (no - * progress). - * Ensured by STORE_SHARED and LOAD_SHARED. - */ - - /* - * Adding a smp_mb() which is _not_ formally required, but makes the - * model easier to understand. It does not have a big performance impact - * anyway, given this is the write-side. - */ - smp_mb(); + /* Remove old registry elements */ + rcu_gc_registry(); /* * Wait for previous parity to be empty of readers. */ - wait_for_quiescent_state(); /* Wait readers in parity 0 */ - - /* - * Must finish waiting for quiescent state for parity 0 before - * committing qparity update to memory. Failure to do so could result in - * the writer waiting forever while new readers are always accessing - * data (no progress). - * Ensured by STORE_SHARED and LOAD_SHARED. - */ + update_counter_and_wait(); /* 0 -> 1, wait readers in parity 0 */ /* * Adding a smp_mb() which is _not_ formally required, but makes the @@ -213,34 +197,18 @@ void synchronize_rcu(void) */ smp_mb(); - switch_next_urcu_qparity(); /* 1 -> 0 */ - /* - * Must commit qparity update to memory before waiting for parity - * 1 quiescent state. Failure to do so could result in the writer - * waiting forever while new readers are always accessing data (no - * progress). - * Ensured by STORE_SHARED and LOAD_SHARED. - */ - - /* - * Adding a smp_mb() which is _not_ formally required, but makes the - * model easier to understand. It does not have a big performance impact - * anyway, given this is the write-side. + * Wait for previous parity to be empty of readers. */ - smp_mb(); + update_counter_and_wait(); /* 1 -> 0, wait readers in parity 1 */ /* - * Wait for previous parity to be empty of readers. + * Finish waiting for reader threads before letting the old ptr being + * freed. */ - wait_for_quiescent_state(); /* Wait readers in parity 1 */ - - /* 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. */ smp_mb(); - - internal_urcu_unlock(); +out: + mutex_unlock(&rcu_gp_lock); ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); assert(!ret); } @@ -290,50 +258,50 @@ static void resize_arena(struct registry_arena *arena, size_t len) /* Called with signals off and mutex locked */ static void add_thread(void) { - struct urcu_reader *urcu_reader_reg; + struct rcu_reader *rcu_reader_reg; if (registry_arena.len - < registry_arena.used + sizeof(struct urcu_reader)) + < registry_arena.used + sizeof(struct rcu_reader)) resize_arena(®istry_arena, max(registry_arena.len << 1, ARENA_INIT_ALLOC)); /* * Find a free spot. */ - for (urcu_reader_reg = registry_arena.p; - (void *)urcu_reader_reg < registry_arena.p + registry_arena.len; - urcu_reader_reg++) { - if (!urcu_reader_reg->alloc) + for (rcu_reader_reg = registry_arena.p; + (void *)rcu_reader_reg < registry_arena.p + registry_arena.len; + rcu_reader_reg++) { + if (!rcu_reader_reg->alloc) break; } - urcu_reader_reg->alloc = 1; - registry_arena.used += sizeof(struct urcu_reader); + rcu_reader_reg->alloc = 1; + registry_arena.used += sizeof(struct rcu_reader); /* Add to registry */ - urcu_reader_reg->tid = pthread_self(); - assert(urcu_reader_reg->ctr == 0); - list_add(&urcu_reader_reg->head, ®istry); - urcu_reader = urcu_reader_reg; + rcu_reader_reg->tid = pthread_self(); + assert(rcu_reader_reg->ctr == 0); + list_add(&rcu_reader_reg->head, ®istry); + rcu_reader = rcu_reader_reg; } /* Called with signals off and mutex locked */ static void rcu_gc_registry(void) { - struct urcu_reader *urcu_reader_reg; + struct rcu_reader *rcu_reader_reg; pthread_t tid; int ret; - for (urcu_reader_reg = registry_arena.p; - (void *)urcu_reader_reg < registry_arena.p + registry_arena.len; - urcu_reader_reg++) { - if (!urcu_reader_reg->alloc) + for (rcu_reader_reg = registry_arena.p; + (void *)rcu_reader_reg < registry_arena.p + registry_arena.len; + rcu_reader_reg++) { + if (!rcu_reader_reg->alloc) continue; - tid = urcu_reader_reg->tid; + tid = rcu_reader_reg->tid; ret = pthread_kill(tid, 0); assert(ret != EINVAL); if (ret == ESRCH) { - list_del(&urcu_reader_reg->head); - urcu_reader_reg->alloc = 0; - registry_arena.used -= sizeof(struct urcu_reader); + list_del(&rcu_reader_reg->head); + rcu_reader_reg->alloc = 0; + registry_arena.used -= sizeof(struct rcu_reader); } } } @@ -352,18 +320,18 @@ void rcu_bp_register(void) /* * Check if a signal concurrently registered our thread since * the check in rcu_read_lock(). */ - if (urcu_reader) + if (rcu_reader) goto end; - internal_urcu_lock(); + mutex_lock(&rcu_gp_lock); add_thread(); - internal_urcu_unlock(); + mutex_unlock(&rcu_gp_lock); end: ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); assert(!ret); } -void urcu_bp_exit() +void rcu_bp_exit() { munmap(registry_arena.p, registry_arena.len); }