hw4.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

unsigned long long int sum = 0;
unsigned long size;
char* filename;
int* arr;

void *runner(void *params);
void fileReader();
void getFileInfo(int c);

pthread_mutex_t mutex1  = PTHREAD_MUTEX_INITIALIZER;

struct thread_args { // [lower, upper)
	int lower; // Inclusive
	int upper; // Exclusive
};

void fileReader() {
	FILE *fp;
	char buffer[30];
	arr = (int*)malloc(size * sizeof(int));

	fp = fopen(filename,"r");
	int counter = 0;

	printf("Reading file\n");
	fflush(stdout);
	while(fgets(buffer,30,fp)) {
		arr[counter] = atoi(buffer);
		counter++;
	}
	printf("Finished reading file\n");
	fflush(stdout);
	fclose(fp);
}

void getFileInfo(int c) {
	switch(c) {
		case 1:
			size = 10000;
			filename = "arr1.txt";
			break;
		case 2:
			size = 100000;
			filename = "arr2.txt";
			break;
		case 3:
			size = 1000000;
			filename = "arr3.txt";
			break;
		case 4:
			size = 10000000l;
			filename = "arr4.txt";
			break;
		case 5:
			size = 100000000;
			filename = "arr5.txt";
			break;
		case 6:
			size = 1000000000;
			filename = "arr6.txt";
			break;
		default:
			size = 10;
			filename = "arr.txt";
	}
}

int main(int argc, char *argv[]) {

	//Args: [num of threads] [filename]
	if(argc != 3) {
		fprintf(stderr,"usage: a.out <integer value>\n");
		return -1;
	}
	if(atoi(argv[1]) <0) {
		fprintf(stderr,"%d must be >= 0\n", atoi(argv[1]));
		return -1;
	}
	if(atoi(argv[2]) < 1 ||  atoi(argv[2]) > 6) {
		fprintf(stderr,"%d must be > 0 and <= 6\n", atoi(argv[2]));
	}
	getFileInfo(atoi(argv[2]));
	fileReader();


	// Let's create all the threads
	const int NUM_OF_THREADS = atoi(argv[1]);
	const int CHUNK_SIZE = size / NUM_OF_THREADS;

	pthread_t tids[NUM_OF_THREADS];
	pthread_attr_t attrs[NUM_OF_THREADS];

	int i;
	clock_t t;
	t = clock();

	for(i = 0; i < NUM_OF_THREADS; i++) {
		pthread_attr_init(&attrs[i]);

		// Each thread has a struct as an argument
		// The struct holds the lower and upper bounds of the array
		struct thread_args *args = malloc(sizeof *args);
		args->lower = (i * CHUNK_SIZE);
		args->upper = args->lower + CHUNK_SIZE;

		pthread_create(&tids[i],&attrs[i],runner, args);
	}

	for(i = 0; i < NUM_OF_THREADS; i++) {
		pthread_join(tids[i], NULL);
	}
	t = clock() - t;
	double time_taken = ((double)t)/CLOCKS_PER_SEC;

	printf("sum = %llu\n", sum);

	float mean = (sum / (float)size);
	printf("mean = %f\n", mean);

	printf("Time taken: %f\n",time_taken);
}


void *runner(void *param) {
	struct thread_args *args = param;

	int lower = args->lower;
	int upper = args->upper;

	unsigned long long int tempSum = 0;

	int i;
	for(i = lower; i < upper; i++) {
		tempSum += arr[i];
	}

	// CRITICAL SECTION
	pthread_mutex_lock(&mutex1);
	sum += tempSum; // Race condition
	pthread_mutex_unlock(&mutex1);
	// End of CRITICAL SECTION
	pthread_exit(0);
}