From 6abb4bd53503c325dc94b0c0f60b44b9550b462f Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Sun, 17 Jan 2010 11:42:56 -0500 Subject: [PATCH] rename internal_rcu_lock() into mutex_lock/unlock(&rcu_gp_lock) Cleanup. Signed-off-by: Mathieu Desnoyers --- urcu-bp.c | 30 +++++++++++++++--------------- urcu-defer.c | 32 ++++++++++++++++---------------- urcu-qsbr.c | 30 +++++++++++++++--------------- urcu.c | 40 ++++++++++++++++++++-------------------- 4 files changed, 66 insertions(+), 66 deletions(-) diff --git a/urcu-bp.c b/urcu-bp.c index d841be6..eda0005 100644 --- a/urcu-bp.c +++ b/urcu-bp.c @@ -45,7 +45,7 @@ void __attribute__((destructor)) rcu_bp_exit(void); -static pthread_mutex_t rcu_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t rcu_gp_lock = PTHREAD_MUTEX_INITIALIZER; #ifdef DEBUG_YIELD unsigned int yield_active; @@ -78,18 +78,18 @@ static struct registry_arena registry_arena; static void rcu_gc_registry(void); -static void internal_rcu_lock(void) +static void mutex_lock(pthread_mutex_t *mutex) { int ret; #ifndef DISTRUST_SIGNALS_EXTREME - ret = pthread_mutex_lock(&rcu_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(&rcu_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"); @@ -105,11 +105,11 @@ static void internal_rcu_lock(void) #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */ } -static void internal_rcu_unlock(void) +static void mutex_unlock(pthread_mutex_t *mutex) { int ret; - ret = pthread_mutex_unlock(&rcu_mutex); + ret = pthread_mutex_unlock(mutex); if (ret) { perror("Error in pthread mutex unlock"); exit(-1); @@ -117,7 +117,7 @@ static void internal_rcu_unlock(void) } /* - * called with rcu_mutex held. + * called with rcu_gp_lock held. */ static void switch_next_rcu_qparity(void) { @@ -165,14 +165,14 @@ void synchronize_rcu(void) ret = pthread_sigmask(SIG_SETMASK, &newmask, &oldmask); assert(!ret); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); /* Remove old registry elements */ rcu_gc_registry(); /* All threads should read qparity before accessing data structure - * where new ptr points to. Must be done within internal_rcu_lock - * because it iterates on reader threads.*/ + * where new ptr points to. Must be done within rcu_gp_lock because it + * iterates on reader threads.*/ /* Write new ptr before changing the qparity */ smp_mb(); @@ -236,11 +236,11 @@ void synchronize_rcu(void) 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_rcu_lock because it iterates on - * reader threads. */ + * freed. Must be done within rcu_gp_lock because it iterates on reader + * threads. */ smp_mb(); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); assert(!ret); } @@ -355,9 +355,9 @@ void rcu_bp_register(void) if (rcu_reader) goto end; - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); add_thread(); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); end: ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); assert(!ret); diff --git a/urcu-defer.c b/urcu-defer.c index 50aa066..696ccae 100644 --- a/urcu-defer.c +++ b/urcu-defer.c @@ -57,7 +57,7 @@ static struct defer_queue __thread defer_queue; static LIST_HEAD(registry); static pthread_t tid_defer; -static void internal_rcu_lock(pthread_mutex_t *mutex) +static void mutex_lock(pthread_mutex_t *mutex) { int ret; @@ -80,7 +80,7 @@ static void internal_rcu_lock(pthread_mutex_t *mutex) #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */ } -static void internal_rcu_unlock(pthread_mutex_t *mutex) +static void mutex_unlock(pthread_mutex_t *mutex) { int ret; @@ -108,12 +108,12 @@ static unsigned long rcu_defer_num_callbacks(void) unsigned long num_items = 0, head; struct defer_queue *index; - internal_rcu_lock(&rcu_defer_mutex); + mutex_lock(&rcu_defer_mutex); list_for_each_entry(index, ®istry, list) { head = LOAD_SHARED(index->head); num_items += head - index->tail; } - internal_rcu_unlock(&rcu_defer_mutex); + mutex_unlock(&rcu_defer_mutex); return num_items; } @@ -184,9 +184,9 @@ static void _rcu_defer_barrier_thread(void) void rcu_defer_barrier_thread(void) { - internal_rcu_lock(&rcu_defer_mutex); + mutex_lock(&rcu_defer_mutex); _rcu_defer_barrier_thread(); - internal_rcu_unlock(&rcu_defer_mutex); + mutex_unlock(&rcu_defer_mutex); } /* @@ -210,7 +210,7 @@ void rcu_defer_barrier(void) if (list_empty(®istry)) return; - internal_rcu_lock(&rcu_defer_mutex); + mutex_lock(&rcu_defer_mutex); list_for_each_entry(index, ®istry, list) { index->last_head = LOAD_SHARED(index->head); num_items += index->last_head - index->tail; @@ -226,7 +226,7 @@ void rcu_defer_barrier(void) list_for_each_entry(index, ®istry, list) rcu_defer_barrier_queue(index, index->last_head); end: - internal_rcu_unlock(&rcu_defer_mutex); + mutex_unlock(&rcu_defer_mutex); } /* @@ -347,33 +347,33 @@ void rcu_defer_register_thread(void) assert(defer_queue.q == NULL); defer_queue.q = malloc(sizeof(void *) * DEFER_QUEUE_SIZE); - internal_rcu_lock(&defer_thread_mutex); - internal_rcu_lock(&rcu_defer_mutex); + mutex_lock(&defer_thread_mutex); + mutex_lock(&rcu_defer_mutex); was_empty = list_empty(®istry); list_add(&defer_queue.list, ®istry); - internal_rcu_unlock(&rcu_defer_mutex); + mutex_unlock(&rcu_defer_mutex); if (was_empty) start_defer_thread(); - internal_rcu_unlock(&defer_thread_mutex); + mutex_unlock(&defer_thread_mutex); } void rcu_defer_unregister_thread(void) { int is_empty; - internal_rcu_lock(&defer_thread_mutex); - internal_rcu_lock(&rcu_defer_mutex); + mutex_lock(&defer_thread_mutex); + mutex_lock(&rcu_defer_mutex); list_del(&defer_queue.list); _rcu_defer_barrier_thread(); free(defer_queue.q); defer_queue.q = NULL; is_empty = list_empty(®istry); - internal_rcu_unlock(&rcu_defer_mutex); + mutex_unlock(&rcu_defer_mutex); if (is_empty) stop_defer_thread(); - internal_rcu_unlock(&defer_thread_mutex); + mutex_unlock(&defer_thread_mutex); } void rcu_defer_exit(void) diff --git a/urcu-qsbr.c b/urcu-qsbr.c index 3d576b5..1ac553f 100644 --- a/urcu-qsbr.c +++ b/urcu-qsbr.c @@ -39,7 +39,7 @@ void __attribute__((destructor)) rcu_exit(void); -static pthread_mutex_t rcu_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t rcu_gp_lock = PTHREAD_MUTEX_INITIALIZER; int gp_futex; @@ -61,18 +61,18 @@ unsigned int __thread rand_yield; static LIST_HEAD(registry); -static void internal_rcu_lock(void) +static void mutex_lock(pthread_mutex_t *mutex) { int ret; #ifndef DISTRUST_SIGNALS_EXTREME - ret = pthread_mutex_lock(&rcu_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(&rcu_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"); @@ -83,11 +83,11 @@ static void internal_rcu_lock(void) #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */ } -static void internal_rcu_unlock(void) +static void mutex_unlock(pthread_mutex_t *mutex) { int ret; - ret = pthread_mutex_unlock(&rcu_mutex); + ret = pthread_mutex_unlock(mutex); if (ret) { perror("Error in pthread mutex unlock"); exit(-1); @@ -160,7 +160,7 @@ static void wait_for_quiescent_state(void) #if (BITS_PER_LONG < 64) /* - * called with rcu_mutex held. + * called with rcu_gp_lock held. */ static void switch_next_rcu_qparity(void) { @@ -187,7 +187,7 @@ void synchronize_rcu(void) if (was_online) STORE_SHARED(rcu_reader.ctr, 0); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); switch_next_rcu_qparity(); /* 0 -> 1 */ @@ -227,7 +227,7 @@ void synchronize_rcu(void) */ wait_for_quiescent_state(); /* Wait readers in parity 1 */ - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); /* * Finish waiting for reader threads before letting the old ptr being @@ -253,10 +253,10 @@ void synchronize_rcu(void) if (was_online) STORE_SHARED(rcu_reader.ctr, 0); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr + RCU_GP_CTR); wait_for_quiescent_state(); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); if (was_online) _STORE_SHARED(rcu_reader.ctr, LOAD_SHARED(rcu_gp_ctr)); @@ -298,9 +298,9 @@ void rcu_register_thread(void) rcu_reader.tid = pthread_self(); assert(rcu_reader.ctr == 0); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); list_add(&rcu_reader.head, ®istry); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); _rcu_thread_online(); } @@ -311,9 +311,9 @@ void rcu_unregister_thread(void) * with a waiting writer. */ _rcu_thread_offline(); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); list_del(&rcu_reader.head); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); } void rcu_exit(void) diff --git a/urcu.c b/urcu.c index 7b75d4c..6e95891 100644 --- a/urcu.c +++ b/urcu.c @@ -57,7 +57,7 @@ void __attribute__((constructor)) rcu_init(void); void __attribute__((destructor)) rcu_exit(void); #endif -static pthread_mutex_t rcu_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t rcu_gp_lock = PTHREAD_MUTEX_INITIALIZER; int gp_futex; @@ -82,18 +82,18 @@ unsigned int __thread rand_yield; static LIST_HEAD(registry); -static void internal_rcu_lock(void) +static void mutex_lock(pthread_mutex_t *mutex) { int ret; #ifndef DISTRUST_SIGNALS_EXTREME - ret = pthread_mutex_lock(&rcu_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(&rcu_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"); @@ -109,11 +109,11 @@ static void internal_rcu_lock(void) #endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */ } -static void internal_rcu_unlock(void) +static void mutex_unlock(pthread_mutex_t *mutex) { int ret; - ret = pthread_mutex_unlock(&rcu_mutex); + ret = pthread_mutex_unlock(mutex); if (ret) { perror("Error in pthread mutex unlock"); exit(-1); @@ -121,7 +121,7 @@ static void internal_rcu_unlock(void) } /* - * called with rcu_mutex held. + * called with rcu_gp_lock held. */ static void switch_next_rcu_qparity(void) { @@ -278,11 +278,11 @@ void wait_for_quiescent_state(void) void synchronize_rcu(void) { - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); /* All threads should read qparity before accessing data structure - * where new ptr points to. Must be done within internal_rcu_lock - * because it iterates on reader threads.*/ + * where new ptr points to. Must be done within rcu_gp_lock because it + * iterates on reader threads.*/ /* Write new ptr before changing the qparity */ smp_mb_heavy(); @@ -346,11 +346,11 @@ void synchronize_rcu(void) 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_rcu_lock because it iterates on - * reader threads. */ + * freed. Must be done within rcu_gp_lock because it iterates on reader + * threads. */ smp_mb_heavy(); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); } /* @@ -373,17 +373,17 @@ void rcu_register_thread(void) assert(rcu_reader.need_mb == 0); assert(rcu_reader.ctr == 0); - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); rcu_init(); /* In case gcc does not support constructor attribute */ list_add(&rcu_reader.head, ®istry); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); } void rcu_unregister_thread(void) { - internal_rcu_lock(); + mutex_lock(&rcu_gp_lock); list_del(&rcu_reader.head); - internal_rcu_unlock(); + mutex_unlock(&rcu_gp_lock); } #ifdef RCU_MEMBARRIER @@ -414,9 +414,9 @@ static void sigrcu_handler(int signo, siginfo_t *siginfo, void *context) * rcu_init constructor. Called when the library is linked, but also when * reader threads are calling rcu_register_thread(). * Should only be called by a single thread at a given time. This is ensured by - * holing the internal_rcu_lock() from rcu_register_thread() or by running at - * library load time, which should not be executed by multiple threads nor - * concurrently with rcu_register_thread() anyway. + * holing the rcu_gp_lock from rcu_register_thread() or by running at library + * load time, which should not be executed by multiple threads nor concurrently + * with rcu_register_thread() anyway. */ void rcu_init(void) { -- 2.34.1