chrislo-sourceclassifier 0.2.0

data/sources/gcc/chameneosredux.gcc

@@ -0,0 +1,306 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org
+
+   contributed by Alex Burlyga
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+typedef enum _color { 
+   ZERO    = 0, 
+   BLUE    = 1, 
+   RED     = 2,
+   YELLOW  = 3, 
+   INVALID = 4,
+} color;
+
+char *colors[] = { "zero", 
+         "blue",
+         "red",
+         "yellow",
+         "invalid"
+       };
+
+char *digits[] = { "zero", "one", "two", "three", "four", "five", 
+              "six", "seven", "eight", "nine"
+            };
+            
+sem_t at_most_two;
+sem_t mutex;
+sem_t sem_priv;
+sem_t sem_print;
+
+pthread_mutex_t print_mutex;
+
+int meetings_left = 0;
+int first_arrived = 0;
+int done = 0;
+
+typedef struct _creature {
+   color my_color;
+   pthread_t id;
+   int number_of_meetings;
+} chameos;
+
+chameos A;
+chameos B;
+
+static color
+compliment_color(color c1, color c2) {
+   color result;
+   
+   switch(c1) {
+   case BLUE:
+      switch(c2) {
+      case BLUE:
+         result = BLUE;
+         break;
+      case RED:
+         result = YELLOW;
+         break;
+      case YELLOW:
+         result = RED;
+         break;
+      default:
+         printf("error complementing colors: %d, %d\n", c1, c2);
+         exit(1);
+      }
+      break;
+   case RED:
+      switch(c2) {
+      case BLUE:
+         result = YELLOW;
+         break;
+      case RED:
+         result = RED;
+         break;
+      case YELLOW:
+         result = BLUE;
+         break;
+      default:
+         printf("error complementing colors: %d, %d\n", c1, c2);
+         exit(2);
+      }
+      break;
+   case YELLOW:
+      switch(c2) {
+      case BLUE:
+         result = RED;
+         break;
+      case RED:
+         result = BLUE;
+         break;
+      case YELLOW:
+         result = YELLOW;
+         break;
+      default:
+         printf("error complementing colors: %d, %d\n", c1, c2);
+         exit(3);
+      }
+      break;
+   default:
+      printf("error complementing colors: %d, %d\n", c1, c2);
+      exit(4);
+   }
+   return result;
+}
+
+static void
+spell_the_number(int prefix, int number) {
+   char *string_number;
+   int string_length;
+   int i;
+   int digit;
+   int output_so_far  = 0;
+   char buff[1024];
+   
+   if(prefix != -1) {
+      output_so_far = sprintf(buff, "%d", prefix);
+   }
+   
+   string_number = malloc(sizeof(char)*10);
+   string_length = sprintf(string_number, "%d", number);
+   for(i = 0; i < string_length; i++) {
+      digit = string_number[i] - '0';
+      output_so_far += sprintf(buff+output_so_far, " %s", digits[digit]);
+   }
+   printf("%s\n",buff);
+   
+}
+
+static chameos *
+meeting(chameos c) {   
+   chameos *other_critter;
+   other_critter = malloc(sizeof(chameos));
+   
+   sem_wait(&at_most_two);
+   if(done == 1) {
+      sem_post(&at_most_two);
+      return NULL;
+   }
+   
+   sem_wait(&mutex);
+   if(done == 1) {
+      sem_post(&mutex);
+      sem_post(&at_most_two);
+      return NULL;
+   }
+   
+   if(first_arrived == 0) {
+      first_arrived = 1;
+      
+      A.my_color = c.my_color;
+      A.id = c.id;
+      
+      sem_post(&mutex);
+      sem_wait(&sem_priv);
+      
+      other_critter->my_color = B.my_color;
+      other_critter->id = B.id;
+
+      meetings_left--;
+      if(meetings_left == 0) {
+         done = 1;
+      }
+      
+      sem_post(&mutex);
+      sem_post(&at_most_two); sem_post(&at_most_two);
+   } else {
+      first_arrived = 0;
+      
+      B.my_color = c.my_color;
+      B.id = c.id;
+      
+      other_critter->my_color = A.my_color;
+      other_critter->id = A.id;
+      
+      sem_post(&sem_priv);
+   }
+   
+   return other_critter;
+}
+
+static void *
+creature(void *arg) {
+   chameos critter;
+   critter.my_color = (color)arg;
+   critter.id = pthread_self();
+   critter.number_of_meetings = 0;
+   
+   chameos *other_critter;
+
+   int met_others = 0;
+   int met_self = 0;
+   int *total_meetings = NULL;
+   
+   while(done != 1) {
+      other_critter = meeting(critter);
+      
+      if(other_critter == NULL) {
+         break;
+      }
+      
+      if(critter.id == other_critter->id) {
+         met_self++;
+      }else{
+         met_others++;
+      }
+      
+      critter.my_color = compliment_color(critter.my_color, other_critter->my_color);
+      free(other_critter);
+   } 
+   
+   sem_wait(&sem_print);
+   pthread_mutex_lock(&print_mutex);
+   spell_the_number(met_others + met_self, met_self);
+   pthread_mutex_unlock(&print_mutex);
+   
+   total_meetings = malloc(sizeof(int));
+   *total_meetings =met_others + met_self;
+   
+   pthread_exit((void *)total_meetings);
+}
+   
+void
+print_colors(void) {
+   int i, j;
+   color c;
+   
+   for(i = 1; i < INVALID; i++) {
+      for(j = 1; j < INVALID; j++) {
+         c = compliment_color(i,j);
+         printf("%s + %s -> %s\n",colors[i],colors[j], colors[c]);
+      }
+   }
+   printf("\n"); 
+}
+
+
+#define NUMBER1      3
+#define NUMBER2    10
+
+void
+run_the_meetings(color *starting_colors, int n_colors, int total_meetings_to_run) {
+   struct sched_param priority;
+   priority.sched_priority = 1;
+   
+   pthread_t pid_tab[NUMBER2];
+   memset(pid_tab, 0, sizeof(pthread_t)*NUMBER2);
+   
+   int i;
+   int total = 0;
+   void *rslt = NULL;
+   
+   sem_init(&at_most_two, 0, 2);
+   sem_init(&mutex, 0, 1);
+   sem_init(&sem_priv, 0, 0);
+   sem_init(&sem_print, 0, 0);
+   
+   pthread_mutex_init(&print_mutex, NULL);
+
+   meetings_left = total_meetings_to_run;
+   first_arrived = 0;
+   done = 0;
+   
+   sched_setscheduler(0, SCHED_FIFO, &priority);
+   
+   for(i = 0; i < n_colors; i++) {
+      printf(" %s", colors[starting_colors[i]]);
+      pthread_create(&pid_tab[i], NULL, &creature, (void *)starting_colors[i]);
+   }
+   printf("\n");
+   for(i = 0; i < n_colors; i++) {
+      sem_post(&sem_print);
+   }
+   
+   for(i = 0; i < n_colors; i++) {
+      pthread_join(pid_tab[i], &rslt);
+      total += *(int *)rslt;
+      free(rslt);
+   }
+   spell_the_number(-1, total);
+   printf("\n");
+}
+
+int
+main(int argc, char **argv) {
+   color first_generation[NUMBER1] = { BLUE, RED, YELLOW };
+   color second_generation[NUMBER2] = {BLUE, RED, YELLOW, RED, YELLOW,
+                   BLUE, RED, YELLOW, RED, BLUE};
+   int number_of_meetings_to_run = 600;
+   
+   if(argc > 1) {
+      number_of_meetings_to_run = strtol(argv[1], NULL, 10);
+   }
+   
+   print_colors();
+   run_the_meetings(first_generation, NUMBER1, number_of_meetings_to_run);
+   run_the_meetings(second_generation, NUMBER2, number_of_meetings_to_run);
+      
+   return 0;
+}

data/sources/gcc/echo.gcc

@@ -0,0 +1,144 @@
+/* -*- mode: c -*-
+ * $Id: echo.gcc,v 1.1.1.1 2004-05-19 18:09:36 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <netinet/in.h>
+
+
+typedef int (*SOCKACTION_P)(int,struct sockaddr *,socklen_t);
+#define DATA "Hello there sailor\n"
+
+void myabort (char *m) { fprintf(stderr, "%s\n", m); exit(1); }
+void sysabort (char *m) { perror(m); exit(1); }
+
+int sigchld = 0;
+void reaper (int sig) { sigchld = 1; }
+
+int 
+genericSock(int port,SOCKACTION_P action,char *actionExceptionText) {
+    int ss, optval = 1;
+    struct sockaddr_in sin;
+    if ((ss = socket(PF_INET, SOCK_STREAM, 0)) == -1)
+	sysabort("socket");
+    if (setsockopt(ss, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1)
+	sysabort("setsockopt");
+    memset(&sin,0,sizeof(sin));
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    sin.sin_port = port; 
+    if (action(ss, (struct sockaddr *)&sin,(socklen_t)sizeof(sin)) == -1)
+	sysabort(actionExceptionText);
+
+    return(ss);
+}
+
+int
+server_sock () {
+    int ss = genericSock(0,(SOCKACTION_P)bind,"server/bind");
+    return(listen(ss,2),ss);
+}
+
+int
+client_sock (int port) {
+    return(genericSock(port,(SOCKACTION_P)connect,"client/connect"));
+}
+
+int
+get_port (int sock) {
+    struct sockaddr_in sin;
+    socklen_t slen = sizeof(sin);
+    if (getsockname(sock, (struct sockaddr *)&sin, &slen) == -1)
+	sysabort("server/getsockname");
+    return(sin.sin_port);
+}    
+
+void
+echo_client (int n, int port) {
+    int i, sock, olen, len, nwritten, nread;
+    char *offset, obuf[64], ibuf[64];
+    char *end = ibuf + sizeof(ibuf);
+
+    sock = client_sock(port);
+    strcpy(obuf, DATA);
+    olen = strlen(obuf);
+    for (i=0; i<n; i++) {
+	len = olen;
+	offset = obuf;
+	while (len > 0) {
+	    if ((nwritten = write(sock, offset, len)) == -1)
+		sysabort("client/write");
+	    offset += nwritten;
+	    len -= nwritten;
+	}
+	offset = ibuf;
+	while ((nread = read(sock, offset, (end - offset))) > 0) {
+	    offset += nread;
+	    if (*(offset-1) == '\n') break;
+	}
+	if (nread == -1)
+	    sysabort("client/read");
+	*offset = 0;
+	if ((strcmp(obuf, ibuf)) != 0) {
+	    char mbuf[128];
+	    sprintf(mbuf, "client: \"%s\" ne \"%s\"", obuf, ibuf);
+	    myabort(mbuf);
+	}
+    }
+    close(sock);
+}
+
+void
+echo_server (int n) {
+    int ssock, csock, len, nwritten, total_bytes;
+    pid_t pid;
+    char buf[64], *offset;
+    struct sockaddr_in sin;
+    socklen_t slen = sizeof(sin);
+    int status;
+
+    ssock = server_sock();
+    signal(SIGCHLD, reaper);
+    if ((pid = fork()) == -1)
+	sysabort("server/fork");
+    if (pid) {
+	/* parent is server */
+	if ((csock = accept(ssock, (struct sockaddr *)&sin, &slen)) == -1)
+	    sysabort("server/accept");
+	total_bytes = 0;
+	while ((len = read(csock, buf, sizeof(buf))) > 0) {
+	    if (sigchld) myabort("server/sigchld");
+	    offset = buf;
+	    total_bytes += len;
+	    while (len > 0) {
+		if ((nwritten = write(csock, offset, len)) == -1)
+		    sysabort("server/write");
+		offset += nwritten;
+		len -= nwritten;
+	    }
+	}
+	if (len == -1)
+	    sysabort("server/read");
+	close(csock);
+	fprintf(stdout, "server processed %d bytes\n", total_bytes);
+    } else {
+	/* child is client */
+	echo_client(n, get_port(ssock));
+    }
+    wait(&status);
+}
+
+int
+main(int argc, char *argv[]) {
+    echo_server((argc == 2) ? atoi(argv[1]) : 1);
+    return(0);
+}