X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=urcu.c;h=475b4d1c991a00832409ae7332e6317442b1f042;hb=6d0ce021ac1529a40ca7029133e09ad14c064df4;hp=8cb32a117bb065405ca3f45e0224dfe8fbebbf5d;hpb=8895e525a86e679e775b8267546799a0e7bc569f;p=urcu.git

diff --git a/urcu.c b/urcu.c
index 8cb32a1..475b4d1 100644
--- a/urcu.c
+++ b/urcu.c
@@ -23,15 +23,20 @@ pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
  * Global grace period counter.
  * Contains the current RCU_GP_CTR_BIT.
  * Also has a RCU_GP_CTR_BIT 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;
 
+/*
+ * Written to only by each individual reader. Read by both the reader and the
+ * writers.
+ */
 long __thread urcu_active_readers;
 
 /* Thread IDs of registered readers */
 #define INIT_NUM_THREADS 4
 
-struct reader_data {
+struct reader_registry {
 	pthread_t tid;
 	long *urcu_active_readers;
 };
@@ -41,7 +46,7 @@ unsigned int yield_active;
 unsigned int __thread rand_yield;
 #endif
 
-static struct reader_data *reader_data;
+static struct reader_registry *registry;
 static int num_readers, alloc_readers;
 #ifndef DEBUG_FULL_MB
 static int sig_done;
@@ -49,12 +54,17 @@ static int sig_done;
 
 void internal_urcu_lock(void)
 {
+#if 0
 	int ret;
+	/* Mutex sleeping does not play well with busy-waiting loop. */
 	ret = pthread_mutex_lock(&urcu_mutex);
 	if (ret) {
 		perror("Error in pthread mutex lock");
 		exit(-1);
 	}
+#endif
+	while (pthread_mutex_trylock(&urcu_mutex) != 0)
+		cpu_relax();
 }
 
 void internal_urcu_unlock(void)
@@ -73,7 +83,7 @@ void internal_urcu_unlock(void)
  */
 static void switch_next_urcu_qparity(void)
 {
-	urcu_gp_ctr ^= RCU_GP_CTR_BIT;
+	STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_CTR_BIT);
 }
 
 #ifdef DEBUG_FULL_MB
@@ -90,7 +100,7 @@ static void force_mb_all_threads(void)
 
 static void force_mb_single_thread(pthread_t tid)
 {
-	assert(reader_data);
+	assert(registry);
 	sig_done = 0;
 	/*
 	 * pthread_kill has a smp_mb(). But beware, we assume it performs
@@ -112,12 +122,12 @@ static void force_mb_single_thread(pthread_t tid)
 
 static void force_mb_all_threads(void)
 {
-	struct reader_data *index;
+	struct reader_registry *index;
 	/*
 	 * Ask for each threads to execute a smp_mb() so we can consider the
 	 * compiler barriers around rcu read lock as real memory barriers.
 	 */
-	if (!reader_data)
+	if (!registry)
 		return;
 	sig_done = 0;
 	/*
@@ -128,7 +138,7 @@ static void force_mb_all_threads(void)
 	 * smp_mb();    write sig_done before sending the signals
 	 */
 	smp_mc();	/* write sig_done before sending the signals */
-	for (index = reader_data; index < reader_data + num_readers; index++)
+	for (index = registry; index < registry + num_readers; index++)
 		pthread_kill(index->tid, SIGURCU);
 	/*
 	 * Wait for sighandler (and thus mb()) to execute on every thread.
@@ -142,14 +152,14 @@ static void force_mb_all_threads(void)
 
 void wait_for_quiescent_state(void)
 {
-	struct reader_data *index;
+	struct reader_registry *index;
 
-	if (!reader_data)
+	if (!registry)
 		return;
 	/*
 	 * Wait for each thread urcu_active_readers count to become 0.
 	 */
-	for (index = reader_data; index < reader_data + num_readers; index++) {
+	for (index = registry; index < registry + num_readers; index++) {
 		int wait_loops = 0;
 		/*
 		 * BUSY-LOOP. Force the reader thread to commit its
@@ -183,8 +193,8 @@ void synchronize_rcu(void)
 	 * 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.
 	 */
-	smp_mc();
 
 	/*
 	 * Wait for previous parity to be empty of readers.
@@ -196,8 +206,8 @@ void synchronize_rcu(void)
 	 * 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.
 	 */
-	smp_mc();
 
 	switch_next_urcu_qparity();	/* 1 -> 0 */
 
@@ -206,8 +216,8 @@ void synchronize_rcu(void)
 	 * 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.
 	 */
-	smp_mc();
 
 	/*
 	 * Wait for previous parity to be empty of readers.
@@ -224,26 +234,26 @@ void synchronize_rcu(void)
 
 void urcu_add_reader(pthread_t id)
 {
-	struct reader_data *oldarray;
+	struct reader_registry *oldarray;
 
-	if (!reader_data) {
+	if (!registry) {
 		alloc_readers = INIT_NUM_THREADS;
 		num_readers = 0;
-		reader_data =
-			malloc(sizeof(struct reader_data) * alloc_readers);
+		registry =
+			malloc(sizeof(struct reader_registry) * alloc_readers);
 	}
 	if (alloc_readers < num_readers + 1) {
-		oldarray = reader_data;
-		reader_data = malloc(sizeof(struct reader_data)
+		oldarray = registry;
+		registry = malloc(sizeof(struct reader_registry)
 				* (alloc_readers << 1));
-		memcpy(reader_data, oldarray,
-			sizeof(struct reader_data) * alloc_readers);
+		memcpy(registry, oldarray,
+			sizeof(struct reader_registry) * alloc_readers);
 		alloc_readers <<= 1;
 		free(oldarray);
 	}
-	reader_data[num_readers].tid = id;
+	registry[num_readers].tid = id;
 	/* reference to the TLS of _this_ reader thread. */
-	reader_data[num_readers].urcu_active_readers = &urcu_active_readers;
+	registry[num_readers].urcu_active_readers = &urcu_active_readers;
 	num_readers++;
 }
 
@@ -253,15 +263,15 @@ void urcu_add_reader(pthread_t id)
  */
 void urcu_remove_reader(pthread_t id)
 {
-	struct reader_data *index;
+	struct reader_registry *index;
 
-	assert(reader_data != NULL);
-	for (index = reader_data; index < reader_data + num_readers; index++) {
+	assert(registry != NULL);
+	for (index = registry; index < registry + num_readers; index++) {
 		if (pthread_equal(index->tid, id)) {
-			memcpy(index, &reader_data[num_readers - 1],
-				sizeof(struct reader_data));
-			reader_data[num_readers - 1].tid = 0;
-			reader_data[num_readers - 1].urcu_active_readers = NULL;
+			memcpy(index, &registry[num_readers - 1],
+				sizeof(struct reader_registry));
+			registry[num_readers - 1].tid = 0;
+			registry[num_readers - 1].urcu_active_readers = NULL;
 			num_readers--;
 			return;
 		}
@@ -320,6 +330,6 @@ void __attribute__((destructor)) urcu_exit(void)
 		exit(-1);
 	}
 	assert(act.sa_sigaction == sigurcu_handler);
-	free(reader_data);
+	free(registry);
 }
 #endif