[lttv.git] / trunk / tests / kernel / test-wbias-rwlock.c

/* test-wbias-rwlock.c
 *
 */

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/timex.h>
#include <linux/wbias-rwlock.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/hardirq.h>
#include <linux/module.h>
#include <linux/percpu.h>
#include <linux/spinlock.h>
#include <asm/ptrace.h>

#if (NR_CPUS > 64 && (BITS_PER_LONG == 32 || NR_CPUS > 32768))
#error "writer-biased rwlock needs more bits per long to deal with so many CPUs"
#endif

/* Test with no contention duration, in seconds */
#define SINGLE_WRITER_TEST_DURATION 10
#define SINGLE_READER_TEST_DURATION 10
#define MULTIPLE_READERS_TEST_DURATION 10

/* Test duration, in seconds */
#define TEST_DURATION 60

#define NR_VARS 100
//#define NR_WRITERS 2
#define NR_WRITERS 2
//#define NR_TRYLOCK_WRITERS 2
#define NR_TRYLOCK_WRITERS 0
#define NR_READERS 4
//#define NR_TRYLOCK_READERS 2
#define NR_TRYLOCK_READERS 0

/*
 * 1 : test standard rwlock
 * 0 : test wbiasrwlock
 */
#define TEST_STD_RWLOCK 0

/*
 * 1 : test with thread and interrupt readers.
 * 0 : test only with thread readers.
 */
#define TEST_INTERRUPTS 1

#if (TEST_INTERRUPTS)
#define NR_INTERRUPT_READERS 1
#define NR_TRYLOCK_INTERRUPT_READERS 1
#else
#define NR_INTERRUPT_READERS 0
#define NR_TRYLOCK_INTERRUPT_READERS 0
#endif

/*
 * Writer iteration delay, in us. 0 for busy loop. Caution : writers can
 * starve readers.
 */
#define WRITER_DELAY 100
#define TRYLOCK_WRITER_DELAY 1000

/*
 * Number of iterations after which a trylock writer fails.
 * -1 for infinite loop.
 */
#define TRYLOCK_WRITERS_FAIL_ITER 100

/* Thread and interrupt reader delay, in ms */
#define THREAD_READER_DELAY 0	/* busy loop */
#define INTERRUPT_READER_DELAY 100

static int var[NR_VARS];
static struct task_struct *reader_threads[NR_READERS];
static struct task_struct *trylock_reader_threads[NR_TRYLOCK_READERS];
static struct task_struct *writer_threads[NR_WRITERS];
static struct task_struct *trylock_writer_threads[NR_TRYLOCK_WRITERS];
static struct task_struct *interrupt_reader[NR_INTERRUPT_READERS];
static struct task_struct *trylock_interrupt_reader[NR_TRYLOCK_INTERRUPT_READERS];

#if (TEST_STD_RWLOCK)

static DEFINE_RWLOCK(std_rw_lock);

#define wrap_read_lock()	read_lock(&std_rw_lock)
#define wrap_read_trylock()	read_trylock(&std_rw_lock)
#define wrap_read_unlock()	read_unlock(&std_rw_lock)

#define wrap_read_lock_irq()	read_lock(&std_rw_lock)
#define wrap_read_trylock_irq()	read_trylock(&std_rw_lock)
#define wrap_read_unlock_irq()	read_unlock(&std_rw_lock)

#if (TEST_INTERRUPTS)
#define wrap_write_lock()	write_lock_irq(&std_rw_lock)
#define wrap_write_unlock()	write_unlock_irq(&std_rw_lock)
#else
#define wrap_write_lock()	write_lock(&std_rw_lock)
#define wrap_write_unlock()	write_unlock(&std_rw_lock)
#endif

#else

static DEFINE_WBIAS_RWLOCK(wbiasrwlock);

#define wrap_read_lock()	wbias_read_lock(&wbiasrwlock)
#define wrap_read_trylock()	wbias_read_trylock(&wbiasrwlock)
#define wrap_read_unlock()	wbias_read_unlock(&wbiasrwlock)

#define wrap_read_lock_irq()	wbias_read_lock_irq(&wbiasrwlock)
#define wrap_read_trylock_irq()	wbias_read_trylock_irq(&wbiasrwlock)
#define wrap_read_unlock_irq()	wbias_read_unlock_irq(&wbiasrwlock)

#if (TEST_INTERRUPTS)
#define wrap_write_lock()	wbias_write_lock_irq(&wbiasrwlock)
#define wrap_write_unlock()	wbias_write_unlock_irq(&wbiasrwlock)
#else
#define wrap_write_lock()	wbias_write_lock(&wbiasrwlock)
#define wrap_write_unlock()	wbias_write_unlock(&wbiasrwlock)
#endif

#endif

static cycles_t cycles_calibration_min,
	cycles_calibration_avg,
	cycles_calibration_max;

static inline cycles_t calibrate_cycles(cycles_t cycles)
{
	return cycles - cycles_calibration_avg;
}

struct proc_dir_entry *pentry = NULL;

static int reader_thread(void *data)
{
	int i;
	int prev, cur;
	unsigned long iter = 0;
	cycles_t time1, time2, delay, delaymax = 0, delaymin = ULLONG_MAX,
		delayavg = 0;

	printk("reader_thread/%lu runnning\n", (unsigned long)data);
	do {
		iter++;
		preempt_disable();	/* for get_cycles accuracy */
		rdtsc_barrier();
		time1 = get_cycles();
		rdtsc_barrier();

		wrap_read_lock();

		rdtsc_barrier();
		time2 = get_cycles();
		rdtsc_barrier();
		delay = time2 - time1;
		delaymax = max(delaymax, delay);
		delaymin = min(delaymin, delay);
		delayavg += delay;
		prev = var[0];
		for (i = 1; i < NR_VARS; i++) {
			cur = var[i];
			if (cur != prev)
				printk(KERN_ALERT
				"Unequal cur %d/prev %d at i %d, iter %lu "
				"in thread\n", cur, prev, i, iter);
		}

		wrap_read_unlock();

		preempt_enable();	/* for get_cycles accuracy */
		if (THREAD_READER_DELAY)
			msleep(THREAD_READER_DELAY);
	} while (!kthread_should_stop());
	if (!iter) {
		printk("reader_thread/%lu iterations : %lu",
			(unsigned long)data, iter);
	} else {
		delayavg /= iter;
		printk("reader_thread/%lu iterations : %lu, "
			"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
			(unsigned long)data, iter,
			calibrate_cycles(delaymin),
			calibrate_cycles(delayavg),
			calibrate_cycles(delaymax));
	}
	return 0;
}

static int trylock_reader_thread(void *data)
{
	int i;
	int prev, cur;
	unsigned long iter = 0, success_iter = 0;

	printk("trylock_reader_thread/%lu runnning\n", (unsigned long)data);
	do {
		while (!wrap_read_trylock())
			iter++;
		success_iter++;
		prev = var[0];
		for (i = 1; i < NR_VARS; i++) {
			cur = var[i];
			if (cur != prev)
				printk(KERN_ALERT
				"Unequal cur %d/prev %d at i %d, iter %lu "
				"in thread\n", cur, prev, i, iter);
		}
		wrap_read_unlock();
		if (THREAD_READER_DELAY)
			msleep(THREAD_READER_DELAY);
	} while (!kthread_should_stop());
	printk("trylock_reader_thread/%lu iterations : %lu, "
		"successful iterations : %lu\n",
		(unsigned long)data, iter, success_iter);
	return 0;
}

DEFINE_PER_CPU(cycles_t, int_delaymin);
DEFINE_PER_CPU(cycles_t, int_delayavg);
DEFINE_PER_CPU(cycles_t, int_delaymax);
DEFINE_PER_CPU(cycles_t, int_ipi_nr);

static void interrupt_reader_ipi(void *data)
{
	int i;
	int prev, cur;
	cycles_t time1, time2;
	cycles_t *delaymax, *delaymin, *delayavg, *ipi_nr, delay;

	/*
	 * Skip the ipi caller, not in irq context.
	 */
	if (!in_irq())
		return;

	delaymax = &per_cpu(int_delaymax, smp_processor_id());
	delaymin = &per_cpu(int_delaymin, smp_processor_id());
	delayavg = &per_cpu(int_delayavg, smp_processor_id());
	ipi_nr = &per_cpu(int_ipi_nr, smp_processor_id());

	rdtsc_barrier();
	time1 = get_cycles();
	rdtsc_barrier();

	wrap_read_lock_irq();

	rdtsc_barrier();
	time2 = get_cycles();
	rdtsc_barrier();
	delay = time2 - time1;
	*delaymax = max(*delaymax, delay);
	*delaymin = min(*delaymin, delay);
	*delayavg += delay;
	(*ipi_nr)++;
	prev = var[0];
	for (i = 1; i < NR_VARS; i++) {
		cur = var[i];
		if (cur != prev)
			printk(KERN_ALERT
			"Unequal cur %d/prev %d at i %d in interrupt\n",
				cur, prev, i);
	}
	wrap_read_unlock_irq();
}

DEFINE_PER_CPU(unsigned long, trylock_int_iter);
DEFINE_PER_CPU(unsigned long, trylock_int_success);

static void trylock_interrupt_reader_ipi(void *data)
{
	int i;
	int prev, cur;

	/*
	 * Skip the ipi caller, not in irq context.
	 */
	if (!in_irq())
		return;

	per_cpu(trylock_int_iter, smp_processor_id())++;
	while (!wrap_read_trylock_irq())
		per_cpu(trylock_int_iter, smp_processor_id())++;
	per_cpu(trylock_int_success, smp_processor_id())++;
	prev = var[0];
	for (i = 1; i < NR_VARS; i++) {
		cur = var[i];
		if (cur != prev)
			printk(KERN_ALERT
			"Unequal cur %d/prev %d at i %d in interrupt\n",
				cur, prev, i);
	}
	wrap_read_unlock_irq();
}


static int interrupt_reader_thread(void *data)
{
	unsigned long iter = 0;
	int i;

	for_each_online_cpu(i) {
		per_cpu(int_delaymax, i) = 0;
		per_cpu(int_delaymin, i) = ULLONG_MAX;
		per_cpu(int_delayavg, i) = 0;
		per_cpu(int_ipi_nr, i) = 0;
	}
	do {
		iter++;
		on_each_cpu(interrupt_reader_ipi, NULL, 0);
		if (INTERRUPT_READER_DELAY)
			msleep(INTERRUPT_READER_DELAY);
	} while (!kthread_should_stop());
	printk("interrupt_reader_thread/%lu iterations : %lu\n",
			(unsigned long)data, iter);
	for_each_online_cpu(i) {
		if (!per_cpu(int_ipi_nr, i))
			continue;
		per_cpu(int_delayavg, i) /= per_cpu(int_ipi_nr, i);
		printk("interrupt readers on CPU %i, "
			"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
			i,
			calibrate_cycles(per_cpu(int_delaymin, i)),
			calibrate_cycles(per_cpu(int_delayavg, i)),
			calibrate_cycles(per_cpu(int_delaymax, i)));
	}
	return 0;
}

static int trylock_interrupt_reader_thread(void *data)
{
	unsigned long iter = 0;
	int i;

	do {
		iter++;
		on_each_cpu(trylock_interrupt_reader_ipi, NULL, 0);
		if (INTERRUPT_READER_DELAY)
			msleep(INTERRUPT_READER_DELAY);
	} while (!kthread_should_stop());
	printk("trylock_interrupt_reader_thread/%lu iterations : %lu\n",
			(unsigned long)data, iter);
	for_each_online_cpu(i) {
		printk("trylock interrupt readers on CPU %i, "
			"iterations %lu, "
			"successful iterations : %lu\n",
			i, per_cpu(trylock_int_iter, i),
			per_cpu(trylock_int_success, i));
		per_cpu(trylock_int_iter, i) = 0;
		per_cpu(trylock_int_success, i) = 0;
	}
	return 0;
}

static int writer_thread(void *data)
{
	int i;
	int new;
	unsigned long iter = 0;
	cycles_t time1, time2, delay, delaymax = 0, delaymin = ULLONG_MAX,
		delayavg = 0;

	printk("writer_thread/%lu runnning\n", (unsigned long)data);
	do {
		iter++;
		preempt_disable();	/* for get_cycles accuracy */
		rdtsc_barrier();
		time1 = get_cycles();
		rdtsc_barrier();

		wrap_write_lock();

		rdtsc_barrier();
		time2 = get_cycles();
		rdtsc_barrier();
		delay = time2 - time1;
		delaymax = max(delaymax, delay);
		delaymin = min(delaymin, delay);
		delayavg += delay;
		new = (int)get_cycles();
		for (i = 0; i < NR_VARS; i++) {
			var[i] = new;
		}

		wrap_write_unlock();

		preempt_enable();	/* for get_cycles accuracy */
		if (WRITER_DELAY > 0)
			udelay(WRITER_DELAY);
	} while (!kthread_should_stop());
	delayavg /= iter;
	printk("writer_thread/%lu iterations : %lu, "
		"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
		(unsigned long)data, iter,
		calibrate_cycles(delaymin),
		calibrate_cycles(delayavg),
		calibrate_cycles(delaymax));
	return 0;
}

#if (TEST_STD_RWLOCK)
static int trylock_writer_thread(void *data)
{
	int i;
	int new;
	unsigned long iter = 0, success = 0, fail = 0;

	printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data);
	do {
#if (TEST_INTERRUPTS)
		/* std write trylock cannot disable interrupts. */
		local_irq_disable();
#endif

#if (TRYLOCK_WRITERS_FAIL_ITER == -1)
		for (;;) {
			iter++;
			if (write_trylock(&std_rw_lock))
				goto locked;
		}
#else
		for (i = 0; i < TRYLOCK_WRITERS_FAIL_ITER; i++) {
			iter++;
			if (write_trylock(&std_rw_lock))
				goto locked;
		}
#endif
		fail++;
#if (TEST_INTERRUPTS)
		local_irq_enable();
#endif
		goto loop;
locked:
		success++;
		new = (int)get_cycles();
		for (i = 0; i < NR_VARS; i++) {
			var[i] = new;
		}
#if (TEST_INTERRUPTS)
		write_unlock_irq(&std_rw_lock);
#else
		write_unlock(&std_rw_lock);
#endif
loop:
		if (TRYLOCK_WRITER_DELAY > 0)
			udelay(TRYLOCK_WRITER_DELAY);
	} while (!kthread_should_stop());
	printk("trylock_writer_thread/%lu iterations : "
		"[try,success,fail after %d try], "
		"%lu,%lu,%lu\n",
		(unsigned long)data, TRYLOCK_WRITERS_FAIL_ITER,
		iter, success, fail);
	return 0;
}

#else /* !TEST_STD_RWLOCK */

static int trylock_writer_thread(void *data)
{
	int i;
	int new;
	unsigned long iter = 0, success = 0, fail = 0;

	printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data);
	do {
		iter++;
#if (TEST_INTERRUPTS)
		if (wbias_write_trylock_irq_else_subscribe(&wbiasrwlock))
#else
		if (wbias_write_trylock_else_subscribe(&wbiasrwlock))
#endif
			goto locked;

#if (TRYLOCK_WRITERS_FAIL_ITER == -1)
		for (;;) {
			iter++;
#if (TEST_INTERRUPTS)
			if (wbias_write_trylock_irq_subscribed(&wbiasrwlock))
#else
			if (wbias_write_trylock_subscribed(&wbiasrwlock))
#endif
				goto locked;
		}
#else
		for (i = 0; i < TRYLOCK_WRITERS_FAIL_ITER - 1; i++) {
			iter++;
#if (TEST_INTERRUPTS)
			if (wbias_write_trylock_irq_subscribed(&wbiasrwlock))
#else
			if (wbias_write_trylock_subscribed(&wbiasrwlock))
#endif
				goto locked;
		}
#endif
		fail++;
		wbias_write_unsubscribe(&wbiasrwlock);
		goto loop;
locked:
		success++;
		new = (int)get_cycles();
		for (i = 0; i < NR_VARS; i++) {
			var[i] = new;
		}
#if (TEST_INTERRUPTS)
		wbias_write_unlock_irq(&wbiasrwlock);
#else
		wbias_write_unlock(&wbiasrwlock);
#endif
loop:
		if (TRYLOCK_WRITER_DELAY > 0)
			udelay(TRYLOCK_WRITER_DELAY);
	} while (!kthread_should_stop());
	printk("trylock_writer_thread/%lu iterations : "
		"[try,success,fail after %d try], "
		"%lu,%lu,%lu\n",
		(unsigned long)data, TRYLOCK_WRITERS_FAIL_ITER,
		iter, success, fail);
	return 0;
}

#endif	/* TEST_STD_RWLOCK */

static void wbias_rwlock_create(void)
{
	unsigned long i;

	for (i = 0; i < NR_READERS; i++) {
		printk("starting reader thread %lu\n", i);
		reader_threads[i] = kthread_run(reader_thread, (void *)i,
			"wbiasrwlock_reader");
		BUG_ON(!reader_threads[i]);
	}

	for (i = 0; i < NR_TRYLOCK_READERS; i++) {
		printk("starting trylock reader thread %lu\n", i);
		trylock_reader_threads[i] = kthread_run(trylock_reader_thread,
			(void *)i, "wbiasrwlock_trylock_reader");
		BUG_ON(!trylock_reader_threads[i]);
	}
	for (i = 0; i < NR_INTERRUPT_READERS; i++) {
		printk("starting interrupt reader %lu\n", i);
		interrupt_reader[i] = kthread_run(interrupt_reader_thread,
			(void *)i,
			"wbiasrwlock_interrupt_reader");
	}
	for (i = 0; i < NR_TRYLOCK_INTERRUPT_READERS; i++) {
		printk("starting trylock interrupt reader %lu\n", i);
		trylock_interrupt_reader[i] =
			kthread_run(trylock_interrupt_reader_thread,
			(void *)i, "wbiasrwlock_trylock_interrupt_reader");
	}
	for (i = 0; i < NR_WRITERS; i++) {
		printk("starting writer thread %lu\n", i);
		writer_threads[i] = kthread_run(writer_thread, (void *)i,
			"wbiasrwlock_writer");
		BUG_ON(!writer_threads[i]);
	}
	for (i = 0; i < NR_TRYLOCK_WRITERS; i++) {
		printk("starting trylock writer thread %lu\n", i);
		trylock_writer_threads[i] = kthread_run(trylock_writer_thread,
			(void *)i, "wbiasrwlock_trylock_writer");
		BUG_ON(!trylock_writer_threads[i]);
	}
}

static void wbias_rwlock_stop(void)
{
	unsigned long i;

	for (i = 0; i < NR_WRITERS; i++)
		kthread_stop(writer_threads[i]);
	for (i = 0; i < NR_TRYLOCK_WRITERS; i++)
		kthread_stop(trylock_writer_threads[i]);
	for (i = 0; i < NR_READERS; i++)
		kthread_stop(reader_threads[i]);
	for (i = 0; i < NR_TRYLOCK_READERS; i++)
		kthread_stop(trylock_reader_threads[i]);
	for (i = 0; i < NR_INTERRUPT_READERS; i++)
		kthread_stop(interrupt_reader[i]);
	for (i = 0; i < NR_TRYLOCK_INTERRUPT_READERS; i++)
		kthread_stop(trylock_interrupt_reader[i]);
}


static void perform_test(const char *name, void (*callback)(void))
{
	printk("%s\n", name);
	callback();
}

static int my_open(struct inode *inode, struct file *file)
{
	unsigned long i;
	cycles_t time1, time2, delay;

	printk("** get_cycles calibration **\n");
	cycles_calibration_min = ULLONG_MAX;
	cycles_calibration_avg = 0;
	cycles_calibration_max = 0;

	local_irq_disable();
	for (i = 0; i < 10; i++) {
		rdtsc_barrier();
		time1 = get_cycles();
		rdtsc_barrier();
		rdtsc_barrier();
		time2 = get_cycles();
		rdtsc_barrier();
		delay = time2 - time1;
		cycles_calibration_min = min(cycles_calibration_min, delay);
		cycles_calibration_avg += delay;
		cycles_calibration_max = max(cycles_calibration_max, delay);
	}
	cycles_calibration_avg /= 10;
	local_irq_enable();

	printk("get_cycles takes [min,avg,max] %llu,%llu,%llu cycles, "
		"results calibrated on avg\n",
		cycles_calibration_min,
		cycles_calibration_avg,
		cycles_calibration_max);

	printk("** Single writer test, no contention **\n");
	writer_threads[0] = kthread_run(writer_thread, (void *)0,
		"wbiasrwlock_writer");
	BUG_ON(!writer_threads[0]);
	ssleep(SINGLE_WRITER_TEST_DURATION);
	kthread_stop(writer_threads[0]);

	printk("** Single trylock writer test, no contention **\n");
	trylock_writer_threads[0] = kthread_run(trylock_writer_thread,
		(void *)0,
		"trylock_wbiasrwlock_writer");
	BUG_ON(!trylock_writer_threads[0]);
	ssleep(SINGLE_WRITER_TEST_DURATION);
	kthread_stop(trylock_writer_threads[0]);

	printk("** Single reader test, no contention **\n");
	reader_threads[0] = kthread_run(reader_thread, (void *)0,
		"wbiasrwlock_reader");
	BUG_ON(!reader_threads[0]);
	ssleep(SINGLE_READER_TEST_DURATION);
	kthread_stop(reader_threads[0]);

	printk("** Multiple readers test, no contention **\n");
	for (i = 0; i < NR_READERS; i++) {
		printk("starting reader thread %lu\n", i);
		reader_threads[i] = kthread_run(reader_thread, (void *)i,
			"wbiasrwlock_reader");
		BUG_ON(!reader_threads[i]);
	}
	ssleep(SINGLE_READER_TEST_DURATION);
	for (i = 0; i < NR_READERS; i++)
		kthread_stop(reader_threads[i]);

	printk("** High contention test **\n");
	perform_test("wbias-rwlock-create", wbias_rwlock_create);
	ssleep(TEST_DURATION);
	perform_test("wbias-rwlock-stop", wbias_rwlock_stop);

	return -EPERM;
}


static struct file_operations my_operations = {
	.open = my_open,
};

int init_module(void)
{
	pentry = create_proc_entry("testwbiasrwlock", 0444, NULL);
	if (pentry)
		pentry->proc_fops = &my_operations;

	printk("NR_CPUS : %d\n", NR_CPUS);
	printk("THREAD_ROFFSET : %lX\n", THREAD_ROFFSET);
	printk("THREAD_RMASK : %lX\n", THREAD_RMASK);
	printk("SOFTIRQ_ROFFSET : %lX\n", SOFTIRQ_ROFFSET);
	printk("SOFTIRQ_RMASK : %lX\n", SOFTIRQ_RMASK);
	printk("HARDIRQ_ROFFSET : %lX\n", HARDIRQ_ROFFSET);
	printk("HARDIRQ_RMASK : %lX\n", HARDIRQ_RMASK);
	printk("SUBSCRIBERS_WOFFSET : %lX\n", SUBSCRIBERS_WOFFSET);
	printk("SUBSCRIBERS_WMASK : %lX\n", SUBSCRIBERS_WMASK);
	printk("WRITER_MUTEX : %lX\n", WRITER_MUTEX);
	printk("SOFTIRQ_WMASK : %lX\n", SOFTIRQ_WMASK);
	printk("HARDIRQ_WMASK : %lX\n", HARDIRQ_WMASK);

	return 0;
}

void cleanup_module(void)
{
	remove_proc_entry("testwbiasrwlock", NULL);
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("wbias rwlock test");
Commit	Line	Data
	1	/* test-wbias-rwlock.c
	2	*
	3	*/
	4
	5	#include <linux/module.h>
	6	#include <linux/proc_fs.h>
	7	#include <linux/sched.h>
	8	#include <linux/timex.h>
	9	#include <linux/wbias-rwlock.h>
	10	#include <linux/kthread.h>
	11	#include <linux/delay.h>
	12	#include <linux/hardirq.h>
	13	#include <linux/module.h>
	14	#include <linux/percpu.h>
	15	#include <linux/spinlock.h>
	16	#include <asm/ptrace.h>
	17
	18	#if (NR_CPUS > 64 && (BITS_PER_LONG == 32 \|\| NR_CPUS > 32768))
	19	#error "writer-biased rwlock needs more bits per long to deal with so many CPUs"
	20	#endif
	21
	22	/* Test with no contention duration, in seconds */
	23	#define SINGLE_WRITER_TEST_DURATION 10
	24	#define SINGLE_READER_TEST_DURATION 10
	25	#define MULTIPLE_READERS_TEST_DURATION 10
	26
	27	/* Test duration, in seconds */
	28	#define TEST_DURATION 60
	29
	30	#define NR_VARS 100
	31	//#define NR_WRITERS 2
	32	#define NR_WRITERS 2
	33	//#define NR_TRYLOCK_WRITERS 2
	34	#define NR_TRYLOCK_WRITERS 0
	35	#define NR_READERS 4
	36	//#define NR_TRYLOCK_READERS 2
	37	#define NR_TRYLOCK_READERS 0
	38
	39	/*
	40	* 1 : test standard rwlock
	41	* 0 : test wbiasrwlock
	42	*/
	43	#define TEST_STD_RWLOCK 0
	44
	45	/*
	46	* 1 : test with thread and interrupt readers.
	47	* 0 : test only with thread readers.
	48	*/
	49	#define TEST_INTERRUPTS 1
	50
	51	#if (TEST_INTERRUPTS)
	52	#define NR_INTERRUPT_READERS 1
	53	#define NR_TRYLOCK_INTERRUPT_READERS 1
	54	#else
	55	#define NR_INTERRUPT_READERS 0
	56	#define NR_TRYLOCK_INTERRUPT_READERS 0
	57	#endif
	58
	59	/*
	60	* Writer iteration delay, in us. 0 for busy loop. Caution : writers can
	61	* starve readers.
	62	*/
	63	#define WRITER_DELAY 100
	64	#define TRYLOCK_WRITER_DELAY 1000
	65
	66	/*
	67	* Number of iterations after which a trylock writer fails.
	68	* -1 for infinite loop.
	69	*/
	70	#define TRYLOCK_WRITERS_FAIL_ITER 100
	71
	72	/* Thread and interrupt reader delay, in ms */
	73	#define THREAD_READER_DELAY 0 /* busy loop */
	74	#define INTERRUPT_READER_DELAY 100
	75
	76	static int var[NR_VARS];
	77	static struct task_struct *reader_threads[NR_READERS];
	78	static struct task_struct *trylock_reader_threads[NR_TRYLOCK_READERS];
	79	static struct task_struct *writer_threads[NR_WRITERS];
	80	static struct task_struct *trylock_writer_threads[NR_TRYLOCK_WRITERS];
	81	static struct task_struct *interrupt_reader[NR_INTERRUPT_READERS];
	82	static struct task_struct *trylock_interrupt_reader[NR_TRYLOCK_INTERRUPT_READERS];
	83
	84	#if (TEST_STD_RWLOCK)
	85
	86	static DEFINE_RWLOCK(std_rw_lock);
	87
	88	#define wrap_read_lock() read_lock(&std_rw_lock)
	89	#define wrap_read_trylock() read_trylock(&std_rw_lock)
	90	#define wrap_read_unlock() read_unlock(&std_rw_lock)
	91
	92	#define wrap_read_lock_irq() read_lock(&std_rw_lock)
	93	#define wrap_read_trylock_irq() read_trylock(&std_rw_lock)
	94	#define wrap_read_unlock_irq() read_unlock(&std_rw_lock)
	95
	96	#if (TEST_INTERRUPTS)
	97	#define wrap_write_lock() write_lock_irq(&std_rw_lock)
	98	#define wrap_write_unlock() write_unlock_irq(&std_rw_lock)
	99	#else
	100	#define wrap_write_lock() write_lock(&std_rw_lock)
	101	#define wrap_write_unlock() write_unlock(&std_rw_lock)
	102	#endif
	103
	104	#else
	105
	106	static DEFINE_WBIAS_RWLOCK(wbiasrwlock);
	107
	108	#define wrap_read_lock() wbias_read_lock(&wbiasrwlock)
	109	#define wrap_read_trylock() wbias_read_trylock(&wbiasrwlock)
	110	#define wrap_read_unlock() wbias_read_unlock(&wbiasrwlock)
	111
	112	#define wrap_read_lock_irq() wbias_read_lock_irq(&wbiasrwlock)
	113	#define wrap_read_trylock_irq() wbias_read_trylock_irq(&wbiasrwlock)
	114	#define wrap_read_unlock_irq() wbias_read_unlock_irq(&wbiasrwlock)
	115
	116	#if (TEST_INTERRUPTS)
	117	#define wrap_write_lock() wbias_write_lock_irq(&wbiasrwlock)
	118	#define wrap_write_unlock() wbias_write_unlock_irq(&wbiasrwlock)
	119	#else
	120	#define wrap_write_lock() wbias_write_lock(&wbiasrwlock)
	121	#define wrap_write_unlock() wbias_write_unlock(&wbiasrwlock)
	122	#endif
	123
	124	#endif
	125
	126	static cycles_t cycles_calibration_min,
	127	cycles_calibration_avg,
	128	cycles_calibration_max;
	129
	130	static inline cycles_t calibrate_cycles(cycles_t cycles)
	131	{
	132	return cycles - cycles_calibration_avg;
	133	}
	134
	135	struct proc_dir_entry *pentry = NULL;
	136
	137	static int reader_thread(void *data)
	138	{
	139	int i;
	140	int prev, cur;
	141	unsigned long iter = 0;
	142	cycles_t time1, time2, delay, delaymax = 0, delaymin = ULLONG_MAX,
	143	delayavg = 0;
	144
	145	printk("reader_thread/%lu runnning\n", (unsigned long)data);
	146	do {
	147	iter++;
	148	preempt_disable(); /* for get_cycles accuracy */
	149	rdtsc_barrier();
	150	time1 = get_cycles();
	151	rdtsc_barrier();
	152
	153	wrap_read_lock();
	154
	155	rdtsc_barrier();
	156	time2 = get_cycles();
	157	rdtsc_barrier();
	158	delay = time2 - time1;
	159	delaymax = max(delaymax, delay);
	160	delaymin = min(delaymin, delay);
	161	delayavg += delay;
	162	prev = var[0];
	163	for (i = 1; i < NR_VARS; i++) {
	164	cur = var[i];
	165	if (cur != prev)
	166	printk(KERN_ALERT
	167	"Unequal cur %d/prev %d at i %d, iter %lu "
	168	"in thread\n", cur, prev, i, iter);
	169	}
	170
	171	wrap_read_unlock();
	172
	173	preempt_enable(); /* for get_cycles accuracy */
	174	if (THREAD_READER_DELAY)
	175	msleep(THREAD_READER_DELAY);
	176	} while (!kthread_should_stop());
	177	if (!iter) {
	178	printk("reader_thread/%lu iterations : %lu",
	179	(unsigned long)data, iter);
	180	} else {
	181	delayavg /= iter;
	182	printk("reader_thread/%lu iterations : %lu, "
	183	"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
	184	(unsigned long)data, iter,
	185	calibrate_cycles(delaymin),
	186	calibrate_cycles(delayavg),
	187	calibrate_cycles(delaymax));
	188	}
	189	return 0;
	190	}
	191
	192	static int trylock_reader_thread(void *data)
	193	{
	194	int i;
	195	int prev, cur;
	196	unsigned long iter = 0, success_iter = 0;
	197
	198	printk("trylock_reader_thread/%lu runnning\n", (unsigned long)data);
	199	do {
	200	while (!wrap_read_trylock())
	201	iter++;
	202	success_iter++;
	203	prev = var[0];
	204	for (i = 1; i < NR_VARS; i++) {
	205	cur = var[i];
	206	if (cur != prev)
	207	printk(KERN_ALERT
	208	"Unequal cur %d/prev %d at i %d, iter %lu "
	209	"in thread\n", cur, prev, i, iter);
	210	}
	211	wrap_read_unlock();
	212	if (THREAD_READER_DELAY)
	213	msleep(THREAD_READER_DELAY);
	214	} while (!kthread_should_stop());
	215	printk("trylock_reader_thread/%lu iterations : %lu, "
	216	"successful iterations : %lu\n",
	217	(unsigned long)data, iter, success_iter);
	218	return 0;
	219	}
	220
	221	DEFINE_PER_CPU(cycles_t, int_delaymin);
	222	DEFINE_PER_CPU(cycles_t, int_delayavg);
	223	DEFINE_PER_CPU(cycles_t, int_delaymax);
	224	DEFINE_PER_CPU(cycles_t, int_ipi_nr);
	225
	226	static void interrupt_reader_ipi(void *data)
	227	{
	228	int i;
	229	int prev, cur;
	230	cycles_t time1, time2;
	231	cycles_t delaymax, delaymin, delayavg, ipi_nr, delay;
	232
	233	/*
	234	* Skip the ipi caller, not in irq context.
	235	*/
	236	if (!in_irq())
	237	return;
	238
	239	delaymax = &per_cpu(int_delaymax, smp_processor_id());
	240	delaymin = &per_cpu(int_delaymin, smp_processor_id());
	241	delayavg = &per_cpu(int_delayavg, smp_processor_id());
	242	ipi_nr = &per_cpu(int_ipi_nr, smp_processor_id());
	243
	244	rdtsc_barrier();
	245	time1 = get_cycles();
	246	rdtsc_barrier();
	247
	248	wrap_read_lock_irq();
	249
	250	rdtsc_barrier();
	251	time2 = get_cycles();
	252	rdtsc_barrier();
	253	delay = time2 - time1;
	254	delaymax = max(delaymax, delay);
	255	delaymin = min(delaymin, delay);
	256	*delayavg += delay;
	257	(*ipi_nr)++;
	258	prev = var[0];
	259	for (i = 1; i < NR_VARS; i++) {
	260	cur = var[i];
	261	if (cur != prev)
	262	printk(KERN_ALERT
	263	"Unequal cur %d/prev %d at i %d in interrupt\n",
	264	cur, prev, i);
	265	}
	266	wrap_read_unlock_irq();
	267	}
	268
	269	DEFINE_PER_CPU(unsigned long, trylock_int_iter);
	270	DEFINE_PER_CPU(unsigned long, trylock_int_success);
	271
	272	static void trylock_interrupt_reader_ipi(void *data)
	273	{
	274	int i;
	275	int prev, cur;
	276
	277	/*
	278	* Skip the ipi caller, not in irq context.
	279	*/
	280	if (!in_irq())
	281	return;
	282
	283	per_cpu(trylock_int_iter, smp_processor_id())++;
	284	while (!wrap_read_trylock_irq())
	285	per_cpu(trylock_int_iter, smp_processor_id())++;
	286	per_cpu(trylock_int_success, smp_processor_id())++;
	287	prev = var[0];
	288	for (i = 1; i < NR_VARS; i++) {
	289	cur = var[i];
	290	if (cur != prev)
	291	printk(KERN_ALERT
	292	"Unequal cur %d/prev %d at i %d in interrupt\n",
	293	cur, prev, i);
	294	}
	295	wrap_read_unlock_irq();
	296	}
	297
	298
	299	static int interrupt_reader_thread(void *data)
	300	{
	301	unsigned long iter = 0;
	302	int i;
	303
	304	for_each_online_cpu(i) {
	305	per_cpu(int_delaymax, i) = 0;
	306	per_cpu(int_delaymin, i) = ULLONG_MAX;
	307	per_cpu(int_delayavg, i) = 0;
	308	per_cpu(int_ipi_nr, i) = 0;
	309	}
	310	do {
	311	iter++;
	312	on_each_cpu(interrupt_reader_ipi, NULL, 0);
	313	if (INTERRUPT_READER_DELAY)
	314	msleep(INTERRUPT_READER_DELAY);
	315	} while (!kthread_should_stop());
	316	printk("interrupt_reader_thread/%lu iterations : %lu\n",
	317	(unsigned long)data, iter);
	318	for_each_online_cpu(i) {
	319	if (!per_cpu(int_ipi_nr, i))
	320	continue;
	321	per_cpu(int_delayavg, i) /= per_cpu(int_ipi_nr, i);
	322	printk("interrupt readers on CPU %i, "
	323	"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
	324	i,
	325	calibrate_cycles(per_cpu(int_delaymin, i)),
	326	calibrate_cycles(per_cpu(int_delayavg, i)),
	327	calibrate_cycles(per_cpu(int_delaymax, i)));
	328	}
	329	return 0;
	330	}
	331
	332	static int trylock_interrupt_reader_thread(void *data)
	333	{
	334	unsigned long iter = 0;
	335	int i;
	336
	337	do {
	338	iter++;
	339	on_each_cpu(trylock_interrupt_reader_ipi, NULL, 0);
	340	if (INTERRUPT_READER_DELAY)
	341	msleep(INTERRUPT_READER_DELAY);
	342	} while (!kthread_should_stop());
	343	printk("trylock_interrupt_reader_thread/%lu iterations : %lu\n",
	344	(unsigned long)data, iter);
	345	for_each_online_cpu(i) {
	346	printk("trylock interrupt readers on CPU %i, "
	347	"iterations %lu, "
	348	"successful iterations : %lu\n",
	349	i, per_cpu(trylock_int_iter, i),
	350	per_cpu(trylock_int_success, i));
	351	per_cpu(trylock_int_iter, i) = 0;
	352	per_cpu(trylock_int_success, i) = 0;
	353	}
	354	return 0;
	355	}
	356
	357	static int writer_thread(void *data)
	358	{
	359	int i;
	360	int new;
	361	unsigned long iter = 0;
	362	cycles_t time1, time2, delay, delaymax = 0, delaymin = ULLONG_MAX,
	363	delayavg = 0;
	364
	365	printk("writer_thread/%lu runnning\n", (unsigned long)data);
	366	do {
	367	iter++;
	368	preempt_disable(); /* for get_cycles accuracy */
	369	rdtsc_barrier();
	370	time1 = get_cycles();
	371	rdtsc_barrier();
	372
	373	wrap_write_lock();
	374
	375	rdtsc_barrier();
	376	time2 = get_cycles();
	377	rdtsc_barrier();
	378	delay = time2 - time1;
	379	delaymax = max(delaymax, delay);
	380	delaymin = min(delaymin, delay);
	381	delayavg += delay;
	382	new = (int)get_cycles();
	383	for (i = 0; i < NR_VARS; i++) {
	384	var[i] = new;
	385	}
	386
	387	wrap_write_unlock();
	388
	389	preempt_enable(); /* for get_cycles accuracy */
	390	if (WRITER_DELAY > 0)
	391	udelay(WRITER_DELAY);
	392	} while (!kthread_should_stop());
	393	delayavg /= iter;
	394	printk("writer_thread/%lu iterations : %lu, "
	395	"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
	396	(unsigned long)data, iter,
	397	calibrate_cycles(delaymin),
	398	calibrate_cycles(delayavg),
	399	calibrate_cycles(delaymax));
	400	return 0;
	401	}
	402
	403	#if (TEST_STD_RWLOCK)
	404	static int trylock_writer_thread(void *data)
	405	{
	406	int i;
	407	int new;
	408	unsigned long iter = 0, success = 0, fail = 0;
	409
	410	printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data);
	411	do {
	412	#if (TEST_INTERRUPTS)
	413	/* std write trylock cannot disable interrupts. */
	414	local_irq_disable();
	415	#endif
	416
	417	#if (TRYLOCK_WRITERS_FAIL_ITER == -1)
	418	for (;;) {
	419	iter++;
	420	if (write_trylock(&std_rw_lock))
	421	goto locked;
	422	}
	423	#else
	424	for (i = 0; i < TRYLOCK_WRITERS_FAIL_ITER; i++) {
	425	iter++;
	426	if (write_trylock(&std_rw_lock))
	427	goto locked;
	428	}
	429	#endif
	430	fail++;
	431	#if (TEST_INTERRUPTS)
	432	local_irq_enable();
	433	#endif
	434	goto loop;
	435	locked:
	436	success++;
	437	new = (int)get_cycles();
	438	for (i = 0; i < NR_VARS; i++) {
	439	var[i] = new;
	440	}
	441	#if (TEST_INTERRUPTS)
	442	write_unlock_irq(&std_rw_lock);
	443	#else
	444	write_unlock(&std_rw_lock);
	445	#endif
	446	loop:
	447	if (TRYLOCK_WRITER_DELAY > 0)
	448	udelay(TRYLOCK_WRITER_DELAY);
	449	} while (!kthread_should_stop());
	450	printk("trylock_writer_thread/%lu iterations : "
	451	"[try,success,fail after %d try], "
	452	"%lu,%lu,%lu\n",
	453	(unsigned long)data, TRYLOCK_WRITERS_FAIL_ITER,
	454	iter, success, fail);
	455	return 0;
	456	}
	457
	458	#else /* !TEST_STD_RWLOCK */
	459
	460	static int trylock_writer_thread(void *data)
	461	{
	462	int i;
	463	int new;
	464	unsigned long iter = 0, success = 0, fail = 0;
	465
	466	printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data);
	467	do {
	468	iter++;
	469	#if (TEST_INTERRUPTS)
	470	if (wbias_write_trylock_irq_else_subscribe(&wbiasrwlock))
	471	#else
	472	if (wbias_write_trylock_else_subscribe(&wbiasrwlock))
	473	#endif
	474	goto locked;
	475
	476	#if (TRYLOCK_WRITERS_FAIL_ITER == -1)
	477	for (;;) {
	478	iter++;
	479	#if (TEST_INTERRUPTS)
	480	if (wbias_write_trylock_irq_subscribed(&wbiasrwlock))
	481	#else
	482	if (wbias_write_trylock_subscribed(&wbiasrwlock))
	483	#endif
	484	goto locked;
	485	}
	486	#else
	487	for (i = 0; i < TRYLOCK_WRITERS_FAIL_ITER - 1; i++) {
	488	iter++;
	489	#if (TEST_INTERRUPTS)
	490	if (wbias_write_trylock_irq_subscribed(&wbiasrwlock))
	491	#else
	492	if (wbias_write_trylock_subscribed(&wbiasrwlock))
	493	#endif
	494	goto locked;
	495	}
	496	#endif
	497	fail++;
	498	wbias_write_unsubscribe(&wbiasrwlock);
	499	goto loop;
	500	locked:
	501	success++;
	502	new = (int)get_cycles();
	503	for (i = 0; i < NR_VARS; i++) {
	504	var[i] = new;
	505	}
	506	#if (TEST_INTERRUPTS)
	507	wbias_write_unlock_irq(&wbiasrwlock);
	508	#else
	509	wbias_write_unlock(&wbiasrwlock);
	510	#endif
	511	loop:
	512	if (TRYLOCK_WRITER_DELAY > 0)
	513	udelay(TRYLOCK_WRITER_DELAY);
	514	} while (!kthread_should_stop());
	515	printk("trylock_writer_thread/%lu iterations : "
	516	"[try,success,fail after %d try], "
	517	"%lu,%lu,%lu\n",
	518	(unsigned long)data, TRYLOCK_WRITERS_FAIL_ITER,
	519	iter, success, fail);
	520	return 0;
	521	}
	522
	523	#endif /* TEST_STD_RWLOCK */
	524
	525	static void wbias_rwlock_create(void)
	526	{
	527	unsigned long i;
	528
	529	for (i = 0; i < NR_READERS; i++) {
	530	printk("starting reader thread %lu\n", i);
	531	reader_threads[i] = kthread_run(reader_thread, (void *)i,
	532	"wbiasrwlock_reader");
	533	BUG_ON(!reader_threads[i]);
	534	}
	535
	536	for (i = 0; i < NR_TRYLOCK_READERS; i++) {
	537	printk("starting trylock reader thread %lu\n", i);
	538	trylock_reader_threads[i] = kthread_run(trylock_reader_thread,
	539	(void *)i, "wbiasrwlock_trylock_reader");
	540	BUG_ON(!trylock_reader_threads[i]);
	541	}
	542	for (i = 0; i < NR_INTERRUPT_READERS; i++) {
	543	printk("starting interrupt reader %lu\n", i);
	544	interrupt_reader[i] = kthread_run(interrupt_reader_thread,
	545	(void *)i,
	546	"wbiasrwlock_interrupt_reader");
	547	}
	548	for (i = 0; i < NR_TRYLOCK_INTERRUPT_READERS; i++) {
	549	printk("starting trylock interrupt reader %lu\n", i);
	550	trylock_interrupt_reader[i] =
	551	kthread_run(trylock_interrupt_reader_thread,
	552	(void *)i, "wbiasrwlock_trylock_interrupt_reader");
	553	}
	554	for (i = 0; i < NR_WRITERS; i++) {
	555	printk("starting writer thread %lu\n", i);
	556	writer_threads[i] = kthread_run(writer_thread, (void *)i,
	557	"wbiasrwlock_writer");
	558	BUG_ON(!writer_threads[i]);
	559	}
	560	for (i = 0; i < NR_TRYLOCK_WRITERS; i++) {
	561	printk("starting trylock writer thread %lu\n", i);
	562	trylock_writer_threads[i] = kthread_run(trylock_writer_thread,
	563	(void *)i, "wbiasrwlock_trylock_writer");
	564	BUG_ON(!trylock_writer_threads[i]);
	565	}
	566	}
	567
	568	static void wbias_rwlock_stop(void)
	569	{
	570	unsigned long i;
	571
	572	for (i = 0; i < NR_WRITERS; i++)
	573	kthread_stop(writer_threads[i]);
	574	for (i = 0; i < NR_TRYLOCK_WRITERS; i++)
	575	kthread_stop(trylock_writer_threads[i]);
	576	for (i = 0; i < NR_READERS; i++)
	577	kthread_stop(reader_threads[i]);
	578	for (i = 0; i < NR_TRYLOCK_READERS; i++)
	579	kthread_stop(trylock_reader_threads[i]);
	580	for (i = 0; i < NR_INTERRUPT_READERS; i++)
	581	kthread_stop(interrupt_reader[i]);
	582	for (i = 0; i < NR_TRYLOCK_INTERRUPT_READERS; i++)
	583	kthread_stop(trylock_interrupt_reader[i]);
	584	}
	585
	586
	587	static void perform_test(const char name, void (callback)(void))
	588	{
	589	printk("%s\n", name);
	590	callback();
	591	}
	592
	593	static int my_open(struct inode inode, struct file file)
	594	{
	595	unsigned long i;
	596	cycles_t time1, time2, delay;
	597
	598	printk(" get_cycles calibration \n");
	599	cycles_calibration_min = ULLONG_MAX;
	600	cycles_calibration_avg = 0;
	601	cycles_calibration_max = 0;
	602
	603	local_irq_disable();
	604	for (i = 0; i < 10; i++) {
	605	rdtsc_barrier();
	606	time1 = get_cycles();
	607	rdtsc_barrier();
	608	rdtsc_barrier();
	609	time2 = get_cycles();
	610	rdtsc_barrier();
	611	delay = time2 - time1;
	612	cycles_calibration_min = min(cycles_calibration_min, delay);
	613	cycles_calibration_avg += delay;
	614	cycles_calibration_max = max(cycles_calibration_max, delay);
	615	}
	616	cycles_calibration_avg /= 10;
	617	local_irq_enable();
	618
	619	printk("get_cycles takes [min,avg,max] %llu,%llu,%llu cycles, "
	620	"results calibrated on avg\n",
	621	cycles_calibration_min,
	622	cycles_calibration_avg,
	623	cycles_calibration_max);
	624
	625	printk(" Single writer test, no contention \n");
	626	writer_threads[0] = kthread_run(writer_thread, (void *)0,
	627	"wbiasrwlock_writer");
	628	BUG_ON(!writer_threads[0]);
	629	ssleep(SINGLE_WRITER_TEST_DURATION);
	630	kthread_stop(writer_threads[0]);
	631
	632	printk(" Single trylock writer test, no contention \n");
	633	trylock_writer_threads[0] = kthread_run(trylock_writer_thread,
	634	(void *)0,
	635	"trylock_wbiasrwlock_writer");
	636	BUG_ON(!trylock_writer_threads[0]);
	637	ssleep(SINGLE_WRITER_TEST_DURATION);
	638	kthread_stop(trylock_writer_threads[0]);
	639
	640	printk(" Single reader test, no contention \n");
	641	reader_threads[0] = kthread_run(reader_thread, (void *)0,
	642	"wbiasrwlock_reader");
	643	BUG_ON(!reader_threads[0]);
	644	ssleep(SINGLE_READER_TEST_DURATION);
	645	kthread_stop(reader_threads[0]);
	646
	647	printk(" Multiple readers test, no contention \n");
	648	for (i = 0; i < NR_READERS; i++) {
	649	printk("starting reader thread %lu\n", i);
	650	reader_threads[i] = kthread_run(reader_thread, (void *)i,
	651	"wbiasrwlock_reader");
	652	BUG_ON(!reader_threads[i]);
	653	}
	654	ssleep(SINGLE_READER_TEST_DURATION);
	655	for (i = 0; i < NR_READERS; i++)
	656	kthread_stop(reader_threads[i]);
	657
	658	printk(" High contention test \n");
	659	perform_test("wbias-rwlock-create", wbias_rwlock_create);
	660	ssleep(TEST_DURATION);
	661	perform_test("wbias-rwlock-stop", wbias_rwlock_stop);
	662
	663	return -EPERM;
	664	}
	665
	666
	667	static struct file_operations my_operations = {
	668	.open = my_open,
	669	};
	670
	671	int init_module(void)
	672	{
	673	pentry = create_proc_entry("testwbiasrwlock", 0444, NULL);
	674	if (pentry)
	675	pentry->proc_fops = &my_operations;
	676
	677	printk("NR_CPUS : %d\n", NR_CPUS);
	678	printk("THREAD_ROFFSET : %lX\n", THREAD_ROFFSET);
	679	printk("THREAD_RMASK : %lX\n", THREAD_RMASK);
	680	printk("SOFTIRQ_ROFFSET : %lX\n", SOFTIRQ_ROFFSET);
	681	printk("SOFTIRQ_RMASK : %lX\n", SOFTIRQ_RMASK);
	682	printk("HARDIRQ_ROFFSET : %lX\n", HARDIRQ_ROFFSET);
	683	printk("HARDIRQ_RMASK : %lX\n", HARDIRQ_RMASK);
	684	printk("SUBSCRIBERS_WOFFSET : %lX\n", SUBSCRIBERS_WOFFSET);
	685	printk("SUBSCRIBERS_WMASK : %lX\n", SUBSCRIBERS_WMASK);
	686	printk("WRITER_MUTEX : %lX\n", WRITER_MUTEX);
	687	printk("SOFTIRQ_WMASK : %lX\n", SOFTIRQ_WMASK);
	688	printk("HARDIRQ_WMASK : %lX\n", HARDIRQ_WMASK);
	689
	690	return 0;
	691	}
	692
	693	void cleanup_module(void)
	694	{
	695	remove_proc_entry("testwbiasrwlock", NULL);
	696	}
	697
	698	MODULE_LICENSE("GPL");
	699	MODULE_AUTHOR("Mathieu Desnoyers");
	700	MODULE_DESCRIPTION("wbias rwlock test");