RTAS 2017 submissionwip-shared-lib

7 files changed, 753 insertions, 2 deletions

diff --git a/.gitignore b/.gitignore
index a52500b..f42c50a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,10 @@ showst
 rtspin
 cycles
 measure_syscall
+mc2spin
+mc2mem_stc
+mc2mem_ssh
+mc2mem
 
 # build system files
 .config
diff --git a/Makefile b/Makefile
index 4742fd2..ee2a9b2 100644
--- a/Makefile
+++ b/Makefile
@@ -19,7 +19,7 @@ LITMUS_KERNEL ?= ../litmus-rt
 # Internal configuration.
 
 # compiler flags
-flags-debug    = -O2 -Wall -Werror -g -Wdeclaration-after-statement
+flags-debug    = -O2 -Wall -g -Wdeclaration-after-statement
 flags-api      = -D_XOPEN_SOURCE=600 -D_GNU_SOURCE
 
 # architecture-specific flags
@@ -73,7 +73,7 @@ AR  := ${CROSS_COMPILE}${AR}
 
 all     = lib ${rt-apps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
-          base_mt_task uncache runtests
+          base_mt_task uncache runtests mc2mem_stc mc2mem_ssh mc2spin
 
 .PHONY: all lib clean dump-config TAGS tags cscope help doc
 
@@ -234,6 +234,14 @@ obj-release_ts = release_ts.o
 obj-measure_syscall = null_call.o
 lib-measure_syscall = -lm
 
+obj-mc2mem_stc = mc2mem.o common.o
+lib-mc2mem_stc = -lrt -static
+
+obj-mc2mem_ssh = mc2mem.o common.o
+lib-mc2mem_ssh = -lrt
+
+obj-mc2spin = mc2spin.o common.o
+lib-mc2spin = -lrt
 # ##############################################################################
 # Build everything that depends on liblitmus.
 
diff --git a/bin/mc2mem.c b/bin/mc2mem.c
new file mode 100644
index 0000000..2fba878
--- /dev/null
+++ b/bin/mc2mem.c
@@ -0,0 +1,304 @@
+#include <sys/time.h>
+#include <sys/mman.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <math.h>
+
+#include "litmus.h"
+#include "common.h"
+#include "cache_common.h"
+
+#define PAGE_SIZE (4096)
+#define CACHELINE_SIZE 32
+#define INTS_IN_CACHELINE (CACHELINE_SIZE/sizeof(int))
+#define CACHELINES_IN_1KB (1024 / sizeof(cacheline_t))
+#define INTS_IN_1KB     (1024 / sizeof(int))
+#define INTS_IN_CACHELINE (CACHELINE_SIZE/sizeof(int))
+
+static int loops = 100;
+static cacheline_t* arena = NULL;
+static int verbose = 0;
+
+#define UNCACHE_DEV "/dev/litmus/uncache"
+
+/* Random walk around the arena in cacheline-sized chunks.
+   Cacheline-sized chucks ensures the same utilization of each
+   hit line as sequential read. (Otherwise, our utilization
+   would only be 1/INTS_IN_CACHELINE.) */
+static int random_walk(cacheline_t *mem, int wss, int write_cycle)
+{
+        /* a random cycle among the cache lines was set up by init_arena(). */
+        int sum, i, next;
+
+        int numlines = wss * CACHELINES_IN_1KB;
+
+        sum = 0;
+
+        /* contents of arena is structured s.t. offsets are all
+           w.r.t. to start of arena, so compute the initial offset */
+        next = mem - arena;
+
+        if (write_cycle == 0) {
+                for (i = 0; i < numlines; i++) {
+                        /* every element in the cacheline has the same value */
+                        next = arena[next].line[0];
+                        sum += next;
+                }
+        }
+        
+        else {
+                int w, which_line;
+                for (i = 0, w = 0; i < numlines; i++) {
+                        which_line = next;
+                        next = arena[next].line[0];
+                        if((w % write_cycle) != (write_cycle - 1)) {
+                                sum += next;
+                        }
+                        else {
+                                ((volatile cacheline_t*)arena)[which_line].line[0] = next;
+                        }
+                }
+        }
+        return sum;
+}
+
+static cacheline_t* random_start(int wss)
+{
+        return arena + randrange(0, ((wss * 1024)/sizeof(cacheline_t)));
+}
+
+static volatile int dont_optimize_me = 0;
+
+static void usage(char *error) {
+        fprintf(stderr, "Error: %s\n", error);
+        fprintf(stderr,
+                "Usage:\n"
+                "       rt_spin [COMMON-OPTS] WCET PERIOD DURATION\n"
+                "       rt_spin [COMMON-OPTS] -f FILE [-o COLUMN] WCET PERIOD\n"
+                "       rt_spin -l\n"
+                "\n"
+                "COMMON-OPTS = [-w] [-s SCALE]\n"
+                "              [-p PARTITION/CLUSTER [-z CLUSTER SIZE]] [-m CRITICALITY LEVEL]\n"
+                "              [-k WSS] [-l LOOPS] [-b BUDGET]\n"
+                "\n"
+                "WCET and PERIOD are milliseconds, DURATION is seconds.\n");
+        exit(EXIT_FAILURE);
+}
+
+static int loop_once(int wss)
+{
+        cacheline_t *mem;
+        int temp;
+        
+        mem = random_start(wss);
+        temp = random_walk(mem, wss, 0);
+    
+        dont_optimize_me = temp;
+        
+        return dont_optimize_me;
+}
+
+static int job(int wss, double exec_time, double program_end)
+{
+        if (wctime() > program_end)
+                return 0;
+        else {
+                register unsigned int iter = 0;
+                register cycles_t t;
+                t = get_cycles();
+                while(iter++ < loops) {
+                        loop_once(wss);
+                }
+                t = get_cycles() - t;
+                if (verbose)
+                        printf("%ld cycles\n", t);
+                sleep_next_period(); 
+        return 1;
+        }
+}
+
+#define OPTSTR "p:wl:m:i:b:k:v"
+int main(int argc, char** argv)
+{
+        int ret;
+        lt_t wcet, period, budget;
+        double wcet_ms, period_ms, budget_ms;
+        unsigned int priority = LITMUS_NO_PRIORITY;
+        int migrate = 0;
+        int cluster = 0;
+        int opt;
+        int wait = 0;
+        double duration = 0, start = 0;
+        struct rt_task param;
+        struct mc2_task mc2_param;
+        struct reservation_config config;
+        int res_type = PERIODIC_POLLING;
+        size_t arena_sz;
+        int wss = 0;
+
+        /* default for reservation */
+        config.id = 0;
+        config.priority = LITMUS_NO_PRIORITY; /* use EDF by default */
+        config.cpu = -1;
+        
+        mc2_param.crit = CRIT_LEVEL_C;
+        
+        budget_ms = 1000;
+        
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'w':
+                        wait = 1;
+                        break;
+                case 'p':
+                        cluster = atoi(optarg);
+                        migrate = 1;
+                        config.cpu = cluster;
+                        break;
+                case 'l':