Removed submodules

lab8-synch/mutex.c

@@ -0,0 +1,89 @@
+#include <assert.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+// Use the struct here for passing arguments to the runner() threads.
+// All instances of this struct should point to the same pthread_mutex_t
+// and shared variables.
+typedef struct args {
+    pthread_mutex_t *lock;
+    int64_t *shared;
+} arg_t;
+
+/* Function to run in concurrent threads. The argument passed should be a
+   pointer to a pthread_mutex_t to be used for mutual exclusion. Within the
+   nested for-loop structure, use the mutex to protect the the increments
+   and decrements of the shared variable. To get the timing right for the
+   unit tests, experiment with placing the lock/unlock calls in different
+   places (e.g., around both for-loops, inside the outer one, inside the
+   inner one, etc.) */
+void *
+runner (void *arg)
+{
+  // Retrieve the shared pointer and mutex from the passed struct.
+  arg_t *args = (arg_t *) arg;
+  pthread_mutex_t *lock = args->lock;
+  int64_t *shared = args->shared;
+
+  for (int j = 0; j < 1000000; j++)
+    {
+      pthread_mutex_lock (lock);
+      for (int i = 0; i < 100; i++)
+        {
+          *shared += 1;
+          *shared -= 1;
+        }
+      pthread_mutex_unlock (lock);
+    }
+
+  pthread_exit (NULL);
+}
+
+/* Simple fork-join routine that creates two threads running the runner()
+   function above. Pass the lock and a pointer to the shared variable to
+   both threads. When both threads complete, return the shared variable,
+   which should have a value of 0.
+ */
+int64_t
+run (void)
+{
+  int64_t shared = 0;
+
+  pthread_mutex_t lock;
+  if (pthread_mutex_init (&lock, NULL) != 0)
+    {
+      fprintf (stderr, "Failed to initialize mutex\n");
+      return shared;
+    }
+
+  arg_t args;
+  args.lock = &lock;
+  args.shared = &shared;
+
+  pthread_t t1, t2;
+  if (pthread_create (&t1, NULL, runner, &args) != 0)
+    {
+      fprintf (stderr, "Failed to create thread 1\n");
+      pthread_mutex_destroy (&lock);
+      return shared;
+    }
+  if (pthread_create (&t2, NULL, runner, &args) != 0)
+    {
+      fprintf (stderr, "Failed to create thread 2\n");
+      pthread_cancel (t1);
+      pthread_join (t1, NULL);
+      pthread_mutex_destroy (&lock);
+      return shared;
+    }
+
+  pthread_join (t1, NULL);
+  pthread_join (t2, NULL);
+
+  pthread_mutex_destroy (&lock);
+
+  return shared;
+}