many benchmarks runs

apps/microbench/Makefile

@@ -1,4 +1,10 @@
 NAME = microbench
-SRCS = src/bench.c src/qsort/qsort.c # $(shell find -L ./src/ -name "*.c" -o -name "*.cpp" -o -name "*.S")
+SRCS = src/bench.c \
+       src/qsort/qsort.c \
+       src/queen/queen.c \
+       src/bf/bf.c \
+       src/fib/fib.c \
+       
+       # $(shell find -L ./src/ -name "*.c" -o -name "*.cpp" -o -name "*.S")
 LIBS = klib
 include $(AM_HOME)/Makefile.app

apps/microbench/include/benchmark.h

@@ -18,19 +18,28 @@ extern "C" {
 #define REF_SCORE  100000
 
 
-#define SETTING 1
+#define SETTING 0
+
 // the list of benchmarks
-#define QSORT_SM {100,      1 KB,    0, 0x6a8e89a3}
-#define QSORT_LG {100000, 640 KB, 5519, 0x057fbc15}
+
+//                 size |  heap | time |  checksum   
+#define QSORT_SM {   100,   1 KB,     0, 0x6a8e89a3}
+#define QSORT_LG {100000, 640 KB,  5519, 0x057fbc15}
+#define QUEEN_SM {     8,   0 KB,     0, 0x0000005c}
+#define QUEEN_LG {    12,   0 KB,  5159, 0x00003778}
+#define    BF_SM {     4,  32 KB,     0, 0xa6f0079e}
+#define    BF_LG {   180,  32 KB, 26209, 0x9221e2b3}
+#define   FIB_SM {     2,   1 KB,     0, 0x7cfeddf0}
+#define   FIB_LG {    91, 256 KB, 28575, 0xebdc5f80}
+
 
 #define BENCHMARK_LIST(def) \
   def(qsort, "qsort", QSORT_SM, QSORT_LG, "Quick sort") \
-
+  def(queen, "queen", QUEEN_SM, QUEEN_LG, "Queen placement") \
+  def(   bf,    "bf",    BF_SM,    BF_LG, "Brainf**k interpreter") \
+  def(  fib,   "fib",   FIB_SM,   FIB_LG, "Fibonacci number") \
 
 /*
-  def(queen, "queen",   0 KB,  5159, true, 0x00003778, "Queen placement") \
-  def(   bf,    "bf",  32 KB, 26209, true, 0x9221e2b3, "Brainf**k interpreter") \
-  def(  fib,   "fib", 256 KB, 28575, true, 0xebdc5f80, "Fibonacci number") \
   def(sieve, "sieve",   2 MB, 42406, true, 0x000a2403, "Eratosthenes sieve") \
   def( 15pz,  "15pz",   8 MB,  5792, true, 0x00068b8c, "A* 15-puzzle search") \
   def(dinic, "dinic",   1 MB, 13536, true, 0x0000c248, "Dinic's maxflow algorithm") \

apps/microbench/src/bench.c

@@ -106,14 +106,14 @@ int main() {
 
 
 void* bench_alloc(size_t size) {
-  if ((unsigned long)start % 16 != 0) {
-    start = start + 16 - ((unsigned long)start % 16);
+  if ((uintptr_t)start % 16 != 0) {
+    start = start + 16 - ((uintptr_t)start % 16);
   }
   char *old = start;
   start += size;
-  assert((unsigned long)_heap.start <= (unsigned long)start && (unsigned long)start < (unsigned long)_heap.end);
+  assert((uintptr_t)_heap.start <= (uintptr_t)start && (uintptr_t)start < (uintptr_t)_heap.end);
   for (char *p = old; p != start; p ++) *p = '\0';
-  assert((unsigned long)start - (unsigned long)_heap.start <= setting->mlim);
+  assert((uintptr_t)start - (uintptr_t)_heap.start <= setting->mlim);
   return old;
 }
 

apps/microbench/src/bf/bf.c

@@ -23,7 +23,8 @@
 
 #include <benchmark.h>
 
-#define ARR_SIZE        180
+static int ARR_SIZE;
+
 #define CODE            ">>+>>>>>,[>+>>,]>+[--[+<<<-]<[<+>-]<[<[->[<<<+>>>>+<-]<<[>>+>[->]<<[<]" \
                         "<-]>]>>>+<[[-]<[>+<-]<]>[[>>>]+<<<-<[<<[<<<]>>+>[>>>]<-]<<[<<<]>[>>[>>" \
                         ">]<+<<[<<<]>-]]+<<<]+[->>>]>>]>>[.>>>]"
@@ -123,6 +124,7 @@ void execute_bf() {
 }
 
 void bench_bf_prepare() {
+  ARR_SIZE = setting->size;
   SP = 0;
   PROGRAM = bench_alloc(sizeof(PROGRAM[0]) * PROGRAM_SIZE);
   STACK = bench_alloc(sizeof(STACK[0]) * STACK_SIZE);
@@ -143,8 +145,7 @@ void bench_bf_run() {
   execute_bf();
 }
 
-const char * bench_bf_validate() {
+int bench_bf_validate() {
   uint32_t cs = checksum(output, output + noutput);
-  return ((noutput == ARR_SIZE && cs == current->checksum) ? \
-            NULL : "wrong answer");
+  return noutput == ARR_SIZE && cs == setting->checksum;
 }

apps/microbench/src/fib/fib.c

@@ -3,41 +3,50 @@
 // f(n) = (f(n-1) + f(n-2) + .. f(n-m)) mod 2^32
 
 #define N 2147483603
-#define M 91
-#define DIM M
+static int M;
 
-typedef uint32_t Matrix[DIM][DIM];
+static void put(uint32_t *m, int i, int j, uint32_t data) {
+  m[i * M + j] = data;
+}
 
-static inline void mult(Matrix *c, Matrix *a, Matrix *b) {
-  for (int i = 0; i < DIM; i ++)
-    for (int j = 0; j < DIM; j ++) {
-      (*c)[i][j] = 0;
-      for (int k = 0; k < DIM; k ++) {
-        (*c)[i][j] += (*a)[i][k] * (*b)[k][j];
+static uint32_t get(uint32_t *m, int i, int j) {
+  return m[i * M + j];
+}
+
+static inline void mult(uint32_t *c, uint32_t *a, uint32_t *b) {
+  for (int i = 0; i < M; i ++)
+    for (int j = 0; j < M; j ++) {
+      put(c, i, j, 0);
+      for (int k = 0; k < M; k ++) {
+        put(c, i, j, get(c, i, j) + get(a, i, k) * get(b, k, j));
       }
     }
 }
 
-static inline void assign(Matrix *a, Matrix *b) {
-  for (int i = 0; i < DIM; i ++)
-    for (int j = 0; j < DIM; j ++)
-      (*a)[i][j] = (*b)[i][j];
+static inline void assign(uint32_t *a, uint32_t *b) {
+  for (int i = 0; i < M; i ++)
+    for (int j = 0; j < M; j ++)
+      put(a, i, j, get(b, i, j));
 }
 
-static Matrix *A, *ans, *T, *tmp;
+static uint32_t *A, *ans, *T, *tmp;
 
 void bench_fib_prepare() {
-  A = bench_alloc(sizeof(Matrix));
-  T = bench_alloc(sizeof(Matrix));
-  ans = bench_alloc(sizeof(Matrix));
-  tmp = bench_alloc(sizeof(Matrix));
+  M = setting->size;
+  int sz = sizeof(uint32_t) * M * M;
+  A = bench_alloc(sz);
+  T = bench_alloc(sz);
+  ans = bench_alloc(sz);
+  tmp = bench_alloc(sz);
 }
 
 void bench_fib_run() {
-  for (int i = 0; i < DIM; i ++)
-    for (int j = 0; j < DIM; j ++) {
-      (*T)[i][j] = (*A)[i][j] = (i == DIM - 1 || j == i + 1);
-      (*ans)[i][j] = (i == j);
+  for (int i = 0; i < M; i ++)
+    for (int j = 0; j < M; j ++) {
+      uint32_t x = (i == M - 1 || j == i + 1);
+      put(A, i, j, x);
+      put(T, i, j, x);
+      put(ans, i, j, i == j);
     }
 
   for (int n = N; n > 0; n >>= 1) {
@@ -50,6 +59,6 @@ void bench_fib_run() {
   }
 }
 
-const char * bench_fib_validate() {
-  return (*ans)[DIM-1][DIM-1] == (uint32_t)current->checksum ? NULL : "wrong answer";
+int bench_fib_validate() {
+  return get(ans, M-1, M-1) == setting->checksum;
 }

apps/microbench/src/qsort/qsort.c

@@ -1,6 +1,6 @@
 #include <benchmark.h>
 
-int N, *data;
+static int N, *data;
 
 void bench_qsort_prepare() {
   bench_srand(1);

apps/microbench/src/queen/queen.c

@@ -1,15 +1,14 @@
 #include <benchmark.h>
 
-#define N 12
-#define FULL ((1 << N) - 1)
+static unsigned int FULL;
 
-static int dfs(int row, int ld, int rd) {
+static unsigned int dfs(unsigned int row, unsigned int ld, unsigned int rd) {
   if (row == FULL) {
     return 1;
   } else {
-    int pos = FULL & (~(row | ld | rd)), ans = 0;
+    unsigned int pos = FULL & (~(row | ld | rd)), ans = 0;
     while (pos) {
-      int p = (pos & (~pos + 1));
+      unsigned int p = (pos & (~pos + 1));
       pos -= p;
       ans += dfs(row | p, (ld | p) << 1, (rd | p) >> 1);
     }
@@ -17,16 +16,17 @@ static int dfs(int row, int ld, int rd) {
   }
 }
 
-static int ans;
+static unsigned int ans;
 
 void bench_queen_prepare() {
   ans = 0;
+  FULL = (1 << setting->size) - 1;
 }
 
 void bench_queen_run() {
   ans = dfs(0, 0, 0);
 }
 
-const char * bench_queen_validate() {
-  return (ans == current->checksum) ? NULL : "wrong answer";
+int bench_queen_validate() {
+  return ans == setting->checksum;
 }