#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/percpu.h>
#include <linux/spinlock.h>
#include <asm/ptrace.h>
+#include <linux/wbias-rwlock.h>
/* Test with no contention duration, in seconds */
#define SINGLE_WRITER_TEST_DURATION 10
#define NR_VARS 100
#define NR_WRITERS 2
#define NR_TRYLOCK_WRITERS 1
-#define NR_PREADERS 2
#define NR_NPREADERS 2
#define NR_TRYLOCK_READERS 1
#define NR_TRYLOCK_INTERRUPT_READERS 0
#endif
+/*
+ * 1 : test with thread preemption readers.
+ * 0 : test only with non-preemptable thread readers.
+ */
+#define TEST_PREEMPT 1
+
+#if (TEST_PREEMPT)
+#define NR_PREADERS 2
+#else
+#define NR_PREADERS 0
+#endif
+
+
/*
* Writer iteration delay, in us. 0 for busy loop. Caution : writers can
* starve readers.
#if (TEST_INTERRUPTS)
#define wrap_write_lock() wbias_write_lock_irq(&wbiasrwlock)
#define wrap_write_unlock() wbias_write_unlock_irq(&wbiasrwlock)
+#define wrap_write_trylock_else_subscribe() \
+ wbias_write_trylock_irq_else_subscribe(&wbiasrwlock)
+#define wrap_write_trylock_subscribed() \
+ wbias_write_trylock_irq_subscribed(&wbiasrwlock)
#else
+#if (TEST_PREEMPT)
#define wrap_write_lock() wbias_write_lock(&wbiasrwlock)
#define wrap_write_unlock() wbias_write_unlock(&wbiasrwlock)
+#define wrap_write_trylock_else_subscribe() \
+ wbias_write_trylock_else_subscribe(&wbiasrwlock)
+#define wrap_write_trylock_subscribed() \
+ wbias_write_trylock_subscribed(&wbiasrwlock)
+#else
+#define wrap_write_lock() wbias_write_lock_atomic(&wbiasrwlock)
+#define wrap_write_unlock() wbias_write_unlock_atomic(&wbiasrwlock)
+#define wrap_write_trylock_else_subscribe() \
+ wbias_write_trylock_atomic_else_subscribe(&wbiasrwlock)
+#define wrap_write_trylock_subscribed() \
+ wbias_write_trylock_atomic_subscribed(&wbiasrwlock)
+#endif
#endif
#endif
struct proc_dir_entry *pentry = NULL;
-static int p_or_np_reader_thread(void *data, int preemptable)
+static int p_or_np_reader_thread(const char *typename,
+ void *data, int preemptable)
{
int i;
int prev, cur;
cycles_t time1, time2, delay, delaymax = 0, delaymin = ULLONG_MAX,
delayavg = 0;
- printk("reader_thread/%lu runnning\n", (unsigned long)data);
+ printk("%s/%lu runnning\n", typename, (unsigned long)data);
do {
iter++;
if (!preemptable)
msleep(THREAD_READER_DELAY);
} while (!kthread_should_stop());
if (!iter) {
- printk("reader_thread/%lu iterations : %lu",
+ printk("%s/%lu iterations : %lu", typename,
(unsigned long)data, iter);
} else {
delayavg /= iter;
- printk("reader_thread/%lu iterations : %lu, "
+ printk("%s/%lu iterations : %lu, "
"lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
+ typename,
(unsigned long)data, iter,
calibrate_cycles(delaymin),
calibrate_cycles(delayavg),
static int preader_thread(void *data)
{
- return p_or_np_reader_thread(data, 1);
+ return p_or_np_reader_thread("preader_thread", data, 1);
}
static int npreader_thread(void *data)
{
- return p_or_np_reader_thread(data, 0);
+ return p_or_np_reader_thread("npreader_thread", data, 0);
}
static int trylock_reader_thread(void *data)
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
+ if (wrap_write_trylock_else_subscribe())
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
+ if (wrap_write_trylock_subscribed())
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
+ if (wrap_write_trylock_subscribed())
goto locked;
}
#endif
for (i = 0; i < NR_VARS; i++) {
var[i] = new;
}
-#if (TEST_INTERRUPTS)
- wbias_write_unlock_irq(&wbiasrwlock);
-#else
- wbias_write_unlock(&wbiasrwlock);
-#endif
+ wrap_write_unlock();
loop:
if (TRYLOCK_WRITER_DELAY > 0)
udelay(TRYLOCK_WRITER_DELAY);
if (pentry)
pentry->proc_fops = &my_operations;
- printk("PTHREAD_ROFFSET : %lX\n", PTHREAD_ROFFSET);
- printk("PTHREAD_RMASK : %lX\n", PTHREAD_RMASK);
- printk("NPTHREAD_ROFFSET : %lX\n", NPTHREAD_ROFFSET);
- printk("NPTHREAD_RMASK : %lX\n", NPTHREAD_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("NPTHREAD_WMASK : %lX\n", SOFTIRQ_WMASK);
- printk("SOFTIRQ_WMASK : %lX\n", SOFTIRQ_WMASK);
- printk("HARDIRQ_WMASK : %lX\n", HARDIRQ_WMASK);
+ printk("PTHREAD_ROFFSET : %016lX\n", PTHREAD_ROFFSET);
+ printk("PTHREAD_RMASK : %016lX\n", PTHREAD_RMASK);
+ printk("NPTHREAD_ROFFSET : %016lX\n", NPTHREAD_ROFFSET);
+ printk("NPTHREAD_RMASK : %016lX\n", NPTHREAD_RMASK);
+ printk("SOFTIRQ_ROFFSET : %016lX\n", SOFTIRQ_ROFFSET);
+ printk("SOFTIRQ_RMASK : %016lX\n", SOFTIRQ_RMASK);
+ printk("HARDIRQ_ROFFSET : %016lX\n", HARDIRQ_ROFFSET);
+ printk("HARDIRQ_RMASK : %016lX\n", HARDIRQ_RMASK);
+ printk("PTHREAD_WOFFSET : %016lX\n", PTHREAD_WOFFSET);
+ printk("PTHREAD_WMASK : %016lX\n", PTHREAD_WMASK);
+ printk("NPTHREAD_WOFFSET : %016lX\n", NPTHREAD_WOFFSET);
+ printk("NPTHREAD_WMASK : %016lX\n", NPTHREAD_WMASK);
+ printk("WRITER_MUTEX : %016lX\n", WRITER_MUTEX);
+ printk("SOFTIRQ_WMASK : %016lX\n", SOFTIRQ_WMASK);
+ printk("HARDIRQ_WMASK : %016lX\n", HARDIRQ_WMASK);
return 0;
}