/* 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;

}

/* 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 * params)
{

  int candidate = * ((int*) params);

  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;
      }
  }
  return (int*)is_prime;
}

int main () {
  pthread_t thread1, thread2, thread3, thread4;
  int prime1, prime2, prime3, prime4;
  int isPrime1, isPrime2, isPrime3, isPrime4;

  int which_prime     =    10;
  int factor          =    3;            //Amount of concurrent threads we are using
  int loop_control1   =    1;            //Counter for first loop
  int loop_control2   =    0;            //Counter for second loop
  int finished        = which_prime - (factor +2); //want to do the last (factor) on our own, plus 1 and 2 are given
  int answer;

  //This solution breaks down for small cases: hard-coded for "sanity check"
  if (which_prime == 2)
          printf("The %dth prime is 2.\n", which_prime);
  if (which_prime == 3)
          printf("The %dth prime is 5.\n", which_prime);
  if (which_prime == 4)
          printf("The %dth prime is 7.\n", which_prime);
  if (which_prime == 5)
          printf("The %dth prime is 11.\n", which_prime);

  while(1)
  {
        //Hard coded for small case "sanity check"
        if (which_prime < 6)
                break;

        prime1 = factor * loop_control1;
        prime2 = prime1 +1;
        prime3 = prime2 +1;

        /* Start 3 threads, each returns if it's number is prime*/
        pthread_create(&thread1, NULL, &compute_prime, &prime1);
        pthread_create(&thread2, NULL, &compute_prime, &prime2);
        pthread_create(&thread3, NULL, &compute_prime, &prime3);

        /* Wait for all threads to complete, and grab the values when they are done */
        pthread_join(thread1, (void*) &isPrime1);
        pthread_join(thread2, (void*) &isPrime2);
        pthread_join(thread3, (void*) &isPrime3);
        if (isPrime1)
        {
                --finished;
                if (finished == 0)
                {
                        answer = prime1;
                        break;
                }
        }

        if (isPrime2)
        {
                --finished;
                if (finished == 0)
                {
                        answer = prime2;
                        break;
                }
        }
        if (isPrime3)
        {
                --finished;
                if (finished == 0)
                {
                        answer = prime3;
                        break;
                }
        }

        ++loop_control1;
  }

  //Exactly 3 are left: test each number after what last loop gave us,
  //but only increment for loop's counter if one is found
  loop_control2 = factor; //need to find the last (factor) primes
  while (1)
  {
          //Hard coded for small case "sanity check"
          if (which_prime < 6)
                break;

          answer = answer + 1;
          pthread_create(&thread4, NULL, &compute_prime, &answer);
          pthread_join(thread4, (void*) &isPrime4);

          if (isPrime4)
          {
                  --loop_control2;
                  if (loop_control2 == 0)
                        break;
          }
  }
  //after this, answer should be the correct prime
  /* Print the largest prime that it computed */
  //Hard coded for small case "sanity check"
  if (which_prime > 5)
        printf("The %dth prime number computed is %d.\n", which_prime, answer);
  return 0;
}