Initial commit

Author: Christian Howe

.gitignore

@@ -0,0 +1 @@
+test

Makefile

@@ -0,0 +1,8 @@
+build:
+	gcc -g -lpthread -o test main.c message-queue.c
+
+memcheck:
+	valgrind --leak-check=full ./test
+
+clean:
+	rm test

README.md

@@ -0,0 +1,40 @@
+# Multithreaded Test
+
+This is my testbed for multithreaded classes. I've written a MessageQueue class
+that uses locking already. I use pthreads for everything, as any respectable
+unix programmer would. To see some examples for my method of writing C code that
+has object orientation, see
+[object-oriented-test](https://github.com/coderarity/object-oriented-test).
+
+Examples are provided in main.c. I may expand this testbed as I add more classes
+for multithreaded communications.
+
+## Build it
+
+```
+make
+```
+
+## Try it
+
+```
+./test
+```
+
+## Clean it
+
+```
+make clean
+```
+
+## Check it for memory leaks (requires valgrind)
+
+```
+make memcheck
+```
+
+# License
+
+All code and documentation in this repository is released under the MIT license.
+See [license text](http://coderarity.mit-license.org/).
+

error.h

@@ -0,0 +1,9 @@
+#ifndef ERROR_H
+#define ERROR_H
+
+#include <errno.h>
+
+#define ERROR_VAL 2 // 1 is used by bool, bool can't be negative, next is 2
+#define SUCCESS_VAL 0
+
+#endif // ERROR_H

main.c

@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "message-queue.h"
+
+messagequeue_t* threadQueue;
+
+void* threadFunc (void* arg) {
+  int i;
+  message_t msg;
+  // 1 extra loop to give a bit of time for main to catch up
+  for (i = 0; i < 6; ++i) {
+    sleep(1);
+    if (MessageQueue.pop(threadQueue, &msg) == ERROR_VAL) {
+      if (errno != ENOMSG) {
+        perror("Popping from threadQueue failed");
+        return (void*)EXIT_FAILURE;
+      }
+      else {
+        continue;
+      }
+    }
+    printf("value: %s\n", (const char*)msg.data);
+    free(msg.data); // we malloc'd earlier, remember? always free your mallocs!
+  }
+  return (void*)EXIT_SUCCESS;
+}
+
+int main (int argc, char* argv[]) {
+  threadQueue = malloc(sizeof(messagequeue_t));
+
+  if (threadQueue == NULL) {
+    errno = ENOMEM;
+    perror("Allocating threadQueue failed");
+    return EXIT_FAILURE;
+  }
+
+  if (MessageQueue.new(threadQueue) == ERROR_VAL) {
+    perror("Intializing threadQueue failed");
+    return EXIT_FAILURE;
+  }
+
+  pthread_t thread;
+  if (pthread_create(&thread, NULL, threadFunc, NULL) != 0) {
+    perror("Creating thread failed");
+    return EXIT_FAILURE;
+  }
+
+  int i;
+  const char* text = "hello!";
+  message_t msg;
+  msg.type = 1;
+  for (i = 0; i < 5; ++i) {
+    sleep(1);
+    msg.data = malloc(strlen(text)+1); // we malloc this! don't forget to free!
+
+    if (msg.data == NULL) {
+      errno = ENOMEM;
+      perror("Allocating message data failed");
+      return EXIT_FAILURE;
+    }
+
+    // Copy the data to prevent race conditions
+    strcpy(msg.data, text);
+
+    if (MessageQueue.push(threadQueue, &msg) == ERROR_VAL) {
+      perror("Pushing to threadQueue failed");
+      return EXIT_FAILURE;
+    }
+  }
+
+  void* retValue;
+  if ((errno = pthread_join(thread, &retValue)) != 0) {
+    perror("Joining thread failed");
+    return EXIT_FAILURE;
+  }
+
+  if (MessageQueue.delete(threadQueue) == ERROR_VAL) {
+    perror("Deleting threadQueue failed");
+    return EXIT_FAILURE;
+  }
+  free(threadQueue);
+  threadQueue = NULL;
+
+  if (retValue == (void*)EXIT_FAILURE)
+    return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}