chrislo-sourceclassifier 0.2.0

data/sources/gcc/binarytrees.gcc-3.gcc

@@ -0,0 +1,134 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org/
+
+   contributed by Kevin Carson
+   modified by Anthony Piron
+*/
+
+#include <malloc.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+typedef struct tn {
+    struct tn*    left;
+    struct tn*    right;
+    long          item;
+} treeNode;
+
+
+treeNode* InitTreeNode(treeNode* new, treeNode* left, treeNode* right, long item)
+{
+    new->left = left;
+    new->right = right;
+    new->item = item;
+
+    return new;
+} /* NewTreeNode() */
+
+
+long ItemCheck(treeNode* tree)
+{
+    if (tree->left == NULL)
+        return tree->item;
+    else
+        return tree->item + ItemCheck(tree->left) - ItemCheck(tree->right);
+} /* ItemCheck() */
+
+
+treeNode* BottomUpTreeBis(treeNode array[], long index, 
+			  long item, unsigned depth)
+{
+    if (depth > 0)
+        return InitTreeNode
+        (
+	    array + index,
+            BottomUpTreeBis(array, index*2+1, 2 * item - 1, depth - 1),
+            BottomUpTreeBis(array,index*2+2,  2 * item, depth - 1),
+            item
+        );
+    else
+        return InitTreeNode( array+index,NULL, NULL, item);
+} /* BottomUpTree() */
+
+treeNode* BottomUpTree(long item, unsigned depth)
+{
+  treeNode* array = malloc(sizeof(treeNode)* pow(2,depth+1) );
+
+  return BottomUpTreeBis(array,0, item, depth);
+}
+
+void DeleteTree(treeNode* tree)
+{
+
+  free(tree);
+
+} /* DeleteTree() */
+
+
+int main(int argc, char* argv[])
+{
+    unsigned   N, depth, minDepth, maxDepth, stretchDepth;
+    treeNode   *stretchTree, *longLivedTree, *tempTree;
+
+    N = atol(argv[1]);
+ 
+    minDepth = 4;
+
+    if ((minDepth + 2) > N)
+        maxDepth = minDepth + 2;
+    else
+        maxDepth = N;
+
+    stretchDepth = maxDepth + 1;
+
+    stretchTree = BottomUpTree(0, stretchDepth);
+    printf
+    (
+        "stretch tree of depth %u\t check: %li\n",
+        stretchDepth,
+        ItemCheck(stretchTree)
+    );
+
+    DeleteTree(stretchTree);
+
+    longLivedTree = BottomUpTree(0, maxDepth);
+
+    for (depth = minDepth; depth <= maxDepth; depth += 2)
+    {
+        long    i, iterations, check;
+
+        iterations = pow(2, maxDepth - depth + minDepth);
+
+        check = 0;
+
+        for (i = 1; i <= iterations; i++)
+        {
+            tempTree = BottomUpTree(i, depth);
+            check += ItemCheck(tempTree);
+            DeleteTree(tempTree);
+
+            tempTree = BottomUpTree(-i, depth);
+            check += ItemCheck(tempTree);
+            DeleteTree(tempTree);
+        } /* for(i = 1...) */
+
+        printf
+        (
+            "%li\t trees of depth %u\t check: %li\n",
+            iterations * 2,
+            depth,
+            check
+        );
+    } /* for(depth = minDepth...) */
+
+    printf
+    (
+        "long lived tree of depth %u\t check: %li\n",
+        maxDepth,
+        ItemCheck(longLivedTree)
+    );
+
+    return 0;
+} /* main() */

data/sources/gcc/chameneos.gcc

@@ -0,0 +1,117 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+
+   contributed by Josh Goldfoot
+*/
+
+#include <semaphore.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef enum { Blue, Red, Yellow, Faded } color;
+
+sem_t AtMostTwo;
+sem_t Mutex;
+sem_t SemPriv;
+
+int mpStatus = 1;
+color aColor, bColor;
+long meetingsLeft;
+long reports[4];
+
+color complementaryColor (color c1, color c2)
+{
+  if (c2 == Faded) return Faded;
+  if (c1 == c2) return c1;
+  switch (c1)
+    {
+    case Blue:
+      return c2 == Red ? Yellow : Red;
+    case Red:
+      return c2 == Blue ? Yellow : Blue;
+    case Yellow:
+      return c2 == Blue ? Red : Blue;
+    default:
+      return c1;
+    }
+}
+
+color Cooperation (int id, color c)
+{
+  color otherColor;
+
+  sem_wait (&AtMostTwo);
+  sem_wait (&Mutex);
+  switch (mpStatus)
+    {
+    case 1:
+      aColor = c;
+      mpStatus = 2;
+      sem_post (&Mutex);
+      sem_wait (&SemPriv);
+      otherColor = bColor;
+      sem_post (&Mutex);
+      sem_post (&AtMostTwo);
+      sem_post (&AtMostTwo);
+      break;
+    case 2:
+      mpStatus = (--meetingsLeft > 0 ? 1 : 3);
+      bColor = c;
+      otherColor = aColor;
+      sem_post (&SemPriv);
+      break;
+    case 3:
+    default:
+      otherColor = Faded;
+      sem_post (&Mutex);
+      sem_post (&AtMostTwo);
+    }
+  return otherColor;
+}
+
+void chameneosCode (void *args)
+{
+  int myId;
+  long meetings;
+  color myColor, otherColor;
+  sscanf ((char *) args, "%d %d", &myId, &myColor);
+  meetings = 0;
+  while (myColor != Faded)
+    {
+      otherColor = Cooperation (myId, myColor);
+      myColor = complementaryColor (myColor, otherColor);
+      meetings++;
+    }
+  reports[myId] = meetings - 1;
+}
+
+int main (int argc, char *argv[])
+{
+  color tabColor[4] = { Blue, Red, Yellow, Blue };
+  pthread_t tabPid[4];
+  char theArgs[32][4];
+  int i;
+
+  sem_init (&AtMostTwo, 0, 2);
+  sem_init (&Mutex, 0, 1);
+  sem_init (&SemPriv, 0, 0);
+
+  meetingsLeft = (argc > 1) ? atoi (argv[1]) : 1000000;
+
+  for (i = 0; i < 4; i++)
+    {
+      sprintf (theArgs[i], "%d %d", i, tabColor[i]);
+      pthread_create (&tabPid[i], NULL, (void *(*)(void *)) chameneosCode,
+		      theArgs[i]);
+    }
+  for (i = 0; i < 4; i++)
+    pthread_join (tabPid[i], NULL);
+
+  long sum = reports[0];
+  for (i = 1; i < 4; i++)
+    sum += reports[i];
+  printf ("%d\n", sum);
+
+  return 0;
+}

data/sources/gcc/chameneos.gcc-2.gcc

@@ -0,0 +1,134 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org/
+
+   Written by Jorge Peixoto de Morais Neto
+   based on code by Josh Goldfoot */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <err.h>
+
+static sem_t mutex, second_creature;
+
+static unsigned long meetingsleft;
+
+typedef enum { Blue, Red, Yellow, Faded } color_t;
+typedef struct {
+    unsigned long *meetingsp;
+    color_t color;
+} creature_t;
+
+/* When this function is called with two different colors, it must return the other color */
+/* We assume that none of the colors is Faded */
+/* If it is called with two equal colors, the specification allows us to return any color.  */
+/* In this case, we return Red if both colors are Blue, Yellow if both are Red and Blue if both are Yellow */
+static color_t complementarycolor (color_t c1, color_t c2) {
+    switch (c1) {
+    case Blue:
+	return c2 == Red ? Yellow : Red;
+    case Red:
+	return c2 == Yellow ? Blue : Yellow;
+    case Yellow:
+    default:
+	return c2 == Blue ? Red : Blue;
+    }
+}
+
+/* This is the meeting place. Multiple threads call this function.  */
+/* This function returns the new color the creature must assume after the meeting*/
+/* The first creature locks mutex, sets color1 = color, updates mp_state, */
+/* unlocks the mutex and waits to lock second_creature */
+/* The second creature locks mutex, sets othercolor=color1 and color2 = color , */
+/* decrements meetingsleft, updates mp_state, unlocks second_creature and returns */
+/* The first creature sets othercolor = color2, unlocks mutex and returns */
+/* mp_state is EMPTY again, the two semaphores are back to initial values and the cycle continues */
+/* until meetingsleft reaches 0. */
+static color_t new_color (color_t color) {
+/* Meeting place state*/
+    static enum {
+	MEETINGS_LIMIT_REACHED = -1,
+	EMPTY,
+	ONE_CREATURE
+    } mp_state = EMPTY;
+
+    static color_t color1, color2;
+    color_t othercolor;
+    sem_wait (&mutex);
+    switch (mp_state) {
+    case EMPTY:
+	color1 = color;
+	mp_state = ONE_CREATURE;
+	sem_post (&mutex);
+	sem_wait (&second_creature);
+	othercolor = color2;
+	sem_post (&mutex);
+	break;
+    case ONE_CREATURE:
+	othercolor = color1;
+	color2 = color;
+	mp_state = (--meetingsleft ? EMPTY : MEETINGS_LIMIT_REACHED);
+	sem_post (&second_creature);
+	break;
+    case MEETINGS_LIMIT_REACHED:
+    default:
+	sem_post (&mutex);
+	return Faded;
+    }
+    return complementarycolor (color, othercolor);
+}
+
+/* This function simulates a creature. */
+static void *run_creature (void *voidpme) {
+    creature_t const *me = voidpme;
+    unsigned long meetings = 0;
+    color_t color = me->color;
+    do {
+	meetings++;
+	color = new_color (color);
+    } while (color != Faded);
+/* The '-1' compensates the fact that the meetings variable counts the meeting  */
+/* in wich the creature becomes faded (but it shouldn't) */
+    *me->meetingsp = meetings - 1;
+    static int zero = 0;
+/* We return a pointer to 0, meaning success. */
+    return &zero;
+}
+
+/* This function sets loose four creatures and returns the sum of reported meetings*/
+static unsigned long meetings_of_four_creatures (void) {
+    sem_init (&mutex, 0, 1);
+    sem_init (&second_creature, 0, 0);
+
+    unsigned long reports[4];
+    creature_t creatures[4] = {{&reports[0], Blue},
+			       {&reports[1], Red},
+			       {&reports[2], Yellow},
+			       {&reports[3], Blue}};
+    pthread_t pids[4];
+    int i;
+    for (i = 0; i < 4; i++)
+	pthread_create (&pids[i], NULL, run_creature, &creatures[i]);
+
+    for (i = 0; i < 4; i++)
+	pthread_join (pids[i], NULL);
+
+    unsigned long sum = reports[0];
+    for (i = 1; i < 4; i++)
+	sum += reports[i];
+    return sum;
+}
+
+int main (int argc, char const **argv) {
+    meetingsleft = 1e6;
+    if (argc > 1) {
+	char *tail;
+	meetingsleft = strtoul (argv[1], &tail, 0);
+	if (tail == argv[1]) 
+	    errx (1, "Could not convert \"%s\" to an unsigned long integer", argv[1]);
+    }
+    unsigned long sum = meetings_of_four_creatures ();
+    printf ("%lu\n", sum);
+    return 0;
+}

data/sources/gcc/chameneos.gcc-3.gcc

@@ -0,0 +1,120 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org/
+
+   Written by Jorge Peixoto de Morais Neto
+   based on code by Josh Goldfoot
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdbool.h>
+#include <err.h>
+static unsigned long meetingsleft;
+
+typedef enum { Blue, Red, Yellow, Faded } color_t;
+typedef struct {
+    color_t color;
+    bool waiting_partner;
+} creature_t;
+
+/* When this function is called with two different colors, it must return the other color */
+/* We assume that none of the colors is Faded */
+/* If it is called with two equal colors, the specification allows us to return any color.  */
+/* In this case, we return Red if both colors are Blue, Yellow if both are Red and Blue if both are Yellow */
+static color_t complementarycolor (color_t c1, color_t c2) {
+    switch (c1) {
+    case Yellow:
+	return c2 == Blue ? Red : Blue;
+    case Red:
+	return c2 == Yellow ? Blue : Yellow;
+    default:
+    case Blue:
+	return c2 == Red ? Yellow : Red;
+    }
+}
+
+/* This is the meeting place. The threads simulating creatures call this function. */
+/* This function takes a pointer to the creaure data */
+/* and writes to the color field the new color the creature must assume */
+static void meeting_place (creature_t volatile *creature_p) {
+    /* A creature in the meeting place waiting for a partner. NULL means */
+    /* there is no such creature */
+    static creature_t volatile *waiting_creature_p = NULL;
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_lock (&mutex);
+    if (!waiting_creature_p) {
+	if (meetingsleft) {
+	    waiting_creature_p = creature_p;
+	    creature_p->waiting_partner = true;
+	    pthread_mutex_unlock(&mutex);
+	    while (creature_p->waiting_partner)
+		sched_yield ();
+	} else {
+	    pthread_mutex_unlock (&mutex);
+	    creature_p->color = Faded;
+	}
+    } else {
+	color_t newcolor = 
+	    complementarycolor (creature_p->color, waiting_creature_p->color);
+	creature_p->color = newcolor;
+	waiting_creature_p->color = newcolor;
+	waiting_creature_p->waiting_partner = false;
+	waiting_creature_p = NULL;
+	meetingsleft--;
+	pthread_mutex_unlock (&mutex);
+    }
+}
+
+/* This function simulates a creature. */
+/* It returns a pointer to the number of meetings this creature performed */
+static void *run_creature (void *me_voidp) {
+    creature_t *me_p = me_voidp;
+    unsigned long meetings = 0;
+    do {
+	meetings++;
+	meeting_place (me_p);
+    } while (me_p->color != Faded);
+    unsigned long *meetings_p = malloc (sizeof *meetings_p);
+/* The '-1' compensates the fact that the meetings variable counts the meeting */
+/* in wich the creature becomes faded (but it shouldn't) */
+    *meetings_p = meetings - 1;
+    return meetings_p;
+}
+
+#define NCREATURES 4
+/* This function unleashes NCREATURES creatures and returns the sum of reported meetings */
+static unsigned long meetings_of_creatures (void) {
+    creature_t creatures[NCREATURES];
+    creatures[0].color = Blue;
+    creatures[1].color = Red;
+    creatures[2].color = Yellow;
+    creatures[3].color = Blue;
+
+    pthread_t pids[NCREATURES];
+    int i;
+    for (i = NCREATURES - 1; i >= 0; i--)
+	pthread_create (&pids[i], NULL, run_creature, &creatures[i]);
+
+    unsigned long sum = 0;
+    for (i = NCREATURES - 1; i >= 0; i--) {
+	void *result_p;
+	pthread_join (pids[i], &result_p);
+	sum += *(unsigned long *) result_p;
+    }
+    return sum;
+}
+
+int main (int argc, char **argv) {
+    meetingsleft = 1e6;
+    if (argc > 1) {
+	char *tail;
+	meetingsleft = strtoul (argv[1], &tail, 0);
+	if (tail == argv[1]) 
+	    errx (1, "Could not convert \"%s\" to an unsigned long integer", argv[1]);
+    }
+    unsigned long sum = meetings_of_creatures ();
+    printf ("%lu\n", sum);
+    return 0;
+}