Color tools checkpoint.

4 files changed, 410 insertions, 3 deletions

diff --git a/.gitignore b/.gitignore
index 255ac82..07d6c61 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,8 @@ rtspin
 cycles
 measure_syscall
 colortest
+colorbench
+testcounters
 
 # build system files
 .config
diff --git a/Makefile b/Makefile
index 7a95b91..1a48d8f 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 colortest colorbench
+          base_mt_task runtests colortest colorbench testcounters
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -222,6 +222,9 @@ lib-colortest = -static
 obj-colorbench = colorbench.o color.o
 lib-colorbench = -lpthread -lrt
 
+obj-testcounters = testcounters.o
+lib-testcounters =
+
 # ##############################################################################
 # Build everything that depends on liblitmus.
 
@@ -265,7 +268,7 @@ $(error Cannot build without access to the LITMUS^RT kernel source)
 endif
 
 kernel-unistd-hdrs := $(foreach file,${unistd-headers},${LITMUS_KERNEL}/$(file))
-hdr-ok     := $(shell egrep '\#include ["<]litmus/unistd' ${kernel-unistd-hdrs} )
+hdr-ok     := $(shell egrep '\#include .*litmus/unistd' ${kernel-unistd-hdrs} )
 ifeq ($(strip $(hdr-ok)),)
 $(info (!!) Could not find LITMUS^RT system calls in ${kernel-unistd-hdrs}.)
 $(error Your kernel headers do not seem to be LITMUS^RT headers)
diff --git a/bin/colorbench.c b/bin/colorbench.c
index 0212d9c..cf0b927 100644
--- a/bin/colorbench.c
+++ b/bin/colorbench.c
@@ -14,7 +14,7 @@
 #include "color.h"
 
 #define DEBUG           1
-#define NR_LOOPS        1000
+#define NR_LOOPS        10
 
 /* pick ONE of these */
 #define TIME_MONO       1       /* monotonic time */
@@ -45,6 +45,7 @@
 
 #define PAGE_LOWER      ((PAGE_SIZE - 1))
 #define ARENA_INTS      (arena_size / sizeof(int))
+#define ARENA_LINES     (arena_size / LINE_SIZE)
 
 #define THREAD_CPU(t)   (t * (NR_CPUS / nr_threads))
 
diff --git a/bin/testcounters.c b/bin/testcounters.c
new file mode 100644
index 0000000..207851a
--- /dev/null
+++ b/bin/testcounters.c
@@ -0,0 +1,401 @@
+#if 0
+/* done in Makefile */
+#define _GNU_SOURCE        /* or _BSD_SOURCE or _SVID_SOURCE */
+#endif
+
+#include "asm/unistd.h"         /* from kernel source tree */
+#include <unistd.h>             /* for syscall */
+
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <stdint.h>     /* rt_param needs uint32 */
+
+#include "../../litmus-rt/include/linux/perf_event.h"
+
+#include <litmus/rt_param.h> /* page size macro */
+
+/* from kernel tools/perf/perf.h */
+static inline int sys_perf_event_open(struct perf_event_attr *attr, pid_t pid,
+                int cpu, int group_fd, unsigned long flags)
+{
+        attr->size = sizeof(*attr);
+        return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
+}
+
+#define C(x)    (PERF_COUNT_HW_CACHE_##x)
+#define ATTR_CONFIG_CACHE(cache, op, result) \
+        (((C(cache)  & 0xffULL) <<  0) | \
+         ((C(op)     & 0xffULL) <<  8) | \
+         ((C(result) & 0xffULL) << 16))
+
+#define ATTR_CONFIG(event, umask)   \
+        ((((event) & 0xffULL) << 0) | \
+         (((umask) & 0xffULL) << 8))
+
+struct perf_event_attr perf_event_attr = {
+        .type            = 0,     /* set per initilized event */
+        .size            = 0,     /* set later */
+        .config          = 0,     /* set per initilized event */
+        { .sample_period = 0, }, /* is a counter, so no period */
+        .disabled        = 0,     /* event is enabled */
+        .inherit         = 0,     /* children don't inherit */
+        .pinned          = 0,     /* set per initilized event */
+        .exclusive       = 0,     /* set per initilized event */
+        .exclude_user    = 0,     /* don't count user      */
+        .exclude_kernel  = 0,     /* ditto kernel          */
+        .exclude_hv      = 0,     /* ditto hypervisor      */
+        .exclude_idle    = 0,     /* don't count when idle */
+        .mmap            = 0,     /* include mmap data     */
+        .comm            = 0,     /* include comm data     */
+};
+
+/* Pound */
+#define NR_CPUS         4
+#define CACHE_SIZE_MB   8
+#define ASSOC           16
+#define LINE_SIZE       64
+#define CACHE_SIZE      (CACHE_SIZE_MB * 1024 * 1024)
+
+/* arena size in bytes */
+//#define ARENA_SIZE    (CACHE_SIZE * 14 / 16)
+#define ARENA_SIZE      (CACHE_SIZE * 1)
+
+/* number of pages in arena */
+#define ARENA_PAGES     (ARENA_SIZE / PAGE_SIZE)
+
+/* number of cache lines per page */
+#define PAGE_LINES      (PAGE_SIZE / LINE_SIZE)
+
+/* number of cache lines in arena */
+#define ARENA_LINES     (ARENA_SIZE / LINE_SIZE)
+
+/* number of integers in arena */
+#define ARENA_INTS      (ARENA_SIZE / sizeof(int))
+
+/* number of integers in a page */
+#define PAGE_INTS       (PAGE_SIZE / sizeof(int))
+
+/* number of integers in a cache line */
+#define LINE_INTS       (LINE_SIZE / sizeof(int))
+
+/* convert page number and cache line number to an integer index */
+#define PAGE_AND_LINE_TO_IDX(page, line) \
+        (((page) * PAGE_INTS) + ((line) * LINE_INTS))
+
+
+/* not really a good way to do this */
+inline int randrange(const int max)
+{
+        return (rand() / (RAND_MAX / max + 1));
+}
+
+void sequential(int *items, const int len)
+{
+        int i;
+        for (i = 0; i < len; i++)
+                items[i] = (i + 1) % len;
+}
+
+/* Sattolo's algorithm makes a cycle. */
+void sattolo(int *items, const int len)
+{
+        int i;
+        for (i = 0; i < len; i++)
+                items[i] = i;
+        while (1 < i--) {
+                /* 0 <= j < i */
+                int t, j = randrange(i);
+                t = items[i];
+                items[i] = items[j];
+                items[j] = t;
+        }
+}
+
+/*
+ * Write the order to read the arena into the arena. Each page in the arena is
+ * read back, but the page is read in a random order to prevent the prefetcher
+ * from working.
+ */
+static void init_arena_page_line_order(int *arena, int *page_line_order)
+{
+        int cur_page;
+        for (cur_page = 0; cur_page < ARENA_PAGES; cur_page++) {
+                /* for each page in the arena */
+                int cur_line;
+                for (cur_line = 0; cur_line < PAGE_LINES; cur_line++) {
+                        /* for each line in the page */
+                        const int idx = PAGE_AND_LINE_TO_IDX(cur_page,
+                                        cur_line);
+                        const int next_line = page_line_order[cur_line];
+                        int next_idx = PAGE_AND_LINE_TO_IDX(cur_page,
+                                        next_line);
+
+                        if (!next_line) {
+                                /* special case: last line in the page */
+                                if (cur_page < ARENA_PAGES - 1) {
+                                        /* arena has more pages: go to next */
+                                        next_idx = PAGE_AND_LINE_TO_IDX(
+                                                        (cur_page + 1), 0);
+                                } else {
+                                        /* the very last element */
+                                        next_idx = 0;
+                                }
+                        }
+                        arena[idx] = next_idx;
+                }
+        }
+}
+
+static int loop_once(const int perf_fd, int *arena)
+{
+        int i = 0, j;
+        do {
+                i = arena[i];
+                j = i;
+        } while (i);
+        return j;
+}
+
+static int set_affinity(int cpu)
+{
+        cpu_set_t cpu_set;
+        CPU_ZERO(&cpu_set);
+        CPU_SET(cpu, &cpu_set);
+        return sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set);
+}
+
+struct perf_fd {
+        int                     fd;
+        char                    *name;
+        enum perf_type_id       type;
+        __u64                   config;
+        __u64                   exclusive    :  1,
+                                pinned       :  1,
+                                __reserved_1 : 62;
+};
+
+#define PERF_FD_EMPTY(p) \
+        ((p)->fd == 0 && (p)->name == NULL && \
+         (p)->type == 0 && (p)->config == 0)
+#define PERF_FD_NON_EMPTY(p) (!PERF_FD_EMPTY(p))
+
+
+#if 0
+/* these events are always zero */
+static struct perf_fd perf_fds[] = {
+        {
+                .fd        = -1,
+                .name      = "MEM_UNCORE_RETIRED.REMOTE_CACHE_LOCAL_HOME_HIT",
+                .type      = PERF_TYPE_RAW,
+                .config    = ATTR_CONFIG(0x0f, 0x08),
+                .exclusive = 0,
+                .pinned    = 0,
+        },
+        {
+                .fd     = -1,
+                .name   = "MEM_UNCORE_RETIRED.REMOTE_DRAM",
+                .type   = PERF_TYPE_RAW,
+                .config = ATTR_CONFIG(0x0f, 0x10),
+                .exclusive = 0, /* child events cannot be exclusive */
+                .pinned    = 0, /* child events cannot be pinned */
+        },
+        { },
+};
+#endif
+
+static struct perf_fd perf_fds[] = {
+        /* first element is assumed to be group leader */
+#if 0
+        {
+                .fd     = -1,
+                .name   = "MEM_UNCORE_RETIRED.LOCAL_DRAM",
+                .type   = PERF_TYPE_RAW,
+                .config = ATTR_CONFIG(0x0f, 0x20),
+                .exclusive = 1, /* group leader is scheduled exclusively */
+                .pinned    = 1, /* group leader is pinnned to CPU (always on) */
+        },
+#endif
+        {
+                .fd     = -1,
+                .name   = "L2_RQSTS.PREFETCH_HIT",
+                .type   = PERF_TYPE_RAW,
+                .config = ATTR_CONFIG(0x24, 0x40),
+#if 0
+                .exclusive = 0,
+                .pinned    = 0,
+#endif
+                .exclusive = 1, /* group leader is scheduled exclusively */
+                .pinned    = 1, /* group leader is pinnned to CPU (always on) */
+        },
+        {
+                .fd     = -1,
+                .name   = "L2_RQSTS.PREFETCH_MISS",
+                .type   = PERF_TYPE_RAW,
+                .config = ATTR_CONFIG(0x24, 0x80),
+                .exclusive = 0,
+                .pinned    = 0,
+        },
+        {
+                .fd     = -1,
+                .name   = "MEM_LOAD_RETIRED.L3_MISS",
+                .type   = PERF_TYPE_RAW,
+                .config = ATTR_CONFIG(0xcb, 0x10),
+                .exclusive = 0,
+                .pinned    = 0,
+        },
+        {
+                .fd        = -1,
+                .name      = "Off Core Response Counter",
+                .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
+                .exclusive = 0,
+                .pinned    = 0,
+        },
+        { },
+};
+
+
+static inline void events_ioctl(const int request)
+{
+        ioctl(perf_fds[0].fd, request);
+}
+
+static void do_read(double divide)
+{
+        struct perf_fd *perf_fd;
+        for (perf_fd = perf_fds; PERF_FD_NON_EMPTY(perf_fd); perf_fd++) {
+                __u64 perf_val;
+                ssize_t ret;
+                ret = read(perf_fd->fd, &perf_val, sizeof(perf_val));
+                if (0 >= ret)
+                        printf("%50s: ERROR\n", perf_fd->name);
+                else
+                        printf("%50s: %10.3f\n",
+                                        perf_fd->name, (perf_val / divide));
+                ioctl(perf_fd->fd, PERF_EVENT_IOC_RESET);
+        }
+}
+  
+static void write_global_perf_attr(struct perf_fd *perf_fd)
+{
+                perf_event_attr.type      = perf_fd->type;
+                perf_event_attr.config    = perf_fd->config;
+                perf_event_attr.exclusive = perf_fd->exclusive;
+                perf_event_attr.pinned    = perf_fd->pinned;
+}
+
+#define CPU 0
+static int setup_perf(void)
+{
+        /* cannot have pid == -1 and cpu == -1 */
+        const int perf_pid      = -1;   /* -1: all tasks, 0: this task */
+        const int perf_cpu      = CPU;  /* -1: all CPUs (follow task) */
+        struct perf_fd *perf_fd;
+        int err = 0;
+
+        for (perf_fd = perf_fds; PERF_FD_NON_EMPTY(perf_fd); perf_fd++) {
+                /* make a group whose leader is the zeroth element */
+                const int perf_group = perf_fds[0].fd;
+
+                /* setup the attributes to pass in */
+                write_global_perf_attr(perf_fd);
+
+                perf_fd->fd = sys_perf_event_open(&perf_event_attr, perf_pid,
+                                perf_cpu, perf_group, 0);
+
+                if (0 > perf_fd->fd) {
+                        fprintf(stderr, "could not setup %s\n", perf_fd->name);
+                        err = -1;
+                        goto out;
+                }
+        }
+out:
+        return err;
+}
+
+int main(int argc, char **argv)
+{
+
+        const int task_cpu = CPU;
+        int ret = 0, i;
+        int *arena, *page_line_order;
+
+        if (set_affinity(task_cpu)) {
+                fprintf(stderr, "could not set affinity\n");
+                ret = -1;
+                goto out;
+        }
+
+        arena = malloc(ARENA_SIZE);
+        if (!arena) {
+                fprintf(stderr, "could not allocate memory\n");
+                ret = -1;
+                goto out;
+        }
+
+        page_line_order = malloc(PAGE_LINES * sizeof(*page_line_order));
+        if (!page_line_order) {
+                fprintf(stderr, "could not allocate memory\n");
+                ret = -1;
+                goto out;
+        }
+
+        sattolo(page_line_order, PAGE_LINES);
+        //sequential(page_line_order, PAGE_LINES);
+        init_arena_page_line_order(arena, page_line_order);
+
+        if (setup_perf()) {
+                ret = -1;
+                goto out;
+        }
+
+        printf("arena_size:  %d\n", ARENA_SIZE);
+        printf("arena_lines: %d\n", ARENA_LINES);
+
+        printf("initially\n");
+        do_read(1.0);
+
+        events_ioctl(PERF_EVENT_IOC_ENABLE);
+        loop_once(perf_fds[0].fd, arena);
+        events_ioctl(PERF_EVENT_IOC_DISABLE);
+        printf("after a loop\n");
+        do_read(1.0);
+
+        events_ioctl(PERF_EVENT_IOC_ENABLE);
+        loop_once(perf_fds[0].fd, arena);
+        events_ioctl(PERF_EVENT_IOC_DISABLE);
+        printf("after another loop\n");
+        do_read(1.0);
+
+        events_ioctl(PERF_EVENT_IOC_ENABLE);
+        loop_once(perf_fds[0].fd, arena);
+        events_ioctl(PERF_EVENT_IOC_DISABLE);
+        printf("after another loop\n");
+        do_read(1.0);
+
+        events_ioctl(PERF_EVENT_IOC_ENABLE);
+        loop_once(perf_fds[0].fd, arena);
+        events_ioctl(PERF_EVENT_IOC_DISABLE);
+        printf("after another loop\n");
+        do_read(1.0);
+
+        events_ioctl(PERF_EVENT_IOC_ENABLE);
+        for (i = 0; i < 100; i++)
+                loop_once(perf_fds[0].fd, arena);
+        events_ioctl(PERF_EVENT_IOC_DISABLE);
+        printf("after 100 loops\n");
+        do_read(100.0);
+
+out:
+        return ret;
+}