partial benchmark program (squash this)

3 files changed, 175 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index 582e9a7..37f7d57 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
+          base_mt_task runtests colortest colorbench
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -219,6 +219,9 @@ lib-measure_syscall = -lm
 obj-colortest = colortest.o color.o
 lib-colortest = -static
 
+obj-colorbench = colorbench.o color.o
+lib-colorbench = -lpthread -static
+
 # ##############################################################################
 # Build everything that depends on liblitmus.
 
diff --git a/bin/colorbench.c b/bin/colorbench.c
new file mode 100644
index 0000000..186bf92
--- /dev/null
+++ b/bin/colorbench.c
@@ -0,0 +1,169 @@
+#include <stdint.h> /* for uint32_t */
+#include <stdlib.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/mman.h>
+
+#define DEBUG 1
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#include <litmus/rt_param.h>
+
+#include "color.h"
+
+#define NR_CPUS 4
+
+struct pthread_state {
+        int thread;
+        int retval;
+        struct color_ctrl_page *color_ctrl;
+        int *arena;
+};
+
+static pthread_mutex_t ready_mutex;
+static pthread_cond_t ready_cond;
+static int nr_ready;
+static int arena_size = 5 * PAGE_SIZE;
+
+#define ARENA_INTS (arena_size / sizeof(int))
+
+static int loop_once(struct pthread_state *state)
+{
+        int i, j = 0;
+        for (i = 0; i < ARENA_INTS; i++)
+                j += state->arena[i]++;
+        return j;
+}
+
+int thread_init(struct pthread_state *state)
+{
+        cpu_set_t cpu_set;
+        int err = 0;
+
+        CPU_ZERO(&cpu_set);
+        CPU_SET(state->thread, &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
+                goto out;
+        }
+
+        err = map_color_ctrl((void**)&state->color_ctrl);
+        if (err) {
+#ifdef DEBUG
+                fprintf(stderr, "couldn't map control device\n");
+#endif
+                goto out;
+        }
+
+        state->color_ctrl->colors[0] = state->thread;
+        state->arena = color_malloc(arena_size);
+        if (!state->arena) {
+#ifdef DEBUG
+                fprintf(stderr, "T%d: alloc arena failed\n", state->thread);
+#endif
+                err = 1;
+                goto out;
+        }
+
+        err = mlockall(MCL_CURRENT|MCL_FUTURE);
+        if (err)
+        {
+#ifdef DEBUG
+                fprintf(stderr, "T%d: mlockall failed\n", state->thread);
+#endif
+                goto out;
+        }
+out:
+        return err;
+}
+
+#define CHECKPRINT(func, ...) do { \
+        int err = func(__VA_ARGS__); \
+        if (err) \
+                fprintf(stderr, "T%d: func failed\n", state->thread); \
+} while (0)
+
+void * thread_start(void *data)
+{
+        struct pthread_state *state = (struct pthread_state*) data;
+        int i;
+
+        state->retval = thread_init(state);
+        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)
+                loop_once(state);
+out:
+        pthread_exit(&state->retval);
+}
+
+static struct pthread_state pthread_state[NR_CPUS];
+
+#define CHECK(fun, ...) { \
+        int err = fun(__VA_ARGS__); \
+        if (err) \
+                return err; \
+}
+
+int main(int argc, char **argv)
+{
+        int ret = 0, err, i;
+
+        pthread_t threads[NR_CPUS];
+        pthread_attr_t attr;
+
+        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);
+
+        for (i = 0; i < NR_CPUS; i++) {
+                pthread_state[i].thread = i;
+                CHECK(pthread_create, &threads[i], &attr, thread_start,
+                                (void*)&pthread_state[i]);
+        }
+
+        for (i = 0; i < NR_CPUS; i++) {
+                int *retval;
+                printf("join %d\n", i);
+                err = pthread_join(threads[i], (void**)&retval);
+                if (err) {
+#ifdef DEBUG
+                        fprintf(stderr, "pthread_join failed\n");
+#endif
+                        ret = err;
+                        goto out;
+                }
+                if (PTHREAD_CANCELED == retval || *retval) {
+#ifdef DEBUG
+                        fprintf(stderr, "T%d bad retval.\n", i);
+#endif
+                        ret = 1;
+                }
+        }
+
+        CHECK(pthread_cond_destroy, &ready_cond);
+        CHECK(pthread_attr_destroy, &attr);
+        CHECK(pthread_mutex_destroy, &ready_mutex);
+
+out:
+        return ret;
+}
diff --git a/include/color.h b/include/color.h
index 50707fd..dc1b1cc 100644
--- a/include/color.h
+++ b/include/color.h
@@ -1,6 +1,8 @@
 #ifndef COLOR_H
 #define COLOR_H
 
+#include <stddef.h> /* for size_t */
+
 int map_color_ctrl(void **);
 void* color_malloc(size_t);