uncachedev: uncache test tool.

This adds the uncache test tool (bin/uncache.c). The tool
can be used to test Litmus's char device driver for allocating
uncacheable CPU memory. The tool runs various checks and
gathers basic cache vs. main memory statistics.

In the future, uncache could be extended to quantify the
benefits of the L1, L2, and L3 caches, instead of treating
them as a black box.

Note: Uncache works best when compiled with '-O2'.  While '-O2'
has not been added to the Makefile, other code was updated (code
in tests/ and rtspin), to compile with -O2.

DEPENDS UPON LITMUS-RT PATCH 888d097deb6d1fdc0c89a4f9667fd81cf416cfc7.

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;