bench: added benchmarks, fib.s already done

diff --git a/3_test/fib.s b/3_test/fib.s
new file mode 120000 (symlink)
index 0000000..beca666
--- /dev/null
+++ b/3_test/fib.s
@@ -0,0 +1 @@
+../8_benchs/src/fib.s
\ No newline at end of file

diff --git a/8_benchs/angabe/datadeps.s b/8_benchs/angabe/datadeps.s
new file mode 100644 (file)
index 0000000..b7a906d
--- /dev/null
+++ b/8_benchs/angabe/datadeps.s
@@ -0,0 +1,8 @@
+;;; BENCHMARK START
+       ;; implementations must retain all operations!
+       r1 = 7;
+    r2 = 5;
+    r3 = 4;
+    r4 = r2 + r3;
+    r5 = r4 & r1;
+;;; BENCHMARK END

diff --git a/8_benchs/angabe/fib.c b/8_benchs/angabe/fib.c
new file mode 100644 (file)
index 0000000..10cdd9d
--- /dev/null
+++ b/8_benchs/angabe/fib.c
@@ -0,0 +1,16 @@
+/* recursive fibonacci computation */
+/* optimization guideline: applying tail recursion optimizations is
+   okay, using an iterative algorithm is not */
+int fib(int a) {
+       if (a < 2) {
+               return 1;
+       } else {
+               return fib(a-1)+fib(a-2);
+       }
+}
+
+int main() {
+       /* BENCHMARK START */
+       return fib(9);
+       /* BENCHMARK END */
+}

diff --git a/8_benchs/angabe/max.c b/8_benchs/angabe/max.c
new file mode 100644 (file)
index 0000000..b9057f2
--- /dev/null
+++ b/8_benchs/angabe/max.c
@@ -0,0 +1,23 @@
+/* computing the maximum over an array */
+int max(int len, const int arr[]) {
+       int i;
+       int x = arr[0];
+       for (i = 1; i < len; i++) {
+               if (x < arr[i]) {
+                       x = arr[i];
+               }
+       }
+       return x;
+}
+
+int main() {
+
+       /* BENCHMARK START */
+       /* array for benchmark */
+       const int arr [] = { 2,  3,  5,  7, 11, 13, 17, 19,
+                                                23, 29, 31, 37, 41, 43, 47, 53 };
+       int retval = max(16, arr);
+       /* BENCHMARK END */
+
+       return retval;
+}

diff --git a/8_benchs/angabe/sum.c b/8_benchs/angabe/sum.c
new file mode 100644 (file)
index 0000000..4c13761
--- /dev/null
+++ b/8_benchs/angabe/sum.c
@@ -0,0 +1,20 @@
+int sum(int len, const int arr[]) {
+       int i;
+       int sum = 0;
+       for (i = 0; i < len; i++) {
+               sum += arr[i];
+       }
+       return sum;
+}
+
+int main() {
+
+       /* BENCHMARK START */
+       /* array for the benchmark */
+       const int arr [] = { 2,  3,  5,  7, 11, 13, 17, 19,
+                                                23, 29, 31, 37, 41, 43, 47, 53 };
+       int retval = sum(16, arr);
+       /* BENCHMARK END */
+
+       return retval;
+}

diff --git a/8_benchs/angabe/vm.c b/8_benchs/angabe/vm.c
new file mode 100644 (file)
index 0000000..d31264f
--- /dev/null
+++ b/8_benchs/angabe/vm.c
@@ -0,0 +1,129 @@
+/* a ridiculously simplified "virtual machine" */
+
+#include <stdint.h>
+#include <stdio.h>
+
+/* convert four int8_t values into a single int32_t value */
+static int32_t bytes_to_int(int8_t a, int8_t b, int8_t c, int8_t d) {
+       return
+                 (((int32_t)a & 0xff) << 0)
+               | (((int32_t)b & 0xff) << 8)
+               | (((int32_t)c & 0xff) << 16)
+               | (((int32_t)d & 0xff) << 24);
+}
+
+/* the stack of the virtual machine */
+int32_t stack [256];
+
+/* the interpreter for the vm */
+/* FREESTYLE OPTIMIZATIONS */
+int vm(const char *insns) 
+{
+       int pc = 0;
+       int sp = 0;
+       
+       while (insns[pc] != '\0')
+               {
+                       int8_t op = insns[pc];
+                       int32_t t;
+
+                       /* putchar(op); */
+
+                       /* printf(" %d/%d:\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\n", */
+                       /*         pc, sp, */
+                       /*         stack[0], stack[1], stack[2], stack[3], */
+                       /*         stack[4], stack[5], stack[6], stack[7]); */
+
+                       switch (op)
+                               {
+                               case '0':
+                               case '1':
+                               case '2':
+                               case '3':
+                               case '4':
+                               case '5':
+                               case '6':
+                               case '7':
+                               case '8':
+                               case '9':
+                                       stack[sp] = op-'0';
+                                       sp++;
+                                       break;
+                               case 'I': /* immediate */
+                                       stack[sp] = bytes_to_int(insns[pc+1], insns[pc+2], insns[pc+3], insns[pc+4]);
+                                       pc += 4;
+                                       sp++;
+                                       break;
+                               case 'D': /* dup */
+                                       stack[sp] = stack[sp-1];
+                                       sp++;
+                                       break;
+                               case 'X': /* exchange */
+                                       t = stack[sp-1];
+                                       stack[sp-1] = stack[sp-2];
+                                       stack[sp-2] = t;
+                                       break;
+                               case 'P': /* pop */
+                                       sp--;
+                                       break;
+                               case '+': /* add */
+                                       sp--;
+                                       stack[sp-1] = stack[sp-1] + stack[sp];
+                                       break;
+                               case '-': /* subtract */
+                                       sp--;
+                                       stack[sp-1] = stack[sp-1] - stack[sp];
+                                       break;
+                               case '*': /* multiply */
+                                       sp--;
+                                       stack[sp-1] = stack[sp-1] * stack[sp];
+                                       break;
+                               case '~': /* not */
+                                       stack[sp-1] = ~stack[sp-1];
+                                       break;
+                               case '<': /* less than */
+                                       sp--;
+                                       stack[sp-1] = stack[sp-1] < stack[sp] ? -1 : 0;
+                                       break;
+                               case 'J': /* jump if true */
+                                       sp--;
+                                       if (stack[sp] != 0) {
+                                               pc += (int8_t)insns[pc+1];
+                                       } else {
+                                               pc++;
+                                       }
+                                       break;
+                               default:
+                                       /* ignore everything else */
+                                       break;
+                               }
+                       pc++;
+               }
+
+       /* printf("  %d/%d:\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\t%08x\n", */
+       /*         pc, sp, */
+       /*         stack[0], stack[1], stack[2], stack[3], */
+       /*         stack[4], stack[5], stack[6], stack[7]); */
+
+       return stack[sp-1];
+}
+
+int main() {
+
+       /* BENCHMARK START */
+       /* you don't need to understand that code, the answer is '6' */
+       int retval = vm(
+"48*88*\
+X1-X\
+D+\
+DJ\xf8\
+P68*+\
+DI\040\0\0\0\
+<~J\005\
+P88*");        
+       /* BENCHMARK END */
+
+       putchar(retval);
+       
+       return retval;
+}

diff --git a/8_benchs/src/fib.s b/8_benchs/src/fib.s
new file mode 100644 (file)
index 0000000..222ed52
--- /dev/null
+++ b/8_benchs/src/fib.s
@@ -0,0 +1,27 @@
+.text
+main:
+       ldi r1, 1;
+       call+ fib;
+       br+ main;
+
+
+fib:  ; a = r1
+       ldi r2, 0;
+       ldi r0, 0;
+fib_2:
+       ;if(a < 2)
+       cmpi r1, 2;
+       addidlt r0, r0, 1;
+       retlt-; 
+       ;} else {
+       ;fib(a-1)
+fib_3:
+       push r1;
+       subi r1, r1, 1;
+       call+ fib_2;
+       ;fib(a-1) + fib(a-2)
+       add r2, r0, r2;
+       ;fib(a-2)
+       pop r1;
+       subi r1, r1, 2;
+       br+ fib_2;