chrislo-sourceclassifier 0.2.0

data/sources/gcc/mandelbrot.gcc-2.gcc

@@ -0,0 +1,63 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+
+   contributed by Greg Buchholz
+   
+   for the debian (AMD) machine...
+   compile flags:  -O3 -ffast-math -march=athlon-xp -funroll-loops
+
+   for the gp4 (Intel) machine...
+   compile flags:  -O3 -ffast-math -march=pentium4 -funroll-loops
+*/
+
+#include<stdio.h>
+
+int main (int argc, char **argv)
+{
+    int w, h, bit_num = 0;
+    char byte_acc = 0;
+    int i, iter = 50;
+    double x, y, limit = 2.0;
+    double Zr, Zi, Cr, Ci, Tr, Ti;
+    
+    w = h = atoi(argv[1]);
+
+    printf("P4\n%d %d\n",w,h);
+
+    for(y=0;y<h;++y) 
+    {
+        for(x=0;x<w;++x)
+        {
+            Zr = Zi = Tr = Ti = 0.0;
+            Cr = (2.0*x/w - 1.5); Ci=(2.0*y/h - 1.0);
+        
+            for (i=0;i<iter && (Tr+Ti <= limit*limit);++i)
+            {
+                Zi = 2.0*Zr*Zi + Ci;
+                Zr = Tr - Ti + Cr;
+                Tr = Zr * Zr;
+                Ti = Zi * Zi;
+            }
+       
+            byte_acc <<= 1; 
+            if(Tr+Ti <= limit*limit) byte_acc |= 0x01;
+                
+            ++bit_num; 
+
+            if(bit_num == 8)
+            {
+                putc(byte_acc,stdout);
+                byte_acc = 0;
+                bit_num = 0;
+            }
+            else if(x == w-1)
+            {
+                byte_acc <<= (8-w%8);
+                putc(byte_acc,stdout);
+                byte_acc = 0;
+                bit_num = 0;
+            }
+        }
+    }	
+}
+

data/sources/gcc/mandelbrot.gcc-3.gcc

@@ -0,0 +1,91 @@
+/*The Computer Language Shootout
+  http://shootout.alioth.debian.org/
+
+  contributed by Greg Buchholz
+
+  Uses SSE packed doubles to run the inner loop computations in parallel.
+  I don't have a machine with SSE to test with, but the assembly looks
+  pretty nice.  With gcc-3.4.2 there's no difference in the assembly 
+  between -msse2 and -msse3, YMMV.  It uses gcc's vector extentions
+  ( http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Vector-Extensions.html ), 
+  so it will run (slowly) on hardware without SSE.  
+  
+  compile (AMD):
+  gcc -D_ISOC9X_SOURCE -O3 -mfpmath=sse -msse2 -march=athlon-xp 
+      -ffast-math -funroll-loops -o mandelbrot.gcc-3.gcc_run mandelbrot.c -lm
+  
+  compile (INTEL):
+  gcc -D_ISOC9X_SOURCE -O3 -mfpmath=sse -msse2 -march=pentium4
+      -ffast-math -funroll-loops -o mandelbrot.gcc-3.gcc_run mandelbrot.c -lm
+*/
+
+#include<stdio.h>
+#include<math.h>
+#include<fenv.h>
+typedef double v2df __attribute__ ((mode(V2DF))); // vector of two double floats
+
+int main (int argc, char **argv)
+{
+    int w, h, bit_num = 0;
+    char byte_acc = 0;
+    int i, iter = 50;
+    double x, y, limit_sqr = 4.0;
+    v2df Zrv, Ziv, Crv, Civ, Trv, Tiv;
+    v2df zero, one, _1p5, two;
+    double *Zr = (double*)&Zrv, *Zi = (double*)&Ziv, 
+           *Cr = (double*)&Crv, *Ci = (double*)&Civ, 
+           *Tr = (double*)&Trv, *Ti = (double*)&Tiv;
+
+#define initv(name, val) *((double*)&name)   = (double) val; \
+                         *((double*)&name+1) = (double) val
+    initv(zero,0.0); initv(one,1.0); initv(_1p5,1.5); initv(two,2.0);
+    
+    w = h = atoi(argv[1]);
+
+    printf("P4\n%d %d\n",w,h);
+
+    for(y=0;y<h;++y) 
+    {
+        for(x=0;x<w;x+=2)
+        {
+            Zrv = Ziv = Trv = Tiv = zero;
+            *Cr = x/w;  *(Cr+1) = (x+1.0)/w;   
+            *Ci = y/h;  *(Ci+1) = *Ci;
+            Crv = two * Crv - _1p5;
+            Civ = two * Civ - one;
+            
+            for (i=0;i<iter && (islessequal( *Tr    +  *Ti,   limit_sqr) || 
+                                islessequal(*(Tr+1) + *(Ti+1),limit_sqr)   ); ++i)
+            {
+                Ziv = two*Zrv*Ziv + Civ;
+                Zrv = Trv - Tiv + Crv;
+                Trv = Zrv * Zrv;
+                Tiv = Ziv * Ziv;
+            }
+       
+            byte_acc <<= 2; 
+            if(islessequal(*Tr + *Ti, limit_sqr))
+                byte_acc |= 0x02;
+            
+            if(islessequal(*(Tr+1) + *(Ti+1), limit_sqr))
+                byte_acc |= 0x01;
+                
+            bit_num+=2; 
+
+            if(bit_num == 8)
+            {
+                putc(byte_acc,stdout);
+                byte_acc = 0;
+                bit_num = 0;
+            }
+            else if(x == w-1)
+            {
+                byte_acc <<= (8-w%8);
+                putc(byte_acc,stdout);
+                byte_acc = 0;
+                bit_num = 0;
+            }
+        }
+    }	
+}
+

data/sources/gcc/mandelbrot.gcc-4.gcc

@@ -0,0 +1,78 @@
+/*The Computer Language Benchmarks Game
+  http://shootout.alioth.debian.org/
+
+  contributed by Paolo Bonzini
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef double v2df __attribute__ ((vector_size(16))); // vector of two double floats
+typedef int v4si __attribute__ ((vector_size(16))); // vector of four 32-bit ints
+
+int main (int argc, char **argv)
+{
+    int w, h, bit_num = 0;
+    char byte_acc = 0;
+    int i, iter = 50;
+    double x, y;
+    v2df zero = { 0.0, 0.0 };
+    v2df four = { 4.0, 4.0 };
+    v2df nzero = -zero;
+
+    /* Detect endianness.  */
+    v4si mask = (v4si)nzero;
+    int *pmask = (int *) &mask;
+    if (pmask[1]) pmask++;
+
+    w = h = atoi(argv[1]);
+
+    printf("P4\n%d %d\n",w,h);
+
+    for(y=0;y<h;++y)
+    {
+        for(x=0;x<w;x+=2)
+        {
+	    v2df Crv = { 2*x/w-1.5, 2*(x+1.0)/w-1.5 };
+	    v2df Civ = { 2*y/h-1.0, 2*y/h-1.0 };
+	    v2df Zrv = { 0.0, 0.0 };
+	    v2df Ziv = { 0.0, 0.0 };
+            v2df Trv = { 0.0, 0.0 };
+	    v2df Tiv = { 0.0, 0.0 };
+
+            i = 0;
+            do {
+                Ziv = (Zrv*Ziv) + (Zrv*Ziv) + Civ;
+                Zrv = Trv - Tiv + Crv;
+                Trv = Zrv * Zrv;
+                Tiv = Ziv * Ziv;
+
+		/* sign bit zeroed if 4.0 - Trv - Tiv >= 0.0 (i.e. |Z| <= 4.0).  */
+		v2df delta = four - Trv - Tiv;
+		mask = (v4si)delta & (v4si)nzero;
+            } while (++i < iter && !(pmask[0] && pmask[2]));
+
+            byte_acc <<= 2;
+            if(!pmask[0])
+                byte_acc |= 0x02;
+            if(!pmask[2])
+                byte_acc |= 0x01;
+            bit_num+=2;
+
+            if(bit_num == 8) {
+                fputc(byte_acc,stdout);
+                byte_acc = 0;
+                bit_num = 0;
+            }
+        }
+
+        if(bit_num != 0) {
+            byte_acc <<= (8-w%8);
+            fputc(byte_acc,stdout);
+            byte_acc = 0;
+            bit_num = 0;
+        }
+    }
+}
+

data/sources/gcc/matrix.gcc

@@ -0,0 +1,66 @@
+/* -*- mode: c -*-
+ * $Id: matrix.gcc,v 1.1.1.1 2004-05-19 18:10:33 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define SIZE 30
+
+int **mkmatrix(int rows, int cols) {
+    int i, j, count = 1;
+    int **m = (int **) malloc(rows * sizeof(int *));
+    for (i=0; i<rows; i++) {
+	m[i] = (int *) malloc(cols * sizeof(int));
+	for (j=0; j<cols; j++) {
+	    m[i][j] = count++;
+	}
+    }
+    return(m);
+}
+
+void zeromatrix(int rows, int cols, int **m) {
+    int i, j;
+    for (i=0; i<rows; i++)
+	for (j=0; j<cols; j++)
+	    m[i][j] = 0;
+}
+
+void freematrix(int rows, int **m) {
+    while (--rows > -1) { free(m[rows]); }
+    free(m);
+}
+
+int **mmult(int rows, int cols, int **m1, int **m2, int **m3) {
+    int i, j, k, val;
+    for (i=0; i<rows; i++) {
+	for (j=0; j<cols; j++) {
+	    val = 0;
+	    for (k=0; k<cols; k++) {
+		val += m1[i][k] * m2[k][j];
+	    }
+	    m3[i][j] = val;
+	}
+    }
+    return(m3);
+}
+
+int main(int argc, char *argv[]) {
+    int i, n = ((argc == 2) ? atoi(argv[1]) : 1);
+	
+    int **m1 = mkmatrix(SIZE, SIZE);
+    int **m2 = mkmatrix(SIZE, SIZE);
+    int **mm = mkmatrix(SIZE, SIZE);
+
+    for (i=0; i<n; i++) {
+	mm = mmult(SIZE, SIZE, m1, m2, mm);
+    }
+    printf("%d %d %d %d\n", mm[0][0], mm[2][3], mm[3][2], mm[4][4]);
+
+    freematrix(SIZE, m1);
+    freematrix(SIZE, m2);
+    freematrix(SIZE, mm);
+    return(0);
+}

data/sources/gcc/message.gcc-2.gcc

@@ -0,0 +1,72 @@
+/* The Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+ * contributed contributed by Colin Gibbs
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ucontext.h>
+
+#define STACK_SIZE 1024
+
+struct thread_context {
+   struct thread_context *next;
+   ucontext_t ctx;
+   int value;
+   char stack[STACK_SIZE];
+};
+
+static void thread(struct thread_context *c)
+{
+   while (1) {
+      c->next->value = c->value + 1;
+      swapcontext(&c->ctx, &c->next->ctx);
+   }
+}
+
+static void create_threads(struct thread_context **head, struct thread_context **tail, int n)
+{
+   struct thread_context *c;
+   typedef void (*thread_t)(void);
+
+   c = malloc(sizeof(*c));
+   *head = c;
+
+   getcontext(&c->ctx);
+   c->ctx.uc_stack.ss_sp = c->stack;
+   c->ctx.uc_stack.ss_size = sizeof(c->stack);
+   makecontext(&c->ctx, (thread_t)thread, 1, c);
+
+   if (n > 1) {
+      create_threads(&c->next, tail, n - 1);
+   } else {
+      c->next = NULL;
+      *tail = c;
+   }
+}
+
+static int call_threads(struct thread_context *head, struct thread_context *tail)
+{
+   struct thread_context here;
+   tail->next = &here;
+   head->value = 0;
+   swapcontext(&here.ctx, &head->ctx);
+   return here.value;
+}
+
+int main(int argc, char **argv)
+{
+   int n, i, count;
+   struct thread_context *head, *tail;
+
+   n = atoi(argv[1]);
+   create_threads(&head, &tail, 500);
+
+   count = 0;
+   for (i = 0; i < n; i++)
+      count += call_threads(head, tail);
+
+   printf("%d\n", count);
+
+   return 0;
+}

data/sources/gcc/message.gcc-3.gcc

@@ -0,0 +1,64 @@
+/* The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ * contributed contributed by Ian Chiew
+ */
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define THREADS 500
+#define THREAD_STACK_SIZE (1024 * 100)
+
+struct inbox {
+    sem_t sem;
+    int n;
+};
+
+struct worker {
+    struct inbox inbox, *next_inbox;
+    pthread_t thread;
+};
+
+void *work(void *data) {
+    struct worker *worker = (struct worker *)data;
+
+    while (1) {
+        assert(sem_wait(&worker->inbox.sem) == 0);
+        worker->next_inbox->n = worker->inbox.n + 1;
+        assert(sem_post(&worker->next_inbox->sem) == 0);
+    }
+
+    return NULL;
+}
+
+int main(int argc, char **argv) {
+    struct worker workers[THREADS];
+    struct inbox main_inbox;
+    pthread_attr_t attr;
+    int n, i, j, sum = 0;
+
+    assert(argc == 2 && (n = atoi(argv[1])) != -1);
+    assert(sem_init(&main_inbox.sem, 0, 0) == 0);
+    assert(pthread_attr_init(&attr) == 0);
+    assert(pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE) == 0);
+
+    for (i = 0; i < THREADS; i++) {
+        workers[i].next_inbox = i == 0 ? &main_inbox : &workers[i - 1].inbox;
+        sem_init(&workers[i].inbox.sem, 0, 0);
+        assert(pthread_create(&workers[i].thread, &attr, work, &workers[i]) == 0);
+    }
+
+    for (j = 0; j < n; j++)
+    {
+        workers[THREADS - 1].inbox.n = 0;
+        assert(sem_post(&workers[THREADS - 1].inbox.sem) == 0);
+        assert(sem_wait(&main_inbox.sem) == 0);
+        sum += main_inbox.n;
+    }
+
+    printf("%d\n", sum);
+    exit(0);
+}

data/sources/gcc/methcall.gcc

@@ -0,0 +1,89 @@
+/* -*- mode: c -*-
+ * $Id: methcall.gcc,v 1.1.1.1 2004-05-19 18:10:40 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+enum {false, true};
+
+#define TOGGLE \
+    char state; \
+    char (*value)(struct Toggle *); \
+    struct Toggle *(*activate)(struct Toggle *)
+
+#define DESTROY  free
+
+typedef struct Toggle {
+    TOGGLE;
+} Toggle;
+
+char toggle_value(Toggle *this) {
+    return(this->state);
+}
+Toggle *toggle_activate(Toggle *this) {
+    this->state = !this->state;
+    return(this);
+}
+Toggle *init_Toggle(Toggle *this, char start_state) {
+    this->state = start_state;
+    this->value = toggle_value;
+    this->activate = toggle_activate;
+    return(this);
+}
+Toggle *new_Toggle(char start_state) {
+    Toggle *this = (Toggle *)malloc(sizeof(Toggle));
+    return(init_Toggle(this, start_state));
+}
+
+
+typedef struct NthToggle {
+    TOGGLE;
+    int count_max;
+    int counter;
+} NthToggle;
+
+NthToggle *nth_toggle_activate(NthToggle *this) {
+    if (++this->counter >= this->count_max) {
+	this->state = !this->state;
+	this->counter = 0;
+    }
+    return(this);
+}
+NthToggle *init_NthToggle(NthToggle *this, int max_count) {
+    this->count_max = max_count;
+    this->counter = 0;
+    this->activate = (Toggle *(*)(Toggle *))nth_toggle_activate;
+    return(this);
+}
+NthToggle *new_NthToggle(char start_state, int max_count) {
+    NthToggle *this = (NthToggle *)malloc(sizeof(NthToggle));
+    this = (NthToggle *)init_Toggle((Toggle *)this, start_state);
+    return(init_NthToggle(this, max_count));
+}
+
+
+int main(int argc, char *argv[]) {
+    int i, n = ((argc == 2) ? atoi(argv[1]) : 1);
+    Toggle *tog;
+    NthToggle *ntog;
+    char val = true;
+
+    tog = new_Toggle(true);
+    for (i=0; i<n; i++) {
+	val = tog->activate(tog)->value(tog);
+    }
+    fputs(val ? "true\n" : "false\n", stdout);
+    DESTROY(tog);
+    
+    val = true;
+    ntog = new_NthToggle(val, 3);
+    for (i=0; i<n; i++) {
+	val = ntog->activate(ntog)->value(ntog);
+    }
+    fputs(val ? "true\n" : "false\n", stdout);
+    DESTROY(ntog);
+    return 0;
+}