6 files changed, 398 insertions, 14 deletions

diff --git a/Makefile b/Makefile
index 8195752..5432edd 100644
--- a/Makefile
+++ b/Makefile
@@ -71,7 +71,7 @@ AR  := ${CROSS_COMPILE}${AR}
 
 all     = lib ${rt-apps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
-          base_mt_task runtests
+          base_mt_task uncache runtests
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -215,6 +215,9 @@ obj-rt_launch = rt_launch.o common.o
 obj-rtspin = rtspin.o common.o
 lib-rtspin = -lrt
 
+obj-uncache = uncache.o
+lib-uncache = -lrt
+
 obj-release_ts = release_ts.o
 
 obj-measure_syscall = null_call.o
diff --git a/bin/rtspin.c b/bin/rtspin.c
index 5054d0b..657a94c 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -80,7 +80,7 @@ static void get_exec_times(const char *file, const int column,
 
                 for (cur_col = 1; cur_col < column; ++cur_col) {
                         /* discard input until we get to the column we want */
-                        fscanf(fstream, "%*s,");
+                        int unused __attribute__ ((unused)) = fscanf(fstream, "%*s,");
                 }
 
                 /* get the desired exec. time */
@@ -200,11 +200,11 @@ int main(int argc, char** argv)
         int column = 1;
         const char *file = NULL;
         int want_enforcement = 0;
-        double duration = 0, start;
+        double duration = 0, start = 0;
         double *exec_times = NULL;
         double scale = 1.0;
         task_class_t class = RT_CLASS_HARD;
-        int cur_job, num_jobs;
+        int cur_job = 0, num_jobs = 0;
 
         /* locking */
         int lock_od = -1;
diff --git a/bin/uncache.c b/bin/uncache.c
new file mode 100644
index 0000000..b6f6913
--- /dev/null
+++ b/bin/uncache.c
@@ -0,0 +1,381 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <sched.h>
+#include <assert.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/fcntl.h>
+#include <sys/mman.h>
+
+/* Test tool for validating Litmus's uncache device.     */
+/* Tool also capable basic cache vs. sysmem statistics.  */
+/* Compile with '-O2' for significaintly greater margins */
+/* in performance between cache and sysmem:              */
+/* (Intel Xeon X5650)                                    */
+/*    -g -> uncache is 30x slower                        */
+/*    -O2 -> uncache is >100x slower                     */
+
+int PAGE_SIZE;
+#define NR_PAGES 16
+
+#define UNCACHE_DEV "/dev/litmus/uncache"
+
+/* volatile forces a read from memory (or cache) on every reference. Note
+   that volatile does not keep data out of the cache! */
+typedef volatile char* pbuf_t;
+
+/* hit the first byte in each page.
+   addr must be page aligned. */
+inline int linear_write(pbuf_t addr, int size, char val)
+{
+        pbuf_t end = addr + size;
+        pbuf_t step;
+        int nr_pages = (unsigned long)(end - addr)/PAGE_SIZE;
+        int times = nr_pages * PAGE_SIZE;
+        int i;
+
+        for (i = 0; i < times; ++i)
+                for(step = addr; step < end; step += PAGE_SIZE)
+                        *step = val;
+        return 0;
+}
+inline int linear_read(pbuf_t addr, int size, char val)
+{
+        pbuf_t end = addr + size;
+        pbuf_t step;
+        int nr_pages = (unsigned long)(end - addr)/PAGE_SIZE;
+        int times = nr_pages * PAGE_SIZE;
+        int i;
+
+        for (i = 0; i < times; ++i)
+                for(step = addr; step < end; step += PAGE_SIZE) {
+                        if (*step != val)
+                                return -1;
+                }
+        return 0;
+}
+
+/* write to *data nr times. */
+inline int hammer_write(pbuf_t data, char val, int nr)
+{
+        int i;
+        for (i = 0; i < nr; ++i)
+                *data = val;
+        return 0;
+}
+
+/* read from *data nr times. */
+inline int hammer_read(pbuf_t data, char val, int nr)
+{
+        int i;
+        for (i = 0; i < nr; ++i) {
+                if (*data != val)
+                        return -1;
+        }
+        return 0;
+}
+
+inline int test(pbuf_t data, int size, int trials)
+{
+        int HAMMER_TIME = 10000;  /* can't cache this! */
+        char VAL = 0x55;
+        int t;
+        for(t = 0; t < trials; ++t) {
+
+#if 0
+                if (linear_write(data, size, VAL) != 0) {
+                        printf("failed linear_write()\n");
+                        return -1;
+                }
+                if (linear_read(data, size, VAL) != 0) {
+                        printf("failed linear_read()\n");
+                        return -1;
+                }
+#endif
+
+                /* hammer at the first byte in the array */
+                if (hammer_write(data, VAL, HAMMER_TIME) != 0) {
+                        printf("failed hammer_write()\n");
+                        return -1;
+                }
+                if (hammer_read(data, VAL, HAMMER_TIME) != 0) {
+                        printf("failed hammer_read()\n");
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+inline void timespec_normalize(struct timespec* ts, time_t sec, int64_t nsec)
+{
+        while(nsec > 1000000000LL) {
+                asm("" : "+rm"(nsec));
+                nsec -= 1000000000LL;
+                ++sec;
+        }
+        while(nsec < 0) {
+                asm("" : "+rm"(nsec));
+                nsec += 1000000000LL;
+                --sec;
+        }
+
+        ts->tv_sec = sec;
+        ts->tv_nsec = nsec;
+}
+
+inline struct timespec timespec_sub(struct timespec lhs, struct timespec rhs)
+{
+        struct timespec delta;
+        timespec_normalize(&delta, lhs.tv_sec - rhs.tv_sec, lhs.tv_nsec - rhs.tv_nsec);
+        return delta;
+}
+
+inline struct timespec timespec_add(struct timespec lhs, struct timespec rhs)
+{
+        struct timespec delta;
+        timespec_normalize(&delta, lhs.tv_sec + rhs.tv_sec, lhs.tv_nsec + rhs.tv_nsec);
+        return delta;
+}
+
+inline int64_t timespec_to_us(struct timespec ts)
+{
+        int64_t t;
+        t = ts.tv_sec * 1000000LL;
+        t += ts.tv_nsec / 1000LL;
+        return t;
+}
+
+/* hammers away at the first byte in each mmaped page and
+   times how long it took. */
+int do_data(int do_uncache, int64_t* time)
+{
+        int size;
+        int prot = PROT_READ | PROT_WRITE;
+        int flags = MAP_PRIVATE;
+
+        pbuf_t data;
+
+        struct sched_param fifo_params;
+
+        struct timespec start, end;
+        int64_t elapsed;
+        int trials = 1000;
+
+        printf("Running data access test.\n");
+
+        mlockall(MCL_CURRENT | MCL_FUTURE);
+
+        memset(&fifo_params, 0, sizeof(fifo_params));