//hw 4 solving euclid's gcd alg with threads
//Tracy Kapp

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>

void *worker(void *);
void *holder(void *);

pthread_mutex_t security;
pthread_cond_t condition;
unsigned count;
int remaining;
int N;
int ready[10];		//to tell worker if work needs to be done on that index
int pairs[10][2];	//to store pairs for each thread
int temp_pairs[10][2];	//stores original pairs for output at end of computation

main (int argc, char **argv)
{
	pthread_t gcd[10], work;
	int i, index[N+1], ret;
	int j;
	count=0;
	N=argc/2; //sets N to num of threads needed 
	remaining = N;

	if (argc < 3 || argc%2 != 1){	//tests for invalid input
		printf("not enough args\n");
		exit(0);
	}

	for (i=0;i<N;i++){	//loop creates number of threads for num of pairs.
		index[i]=i;
		pairs[i][0]=atoi(argv[2*i+1]);	//puts pairs into array for each thread to
		pairs[i][1]=atoi(argv[2*i+2]);	//be able to access them later
		temp_pairs[i][0]=atoi(argv[2*i+1]);
		temp_pairs[i][1]=atoi(argv[2*i+2]);
		ret=pthread_create(&gcd[i], NULL, holder, (void *) (&index[i]));	
	}
	pthread_create(&work, NULL, worker, (void *) (&index[N]));

	for(j=0;j<N;j++){	//lets all children threads of main run after main exits
        pthread_join(gcd[j],NULL);
    }
	pthread_join(work,NULL);
	return 0;
}
//----------------------------------------------------------------------------------------------------

void *worker(void *arg)
//worker will do the computations
{
	while(remaining>0){
		int k, temp;	
	
		pthread_mutex_lock(&security);	//these lines cut and pasted from dec-inc program
		while(count==0)
			pthread_cond_wait(&condition, &security);
		count--;
		if (remaining<=0)
			exit(0);


		for (k=0;k<N;k++){		//checks for work to be done on pairs
			if(ready[k]==1){
				//do work
				if (pairs[k][1]<pairs[k][0]){		//first larger, second smaller
					temp=pairs[k][0]%pairs[k][1];
					pairs[k][0]=pairs[k][1];
					pairs[k][1]=temp;
				}
				else if (pairs[k][0]<pairs[k][1]){	//second larger, first smaller
					temp=pairs[k][1]%pairs[k][0];
					pairs[k][1]=temp;
				}
				else	//they must be equal
					pairs[k][1]=0;
				
				ready[k]=0;
			}
		}
		pthread_mutex_unlock(&security);
	}
}
//----------------------------------------------------------------------------------------------------

void *holder(void *arg)
//holder threads send pairs to worker for computation, and check for completion
{
	while (1)
	{
		pthread_mutex_lock(&security);
		
		if (pairs[*(int *)arg][1]==0){		//when done with computation, exit
			printf("Thread %d: GCD of %d and %d= %d\n", *(int *)arg, temp_pairs[*(int *)arg][0], temp_pairs[*(int *)arg][1], pairs[*(int *)arg][0]);
			remaining--;	//tell worker that a thread is finished
			pthread_exit(NULL);
		}
		else
			ready[*(int *)arg]=1;	//set ready to 1 if work still to be done

		if (count==0)		//these lines cut and pasted from dec-inc program
			pthread_cond_signal(&condition);
		count++;

		pthread_mutex_unlock(&security);
	}
}