updates to benchmarking program

3 files changed, 163 insertions, 63 deletions

diff --git a/bin/colorbench.c b/bin/colorbench.c
index 186bf92..8547bef 100644
--- a/bin/colorbench.c
+++ b/bin/colorbench.c
@@ -1,71 +1,131 @@
-#include <stdint.h> /* for uint32_t */
+#include <stdint.h> /* for uint16_t */
 #include <stdlib.h>
+#include <limits.h>
 #include <pthread.h>
 #include <sched.h>
 #include <sys/mman.h>
-
-#define DEBUG 1
-#ifdef DEBUG
+#include <errno.h>
 #include <stdio.h>
-#endif
 
 #include <litmus/rt_param.h>
 
 #include "color.h"
 
-#define NR_CPUS 4
+#define DEBUG           1
+#define NR_LOOPS        1000
+
+/* Ludwig */
+//#define NR_CPUS               6
+//#define CACHE_SIZE_MB 12
+//#define ASSOC         12
+
+/* Pound */
+//#define NR_CPUS               4
+//#define CACHE_SIZE_MB 8
+//#define ASSOC         16
+
+/* VM */
+#define NR_CPUS         4
+#define CACHE_SIZE_MB   4
+#define ASSOC           16
+
+#define LINE_SIZE       64
+#define CACHE_SIZE      (CACHE_SIZE_MB * 1024 * 1024)
+#define TOTAL_COLORS    (CACHE_SIZE / ASSOC / PAGE_SIZE)
+
+#define ARENA_PAGES     (arena_size / PAGE_SIZE)
+#define USE_COLORS      (TOTAL_COLORS >> color_shift)
+#define CONTIG_COLORS   (ARENA_PAGES / USE_COLORS)
+
+#define PAGE_LOWER      ((PAGE_SIZE - 1))
+#define ARENA_INTS      (arena_size / sizeof(int))
 
+#define THREAD_CPU(t)   (t * (NR_CPUS / nr_threads))
+
+#define FNAME_LEN 512
 struct pthread_state {
-        int thread;
+        pthread_t thread;
+        int tid;
         int retval;
         struct color_ctrl_page *color_ctrl;
         int *arena;
+        char fname[FNAME_LEN];
 };
 
-static pthread_mutex_t ready_mutex;
-static pthread_cond_t ready_cond;
-static int nr_ready;
-static int arena_size = 5 * PAGE_SIZE;
+static pthread_barrier_t barrier;
+static int nr_threads;
+static int arena_size;
+static int color_shift;
+
+#ifdef DEBUG
+#define debug_print(fmt, args...) do { \
+                fprintf(stderr, fmt, ##args); \
+        } while (0)
+#define debug_print_thread(ts, fmt, args...) do { \
+                debug_print("T%d: " fmt, ts->tid, ##args); \
+        } while (0)
+#else
+#define debug_print(fmt, args...) do {} while (0)
+#define debug_print_thread(ts, fmt, args...) do {} while (0)
+#endif
 
-#define ARENA_INTS (arena_size / sizeof(int))
+static void mk_fname(struct pthread_state *state)
+{
+        snprintf(state->fname, FNAME_LEN, "cache_size=%d_line=%d_assoc=%d_"
+                        "colors=%d_color-shift=%d_use-colors=%d_arena-size=%d_"
+                        "arena-pages=%d_contig-colors=%d_thread=%d_"
+                        "cpu=%d",
+                        CACHE_SIZE, LINE_SIZE, ASSOC, TOTAL_COLORS,
+                        color_shift, USE_COLORS, arena_size,
+                        ARENA_PAGES, CONTIG_COLORS, state->tid,
+                        THREAD_CPU(state->tid));
+}
+
+static void setup_colors(struct pthread_state *state)
+{
+        int i, j;
+        for (i = 0; i < USE_COLORS; i++) {
+                for (j = 0; j < CONTIG_COLORS; j++)
+                        state->color_ctrl->colors[CONTIG_COLORS * i + j] = i;
+        }
+}
 
 static int loop_once(struct pthread_state *state)
 {
         int i, j = 0;
-        for (i = 0; i < ARENA_INTS; i++)
-                j += state->arena[i]++;
+        for (i = 0; i < ARENA_INTS; i += 1)
+                j = state->arena[i];
         return j;
 }
 
 int thread_init(struct pthread_state *state)
 {
+        const int cpu = THREAD_CPU(state->tid);
         cpu_set_t cpu_set;
         int err = 0;
 
+        mk_fname(state);
+        debug_print_thread(state, "%s\n", state->fname);
+
         CPU_ZERO(&cpu_set);
-        CPU_SET(state->thread, &cpu_set);
+        CPU_SET(cpu, &cpu_set);
         err = sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set);
         if (err) {
-#ifdef DEBUG
-                fprintf(stderr, "T%d: set affinity failed\n", state->thread);
-#endif
+                debug_print_thread(state, "set affinity failed\n");
                 goto out;
         }
 
         err = map_color_ctrl((void**)&state->color_ctrl);
         if (err) {
-#ifdef DEBUG
-                fprintf(stderr, "couldn't map control device\n");
-#endif
+                debug_print_thread(state, "mapping control device failed\n");
                 goto out;
         }
 
-        state->color_ctrl->colors[0] = state->thread;
+        setup_colors(state);
+
         state->arena = color_malloc(arena_size);
         if (!state->arena) {
-#ifdef DEBUG
-                fprintf(stderr, "T%d: alloc arena failed\n", state->thread);
-#endif
+                debug_print_thread(state, "alloc arena failed\n");
                 err = 1;
                 goto out;
         }
@@ -73,20 +133,22 @@ int thread_init(struct pthread_state *state)
         err = mlockall(MCL_CURRENT|MCL_FUTURE);
         if (err)
         {
-#ifdef DEBUG
-                fprintf(stderr, "T%d: mlockall failed\n", state->thread);
-#endif
+                debug_print_thread(state, "mlockall failed\n");
                 goto out;
         }
 out:
         return err;
 }
 
+#ifdef DEBUG
 #define CHECKPRINT(func, ...) do { \
         int err = func(__VA_ARGS__); \
         if (err) \
-                fprintf(stderr, "T%d: func failed\n", state->thread); \
+                fprintf(stderr, "T%d: func failed\n", state->tid); \
 } while (0)
+#else
+#define CHECKPRINT(func, ...) func(__VA_ARGS__)
+#endif
 
 void * thread_start(void *data)
 {
@@ -97,72 +159,110 @@ void * thread_start(void *data)
         if (state->retval)
                 goto out;
 
-        CHECKPRINT(pthread_mutex_lock, &ready_mutex);
-        nr_ready++;
-        if (NR_CPUS == nr_ready) {
-                CHECKPRINT(pthread_cond_broadcast, &ready_cond);
-        } else {
-                while (NR_CPUS > nr_ready)
-                        CHECKPRINT(pthread_cond_wait, &ready_cond, &ready_mutex);
-        }
-        CHECKPRINT(pthread_mutex_unlock, &ready_mutex);
-
         loop_once(state);
 
-        for (i = 0; i < 1e5; ++i)
+        for (i = 0; i < NR_LOOPS; ++i) {
+                pthread_barrier_wait(&barrier);
                 loop_once(state);
+        }
 out:
         pthread_exit(&state->retval);
 }
 
-static struct pthread_state pthread_state[NR_CPUS];
+int xstrtol(char *str, long int *conv)
+{
+        char *endptr;
+        long int val;
+        int err = 0;
+
+        errno = 0;
+        val = strtol(str, &endptr, 0);
+        if (0 == val && str == endptr) {
+                err = 1;
+                goto out;
+        }
+        if (ERANGE == errno && (LONG_MIN == val || LONG_MAX == val)) {
+                err = 1;
+                goto out;
+        }
+        *conv = val;
+out:
+        return err;
+}
+
+static struct pthread_state *pthread_state;
 
 #define CHECK(fun, ...) { \
         int err = fun(__VA_ARGS__); \
-        if (err) \
+        if (err) { \
+                debug_print(#fun " failed\n"); \
                 return err; \
+        } \
 }
 
 int main(int argc, char **argv)
 {
         int ret = 0, err, i;
-
-        pthread_t threads[NR_CPUS];
+        long int strtol_val;
         pthread_attr_t attr;
 
+        if (argc < 3) {
+                debug_print("usage: %s <threads> <arena-size> <color-shift>\n",
+                                argv[0]);
+                ret = 1;
+                goto out;
+        }
+
+        err =  xstrtol(argv[1], &strtol_val);
+        nr_threads = strtol_val;
+        err |=  xstrtol(argv[2], &strtol_val);
+        arena_size = strtol_val;
+        err |= xstrtol(argv[3], &strtol_val);
+        color_shift = strtol_val;
+        if (err) {
+                debug_print("non-integer argument?\n");
+                ret = 1;
+                goto out;
+        }
+        if (arena_size & PAGE_LOWER) {
+                debug_print("arena size not page multiple\n");
+                ret = 1;
+                goto out;
+        }
+
+        pthread_state  = malloc(nr_threads * sizeof(*pthread_state));
+        if (!pthread_state) {
+                debug_print("could not malloc for state\n");
+                ret = 1;
+                goto out;
+        }
+
         CHECK(pthread_attr_init, &attr);
         CHECK(pthread_attr_setdetachstate, &attr, PTHREAD_CREATE_JOINABLE);
-        CHECK(pthread_mutex_init, &ready_mutex, NULL);
-        CHECK(pthread_cond_init, &ready_cond, NULL);
+        CHECK(pthread_barrier_init, &barrier, NULL, nr_threads);
 
-        for (i = 0; i < NR_CPUS; i++) {
-                pthread_state[i].thread = i;
-                CHECK(pthread_create, &threads[i], &attr, thread_start,
+        for (i = 0; i < nr_threads; i++) {
+                pthread_state[i].tid= i;
+                CHECK(pthread_create, &pthread_state[i].thread, &attr, thread_start,
                                 (void*)&pthread_state[i]);
         }
 
-        for (i = 0; i < NR_CPUS; i++) {
+        for (i = 0; i < nr_threads; i++) {
                 int *retval;
-                printf("join %d\n", i);
-                err = pthread_join(threads[i], (void**)&retval);
+                err = pthread_join(pthread_state[i].thread, (void**)&retval);
                 if (err) {
-#ifdef DEBUG
-                        fprintf(stderr, "pthread_join failed\n");
-#endif
+                        debug_print("pthread_join failed\n");
                         ret = err;
                         goto out;
                 }
                 if (PTHREAD_CANCELED == retval || *retval) {
-#ifdef DEBUG
-                        fprintf(stderr, "T%d bad retval.\n", i);
-#endif
+                        debug_print("bad retval T%d\n", i);
                         ret = 1;
                 }
         }
 
-        CHECK(pthread_cond_destroy, &ready_cond);
+        CHECK(pthread_barrier_destroy, &barrier);
         CHECK(pthread_attr_destroy, &attr);
-        CHECK(pthread_mutex_destroy, &ready_mutex);
 
 out:
         return ret;
diff --git a/bin/colortest.c b/bin/colortest.c
index db552be..02a9169 100644
--- a/bin/colortest.c
+++ b/bin/colortest.c
@@ -36,8 +36,8 @@ static void check_memory(const char *start, const size_t len, const char expect)
         }
 }
 
-void setup_pages(struct color_ctrl_page *ctrl, uint32_t start,
-                uint32_t nr_pages, uint32_t stride)
+void setup_pages(struct color_ctrl_page *ctrl, uint16_t start,
+                uint16_t nr_pages, uint16_t stride)
 {
         int i;
         for (i = 0; i < nr_pages; i++, start += stride)
diff --git a/bin/rtspin.c b/bin/rtspin.c
index ae76941..a6a8ac6 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -181,7 +181,7 @@ int main(int argc, char** argv)
         double *exec_times = NULL;
         double scale = 1.0;
         task_class_t class = RT_CLASS_HARD;
-        int cur_job, num_jobs;
+        int cur_job, num_jobs = 0;
 
         progname = argv[0];