projects
/
urcu.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
Add barriers
[urcu.git]
/
urcu.h
diff --git
a/urcu.h
b/urcu.h
index 424980650474953be7c7e081ec0fe07f5e14d034..3eca5ea3c44ccc7135635229c41141d5050df1e2 100644
(file)
--- a/
urcu.h
+++ b/
urcu.h
@@
-31,6
+31,19
@@
#define rmb() asm volatile("lfence":::"memory")
#define wmb() asm volatile("sfence" ::: "memory")
#define rmb() asm volatile("lfence":::"memory")
#define wmb() asm volatile("sfence" ::: "memory")
+/* Assume SMP machine, given we don't have this information */
+#define CONFIG_SMP 1
+
+#ifdef CONFIG_SMP
+#define smp_mb() mb()
+#define smp_rmb() rmb()
+#define smp_wmb() wmb()
+#else
+#define smp_mb() barrier()
+#define smp_rmb() barrier()
+#define smp_wmb() barrier()
+#endif
+
static inline void atomic_inc(int *v)
{
asm volatile("lock; incl %0"
static inline void atomic_inc(int *v)
{
asm volatile("lock; incl %0"
@@
-117,14
+130,30
@@
static inline unsigned long __xchg(unsigned long x, volatile void *ptr,
#define SIGURCU SIGUSR1
#define SIGURCU SIGUSR1
+/*
+ * If a reader is really non-cooperative and refuses to commit its
+ * urcu_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
+
#ifdef DEBUG_YIELD
#include <sched.h>
#include <time.h>
#include <pthread.h>
#ifdef DEBUG_YIELD
#include <sched.h>
#include <time.h>
#include <pthread.h>
+#include <unistd.h>
#define YIELD_READ (1 << 0)
#define YIELD_WRITE (1 << 1)
#define YIELD_READ (1 << 0)
#define YIELD_WRITE (1 << 1)
+/* Updates without DEBUG_FULL_MB are much slower. Account this in the delay */
+#ifdef DEBUG_FULL_MB
+/* maximum sleep delay, in us */
+#define MAX_SLEEP 50
+#else
+#define MAX_SLEEP 30000
+#endif
+
extern unsigned int yield_active;
extern unsigned int __thread rand_yield;
extern unsigned int yield_active;
extern unsigned int __thread rand_yield;
@@
-132,14
+161,14
@@
static inline void debug_yield_read(void)
{
if (yield_active & YIELD_READ)
if (rand_r(&rand_yield) & 0x1)
{
if (yield_active & YIELD_READ)
if (rand_r(&rand_yield) & 0x1)
-
sched_yield(
);
+
usleep(rand_r(&rand_yield) % MAX_SLEEP
);
}
static inline void debug_yield_write(void)
{
if (yield_active & YIELD_WRITE)
if (rand_r(&rand_yield) & 0x1)
}
static inline void debug_yield_write(void)
{
if (yield_active & YIELD_WRITE)
if (rand_r(&rand_yield) & 0x1)
-
sched_yield(
);
+
usleep(rand_r(&rand_yield) % MAX_SLEEP
);
}
static inline void debug_yield_init(void)
}
static inline void debug_yield_init(void)
@@
-161,13
+190,25
@@
static inline void debug_yield_init(void)
}
#endif
}
#endif
+#ifdef DEBUG_FULL_MB
+static inline void read_barrier()
+{
+ smp_mb();
+}
+#else
+static inline void read_barrier()
+{
+ barrier();
+}
+#endif
+
/*
* The trick here is that RCU_GP_CTR_BIT must be a multiple of 8 so we can use a
* full 8-bits, 16-bits or 32-bits bitmask for the lower order bits.
*/
/*
* The trick here is that RCU_GP_CTR_BIT must be a multiple of 8 so we can use a
* full 8-bits, 16-bits or 32-bits bitmask for the lower order bits.
*/
-#define RCU_GP_COUNT (1U << 0)
+#define RCU_GP_COUNT (1U
L
<< 0)
/* Use the amount of bits equal to half of the architecture long size */
/* Use the amount of bits equal to half of the architecture long size */
-#define RCU_GP_CTR_BIT (
sizeof(long) << 2
)
+#define RCU_GP_CTR_BIT (
1UL << (sizeof(long) << 2)
)
#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1)
/*
#define RCU_GP_CTR_NEST_MASK (RCU_GP_CTR_BIT - 1)
/*
@@
-179,50
+220,48
@@
extern long urcu_gp_ctr;
extern long __thread urcu_active_readers;
extern long __thread urcu_active_readers;
-static inline int rcu_old_gp_ongoing(
int
*value)
+static inline int rcu_old_gp_ongoing(
long
*value)
{
long v;
if (value == NULL)
return 0;
{
long v;
if (value == NULL)
return 0;
- debug_yield_write();
+ /*
+ * Make sure both tests below are done on the same version of *value
+ * to insure consistency.
+ */
v = ACCESS_ONCE(*value);
v = ACCESS_ONCE(*value);
- debug_yield_write();
return (v & RCU_GP_CTR_NEST_MASK) &&
return (v & RCU_GP_CTR_NEST_MASK) &&
- ((v ^
ACCESS_ONCE(urcu_gp_ctr)
) & RCU_GP_CTR_BIT);
+ ((v ^
urcu_gp_ctr
) & RCU_GP_CTR_BIT);
}
static inline void rcu_read_lock(void)
{
long tmp;
}
static inline void rcu_read_lock(void)
{
long tmp;
- debug_yield_read();
tmp = urcu_active_readers;
tmp = urcu_active_readers;
- debug_yield_read();
+ /* 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. */
if (likely(!(tmp & RCU_GP_CTR_NEST_MASK)))
if (likely(!(tmp & RCU_GP_CTR_NEST_MASK)))
- urcu_active_readers = urcu_gp_ctr
+ RCU_GP_COUNT
;
+ urcu_active_readers = urcu_gp_ctr;
else
urcu_active_readers = tmp + RCU_GP_COUNT;
else
urcu_active_readers = tmp + RCU_GP_COUNT;
- debug_yield_read();
/*
* Increment active readers count before accessing the pointer.
* See force_mb_all_threads().
*/
/*
* Increment active readers count before accessing the pointer.
* See force_mb_all_threads().
*/
- barrier();
- debug_yield_read();
+ read_barrier();
}
static inline void rcu_read_unlock(void)
{
}
static inline void rcu_read_unlock(void)
{
- debug_yield_read();
- barrier();
- debug_yield_read();
+ read_barrier();
/*
* Finish using rcu before decrementing the pointer.
* See force_mb_all_threads().
*/
urcu_active_readers -= RCU_GP_COUNT;
/*
* Finish using rcu before decrementing the pointer.
* See force_mb_all_threads().
*/
urcu_active_readers -= RCU_GP_COUNT;
- debug_yield_read();
}
/**
}
/**
@@
-263,7
+302,6
@@
extern void synchronize_rcu(void);
#define urcu_publish_content(p, v) \
({ \
void *oldptr; \
#define urcu_publish_content(p, v) \
({ \
void *oldptr; \
- debug_yield_write(); \
oldptr = rcu_xchg_pointer(p, v); \
synchronize_rcu(); \
oldptr; \
oldptr = rcu_xchg_pointer(p, v); \
synchronize_rcu(); \
oldptr; \
This page took
0.02552 seconds
and
4
git commands to generate.