/* Programming Project #1
 * Operating Systems, Spring 2005*/
#include <pthread.h>
#include <stdio.h>
#include <math.h>

/* This program successively tests integers for prime numbers.  Return the Nth
prime number, where N is the value pointed to by *ARG. */

void * compute_prime (void * arg)
{
  int candidate = 2;
  int n = *((int*) arg); /* The parameter passed here is only an int so
                            we can abuse this feature by straight casting */

  while (1) {
    int factor;
    int is_prime = 1;
    int upper_limit = (int) sqrt((double)candidate); /*You need only test up to sqrt(x)
                                                     divisiors of x */
    /* Test primality by successive division */
    for (factor = 2; factor <= upper_limit; ++factor)
      if (candidate % factor == 0) {
        is_prime = 0; /*false*/
        break;
      }

    /* Is this the prime number that we're looking for? */
    if (is_prime) {
      if (--n == 0)
        /* Return the desired prime number as the thread return value */
        return (void*) candidate;
    }
    ++candidate;
  }


  return NULL;

}

int main () {
  pthread_t thread;
  int which_prime = 5000;
  int prime;

  /* Start the computing thread, up to the "which prime" prime number. */
  pthread_create(&thread, NULL, &compute_prime, &which_prime);

  /* Wait for the prime number thread to complete, and get the result */
  pthread_join(thread, (void*) &prime);

  /* Print the largest prime that it computed */
  printf("The %dth prime number computed is %d.\n", which_prime, prime);
  return 0;
}

struct ranges
{
  int begin;
  int end;
};

void * compute_prime (void * params)
{
  struct ranges* p = (struct ranges*) params;
  int candidate = p -> begin;
  int n = p -> end; /* The parameter passed here is only an int so
                          we can abuse this feature by straight casting */



  while (1)
  {
    int factor;
    int is_prime = 1;
    int upper_limit = (int) sqrt(candidate); /*You need only test up to sqrt(x)
                                                     divisiors of x */

    /* Test primality by successive division */
    for (factor = 2; factor <= upper_limit; ++factor)
    {
      if (candidate % factor == 0)
      {
        is_prime = 0; /*false*/
        break;
      }
    }

    /*At this point, we know primality*/
    /* Is this the prime number that we're looking for? */
    if (is_prime)
    {
      if (--n == 0)
        /* Return the desired prime number as the thread return value */
        return (void*) candidate;
    }
    ++candidate;
  }


  return NULL;
}

int main () {
  pthread_t thread1, thread2, thread3;
  int prime1, prime2, prime3;

  int which_prime     =    6;
  int begin           =    2;
  int final_result    =    0;
  int first_third     = which_prime/3;
  int final_third     = (first_third * 2);

  struct ranges thread1_args, thread2_args, thread3_args;
  thread1_args.begin = begin;
  thread1_args.end   = first_third - 1;
  thread2_args.begin = first_third;
  thread2_args.end   = final_third - 1;
  thread3_args.begin = final_third;
  thread3_args.end   = which_prime -1;

  /* Wait for all threads to complete, and grab the values when they are done */
  pthread_join(thread1, (void*) &prime1);
  pthread_join(thread2, (void*) &prime2);
  pthread_join(thread3, (void*) &prime3);


  /* Start 3 threads, each computes the amount of primes in one third of which_prime */
  pthread_create(&thread1, NULL, &compute_prime, &thread1_args);
  pthread_create(&thread2, NULL, &compute_prime, &thread2_args);
  pthread_create(&thread3, NULL, &compute_prime, &thread3_args);

printf("first thread %d .\n", prime1);
  printf("second thread %d .\n", prime2);
  printf("third thread %d .\n\n", prime3);
  /* Print the largest prime that it computed */
  printf("The %dth prime number computed is %d.\n", which_prime, prime3);
  return 0;

}