[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>

/* 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_TRYLOCK_WRITERS 1
#define NR_READERS 4
#define NR_TRYLOCK_READERS 1

/*
 * 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("\n");

	printk("** Single writer test, no contention **\n");
	wbias_rwlock_profile_latency_reset();
	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("\n");

	wbias_rwlock_profile_latency_print();

	printk("** Single trylock writer test, no contention **\n");
	wbias_rwlock_profile_latency_reset();
	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("\n");

	wbias_rwlock_profile_latency_print();

	printk("** Single reader test, no contention **\n");
	wbias_rwlock_profile_latency_reset();
	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("\n");

	wbias_rwlock_profile_latency_print();

	printk("** Multiple readers test, no contention **\n");
	wbias_rwlock_profile_latency_reset();
	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("\n");

	wbias_rwlock_profile_latency_print();

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

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