From: Mathieu Desnoyers Date: Fri, 13 Feb 2009 12:25:33 +0000 (-0500) Subject: Turn *_REMOTE into *_SHARED X-Git-Tag: v0.1~282 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=8895e525a86e679e775b8267546799a0e7bc569f;p=urcu.git Turn *_REMOTE into *_SHARED "Paul E. McKenney" : I suspect that LOAD_SHARED() and STORE_SHARED() would be more intuitive. But shouldn't we align with the Linux-kernel usage where reasonable? (Yes, this can be a moving target, but there isn't much else that currently supports this level of SMP function on quite the variety of CPU architectures.) Signed-off-by: Mathieu Desnoyers --- diff --git a/urcu.c b/urcu.c index b04b121..8cb32a1 100644 --- a/urcu.c +++ b/urcu.c @@ -105,7 +105,7 @@ static void force_mb_single_thread(pthread_t tid) * Wait for sighandler (and thus mb()) to execute on every thread. * BUSY-LOOP. */ - while (LOAD_REMOTE(sig_done) < 1) + while (LOAD_SHARED(sig_done) < 1) cpu_relax(); smp_mb(); /* read sig_done before ending the barrier */ } @@ -134,7 +134,7 @@ static void force_mb_all_threads(void) * Wait for sighandler (and thus mb()) to execute on every thread. * BUSY-LOOP. */ - while (LOAD_REMOTE(sig_done) < num_readers) + while (LOAD_SHARED(sig_done) < num_readers) cpu_relax(); smp_mb(); /* read sig_done before ending the barrier */ } diff --git a/urcu.h b/urcu.h index d72cbf6..df27032 100644 --- a/urcu.h +++ b/urcu.h @@ -180,19 +180,19 @@ static inline unsigned long __xchg(unsigned long x, volatile void *ptr, #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) /* - * Load a data from remote memory, doing a cache flush if required. + * Load a data from shared memory, doing a cache flush if required. */ -#define LOAD_REMOTE(p) ({ \ +#define LOAD_SHARED(p) ({ \ smp_rmc(); \ typeof(p) _________p1 = ACCESS_ONCE(p); \ (_________p1); \ }) /* - * Store v into x, where x is located in remote memory. Performs the required + * Store v into x, where x is located in shared memory. Performs the required * cache flush after writing. */ -#define STORE_REMOTE(x, v) \ +#define STORE_SHARED(x, v) \ do { \ (x) = (v); \ smp_wmc; \ @@ -209,7 +209,7 @@ static inline unsigned long __xchg(unsigned long x, volatile void *ptr, */ #define rcu_dereference(p) ({ \ - typeof(p) _________p1 = LOAD_REMOTE(p); \ + typeof(p) _________p1 = LOAD_SHARED(p); \ smp_read_barrier_depends(); \ (_________p1); \ }) @@ -318,7 +318,7 @@ static inline int rcu_old_gp_ongoing(long *value) * Make sure both tests below are done on the same version of *value * to insure consistency. */ - v = LOAD_REMOTE(*value); + v = LOAD_SHARED(*value); return (v & RCU_GP_CTR_NEST_MASK) && ((v ^ urcu_gp_ctr) & RCU_GP_CTR_BIT); } @@ -331,8 +331,8 @@ static inline void rcu_read_lock(void) /* urcu_gp_ctr = RCU_GP_COUNT | (~RCU_GP_CTR_BIT or RCU_GP_CTR_BIT) */ /* * The data dependency "read urcu_gp_ctr, write urcu_active_readers", - * serializes those two memory operations. We are not using STORE_REMOTE - * and LOAD_REMOTE here (although we should) because the writer will + * serializes those two memory operations. We are not using STORE_SHARED + * and LOAD_SHARED here (although we should) because the writer will * wake us up with a signal which does a flush in its handler to perform * urcu_gp_ctr re-read and urcu_active_readers commit to main memory. */