Add benchmark system call for RTSS16 paper

7 files changed, 115 insertions, 8 deletions

diff --git a/arch/arm/include/asm/unistd.h b/arch/arm/include/asm/unistd.h
index 76613c47d4c3..d9b5e057d9bf 100644
--- a/arch/arm/include/asm/unistd.h
+++ b/arch/arm/include/asm/unistd.h
@@ -15,7 +15,7 @@
 
 #include <uapi/asm/unistd.h>
 /** __NR_syscalls padding */
-#define __NR_syscalls  (380 + NR_litmus_syscalls + 3)
+#define __NR_syscalls  (380 + NR_litmus_syscalls + 2)
 
 #define __ARM_NR_cmpxchg                (__ARM_NR_BASE+0x00fff0)
 
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index 97b0c91ef12d..aa09a5d26cfc 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -406,6 +406,7 @@
                 CALL(sys_set_mc2_task_param)
 /* 395 */       CALL(sys_set_page_color)
                 CALL(sys_run_test)
+                CALL(sys_lock_buffer)
                 
 #ifndef syscalls_counted
 .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls
diff --git a/arch/x86/syscalls/syscall_32.tbl b/arch/x86/syscalls/syscall_32.tbl
index c44bc0059cca..b73b7ff70499 100644
--- a/arch/x86/syscalls/syscall_32.tbl
+++ b/arch/x86/syscalls/syscall_32.tbl
@@ -375,3 +375,4 @@
 365     i386    set_mc2_task_param      sys_set_mc2_task_param
 366     i386    set_page_color          sys_set_page_color
 367     i386    run_test                        sys_run_test
+368     i386    lock_buffer                     sys_lock_buffer
diff --git a/arch/x86/syscalls/syscall_64.tbl b/arch/x86/syscalls/syscall_64.tbl
index 93895e3e4593..0cc2f5eb33ec 100644
--- a/arch/x86/syscalls/syscall_64.tbl
+++ b/arch/x86/syscalls/syscall_64.tbl
@@ -338,6 +338,7 @@
 365     common  set_mc2_task_param      sys_set_mc2_task_param
 366     common  set_page_color          sys_set_page_color
 367     common  run_test                        sys_run_test
+368     common  lock_buffer                     sys_lock_buffer
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index ac8995fe508d..8585d51a12a7 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -22,5 +22,6 @@
 #define __NR_set_mc2_task_param __LSC(14)
 #define __NR_set_page_color             __LSC(15)
 #define __NR_run_test                   __LSC(16)
+#define __NR_lock_buffer                __LSC(17)
 
-#define NR_litmus_syscalls 17
+#define NR_litmus_syscalls 18
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index 69d97c8d49e0..49541f0f4174 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -39,5 +39,7 @@ __SYSCALL(__NR_set_mc2_task_param, sys_set_mc2_task_param)
 __SYSCALL(__NR_set_page_color, sys_set_page_color)
 #define __NR_run_test                                   __LSC(16)
 __SYSCALL(__NR_run_test, sys_run_test)
+#define __NR_lock_buffer                                __LSC(17)
+__SYSCALL(__NR_lock_buffer, sys_lock_buffer)
 
-#define NR_litmus_syscalls 17
+#define NR_litmus_syscalls 18
diff --git a/litmus/cache_proc.c b/litmus/cache_proc.c
index 2e9327c9b469..3e47a35e2507 100644
--- a/litmus/cache_proc.c
+++ b/litmus/cache_proc.c
@@ -9,6 +9,7 @@
 #include <linux/io.h>
 #include <linux/mutex.h>
 #include <linux/time.h>
+#include <linux/random.h>
 
 #include <litmus/litmus_proc.h>
 #include <litmus/sched_trace.h>
@@ -23,6 +24,14 @@
 #define LOCK_ALL        (~UNLOCK_ALL)
 #define MAX_NR_WAYS     16
 #define MAX_NR_COLORS   16
+#define CACHELINE_SIZE 32
+#define INTS_IN_CACHELINE (CACHELINE_SIZE/sizeof(int))
+#define CACHELINES_IN_1KB (1024 / sizeof(cacheline_t))
+
+typedef struct cacheline
+{
+        int line[INTS_IN_CACHELINE];
+} __attribute__((aligned(CACHELINE_SIZE))) cacheline_t;
 
 void mem_lock(u32 lock_val, int cpu);
 
@@ -161,6 +170,7 @@ int lock_all;
 int nr_lockregs;
 static raw_spinlock_t cache_lock;
 static raw_spinlock_t prefetch_lock;
+static raw_spinlock_t bench_lock;
 static void ***flusher_pages = NULL;
 
 extern void l2x0_flush_all(void);
@@ -261,6 +271,7 @@ void litmus_setup_lockdown(void __iomem *base, u32 id)
         mutex_init(&lockdown_proc);
         raw_spin_lock_init(&cache_lock);
         raw_spin_lock_init(&prefetch_lock);
+        raw_spin_lock_init(&bench_lock);
         
         test_lockdown(NULL);
 }
@@ -972,30 +983,120 @@ void flush_cache(int all)
         raw_spin_unlock_irqrestore(&cache_lock, flags);
 }
 
-asmlinkage long sys_run_test(int type, size_t size, unsigned long vaddr, lt_t __user *ts)
+/* src = shared, dst = local */
+#if 0 // random
+asmlinkage long sys_run_test(int type, int size, cacheline_t *src, cacheline_t *dst, lt_t __user *ts)
 {
+        /* size is in KB */
         long ret = 0;
         lt_t t1, t2;
+        int numlines = size * CACHELINES_IN_1KB;
+        int next, sum = 0, ran;
+        unsigned long flags;
+        
+        get_random_bytes(&ran, sizeof(int));
+        next = ran % ((size*1024)/sizeof(cacheline_t));
+        
+        //preempt_disable();
+        if (type == 1) {
+                int i, j;
+                color_read_in_mem_lock(0x0000FFF0, 0x0000000f, (void*)src, (void*)src + size*1024);
+                color_read_in_mem_lock(0x0000FF0F, 0x0000000f, (void*)dst, (void*)dst + size*1024);
+                
+                local_irq_save(flags);
+                t1 = litmus_clock();
+                for (i = 0; i < numlines; i++) {
+                        next = src[next].line[0];
+                        for (j = 0; j < INTS_IN_CACHELINE; j++) {
+                                dst[next].line[j] = src[next].line[j]; // read
+                                //src[next].line[j] = dst[next].line[j]; // write
+                        }                       
+                }
+                t2 = litmus_clock();
+                local_irq_restore(flags);
+                sum = next + (int)t2;
+                t2 -= t1;
+                ret = put_user(t2, ts);
+        }
+        else {
+                int i, j;
+                color_read_in_mem_lock(0x0000FF0F, 0x0000000f, (void*)dst, (void*)dst + size*1024);
+                local_irq_save(flags);
+                t1 = litmus_clock();
+                for (i = 0; i < numlines; i++) {
+                        next = src[next].line[0];
+                        for (j = 0; j < INTS_IN_CACHELINE; j++) {
+                                dst[next].line[j] = src[next].line[j]; //read
+                                //src[next].line[j] = dst[next].line[j]; //write
+                        }                       
+                }
+                t2 = litmus_clock();
+                local_irq_restore(flags);
+                sum = next + (int)t2;
+                t2 -= t1;
+                ret = put_user(t2, ts);
+                v7_flush_kern_dcache_area(src, size*1024);
+        }
+        //preempt_enable();
+        flush_cache(1);
 
+        return ret;
+}
+#else
+// sequential
+asmlinkage long sys_run_test(int type, int size, cacheline_t *src, cacheline_t *dst, lt_t __user *ts)
+{
+        /* size is in KB */
+        long ret = 0;
+        lt_t t1, t2;
+        int numlines = size * CACHELINES_IN_1KB;
+        int sum = 0;
+        unsigned long flags;
+        
+        //preempt_disable();
         if (type == 1) {
-                color_read_in_mem_lock(nr_unlocked_way[4], LOCK_ALL, vaddr, vaddr + size);
+                int i, j;
+                color_read_in_mem_lock(0x0000FFF0, 0x0000000f, (void*)src, (void*)src + size*1024);
+                color_read_in_mem_lock(0x0000FF0F, 0x0000000f, (void*)dst, (void*)dst + size*1024);
+                
+                local_irq_save(flags);
                 t1 = litmus_clock();
-                color_read_in_mem(LOCK_ALL, LOCK_ALL, vaddr, vaddr + size);
+                for (i = 0; i < numlines; i++) {
+                        for (j = 0; j < INTS_IN_CACHELINE; j++) {
+                                //dst[i].line[j] = src[i].line[j]; // read
+                                src[i].line[j] = dst[i].line[j]; // write
+                        }                       
+                }
                 t2 = litmus_clock();
+                local_irq_restore(flags);
+                sum = (int)(t1 + t2);
                 t2 -= t1;
                 ret = put_user(t2, ts);
         }
         else {
+                int i, j;
+                color_read_in_mem_lock(0x0000FF0F, 0x0000000f, (void*)dst, (void*)dst + size*1024);
+                local_irq_save(flags);
                 t1 = litmus_clock();
-                color_read_in_mem(LOCK_ALL, LOCK_ALL, vaddr, vaddr + size);
+                for (i = 0; i < numlines; i++) {
+                        for (j = 0; j < INTS_IN_CACHELINE; j++) {
+                                //dst[i].line[j] = src[i].line[j]; //read
+                                src[i].line[j] = dst[i].line[j]; //write
+                        }                       
+                }
                 t2 = litmus_clock();
+                local_irq_restore(flags);
+                sum = (int)(t1 + t2);
                 t2 -= t1;
                 ret = put_user(t2, ts);
-                v7_flush_kern_dcache_area(vaddr, size);
+                v7_flush_kern_dcache_area(src, size*1024);
         }
+        //preempt_enable();
+        flush_cache(1);
 
         return ret;
 }
+#endif
 
 #define TRIALS 1000