Removed submodules

lab7-threads/pthread.c

@@ -0,0 +1,152 @@
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include "discrete.h"
+#include "private.h"
+#include "pthread.h"
+
+/* Create a thread that will run generator(prime). Use pthread_join() to
+   retrieve the result from the thread and return that value. */
+uint64_t
+find_gen (uint64_t prime)
+{
+  pthread_t thread;
+  int rc = pthread_create (&thread, NULL, generator, (void *)prime);
+  if (rc != 0)
+    {
+      return 0;
+    }
+
+  void *result = NULL;
+  rc = pthread_join (thread, &result);
+  if (rc != 0)
+    {
+      return 0;
+    }
+
+  return (uint64_t)result;
+}
+
+/* Helper function that is a wrapper for calling find_generator() in a
+   separate thread. Do not modify. */
+void *
+generator (void *args)
+{
+  uint64_t prime = (uint64_t)args;
+  uint64_t gen = find_generator (prime);
+  pthread_exit ((void *)gen);
+}
+
+/* Create multiple threads, each of which makes a single call to generator().
+   Return a dynamically allocated array structured like the following:
+     results[0] = generator (0);
+     results[1] = generator (1);
+     ...
+   The arguments are the number of threads to create and the array of primes
+   to distribute between the threads (one prime per thread). */
+uint64_t *
+find_gens (size_t num_threads, uint64_t *primes)
+{
+  if (num_threads == 0 || primes == NULL)
+    return NULL;
+
+  pthread_t *threads = calloc (num_threads, sizeof (pthread_t));
+  uint64_t *results = calloc (num_threads, sizeof (uint64_t));
+
+  for (size_t i = 0; i < num_threads; i++)
+    {
+      int rc
+          = pthread_create (&threads[i], NULL, generator, (void *)primes[i]);
+      if (rc != 0)
+        {
+          for (size_t j = 0; j < i; j++)
+            {
+              pthread_join (threads[j], NULL);
+            }
+          free (threads);
+          free (results);
+          return NULL;
+        }
+    }
+
+  for (size_t i = 0; i < num_threads; i++)
+    {
+      void *retval = NULL;
+      int rc = pthread_join (threads[i], &retval);
+      if (rc != 0)
+        {
+          results[i] = 0;
+        }
+      else
+        {
+          results[i] = (uint64_t)retval;
+        }
+    }
+
+  free (threads);
+  return results;
+}
+
+/* Helper function to calculate the difference between a start and end time. */
+double
+time_diff (struct timeval start, struct timeval end)
+{
+  double ending = end.tv_sec + (end.tv_usec * 0.000001);
+  double starting = start.tv_sec + (start.tv_usec * 0.000001);
+  return ending - starting;
+}
+
+/* Calculate the discrete logarithm for several values. That is, given the
+   values g, p, and g^n mod p, determine n. (Note that this is an intentionally
+   SLOW operation!) The parameters are stored in three global arrays:
+     gens[] - this contains the generator values (g)
+     primes[] - this contains the prime numbers (p)
+     mod_powers[] - this contains the values g^n mod p for unknown n values
+   In pseudocode, you should be doing:
+     for i in start_index .. end_index-1
+       logs [i] = discrete_log (parameters[i])
+   The return value is the real time it takes to compute these values. Use
+   the C standard library function gettimeofday() to get a start and end time,
+   then use the helper function time_diff() to compute the difference.
+   This function will be called by time_log_thread() below. */
+double
+time_log (size_t start_index, size_t end_index, uint64_t *gens,
+          uint64_t *primes, uint64_t *mod_powers, uint64_t *logs)
+{
+  struct timeval start, end;
+  gettimeofday (&start, NULL);
+
+  for (size_t i = start_index; i < end_index; i++)
+    {
+      logs[i] = discrete_log (mod_powers[i], gens[i], primes[i]);
+    }
+
+  gettimeofday (&end, NULL);
+  return time_diff (start, end);
+}
+
+/* Wrapper function to call time_log() from within a thread. Given the
+   arguments passed, store the return value from time_log() into the
+   time_taken field. */
+void *
+time_log_thread (void *_args)
+{
+  struct time_args *args = (struct time_args *)_args;
+  if (args == NULL)
+    pthread_exit (NULL);
+
+  size_t start = args->start_index;
+  size_t end = start + args->number;
+
+  args->time_taken = time_log (start, end, args->generators, args->primes,
+                               args->mod_powers, args->results);
+
+  pthread_exit (NULL);
+}