7 files changed, 224 insertions, 18 deletions

diff --git a/Makefile b/Makefile
index 5527862..b4600fc 100644
--- a/Makefile
+++ b/Makefile
@@ -72,7 +72,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 colortest colorbench testcounters bespin
+          base_mt_task runtests colortest colorbench testcounters singlepage
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -236,6 +236,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 =
+
 obj-testcounters = testcounters.o
 lib-testcounters =
 
@@ -244,7 +247,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/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/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.