chrislo-sourceclassifier 0.2.0

data/sources/gcc/tcpecho.gcc-2.gcc

@@ -0,0 +1,136 @@
+/* The Great Computer Language Shootout
+   http://shootout.alioth.debian.org/
+
+   contributed by Rodrigo Queiro
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#define M 6400
+#define REPLY_SIZE 64
+#define REQUEST_SIZE 64
+#define MAX_SIZE 64 // max(REPLY_SIZE, REQUEST_SIZE)
+#define PORT 11000
+#define BUFSIZE 512
+
+int main(int argc, char **argv)
+{
+    int i;
+
+    int n;
+    char buf[BUFSIZE], text[MAX_SIZE];
+
+    pid_t child_pid;
+
+    /* server variables */
+
+    int sockfd, newfd;
+    struct sockaddr_in my_addr, new_addr;
+    int sin_size;
+    int yes=1;
+
+    /* client variables */
+
+    int theirfd, nreplies = 0, nbytes = 0;
+    struct hostent *he;
+    struct sockaddr_in their_addr;
+
+    assert(argc > 1);
+    n = atoi(argv[1]);
+
+    child_pid = fork();
+
+    if(child_pid)
+    {
+        /* server code */
+
+        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+            perror("socket");
+            exit(1);
+        }
+
+        if (setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
+            perror("setsockopt");
+            exit(1);
+        }
+
+        my_addr.sin_family = AF_INET;         // host byte order
+        my_addr.sin_port = htons(PORT);     // short, network byte order
+        my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
+        memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
+
+        if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))
+                == -1) {
+            perror("bind");
+            exit(1);
+        }
+
+        if (listen(sockfd, 2) == -1) {
+            perror("listen");
+            exit(1);
+        }
+        sin_size = sizeof(struct sockaddr_in);
+        if ((newfd = accept(sockfd, (struct sockaddr *)&new_addr,
+                        &sin_size)) == -1) {
+            perror("accept");
+            exit(1);
+        }
+
+        for (i = 0; i < REPLY_SIZE; i++)
+            text[i] = ' ';
+
+        for (i = 0; i < n * M; i++)
+        {
+            recv(newfd, buf, BUFSIZE-1, 0);
+            send(newfd, text, REPLY_SIZE, 0);
+        }
+
+        wait(NULL);
+    }
+    else
+    {
+        if ((he=gethostbyname("localhost")) == NULL) {  // get the host info 
+            perror("gethostbyname");
+            exit(1);
+        }
+
+        if ((theirfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+            perror("socket");
+            exit(1);
+        }
+
+        their_addr.sin_family = AF_INET;    // host byte order 
+        their_addr.sin_port = htons(PORT);  // short, network byte order 
+        their_addr.sin_addr = *((struct in_addr *)he->h_addr);
+        memset(&(their_addr.sin_zero), '\0', 8);  // zero the rest of the struct 
+
+        while (connect(theirfd, (struct sockaddr *)&their_addr,
+                    sizeof(struct sockaddr)) == -1);
+
+        for (i = 0; i < REQUEST_SIZE; i++)
+            text[i] = ' ';
+
+        for (i = 0; i < n * M; i++)
+        {
+            send(theirfd, text, REQUEST_SIZE, 0);
+            nbytes += recv(theirfd, buf, BUFSIZE-1, 0);
+            nreplies++;
+        }
+
+        printf("replies: %d\tbytes: %d\n", nreplies, nbytes);
+    }
+
+    return 0;
+}

data/sources/gcc/tcprequest.gcc

@@ -0,0 +1,122 @@
+/* 
+ The Great Computer Language Shootout
+  http://shootout.alioth.debian.org/
+
+  contributed by John O'Hare 05 August 2005.
+*/
+
+
+#include <stdio.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define PORT_NUMBER 12341
+#define M 100
+#define REPLY_SIZE 4096
+#define REQUEST_SIZE 64
+#define BUFFER_SIZE 1024
+
+void server()
+{
+	int sock;
+	int conn;
+	struct sockaddr_in servaddr;
+	struct sockaddr_in cliaddr;
+	unsigned int cliaddr_len;
+	char* reply = malloc(REPLY_SIZE);
+	char* buf = malloc(BUFFER_SIZE);
+
+	memset(reply, '<', REPLY_SIZE);
+
+	if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+		exit(10);
+
+	memset(&servaddr, 0, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	servaddr.sin_port = htons(PORT_NUMBER);
+
+	if (bind(sock, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
+		exit(11);
+
+	if (listen(sock, 1) < 0)
+		exit(12);
+
+	if ((conn = accept(sock, (struct sockaddr *) &cliaddr, &cliaddr_len)) < 0)
+		exit(13);
+
+	while (recv(conn, buf, BUFFER_SIZE, 0) > 0) {
+		if (send(conn, reply, REPLY_SIZE, 0) != REPLY_SIZE)
+			exit(14);
+	}
+
+	close(conn);
+	close(sock);
+
+	free(buf);
+}
+
+void client(int n)
+{
+	int sock;
+	struct sockaddr_in servaddr;
+	char* request = malloc(REQUEST_SIZE);
+	char* buf = malloc(BUFFER_SIZE);
+	int tmpbytes;
+	int bytes = 0;
+	int replies = 0;
+
+	memset(request, '>', REQUEST_SIZE);
+
+	sleep(2); //wait for server to start
+
+	if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) 
+		exit(2);
+
+	memset(&servaddr, 0, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	servaddr.sin_port = htons(PORT_NUMBER);
+
+	if (connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
+		exit(3);
+
+	while (n-- > 0) {
+		tmpbytes = 0;
+
+		if (send(sock, request, REQUEST_SIZE, 0) != REQUEST_SIZE)
+			exit(4);
+
+		while (tmpbytes < REPLY_SIZE)
+			tmpbytes += recv(sock, buf, BUFFER_SIZE - 1, 0);
+		bytes += tmpbytes;
+		replies++;
+	}
+	close(sock);
+
+	printf("replies: %d\tbytes: %d\n", replies, bytes);
+
+	free(request);
+	free(buf);
+}
+
+int main (int argc, char** argv)
+{	
+	int pid;
+	int n;
+
+	n = (argc == 2 ? atoi(argv[1]) : 1);
+
+	if ((pid = fork()) < 0) {
+		return 1;
+	}
+	if (pid == 0) {
+		client(M * n);
+	} else {
+		server();
+	}
+	return 0;
+}

data/sources/gcc/threadring.gcc

@@ -0,0 +1,73 @@
+/*
+* The Computer Language Benchmarks Game
+* http://shootout.alioth.debian.org/
+
+* contributed by Premysl Hruby
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <string.h>
+#include <limits.h>
+
+#define THREADS (503)
+
+
+struct stack {
+   char x[PTHREAD_STACK_MIN];
+};
+
+
+/* staticaly initialize mutex[0] mutex */
+static pthread_mutex_t mutex[THREADS]; 
+static int data[THREADS];
+static struct stack stacks[THREADS];
+/* stacks must be defined staticaly, or my i386 box run of virtual memory for this
+ * process while creating thread +- #400 */
+
+static void* thread(void *num)
+{
+   int l = (int)num;
+   int r = (l+1) % THREADS;
+   int token;
+
+   while(1) {
+      pthread_mutex_lock(mutex + l);
+      token = data[l];
+      if (token) {
+         data[r] = token - 1;
+         pthread_mutex_unlock(mutex + r);
+      }
+      else {
+         printf("%i\n", l+1);
+         exit(0);
+      }
+   }
+}
+
+
+
+int main(int argc, char **argv)
+{
+   int i;
+   pthread_t cthread;
+   pthread_attr_t stack_attr;
+
+   if (argc != 2)
+      exit(255);
+   data[0] = atoi(argv[1]);
+
+   pthread_attr_init(&stack_attr);
+      
+   for (i = 0; i < THREADS; i++) {
+      pthread_mutex_init(mutex + i, NULL);
+      pthread_mutex_lock(mutex + i);
+
+      pthread_attr_setstack(&stack_attr, &stacks[i], sizeof(struct stack)); 
+      pthread_create(&cthread, &stack_attr, thread, (void*)i);
+   }
+
+   pthread_mutex_unlock(mutex + 0);
+   pthread_join(cthread, NULL);   
+}

data/sources/gcc/wc.gcc

@@ -0,0 +1,52 @@
+/* -*- mode: c -*-
+ * $Id: wc.gcc,v 1.2 2004-06-18 07:02:55 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ *
+ * Author: Waldemar Hebisch (hebisch@math.uni.wroc.pl)
+ * Optimizations: Michael Herf (mike@herfconsulting.com)
+ * Further Revisions: Paul Hsieh (qed@pobox.com)
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <limits.h>
+
+#define BSIZ 4096
+
+unsigned long ws[UCHAR_MAX + 1];
+unsigned long nws[UCHAR_MAX + 1];
+char buff[BSIZ];
+
+int main(void) {
+    unsigned long prev_nws = 0x10000L, w_cnt = 0, l_cnt = 0, b_cnt = 0, cnt;
+
+    /* Fill tables */
+    for (cnt = 0; cnt <= UCHAR_MAX; cnt++) {
+         ws[cnt] =  (cnt == ' ' || cnt == '\n' || cnt == '\t') + (0x10000L & -(cnt == '\n'));
+	nws[cnt] = !(cnt == ' ' || cnt == '\n' || cnt == '\t') +  0x10000L;
+    }
+
+    
+    /* Main loop */
+    while (0 != (cnt = read (0, buff, BSIZ))) {
+        unsigned long vect_count = 0;
+	unsigned char *pp, *pe;
+
+	b_cnt += cnt;
+	pe = buff + cnt;
+	pp = buff;
+
+	while (pp < pe) {
+	    vect_count +=  ws[*pp] & prev_nws;
+	    prev_nws    = nws[*pp];
+	    pp ++;
+	}
+	w_cnt += vect_count  & 0xFFFFL;
+	l_cnt += vect_count >> 16;
+    }
+
+    w_cnt += 1 & prev_nws;
+
+    printf ("%d %d %d\n", l_cnt, w_cnt, b_cnt);
+    return 0;
+}

data/sources/gcc/wc.gcc-2.gcc

@@ -0,0 +1,40 @@
+/* -*- mode: c -*-
+ * $Id: wc.gcc-2.gcc,v 1.1 2004-11-10 06:42:03 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ *
+ * this program is modified from:
+ *   http://cm.bell-labs.com/cm/cs/who/bwk/interps/pap.html
+ * Timing Trials, or, the Trials of Timing: Experiments with Scripting
+ * and User-Interface Languages</a> by Brian W. Kernighan and
+ * Christopher J. Van Wyk.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+enum {
+    OUT,			/* outside a word */
+    IN				/* inside a word */
+};
+
+int
+main() {
+    int c, nl, nw, nc, state;
+
+    state = OUT;
+    nl = nw = nc = 0;
+    while ((c = getchar()) != EOF) {
+	++nc;
+	if (c == '\n')
+	    ++nl;
+	if (c == ' ' || c == '\n' || c == '\t')
+	    state = OUT;
+	else if (state == OUT) {
+	    state = IN;
+	    ++nw;
+	}
+    }
+    printf("%d %d %d\n", nl, nw, nc);
+    return(0);
+}

data/sources/gcc/wc.gcc-3.gcc

@@ -0,0 +1,46 @@
+/* -*- mode: c -*-
+ * $Id: wc.gcc-3.gcc,v 1.1 2004-11-10 06:42:03 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ *
+ * this program is modified from:
+ *   http://cm.bell-labs.com/cm/cs/who/bwk/interps/pap.html
+ * Timing Trials, or, the Trials of Timing: Experiments with Scripting
+ * and User-Interface Languages</a> by Brian W. Kernighan and
+ * Christopher J. Van Wyk.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+enum {
+    OUT,			/* outside a word */
+    IN				/* inside a word */
+};
+
+
+int
+main() {
+    int i, c, nl, nw, nc, state, nread;
+    char buf[4096];
+
+    state = OUT;
+    nl = nw = nc = 0;
+    while ((nread = read(0, buf, sizeof(buf))) > 0) {
+	nc += nread;
+	for (i=0; i<nread; i++) {
+	    c = buf[i];
+	    if (c == '\n')
+		++nl;
+	    if (c == ' ' || c == '\n' || c == '\t')
+		state = OUT;
+	    else if (state == OUT) {
+		state = IN;
+		++nw;
+	    }
+	}
+    }
+    printf("%d %d %d\n", nl, nw, nc);
+    return(0);
+}