11 files changed, 614 insertions, 232 deletions

diff --git a/Makefile b/Makefile
index 5527862..b557ee3 100644
--- a/Makefile
+++ b/Makefile
@@ -12,7 +12,7 @@ host-arch := $(shell uname -m | \
 ARCH ?= ${host-arch}
 
 # LITMUS_KERNEL -- where to find the litmus kernel?
-LITMUS_KERNEL ?= ../backup-litmus-rt
+LITMUS_KERNEL ?= ../litmus-rt
 
 
 # ##############################################################################
@@ -72,7 +72,8 @@ AR  := ${CROSS_COMPILE}${AR}
 
 all     = lib ${rt-apps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
-          base_mt_task runtests colortest colorbench testcounters bespin
+          base_mt_task runtests colortest colorbench testcounters \
+          colorspin singlepage
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -213,6 +214,9 @@ lib-rt_launch =  -lgsl -lgslcblas
 obj-rtspin = rtspin.o common.o
 lib-rtspin = -lrt  -lgsl -lgslcblas
 
+obj-colorspin = colorspin.o common.o
+lib-colorspin = -lrt  -lgsl -lgslcblas
+
 obj-rtspin.ovh = rtspin.ovh.o common.o
 lib-rtspin.ovh = -lrt  -lgsl -lgslcblas
 
@@ -236,6 +240,9 @@ lib-colortest = -static
 obj-colorbench = colorbench.o color.o perfcounters.o common.o
 lib-colorbench = -lpthread -lrt -lgsl -lgslcblas
 
+obj-singlepage = singlepage.o color.o perfcounters.o common.o
+lib-singlepage = -lgsl -lgslcblas
+
 obj-testcounters = testcounters.o
 lib-testcounters =
 
@@ -244,7 +251,7 @@ lib-testcounters =
 
 .SECONDEXPANSION:
 ${rt-apps}: $${obj-$$@} liblitmus.a
-        $(CC) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${liblitmus-flags} ${lib-$@}
+        $(CC) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${lib-$@} ${liblitmus-flags}
 
 # ##############################################################################
 # Dependency resolution.
diff --git a/bin/color.c b/bin/color.c
index 2ec97a4..c1753a4 100644
--- a/bin/color.c
+++ b/bin/color.c
@@ -21,7 +21,7 @@ static int map_file(const char* filename, void **addr, size_t size)
                 if (fd >= 0) {
                         *addr = mmap(NULL, size,
                                      PROT_READ | PROT_WRITE,
-                                     MAP_PRIVATE,
+                                     MAP_SHARED,
                                      fd, 0);
                         if (*addr == MAP_FAILED)
                                 error = -1;
diff --git a/bin/colorbench.c b/bin/colorbench.c
index c91b731..ac0c01a 100644
--- a/bin/colorbench.c
+++ b/bin/colorbench.c
@@ -18,17 +18,25 @@
 #define DEBUG           1
 #define NR_LOOPS        10
 
+#if 0
 /* Pound */
 #define NR_CPUS         4
 #define CACHE_SIZE_MB   8
 #define ASSOC           16
 #define LINE_SIZE       64
+#endif
+
+/* Flare */
+#define NR_CPUS         1
+#define CACHE_SIZE_MB   3
+#define ASSOC           12
+#define LINE_SIZE       64
 
 #define CACHE_SIZE      (CACHE_SIZE_MB * 1024 * 1024)
 #define TOTAL_COLORS    (CACHE_SIZE / ASSOC / PAGE_SIZE)
 
-/* number of colors we actually use */
-#define USE_COLORS      (TOTAL_COLORS >> color_shift)
+/* number of colors we actually use (cannot be zero) */
+#define USE_COLORS      ({int v = TOTAL_COLORS >> color_shift; (v) ? v : 1; })
 
 /* how many adjacent pages of the same color we need to allocate */
 #define CONTIG_COLORS   (ARENA_PAGES / USE_COLORS)
@@ -76,7 +84,7 @@ static pthread_barrier_t barrier;
 static int nr_threads;
 static int arena_size;
 static int color_shift;
-//static int *page_line_order;
+static int *page_line_order;
 static int *arena_line_order;
 static struct perf_counter perf_counters[NR_CPUS * NR_PERF_COUNTERS];
 
@@ -138,7 +146,6 @@ void sattolo(int *items, const int len)
  * Starting at position 0 in the page_line_order means the cycle ends with 0.
  * We use 0 in the arena to signify that we are done reading.
  */
-#if 0
 static void init_arena_page_line_order(int *arena)
 {
         int cur_page;
@@ -168,7 +175,8 @@ static void init_arena_page_line_order(int *arena)
                 }
         }
 }
-#endif
+
+#if 0
 static void init_arena_line_order(int *arena)
 {
         int cur_line;
@@ -184,6 +192,7 @@ static void init_arena_line_order(int *arena)
                 arena[idx] = next_idx;
         }
 }
+#endif
 
 static void setup_colors(struct pthread_state *state)
 {
@@ -262,8 +271,8 @@ int thread_init(struct pthread_state *state)
                 goto out;
         }
 
-        //init_arena_page_line_order(state->arena);
-        init_arena_line_order(state->arena);
+        init_arena_page_line_order(state->arena);
+        //init_arena_line_order(state->arena);
 
         err = mlockall(MCL_CURRENT|MCL_FUTURE);
         if (err)
@@ -405,7 +414,7 @@ int main(int argc, char **argv)
         }
 
         pthread_state   = malloc(nr_threads * sizeof(*pthread_state));
-        //page_line_order = malloc(PAGE_LINES * sizeof(*page_line_order));
+        page_line_order = malloc(PAGE_LINES * sizeof(*page_line_order));
         arena_line_order = malloc(ARENA_LINES * sizeof(*arena_line_order));
         //if (!pthread_state || !page_line_order) {
         if (!pthread_state || !arena_line_order) {
@@ -420,9 +429,10 @@ int main(int argc, char **argv)
         CHECK(pthread_attr_setdetachstate, &attr, PTHREAD_CREATE_JOINABLE);
         CHECK(pthread_barrier_init, &barrier, NULL, nr_threads);
 
-        //sattolo(page_line_order, PAGE_LINES);
-        sattolo(arena_line_order, ARENA_LINES);
+        sattolo(page_line_order, PAGE_LINES);
+        //sattolo(arena_line_order, ARENA_LINES);
         //sequential(page_line_order, PAGE_LINES);
+        //sequential(arena_line_order, PAGE_LINES);
 
         for (i = 0; i < nr_threads; i++) {
                 pthread_state[i].tid = i;
@@ -447,12 +457,15 @@ int main(int argc, char **argv)
         CHECK(pthread_barrier_destroy, &barrier);
         CHECK(pthread_attr_destroy, &attr);
 
+        printf("page size:         %d\n", PAGE_SIZE);
+        printf("cache size:        %d\n", CACHE_SIZE);
+        printf("total colors:      %d\n", TOTAL_COLORS);
+        printf("use colors:        %d\n", USE_COLORS);
+        printf("contiguous colors: %d\n", CONTIG_COLORS);
         printf("arena size:        %d\n", arena_size);
         printf("color shift:       %d\n", color_shift);
         printf("arena pages:       %d\n", ARENA_PAGES);
         printf("arena lines:       %d\n", ARENA_LINES);
-        printf("use colors:        %d\n", USE_COLORS);
-        printf("contiguous colors: %d\n", CONTIG_COLORS);
         //print_perf_counters();
 
 out:
diff --git a/bin/colorspin.c b/bin/colorspin.c
new file mode 100644
index 0000000..83a7390
--- /dev/null
+++ b/bin/colorspin.c
@@ -0,0 +1,99 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <assert.h>
+#include "spin_common.h"
+#include "common.h"
+
+static void usage(char *error) {
+        fprintf(stderr, "Error: %s\n", error);
+        fprintf(stderr,
+                "Usage:\n"
+                "       color_spin [COMMON-OPTS] WCET PERIOD DURATION\n"
+                "       color_spin [COMMON-OPTS] -f FILE [-o COLUMN] WCET PERIOD\n"
+                "\n"
+                "COMMON-OPTS = [-w] [-p PARTITION] [-c CLASS] [-s SCALE]\n"
+                "              [-x COLOR-FILE]\n"
+                "\n"
+                "WCET and PERIOD are milliseconds, DURATION is seconds.\n");
+        exit(EXIT_FAILURE);
+}
+
+static void get_page_colors(const char *file, int *num_colors,
+                            int **colors, int **pages)
+{
+        FILE *fstream;
+        int ch, line;
+        *num_colors = 0;
+
+        fstream = fopen(file, "r");
+        if (!fstream)
+                bail_out("could not open page color file\n");
+
+        do {
+                skip_comments(fstream);
+                ch = skip_to_next_line(fstream);
+                if (ch != EOF)
+                        ++(*num_colors);
+        } while (ch != EOF);
+
+        if (-1 == fseek(fstream, 0L, SEEK_SET))
+                bail_out("rewinding file failed");
+
+        *colors = calloc(*num_colors, sizeof(*colors));
+        *pages = calloc(*num_colors, sizeof(*pages));
+        if (!*pages || !*colors)
+                bail_out("couldn't allocate memory");
+
+        for (line = 0; line < *num_colors && !feof(fstream); ++line) {
+
+                skip_comments(fstream);
+
+                if (2 != fscanf(fstream, "%d,%d",
+                                &(*colors)[line], &(*pages)[line])) {
+                        fprintf(stderr, "invalid color pages near line %d\n",
+                                line);
+                        exit(EXIT_FAILURE);
+                }
+
+                skip_to_next_line(fstream);
+        }
+
+        assert(line == *num_colors);
+        fclose(fstream);
+}
+
+#define OPTSTR SPIN_OPTS "x:"
+
+int main(int argc, char** argv)
+{
+        const char* file = NULL;
+        int *pages, *colors, num_colors, opt, i;
+        struct spin_opts sopts;
+
+        init_spin_opts(&sopts, usage, NULL);
+
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'x':
+                        file = optarg;
+                        break;
+                case ':':
+                        usage("Argument missing.");
+                        break;
+                case '?':
+                default:
+                        if (!do_spin_opt(&sopts, opt, optarg))
+                                usage("Bad argument.");
+                        break;
+                }
+        }
+
+        if (file) {
+                get_page_colors(file, &num_colors, &colors, &pages);
+                for (i = 0; i < num_colors; i++)
+                        printf("color %d has %d pages\n", colors[i], pages[i]);
+        }
+
+        /* setup_spin(&sopts, optind, argc, argv); */
+        return 0;
+}
diff --git a/bin/colortest.c b/bin/colortest.c
index 02a9169..bc66522 100644
--- a/bin/colortest.c
+++ b/bin/colortest.c
@@ -1,7 +1,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
-
 #include <litmus/rt_param.h>
 
 #include "color.h"
diff --git a/bin/perfcounters.c b/bin/perfcounters.c
index 6302164..975ee5b 100644
--- a/bin/perfcounters.c
+++ b/bin/perfcounters.c
@@ -39,7 +39,7 @@ struct perf_counter_setup {
 };
 
 #if 0
-/* these events are always zero */
+/* on Pound, these events are always zero */
 static struct perf_fd perf_fds[] = {
         {
                 .fd        = -1,
@@ -61,6 +61,8 @@ static struct perf_fd perf_fds[] = {
 };
 #endif
 
+#if 0
+/* these are for Pound */
 static struct perf_counter_setup perf_setup[NR_PERF_COUNTERS] = {
 #if 0
         {
@@ -108,7 +110,30 @@ static struct perf_counter_setup perf_setup[NR_PERF_COUNTERS] = {
 #endif
         },
 };
+#endif
 
+static struct perf_counter_setup perf_setup[NR_PERF_COUNTERS] = {
+        {
+                .name      = "Linux LL Cache Read Miss",
+                .type      = PERF_TYPE_HW_CACHE,
+                .config    = ATTR_CONFIG_CACHE(LL, OP_READ, RESULT_MISS),
+#if 0
+                /* read misses */
+                .config = ATTR_CONFIG_CACHE(LL, OP_READ, RESULT_MISS),
+                /* write misses */
+                .config = ATTR_CONFIG_CACHE(LL, OP_WRITE, RESULT_MISS),
+                /* prefetch misses */
+                .config = ATTR_CONFIG_CACHE(LL, OP_PREFETCH, RESULT_MISS),
+#endif
+        },
+#if (2 == NR_PERF_COUNTERS)
+        {
+                .name      = "Cycles",
+                .type      = PERF_TYPE_HARDWARE,
+                .config    = PERF_COUNT_HW_CPU_CYCLES,
+        },
+#endif
+};
 
 /* from kernel tools/perf/perf.h */
 int sys_perf_event_open(struct perf_event_attr *attr, pid_t pid,
diff --git a/bin/rtspin.c b/bin/rtspin.c
index a19637c..d823edc 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -1,15 +1,7 @@
-#include <sys/time.h>
-
-#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <time.h>
-#include <assert.h>
-#include <strings.h>
-#include <string.h>
 
-#include "litmus.h"
-#include "common.h"
+#include "spin_common.h"
 
 static void usage(char *error) {
         fprintf(stderr, "Error: %s\n", error);
@@ -20,80 +12,11 @@ static void usage(char *error) {
                 "       rt_spin -l\n"
                 "\n"
                 "COMMON-OPTS = [-w] [-p PARTITION] [-c CLASS] [-s SCALE]\n"
-                "              [-h NUM-COLORS,AVG-WAYS]\n"
                 "\n"
                 "WCET and PERIOD are milliseconds, DURATION is seconds.\n");
         exit(EXIT_FAILURE);
 }
 
-/*
- * returns the character that made processing stop, newline or EOF
- */
-static int skip_to_next_line(FILE *fstream)
-{
-        int ch;
-        for (ch = fgetc(fstream); ch != EOF && ch != '\n'; ch = fgetc(fstream));
-        return ch;
-}
-
-static void skip_comments(FILE *fstream)
-{
-        int ch;
-        for (ch = fgetc(fstream); ch == '#'; ch = fgetc(fstream))
-                skip_to_next_line(fstream);
-        ungetc(ch, fstream);
-}
-
-static void get_exec_times(const char *file, const int column,
-                           int *num_jobs,    double **exec_times)
-{
-        FILE *fstream;
-        int  cur_job, cur_col, ch;
-        *num_jobs = 0;
-
-        fstream = fopen(file, "r");
-        if (!fstream)
-                bail_out("could not open execution time file");
-
-        /* figure out the number of jobs */
-        do {
-                skip_comments(fstream);
-                ch = skip_to_next_line(fstream);
-                if (ch != EOF)
-                        ++(*num_jobs);
-        } while (ch != EOF);
-
-        if (-1 == fseek(fstream, 0L, SEEK_SET))
-                bail_out("rewinding file failed");
-
-        /* allocate space for exec times */
-        *exec_times = calloc(*num_jobs, sizeof(*exec_times));
-        if (!*exec_times)
-                bail_out("couldn't allocate memory");
-
-        for (cur_job = 0; cur_job < *num_jobs && !feof(fstream); ++cur_job) {
-
-                skip_comments(fstream);
-
-                for (cur_col = 1; cur_col < column; ++cur_col) {
-                        /* discard input until we get to the column we want */
-                        fscanf(fstream, "%*s,");
-                }
-
-                /* get the desired exec. time */
-                if (1 != fscanf(fstream, "%lf", (*exec_times)+cur_job)) {
-                        fprintf(stderr, "invalid execution time near line %d\n",
-                                        cur_job);
-                        exit(EXIT_FAILURE);
-                }
-
-                skip_to_next_line(fstream);
-        }
-
-        assert(cur_job == *num_jobs);
-        fclose(fstream);
-}
-
 #define NUMS 4096
 static int num[NUMS];
 static char* progname;
@@ -161,70 +84,27 @@ static int job(double exec_time, double program_end)
         }
 }
 
-#define OPTSTR "p:c:wlveo:f:s:h:"
+#define OPTSTR SPIN_OPTS "l"
 
 int main(int argc, char** argv)
 {
-        int ret;
-        lt_t wcet;
-        lt_t period;
-        double wcet_ms, period_ms;
-        int migrate = 0;
-        int cpu = 0;
-        int opt;
-        int wait = 0;
-        int test_loop = 0;
-        int column = 1;
-        const char *file = NULL;
-        int want_enforcement = 0;
-        double duration = 0, start;
-        double *exec_times = NULL;
-        double scale = 1.0;
-        task_class_t class = RT_CLASS_HARD;
-        int cur_job, num_jobs;
-        int task_colors = 0;
-        int avg_ways = 0;
+        int opt, test_loop = 0;
+        struct spin_opts sopts;
 
-        progname = argv[0];
+        init_spin_opts(&sopts, usage, job);
 
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
                 switch (opt) {
-                case 'w':
-                        wait = 1;
-                        break;
-                case 'p':
-                        cpu = atoi(optarg);
-                        migrate = 1;
-                        break;
-                case 'c':
-                        class = str2class(optarg);
-                        if (class == -1)
-                                usage("Unknown task class.");
-                        break;
-                case 'e':
-                        want_enforcement = 1;
-                        break;
                 case 'l':
                         test_loop = 1;
                         break;
-                case 'o':
-                        column = atoi(optarg);
-                        break;
-                case 'f':
-                        file = optarg;
-                        break;
-                case 's':
-                        scale = atof(optarg);
-                        break;
-                case 'h':
-                        sscanf(optarg, "%d,%d", &task_colors, &avg_ways);
-                        break;
                 case ':':
                         usage("Argument missing.");
                         break;
                 case '?':
                 default:
-                        usage("Bad argument.");
+                        if (!do_spin_opt(&sopts, opt, optarg))
+                                usage("Bad argument.");
                         break;
                 }
         }
@@ -234,92 +114,8 @@ int main(int argc, char** argv)
                 return 0;
         }
 
-        if (file) {
-                get_exec_times(file, column, &num_jobs, &exec_times);
-
-                if (argc - optind < 2)
-                        usage("Arguments missing.");
-
-                for (cur_job = 0; cur_job < num_jobs; ++cur_job) {
-                        /* convert the execution time to seconds */
-                        duration += exec_times[cur_job] * 0.001;
-                }
-        } else {
-                /*
-                 * if we're not reading from the CSV file, then we need
-                 * three parameters
-                 */
-                if (argc - optind < 3)
-                        usage("Arguments missing.");
-        }
-
-        wcet_ms   = atof(argv[optind + 0]);
-        period_ms = atof(argv[optind + 1]);
-
-        wcet   = wcet_ms * __NS_PER_MS;
-        period = period_ms * __NS_PER_MS;
-        if (wcet <= 0)
-                usage("The worst-case execution time must be a "
-                                "positive number.");
-        if (period <= 0)
-                usage("The period must be a positive number.");
-        if (!file && wcet > period) {
-                usage("The worst-case execution time must not "
-                                "exceed the period.");
-        }
-
-        if (!file)
-                duration  = atof(argv[optind + 2]);
-        else if (file && num_jobs > 1)
-                duration += period_ms * 0.001 * (num_jobs - 1);
-
-        if (migrate) {
-                ret = be_migrate_to(cpu);
-                if (ret < 0)
-                        bail_out("could not migrate to target partition");
-        }
-
-        ret = sporadic_task_ns(wcet, period, 0, cpu, class,
-                               want_enforcement ? PRECISE_ENFORCEMENT
-                                                : NO_ENFORCEMENT,
-                               migrate);
-        if (ret < 0)
-                bail_out("could not setup rt task params");
-
-        init_litmus();
-
-        request_resources(task_colors, avg_ways);
-
-        ret = task_mode(LITMUS_RT_TASK);
-        if (ret != 0)
-                bail_out("could not become RT task");
-
-        if (wait) {
-                ret = wait_for_ts_release();
-                if (ret != 0)
-                        bail_out("wait_for_ts_release()");
-        }
-
-        start = wctime();
-
-        if (file) {
-                /* use times read from the CSV file */
-                for (cur_job = 0; cur_job < num_jobs; ++cur_job) {
-                        /* convert job's length to seconds */
-                        job(exec_times[cur_job] * 0.001 * scale,
-                                        start + duration);
-                }
-        } else {
-                /* conver to seconds and scale */
-                while (job(wcet_ms * 0.001 * scale, start + duration));
-        }
-
-        ret = task_mode(BACKGROUND_TASK);
-        if (ret != 0)
-                bail_out("could not become regular task (huh?)");
-
-        if (file)
-                free(exec_times);
+        setup_spin(&sopts, optind, argc, argv);
+        run_spin(&sopts);
 
         return 0;
 }
diff --git a/bin/singlepage.c b/bin/singlepage.c
new file mode 100644
index 0000000..376f55d
--- /dev/null
+++ b/bin/singlepage.c
@@ -0,0 +1,158 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+
+#include <litmus/rt_param.h>
+
+#include "perfcounters.h"
+#include "color.h"
+#include "litmus.h"
+
+#define CPU             0
+#define NR_PAGES        10
+#define NR_LOOPS        10
+
+struct page {
+        struct page *ptr;
+        char _unused[PAGE_SIZE - sizeof(struct page*)];
+};
+
+/*
+ * Get a random number in [0, max). Not really a good way to do this.
+ */
+static int randrange(const int max)
+{
+        return (rand() / (RAND_MAX / max + 1));
+}
+
+/*
+ * Sattolo's algorithm makes a random cycle that includes all the elements
+ * in the items array.
+ */
+static void sattolo(int *items, const int len)
+{
+        int i;
+        /* first set up 0, 1, ..., n - 1 */
+        for (i = 0; i < len; i++)
+                items[i] = i;
+        /* note: i is now n */
+        while (1 < i--) {
+                /* 0 <= j < i */
+                int t, j = randrange(i);
+                t = items[i];
+                items[i] = items[j];
+                items[j] = t;
+        }
+}
+static struct page * do_read(struct page* page)
+{
+        struct page *old;
+        do {
+                old = page;
+                page = page->ptr;
+        } while (page);
+        return old;
+}
+
+static inline void get_counters(const struct perf_counter *pc, uint64_t *vals)
+{
+        read_perf_counter(&pc[0], &vals[0]);
+#if (2 == NR_PERF_COUNTERS)
+        read_perf_counter(&pc[1], &vals[1]);
+#endif
+}
+
+static void print_counters(uint64_t *vals, double div)
+{
+        int i;
+        for (i = 0; i < NR_PERF_COUNTERS; i++) {
+                printf("counter %d: %12lu  div: %8.3f\n", i, vals[i], vals[i] / div);
+        }
+        printf("\n");
+}
+
+#define quit_on_err(err, msg) do { \
+        if (err) { \
+                fprintf(stderr, "error: " msg); \
+                goto out; \
+        } \
+} while (0)
+
+int main(int argc, char **argv)
+{
+        static struct perf_counter perf_counters[NR_PERF_COUNTERS];
+        struct color_ctrl_page *color_ctrl;
+        struct page *pages[NR_PAGES];
+        struct page *page_ptr;
+        int read_order[NR_PAGES];
+        uint64_t counter_vals[NR_PERF_COUNTERS];
+        int i, err = 0;
+
+        err = be_migrate_to(CPU);
+        quit_on_err(err, "migrate to cpu\n");
+
+        err = setup_cpu_perf(CPU, -1, perf_counters);
+        quit_on_err(err, "setup perf\n");
+
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_DISABLE);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_RESET);
+
+
+        err = map_color_ctrl((void**)&color_ctrl);
+        quit_on_err(err, "map color ctrl\n");
+
+        color_ctrl->colors[0] = 0;
+
+        for (i = 0; i < NR_PAGES; i++) {
+                pages[i] = color_malloc(sizeof(*pages[i]));
+                if (!pages[i]) {
+                        fprintf(stderr, "could not color malloc\n");
+                        err = -1;
+                        goto out;
+                }
+        }
+
+        sattolo(read_order, NR_PAGES);
+
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_ENABLE);
+
+        for (i = 0; i < NR_PAGES; i++) {
+                if (0 != read_order[i]) {
+                        /* not the last element */
+                        pages[i]->ptr = pages[read_order[i]];
+                } else {
+                        /* last element should be NULL (terminate the cycle) */
+                        pages[i]->ptr = NULL;
+                }
+        }
+
+        get_counters(perf_counters, counter_vals);
+        print_counters(counter_vals, NR_PAGES);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_RESET);
+
+        page_ptr = do_read(pages[0]);
+        get_counters(perf_counters, counter_vals);
+        print_counters(counter_vals, NR_PAGES);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_RESET);
+
+        page_ptr = do_read(pages[0]);
+        get_counters(perf_counters, counter_vals);
+        print_counters(counter_vals, NR_PAGES);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_RESET);
+
+        page_ptr = do_read(pages[0]);
+        get_counters(perf_counters, counter_vals);
+        print_counters(counter_vals, NR_PAGES);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_RESET);
+
+        for (i = 0; i < NR_LOOPS; i++) {
+                page_ptr = do_read(pages[0]);
+        }
+        get_counters(perf_counters, counter_vals);
+        print_counters(counter_vals, NR_PAGES * NR_LOOPS);
+        ioctl(perf_counters[0].fd, PERF_EVENT_IOC_DISABLE);
+
+out:
+        return err;
+}
diff --git a/include/perfcounters.h b/include/perfcounters.h
index 03f94fb..0329921 100644
--- a/include/perfcounters.h
+++ b/include/perfcounters.h
@@ -5,7 +5,15 @@
 
 #include "../../litmus-rt/include/linux/perf_event.h"
 
-#define NR_PERF_COUNTERS        4
+/* on Pound */
+//#define NR_PERF_COUNTERS      4
+
+/*
+ * Flare: 1 gets you the L2 read misses and 2 gets you that plus the
+ * CPU clock counter. However, accessing the CPU clock will add misses
+ * when you go to read the performance counters, so I don't use it.
+ */
+#define NR_PERF_COUNTERS        1
 
 /*
  * Retain this information with a performance counter file descriptor.
diff --git a/include/spin_common.h b/include/spin_common.h
new file mode 100644
index 0000000..977c201
--- /dev/null
+++ b/include/spin_common.h
@@ -0,0 +1,42 @@
+#ifndef SPIN_COMMON_H_
+#define SPIN_COMMON_H_
+
+#include <stdio.h>
+#include "litmus.h"
+
+#define SPIN_OPTS "p:c:weo:f:s:"
+
+typedef void (*usage_t)(char *error);
+typedef int (*job_t)(double exec, double end);
+
+struct spin_opts {
+        usage_t         usage;
+        job_t           job;
+
+        int             wait;
+        int             cpu;
+        int             migrate;
+        int             column;
+        int             want_enforcement;
+        double          scale;
+        task_class_t    class;
+        const char*     file;
+
+        int             num_jobs;
+        double          duration;
+        double         *exec_times;
+        double          wcet;
+        double          period;
+};
+
+void init_spin_opts(struct spin_opts *sopts, usage_t usage, job_t job);
+
+int skip_to_next_line(FILE *fstream);
+void skip_comments(FILE *fstream);
+
+int do_spin_opt(struct spin_opts *sopts, int opt, const char *optarg);
+
+void setup_spin(struct spin_opts *sopts, int last, int argc, char** argv);
+void run_spin(struct spin_opts *sopts);
+
+#endif
diff --git a/src/spin_common.c b/src/spin_common.c
new file mode 100644
index 0000000..157a9bb
--- /dev/null
+++ b/src/spin_common.c
@@ -0,0 +1,235 @@
+#include <stdlib.h>
+#include <assert.h>
+
+#include "spin_common.h"
+#include "common.h"
+
+/*
+ * returns the character that made processing stop, newline or EOF
+ */
+int skip_to_next_line(FILE *fstream)
+{
+        int ch;
+        for (ch = fgetc(fstream); ch != EOF && ch != '\n'; ch = fgetc(fstream));
+        return ch;
+}
+
+void skip_comments(FILE *fstream)
+{
+        int ch;
+        for (ch = fgetc(fstream); ch == '#'; ch = fgetc(fstream))
+                skip_to_next_line(fstream);
+        ungetc(ch, fstream);
+}
+
+static void get_exec_times(const char *file, const int column,
+                           int *num_jobs,    double **exec_times)
+{
+        FILE *fstream;
+        int  curr_job, cur_col, ch;
+        *num_jobs = 0;
+
+        fstream = fopen(file, "r");
+        if (!fstream)
+                bail_out("could not open execution time file");
+
+        /* figure out the number of jobs */
+        do {
+                skip_comments(fstream);
+                ch = skip_to_next_line(fstream);
+                if (ch != EOF)
+                        ++(*num_jobs);
+        } while (ch != EOF);
+
+        if (-1 == fseek(fstream, 0L, SEEK_SET))
+                bail_out("rewinding file failed");
+
+        /* allocate space for exec times */
+        *exec_times = calloc(*num_jobs, sizeof(*exec_times));
+        if (!*exec_times)
+                bail_out("couldn't allocate memory");
+
+        for (curr_job = 0; curr_job < *num_jobs && !feof(fstream); ++curr_job) {
+
+                skip_comments(fstream);
+
+                for (cur_col = 1; cur_col < column; ++cur_col) {
+                        /* discard input until we get to the column we want */
+                        fscanf(fstream, "%*s,");
+                }
+
+                /* get the desired exec. time */
+                if (1 != fscanf(fstream, "%lf", (*exec_times)+curr_job)) {
+                        fprintf(stderr, "invalid execution time near line %d\n",
+                                        curr_job);
+                        exit(EXIT_FAILURE);
+                }
+
+                skip_to_next_line(fstream);
+        }
+
+        assert(curr_job == *num_jobs);
+        fclose(fstream);
+}
+
+
+
+int do_spin_opt(struct spin_opts *sopts, int opt, const char *optarg)
+{
+        int ret = 1;
+
+        switch (opt) {
+        case 'w':
+                sopts->wait = 1;
+                break;
+        case 'p':
+                sopts->cpu = atoi(optarg);
+                sopts->migrate = 1;
+                break;
+        case 'c':
+                sopts->class = str2class(optarg);
+                if (sopts->class == -1)
+                        sopts->usage("Unknown task class.");
+                break;
+        case 'e':
+                sopts->want_enforcement = 1;
+                break;
+        case 'o':
+                sopts->column = atoi(optarg);
+                break;
+        case 'f':
+                sopts->file = optarg;
+                break;
+        case 's':
+                sopts->scale = atof(optarg);
+                break;
+        default:
+                ret = 0;
+        }
+
+        return ret;
+}
+
+void init_spin_opts(struct spin_opts *sopts, usage_t usage, job_t job)
+{
+        sopts->usage = usage;
+        sopts->job = job;
+
+        sopts->wait = 0;
+        sopts->cpu = 0;
+        sopts->migrate = 0;
+        sopts->column = 1;
+        sopts->want_enforcement = 0;
+        sopts->scale = 1.0;
+        sopts->class = RT_CLASS_HARD;
+        sopts->file = NULL;
+
+        sopts->num_jobs = 0;
+        sopts->duration = 0;
+        sopts->exec_times = NULL;
+
+        sopts->wcet = 0;
+        sopts->period = 0;
+}
+
+
+void setup_spin(struct spin_opts *sopts, int last, int argc, char** argv)
+{
+        int ret;
+        double wcet_ns, period_ns;
+        int curr_job;
+
+        if (sopts->file) {
+                get_exec_times(sopts->file, sopts->column,
+                               &sopts->num_jobs, &sopts->exec_times);
+
+                if (argc - last < 2)
+                        sopts->usage("Arguments missing.");
+
+                for (curr_job = 0; curr_job < sopts->num_jobs; ++curr_job) {
+                        /* convert the execution time to seconds */
+                        sopts->duration += sopts->exec_times[curr_job] * 0.001;
+                }
+        } else {
+                /*
+                 * if we're not reading from the CSV file, then we need
+                 * three parameters
+                 */
+                if (argc - last < 3)
+                        sopts->usage("Arguments missing.");
+        }
+
+        sopts->wcet   = atof(argv[last + 0]);
+        sopts->period = atof(argv[last + 1]);
+
+        wcet_ns   = sopts->wcet * __NS_PER_MS;
+        period_ns = sopts->period * __NS_PER_MS;
+        if (wcet_ns <= 0)
+                sopts->usage("The worst-case execution time must be a "
+                                "positive number.");
+        if (period_ns <= 0)
+                sopts->usage("The period must be a positive number.");
+        if (!sopts->file && wcet_ns > period_ns) {
+                sopts->usage("The worst-case execution time must not "
+                             "exceed the period.");
+        }
+
+        if (!sopts->file)
+                sopts->duration  = atof(argv[last + 2]);
+        else if (sopts->file && sopts->num_jobs > 1)
+                sopts->duration += period_ns * 0.001 * (sopts->num_jobs - 1);
+
+        if (sopts->migrate) {
+                ret = be_migrate_to(sopts->cpu);
+                if (ret < 0)
+                        bail_out("could not migrate to target partition");
+        }
+
+        ret = sporadic_task_ns(wcet_ns, period_ns, 0,
+                               sopts->cpu, sopts->class,
+                               sopts->want_enforcement ? PRECISE_ENFORCEMENT
+                                                       : NO_ENFORCEMENT,
+                               sopts->migrate);
+
+        if (ret < 0)
+                bail_out("could not setup rt task params");
+}
+
+void run_spin(struct spin_opts *sopts)
+{
+        double end, scale;
+        int ret, curr_job;
+
+        init_litmus();
+
+        ret = task_mode(LITMUS_RT_TASK);
+        if (ret != 0)
+                bail_out("could not become RT task");
+
+        if (sopts->wait) {
+                ret = wait_for_ts_release();
+                if (ret != 0)
+                        bail_out("wait_for_ts_release()");
+        }
+
+        scale = .001 * sopts->scale;
+        end = wctime() + sopts->duration;
+
+        if (sopts->file) {
+                /* use times read from the CSV file */
+                for (curr_job = 0; curr_job < sopts->num_jobs; ++curr_job) {
+                        /* convert job's length to seconds */
+                        sopts->job(sopts->exec_times[curr_job] * scale, end);
+                }
+        } else {
+                /* conver to seconds and scale */
+                while (sopts->job(sopts->wcet * scale, end));
+        }
+
+        ret = task_mode(BACKGROUND_TASK);
+        if (ret != 0)
+                bail_out("could not become regular task (huh?)");
+
+        if (sopts->file)
+                free(sopts->exec_times);
+}