[urcu.git] / urcu-defer.c

/*
 * urcu-defer.c
 *
 * Userspace RCU library - batch memory reclamation
 *
 * Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <pthread.h>
#include <signal.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <poll.h>
#include <linux/futex.h>
#include <sys/time.h>
#include <syscall.h>
#include <unistd.h>

#include "urcu-defer-static.h"
/* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */
#include "urcu-defer.h"

#define futex(...)	syscall(__NR_futex, __VA_ARGS__)

void __attribute__((destructor)) urcu_defer_exit(void);

extern void synchronize_rcu(void);

/*
 * urcu_defer_mutex nests inside defer_thread_mutex.
 */
static pthread_mutex_t urcu_defer_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t defer_thread_mutex = PTHREAD_MUTEX_INITIALIZER;

static int defer_thread_futex;

/*
 * Written to only by each individual deferer. Read by both the deferer and
 * the reclamation tread.
 */
static struct defer_queue __thread defer_queue;

/* Thread IDs of registered deferers */
#define INIT_NUM_THREADS 4

struct deferer_registry {
	pthread_t tid;
	struct defer_queue *defer_queue;
	unsigned long last_head;
};

static struct deferer_registry *registry;
static int num_deferers, alloc_deferers;

static pthread_t tid_defer;

static void internal_urcu_lock(pthread_mutex_t *mutex)
{
	int ret;

#ifndef DISTRUST_SIGNALS_EXTREME
	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(mutex)) != 0) {
		if (ret != EBUSY && ret != EINTR) {
			printf("ret = %d, errno = %d\n", ret, errno);
			perror("Error in pthread mutex lock");
			exit(-1);
		}
		pthread_testcancel();
		poll(NULL,0,10);
	}
#endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
}

static void internal_urcu_unlock(pthread_mutex_t *mutex)
{
	int ret;

	ret = pthread_mutex_unlock(mutex);
	if (ret) {
		perror("Error in pthread mutex unlock");
		exit(-1);
	}
}

/*
 * Wake-up any waiting defer thread. Called from many concurrent threads.
 */
static void wake_up_defer(void)
{
	if (unlikely(atomic_read(&defer_thread_futex) == -1)) {
		atomic_set(&defer_thread_futex, 0);
		futex(&defer_thread_futex, FUTEX_WAKE, 0,
		      NULL, NULL, 0);
	}
}

static unsigned long rcu_defer_num_callbacks(void)
{
	unsigned long num_items = 0, head;
	struct deferer_registry *index;

	internal_urcu_lock(&urcu_defer_mutex);
	for (index = registry; index < registry + num_deferers; index++) {
		head = LOAD_SHARED(index->defer_queue->head);
		num_items += head - index->defer_queue->tail;
	}
	internal_urcu_unlock(&urcu_defer_mutex);
	return num_items;
}

/*
 * Defer thread waiting. Single thread.
 */
static void wait_defer(void)
{
	atomic_dec(&defer_thread_futex);
	smp_mb();	/* Write futex before read queue */
	if (rcu_defer_num_callbacks()) {
		smp_mb();	/* Read queue before write futex */
		/* Callbacks are queued, don't wait. */
		atomic_set(&defer_thread_futex, 0);
	} else {
		smp_rmb();	/* Read queue before read futex */
		if (atomic_read(&defer_thread_futex) == -1)
			futex(&defer_thread_futex, FUTEX_WAIT, -1,
			      NULL, NULL, 0);
	}
}

/*
 * Must be called after Q.S. is reached.
 */
static void rcu_defer_barrier_queue(struct defer_queue *queue,
				    unsigned long head)
{
	unsigned long i;
	void (*fct)(void *p);
	void *p;

	/*
	 * Tail is only modified when lock is held.
	 * Head is only modified by owner thread.
	 */

	for (i = queue->tail; i != head;) {
		smp_rmb();       /* read head before q[]. */
		p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
		if (unlikely(DQ_IS_FCT_BIT(p))) {
			DQ_CLEAR_FCT_BIT(p);
			queue->last_fct_out = p;
			p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
		} else if (unlikely(p == DQ_FCT_MARK)) {
			p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
			queue->last_fct_out = p;
			p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
		}
		fct = queue->last_fct_out;
		fct(p);
	}
	smp_mb();	/* push tail after having used q[] */
	STORE_SHARED(queue->tail, i);
}

static void _rcu_defer_barrier_thread(void)
{
	unsigned long head, num_items;

	head = defer_queue.head;
	num_items = head - defer_queue.tail;
	if (unlikely(!num_items))
		return;
	synchronize_rcu();
	rcu_defer_barrier_queue(&defer_queue, head);
}


void rcu_defer_barrier_thread(void)
{
	internal_urcu_lock(&urcu_defer_mutex);
	_rcu_defer_barrier_thread();
	internal_urcu_unlock(&urcu_defer_mutex);
}

/*
 * rcu_defer_barrier - Execute all queued rcu callbacks.
 *
 * Execute all RCU callbacks queued before rcu_defer_barrier() execution.
 * All callbacks queued on the local thread prior to a rcu_defer_barrier() call
 * are guaranteed to be executed.
 * Callbacks queued by other threads concurrently with rcu_defer_barrier()
 * execution are not guaranteed to be executed in the current batch (could
 * be left for the next batch). These callbacks queued by other threads are only
 * guaranteed to be executed if there is explicit synchronization between
 * the thread adding to the queue and the thread issuing the defer_barrier call.
 */

void rcu_defer_barrier(void)
{
	struct deferer_registry *index;
	unsigned long num_items = 0;

	if (!registry)
		return;

	internal_urcu_lock(&urcu_defer_mutex);
	for (index = registry; index < registry + num_deferers; index++) {
		index->last_head = LOAD_SHARED(index->defer_queue->head);
		num_items += index->last_head - index->defer_queue->tail;
	}
	if (likely(!num_items)) {
		/*
		 * We skip the grace period because there are no queued
		 * callbacks to execute.
		 */
		goto end;
	}
	synchronize_rcu();
	for (index = registry; index < registry + num_deferers; index++)
		rcu_defer_barrier_queue(index->defer_queue,
					  index->last_head);
end:
	internal_urcu_unlock(&urcu_defer_mutex);
}

/*
 * _rcu_defer_queue - Queue a RCU callback.
 */
void _rcu_defer_queue(void (*fct)(void *p), void *p)
{
	unsigned long head, tail;

	/*
	 * Head is only modified by ourself. Tail can be modified by reclamation
	 * thread.
	 */
	head = defer_queue.head;
	tail = LOAD_SHARED(defer_queue.tail);

	/*
	 * If queue is full, empty it ourself.
	 * Worse-case: must allow 2 supplementary entries for fct pointer.
	 */
	if (unlikely(head - tail >= DEFER_QUEUE_SIZE - 2)) {
		assert(head - tail <= DEFER_QUEUE_SIZE);
		rcu_defer_barrier_thread();
		assert(head - LOAD_SHARED(defer_queue.tail) == 0);
	}

	if (unlikely(defer_queue.last_fct_in != fct)) {
		defer_queue.last_fct_in = fct;
		if (unlikely(DQ_IS_FCT_BIT(fct) || fct == DQ_FCT_MARK)) {
			/*
			 * If the function to encode is not aligned or the
			 * marker, write DQ_FCT_MARK followed by the function
			 * pointer.
			 */
			_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
				      DQ_FCT_MARK);
			_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
				      fct);
		} else {
			DQ_SET_FCT_BIT(fct);
			_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
				      fct);
		}
	} else {
		if (unlikely(DQ_IS_FCT_BIT(p) || p == DQ_FCT_MARK)) {
			/*
			 * If the data to encode is not aligned or the marker,
			 * write DQ_FCT_MARK followed by the function pointer.
			 */
			_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
				      DQ_FCT_MARK);
			_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
				      fct);
		}
	}
	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK], p);
	smp_wmb();	/* Publish new pointer before head */
			/* Write q[] before head. */
	STORE_SHARED(defer_queue.head, head);
	smp_mb();	/* Write queue head before read futex */
	/*
	 * Wake-up any waiting defer thread.
	 */
	wake_up_defer();
}

void *thr_defer(void *args)
{
	for (;;) {
		pthread_testcancel();
		/*
		 * "Be green". Don't wake up the CPU if there is no RCU work
		 * to perform whatsoever. Aims at saving laptop battery life by
		 * leaving the processor in sleep state when idle.
		 */
		wait_defer();
		/* Sleeping after wait_defer to let many callbacks enqueue */
		poll(NULL,0,100);	/* wait for 100ms */
		rcu_defer_barrier();
	}

	return NULL;
}

/*
 * library wrappers to be used by non-LGPL compatible source code.
 */

void rcu_defer_queue(void (*fct)(void *p), void *p)
{
	_rcu_defer_queue(fct, p);
}

static void rcu_add_deferer(pthread_t id)
{
	struct deferer_registry *oldarray;

	if (!registry) {
		alloc_deferers = INIT_NUM_THREADS;
		num_deferers = 0;
		registry =
			malloc(sizeof(struct deferer_registry) * alloc_deferers);
	}
	if (alloc_deferers < num_deferers + 1) {
		oldarray = registry;
		registry = malloc(sizeof(struct deferer_registry)
				* (alloc_deferers << 1));
		memcpy(registry, oldarray,
			sizeof(struct deferer_registry) * alloc_deferers);
		alloc_deferers <<= 1;
		free(oldarray);
	}
	registry[num_deferers].tid = id;
	/* reference to the TLS of _this_ deferer thread. */
	registry[num_deferers].defer_queue = &defer_queue;
	registry[num_deferers].last_head = 0;
	num_deferers++;
}

/*
 * Never shrink (implementation limitation).
 * This is O(nb threads). Eventually use a hash table.
 */
static void rcu_remove_deferer(pthread_t id)
{
	struct deferer_registry *index;

	assert(registry != NULL);
	for (index = registry; index < registry + num_deferers; index++) {
		if (pthread_equal(index->tid, id)) {
			memcpy(index, &registry[num_deferers - 1],
				sizeof(struct deferer_registry));
			registry[num_deferers - 1].tid = 0;
			registry[num_deferers - 1].defer_queue = NULL;
			registry[num_deferers - 1].last_head = 0;
			num_deferers--;
			return;
		}
	}
	/* Hrm not found, forgot to register ? */
	assert(0);
}

static void start_defer_thread(void)
{
	int ret;

	ret = pthread_create(&tid_defer, NULL, thr_defer,
		NULL);
	assert(!ret);
}

static void stop_defer_thread(void)
{
	int ret;
	void *tret;

	pthread_cancel(tid_defer);
	wake_up_defer();
	ret = pthread_join(tid_defer, &tret);
	assert(!ret);
}

void rcu_defer_register_thread(void)
{
	int deferers;

	internal_urcu_lock(&defer_thread_mutex);
	internal_urcu_lock(&urcu_defer_mutex);
	defer_queue.q = malloc(sizeof(void *) * DEFER_QUEUE_SIZE);
	rcu_add_deferer(pthread_self());
	deferers = num_deferers;
	internal_urcu_unlock(&urcu_defer_mutex);

	if (deferers == 1)
		start_defer_thread();
	internal_urcu_unlock(&defer_thread_mutex);
}

void rcu_defer_unregister_thread(void)
{
	int deferers;

	internal_urcu_lock(&defer_thread_mutex);
	internal_urcu_lock(&urcu_defer_mutex);
	rcu_remove_deferer(pthread_self());
	_rcu_defer_barrier_thread();
	free(defer_queue.q);
	defer_queue.q = NULL;
	deferers = num_deferers;
	internal_urcu_unlock(&urcu_defer_mutex);

	if (deferers == 0)
		stop_defer_thread();
	internal_urcu_unlock(&defer_thread_mutex);
}

void urcu_defer_exit(void)
{
	free(registry);
}
Commit	Line	Data
786ee85b MD	1	/*
	2	* urcu-defer.c
	3	*
	4	* Userspace RCU library - batch memory reclamation
	5	*
	6	* Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <stdio.h>
	24	#include <pthread.h>
	25	#include <signal.h>
	26	#include <assert.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <errno.h>
	30	#include <poll.h>
4ce9e4f2 MD	31	#include <linux/futex.h>
	32	#include <sys/time.h>
	33	#include <syscall.h>
	34	#include <unistd.h>
786ee85b MD	35
	36	#include "urcu-defer-static.h"
	37	/* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */
	38	#include "urcu-defer.h"
	39
4ce9e4f2 MD	40	#define futex(...) syscall(__NR_futex, __VA_ARGS__)
4ce9e4f2 MD	41
786ee85b MD	42	void __attribute__((destructor)) urcu_defer_exit(void);
	43
	44	extern void synchronize_rcu(void);
	45
	46	/*
	47	* urcu_defer_mutex nests inside defer_thread_mutex.
	48	*/
	49	static pthread_mutex_t urcu_defer_mutex = PTHREAD_MUTEX_INITIALIZER;
	50	static pthread_mutex_t defer_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
	51
3dce4bfa	52	static int defer_thread_futex;
4ce9e4f2	53
786ee85b MD	54	/*
	55	* Written to only by each individual deferer. Read by both the deferer and
	56	* the reclamation tread.
	57	*/
3dce4bfa	58	static struct defer_queue __thread defer_queue;
786ee85b MD	59
	60	/* Thread IDs of registered deferers */
	61	#define INIT_NUM_THREADS 4
	62
	63	struct deferer_registry {
	64	pthread_t tid;
	65	struct defer_queue *defer_queue;
	66	unsigned long last_head;
	67	};
	68
	69	static struct deferer_registry *registry;
	70	static int num_deferers, alloc_deferers;
	71
	72	static pthread_t tid_defer;
4ce9e4f2	73
786ee85b MD	74	static void internal_urcu_lock(pthread_mutex_t *mutex)
	75	{
	76	int ret;
	77
	78	#ifndef DISTRUST_SIGNALS_EXTREME
	79	ret = pthread_mutex_lock(mutex);
	80	if (ret) {
	81	perror("Error in pthread mutex lock");
	82	exit(-1);
	83	}
	84	#else /* #ifndef DISTRUST_SIGNALS_EXTREME */
	85	while ((ret = pthread_mutex_trylock(mutex)) != 0) {
	86	if (ret != EBUSY && ret != EINTR) {
	87	printf("ret = %d, errno = %d\n", ret, errno);
	88	perror("Error in pthread mutex lock");
	89	exit(-1);
	90	}
4ce9e4f2	91	pthread_testcancel();
786ee85b MD	92	poll(NULL,0,10);
	93	}
	94	#endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
	95	}
	96
	97	static void internal_urcu_unlock(pthread_mutex_t *mutex)
	98	{
	99	int ret;
	100
	101	ret = pthread_mutex_unlock(mutex);
	102	if (ret) {
	103	perror("Error in pthread mutex unlock");
	104	exit(-1);
	105	}
	106	}
	107
04eb9c4f MD	108	/*
	109	* Wake-up any waiting defer thread. Called from many concurrent threads.
	110	*/
	111	static void wake_up_defer(void)
	112	{
	113	if (unlikely(atomic_read(&defer_thread_futex) == -1)) {
	114	atomic_set(&defer_thread_futex, 0);
	115	futex(&defer_thread_futex, FUTEX_WAKE, 0,
	116	NULL, NULL, 0);
	117	}
	118	}
	119
	120	static unsigned long rcu_defer_num_callbacks(void)
	121	{
	122	unsigned long num_items = 0, head;
	123	struct deferer_registry *index;
	124
	125	internal_urcu_lock(&urcu_defer_mutex);
	126	for (index = registry; index < registry + num_deferers; index++) {
	127	head = LOAD_SHARED(index->defer_queue->head);
	128	num_items += head - index->defer_queue->tail;
	129	}
	130	internal_urcu_unlock(&urcu_defer_mutex);
	131	return num_items;
	132	}
	133
	134	/*
	135	* Defer thread waiting. Single thread.
	136	*/
	137	static void wait_defer(void)
	138	{
	139	atomic_dec(&defer_thread_futex);
	140	smp_mb(); /* Write futex before read queue */
	141	if (rcu_defer_num_callbacks()) {
	142	smp_mb(); /* Read queue before write futex */
	143	/* Callbacks are queued, don't wait. */
	144	atomic_set(&defer_thread_futex, 0);
	145	} else {
	146	smp_rmb(); /* Read queue before read futex */
	147	if (atomic_read(&defer_thread_futex) == -1)
	148	futex(&defer_thread_futex, FUTEX_WAIT, -1,
	149	NULL, NULL, 0);
	150	}
	151	}
	152
786ee85b MD	153	/*
	154	* Must be called after Q.S. is reached.
	155	*/
	156	static void rcu_defer_barrier_queue(struct defer_queue *queue,
804b4375	157	unsigned long head)
786ee85b MD	158	{
786ee85b MD	159	unsigned long i;
804b4375 MD	160	void (fct)(void p);
804b4375 MD	161	void *p;
786ee85b MD	162
	163	/*
	164	* Tail is only modified when lock is held.
	165	* Head is only modified by owner thread.
	166	*/
	167
804b4375	168	for (i = queue->tail; i != head;) {
786ee85b	169	smp_rmb(); /* read head before q[]. */
804b4375 MD	170	p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
804b4375 MD	171	if (unlikely(DQ_IS_FCT_BIT(p))) {
804b4375 MD	172	DQ_CLEAR_FCT_BIT(p);
	173	queue->last_fct_out = p;
	174	p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
	175	} else if (unlikely(p == DQ_FCT_MARK)) {
804b4375 MD	176	p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
	177	queue->last_fct_out = p;
	178	p = LOAD_SHARED(queue->q[i++ & DEFER_QUEUE_MASK]);
29cdb8d8	179	}
804b4375	180	fct = queue->last_fct_out;
804b4375	181	fct(p);
786ee85b MD	182	}
	183	smp_mb(); /* push tail after having used q[] */
	184	STORE_SHARED(queue->tail, i);
	185	}
	186
	187	static void _rcu_defer_barrier_thread(void)
	188	{
0d0e6c21	189	unsigned long head, num_items;
786ee85b MD	190
786ee85b MD	191	head = defer_queue.head;
0d0e6c21 MD	192	num_items = head - defer_queue.tail;
	193	if (unlikely(!num_items))
	194	return;
786ee85b MD	195	synchronize_rcu();
	196	rcu_defer_barrier_queue(&defer_queue, head);
	197	}
	198
	199
	200	void rcu_defer_barrier_thread(void)
	201	{
	202	internal_urcu_lock(&urcu_defer_mutex);
	203	_rcu_defer_barrier_thread();
	204	internal_urcu_unlock(&urcu_defer_mutex);
	205	}
	206
0d0e6c21 MD	207	/*
	208	* rcu_defer_barrier - Execute all queued rcu callbacks.
	209	*
	210	* Execute all RCU callbacks queued before rcu_defer_barrier() execution.
	211	* All callbacks queued on the local thread prior to a rcu_defer_barrier() call
	212	* are guaranteed to be executed.
	213	* Callbacks queued by other threads concurrently with rcu_defer_barrier()
	214	* execution are not guaranteed to be executed in the current batch (could
	215	* be left for the next batch). These callbacks queued by other threads are only
	216	* guaranteed to be executed if there is explicit synchronization between
	217	* the thread adding to the queue and the thread issuing the defer_barrier call.
	218	*/
	219
786ee85b MD	220	void rcu_defer_barrier(void)
	221	{
	222	struct deferer_registry *index;
0d0e6c21	223	unsigned long num_items = 0;
786ee85b MD	224
	225	if (!registry)
	226	return;
	227
	228	internal_urcu_lock(&urcu_defer_mutex);
0d0e6c21	229	for (index = registry; index < registry + num_deferers; index++) {
786ee85b	230	index->last_head = LOAD_SHARED(index->defer_queue->head);
0d0e6c21 MD	231	num_items += index->last_head - index->defer_queue->tail;
	232	}
	233	if (likely(!num_items)) {
	234	/*
	235	* We skip the grace period because there are no queued
	236	* callbacks to execute.
	237	*/
	238	goto end;
	239	}
786ee85b MD	240	synchronize_rcu();
	241	for (index = registry; index < registry + num_deferers; index++)
	242	rcu_defer_barrier_queue(index->defer_queue,
	243	index->last_head);
0d0e6c21	244	end:
786ee85b MD	245	internal_urcu_unlock(&urcu_defer_mutex);
	246	}
	247
2c22932b MD	248	/*
	249	* _rcu_defer_queue - Queue a RCU callback.
	250	*/
	251	void _rcu_defer_queue(void (fct)(void p), void *p)
	252	{
	253	unsigned long head, tail;
	254
	255	/*
	256	* Head is only modified by ourself. Tail can be modified by reclamation
	257	* thread.
	258	*/
	259	head = defer_queue.head;
	260	tail = LOAD_SHARED(defer_queue.tail);
	261
	262	/*
	263	* If queue is full, empty it ourself.
	264	* Worse-case: must allow 2 supplementary entries for fct pointer.
	265	*/
	266	if (unlikely(head - tail >= DEFER_QUEUE_SIZE - 2)) {
	267	assert(head - tail <= DEFER_QUEUE_SIZE);
	268	rcu_defer_barrier_thread();
	269	assert(head - LOAD_SHARED(defer_queue.tail) == 0);
	270	}
	271
	272	if (unlikely(defer_queue.last_fct_in != fct)) {
	273	defer_queue.last_fct_in = fct;
	274	if (unlikely(DQ_IS_FCT_BIT(fct) \|\| fct == DQ_FCT_MARK)) {
	275	/*
	276	* If the function to encode is not aligned or the
	277	* marker, write DQ_FCT_MARK followed by the function
	278	* pointer.
	279	*/
	280	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
	281	DQ_FCT_MARK);
	282	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
	283	fct);
	284	} else {
	285	DQ_SET_FCT_BIT(fct);
	286	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
	287	fct);
	288	}
	289	} else {
	290	if (unlikely(DQ_IS_FCT_BIT(p) \|\| p == DQ_FCT_MARK)) {
	291	/*
	292	* If the data to encode is not aligned or the marker,
	293	* write DQ_FCT_MARK followed by the function pointer.
	294	*/
	295	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
	296	DQ_FCT_MARK);
	297	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK],
	298	fct);
	299	}
	300	}
	301	_STORE_SHARED(defer_queue.q[head++ & DEFER_QUEUE_MASK], p);
	302	smp_wmb(); /* Publish new pointer before head */
	303	/* Write q[] before head. */
	304	STORE_SHARED(defer_queue.head, head);
04eb9c4f	305	smp_mb(); /* Write queue head before read futex */
2c22932b MD	306	/*
	307	* Wake-up any waiting defer thread.
	308	*/
	309	wake_up_defer();
	310	}
	311
786ee85b MD	312	void thr_defer(void args)
	313	{
	314	for (;;) {
4ce9e4f2	315	pthread_testcancel();
4ce9e4f2 MD	316	/*
	317	* "Be green". Don't wake up the CPU if there is no RCU work
	318	* to perform whatsoever. Aims at saving laptop battery life by
	319	* leaving the processor in sleep state when idle.
	320	*/
4ce9e4f2	321	wait_defer();
4ce9e4f2	322	/* Sleeping after wait_defer to let many callbacks enqueue */
71df5ef4	323	poll(NULL,0,100); /* wait for 100ms */
786ee85b MD	324	rcu_defer_barrier();
	325	}
	326
	327	return NULL;
	328	}
	329
	330	/*
	331	* library wrappers to be used by non-LGPL compatible source code.
	332	*/
	333
804b4375	334	void rcu_defer_queue(void (fct)(void p), void *p)
786ee85b	335	{
804b4375	336	_rcu_defer_queue(fct, p);
786ee85b MD	337	}
	338
	339	static void rcu_add_deferer(pthread_t id)
	340	{
	341	struct deferer_registry *oldarray;
	342
	343	if (!registry) {
	344	alloc_deferers = INIT_NUM_THREADS;
	345	num_deferers = 0;
	346	registry =
	347	malloc(sizeof(struct deferer_registry) * alloc_deferers);
	348	}
	349	if (alloc_deferers < num_deferers + 1) {
	350	oldarray = registry;
	351	registry = malloc(sizeof(struct deferer_registry)
	352	* (alloc_deferers << 1));
	353	memcpy(registry, oldarray,
	354	sizeof(struct deferer_registry) * alloc_deferers);
	355	alloc_deferers <<= 1;
	356	free(oldarray);
	357	}
	358	registry[num_deferers].tid = id;
	359	/* reference to the TLS of _this_ deferer thread. */
	360	registry[num_deferers].defer_queue = &defer_queue;
804b4375	361	registry[num_deferers].last_head = 0;
786ee85b MD	362	num_deferers++;
	363	}
	364
	365	/*
	366	* Never shrink (implementation limitation).
	367	* This is O(nb threads). Eventually use a hash table.
	368	*/
	369	static void rcu_remove_deferer(pthread_t id)
	370	{
	371	struct deferer_registry *index;
	372
	373	assert(registry != NULL);
	374	for (index = registry; index < registry + num_deferers; index++) {
	375	if (pthread_equal(index->tid, id)) {
	376	memcpy(index, &registry[num_deferers - 1],
	377	sizeof(struct deferer_registry));
	378	registry[num_deferers - 1].tid = 0;
	379	registry[num_deferers - 1].defer_queue = NULL;
804b4375	380	registry[num_deferers - 1].last_head = 0;
786ee85b MD	381	num_deferers--;
	382	return;
	383	}
	384	}
	385	/* Hrm not found, forgot to register ? */
	386	assert(0);
	387	}
	388
	389	static void start_defer_thread(void)
	390	{
	391	int ret;
	392
	393	ret = pthread_create(&tid_defer, NULL, thr_defer,
	394	NULL);
	395	assert(!ret);
	396	}
	397
	398	static void stop_defer_thread(void)
	399	{
	400	int ret;
	401	void *tret;
	402
4ce9e4f2 MD	403	pthread_cancel(tid_defer);
4ce9e4f2 MD	404	wake_up_defer();
786ee85b MD	405	ret = pthread_join(tid_defer, &tret);
	406	assert(!ret);
	407	}
	408
	409	void rcu_defer_register_thread(void)
	410	{
	411	int deferers;
	412
	413	internal_urcu_lock(&defer_thread_mutex);
	414	internal_urcu_lock(&urcu_defer_mutex);
	415	defer_queue.q = malloc(sizeof(void ) DEFER_QUEUE_SIZE);
	416	rcu_add_deferer(pthread_self());
	417	deferers = num_deferers;
	418	internal_urcu_unlock(&urcu_defer_mutex);
	419
	420	if (deferers == 1)
	421	start_defer_thread();
	422	internal_urcu_unlock(&defer_thread_mutex);
	423	}
	424
	425	void rcu_defer_unregister_thread(void)
	426	{
	427	int deferers;
	428
	429	internal_urcu_lock(&defer_thread_mutex);
	430	internal_urcu_lock(&urcu_defer_mutex);
	431	rcu_remove_deferer(pthread_self());
	432	_rcu_defer_barrier_thread();
	433	free(defer_queue.q);
	434	defer_queue.q = NULL;
	435	deferers = num_deferers;
	436	internal_urcu_unlock(&urcu_defer_mutex);
	437
	438	if (deferers == 0)
	439	stop_defer_thread();
	440	internal_urcu_unlock(&defer_thread_mutex);
	441	}
	442
	443	void urcu_defer_exit(void)
	444	{
	445	free(registry);
	446	}