changes

PA2_2020/2_barrier_using_condVariable/Makefile

+# Default to debugging flags. Set to -O3 if you want optimisations
+# (either change it here, or type 'make CFLAGS=-O3' in the shell).
+CFLAGS?=-g -Wall -Wno-unused-value
+
+all: barrier_exec
+
+barrier_exec: barrier.c barrier-testcase1.c barrier-testcase2.c barrier-testcase3.c barrier-testcase4.c barrier-testcase5.c barrier.h
+	$(CC) $(CFLAGS) -o barrier1 barrier-testcase1.c barrier.c -lpthread
+	$(CC) $(CFLAGS) -o barrier2 barrier-testcase2.c barrier.c -lpthread
+	$(CC) $(CFLAGS) -o barrier3 barrier-testcase3.c barrier.c -lpthread
+	$(CC) $(CFLAGS) -o barrier4 barrier-testcase4.c barrier.c -lpthread
+	$(CC) $(CFLAGS) -o barrier5 barrier-testcase5.c barrier.c -lpthread 
+
+clean:
+	$(RM) barrier1
+	$(RM) barrier2
+	$(RM) barrier3
+	$(RM) barrier4
+	$(RM) barrier5
+	$(RM) -r *.dSYM
+
+run: barrier_exec
+	./barrier1
+	./barrier2
+	./barrier3
+	./barrier4
+	./barrier5

PA2_2020/2_barrier_using_condVariable/barrier-testcase1.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "barrier.h"
+
+#define NTHREADS 10
+
+struct barrier_t barrier1;
+int array[NTHREADS] = { 0 };
+
+void *ThreadRoutine(void *arg)
+{
+	int id = *((int *)arg);
+	long int sum = 0;
+
+	array[id]++;
+
+	barrier_wait(&barrier1);
+	if(id == 0)
+	{
+		for(int i=0; i<NTHREADS; i++)
+			sum += array[i];
+		printf("Sum = %ld \n", sum);
+	}
+	return NULL;
+}
+
+int main()
+{
+	int ids[NTHREADS];
+	pthread_t threads[NTHREADS];
+
+	barrier_init(&barrier1, NTHREADS);
+
+	for(int i=0; i<NTHREADS; i++)
+	{
+		ids[i] = i;
+		pthread_create(&threads[i], NULL, ThreadRoutine, (void *)&ids[i]);
+	}
+
+	for(int i=0; i<NTHREADS; i++)
+		pthread_join(threads[i], NULL);
+
+	return 0;
+}

PA2_2020/2_barrier_using_condVariable/barrier-testcase2.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "barrier.h"
+
+#define NTHREADS 1000
+
+struct barrier_t barrier;
+int array[NTHREADS];
+
+void *ThreadRoutine(void *arg)
+{
+	int id = *((int *)arg);
+	long int sum=0;
+
+	array[id]++;
+
+	barrier_wait(&barrier);
+	if(id == 0)
+	{
+		for(int i=0; i<NTHREADS; i++)
+			sum += array[i];
+		printf("Sum1 = %ld \n",sum);
+	}
+
+	barrier_wait(&barrier);
+	array[id] += 10;
+
+	barrier_wait(&barrier);
+	if(id == 0)
+	{
+		sum = 0;
+		for(int i=0; i<NTHREADS; i++)
+			sum += array[i];
+		printf("Sum2 = %ld \n",sum);
+	}
+	return NULL;
+}
+
+int main()
+{
+	int ids[NTHREADS];
+	pthread_t threads[NTHREADS];
+
+	barrier_init(&barrier, NTHREADS);
+
+	for(int i=0; i<NTHREADS; i++)
+	{
+		ids[i] = i;
+		pthread_create(&threads[i], NULL, ThreadRoutine, (void *)&ids[i]);
+	}
+
+	for(int i=0; i<NTHREADS; i++)
+		pthread_join(threads[i], NULL);
+
+	return 0;
+}

PA2_2020/2_barrier_using_condVariable/barrier-testcase3.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "barrier.h"
+
+#define NTHREADS 1000
+
+int error = 1;
+struct barrier_t barrier1;
+
+void *ThreadRoutine(void *arg)
+{
+	int id = *((int *)arg);
+
+	barrier_wait(&barrier1);
+	if(id == 0)
+	{
+		printf("Thread 0: I am going to wait for 5s beforing calling 'barrier_wait()'\n");
+		
+		sleep(5);
+		error = 0;
+		printf("Thread 0: I am calling barrier_wait(). Everbody ready to cross the barrier.\n");
+		
+		barrier_wait(&barrier1);
+		printf("Looks good !\n");
+	}
+	else
+	{
+		barrier_wait(&barrier1);
+		if(error)
+		{
+			printf("Error: Thread %d:  How I crossed the barrier before Thread 0 invokes barrier_wait()?.\n", id);
+			exit(1);
+		}
+	}
+return NULL;
+}
+
+int main()
+{
+	pthread_t threads[NTHREADS];
+	int ids[NTHREADS];
+
+	barrier_init(&barrier1, NTHREADS);
+
+	for(int i=0; i<NTHREADS; i++)
+	{
+		ids[i] = i;
+		pthread_create(&threads[i], NULL, ThreadRoutine, (void *)&ids[i]);
+	}
+	
+	for(int i=0; i<NTHREADS; i++)
+		pthread_join(threads[i], NULL);
+
+	return 0;
+}

PA2_2020/2_barrier_using_condVariable/barrier-testcase4.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "barrier.h"
+
+#define ELEMENTS 1000
+#define NTHREADS 4
+
+struct barrier_t barrier1;
+struct barrier_t barrier2;
+struct barrier_t barrier3;
+
+int array[ELEMENTS];
+long int sum[NTHREADS];
+
+void *ThreadRoutine(void *arg)
+{
+	int id;
+
+	id = *((int *)arg);
+
+	for(int i = id *250; i<(id+1)*250; i++)
+		sum[id]	+= array[i];
+	// printf("Sum[%d - %d]: %ld \n", id*250, (id+1)*250, sum[id]);
+
+	if(id == 0)
+	{
+		barrier_wait(&barrier1);
+		sum[0] = sum[0] + sum [1];
+
+		barrier_wait(&barrier3);
+		// printf("\nSum[0]: %ld \n", sum[0]);
+		// printf("Sum[2]: %ld \n", sum[2]);
+		sum[0] = sum[0] + sum[2];
+		printf("\nSum: %ld \n", sum[0]);
+
+	}
+	else if(id == 1)
+	{
+		barrier_wait(&barrier1);
+	}
+	else if (id == 2)
+	{	
+		barrier_wait(&barrier2);
+		sum[2] = sum[2] + sum [3];
+
+		barrier_wait(&barrier3);
+	}
+	else if(id == 3)
+	{
+		barrier_wait(&barrier2);
+	}
+return NULL;
+}
+
+int main()
+{
+	int ids[NTHREADS];
+	pthread_t threads[NTHREADS];
+
+	for(int i=0; i<ELEMENTS; i++)
+		array[i] = 2;
+
+	barrier_init(&barrier1, 2);
+	barrier_init(&barrier2, 2);
+	barrier_init(&barrier3, 2);
+
+	for(int i=0; i<NTHREADS; i++)
+	{
+		ids[i] = i;
+		pthread_create(&threads[i], NULL, ThreadRoutine, (void *)&ids[i]);
+	}
+
+	for(int i=0; i<NTHREADS; i++)
+		pthread_join(threads[i], NULL);
+
+	return 0;
+}

PA2_2020/2_barrier_using_condVariable/barrier-testcase5.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "barrier.h"
+
+#define NTHREADS 2
+
+struct barrier_t b1;
+struct barrier_t b2;
+
+void *ThreadRoutine(void *arg)
+{
+	int id = *((int *)arg);
+
+	for(int i=0; i<10; i++)
+	{
+		if(id == 1)					// Thread 1
+		{
+			barrier_wait(&b1);
+			printf("Thread 1: Hii \n");
+
+			barrier_wait(&b2);
+		}
+		else						// Thread 2
+		{
+			barrier_wait(&b2);
+			printf("Thread 2: \tHello \n");
+
+			barrier_wait(&b1);
+		}
+	}
+
+	if(id == 1) 
+		barrier_wait(&b1);
+return NULL;
+}
+
+int main()
+{
+	int ids[NTHREADS];
+	pthread_t threads[NTHREADS];
+
+	barrier_init(&b1, 2);
+	barrier_init(&b2, 2);
+
+	for(int i=0; i<NTHREADS; i++)
+	{
+		ids[i] = i+1;
+		pthread_create(&threads[i], NULL, ThreadRoutine, (void *)&ids[i]);
+	}
+
+	barrier_wait(&b1);
+
+	for(int i=0; i<NTHREADS; i++)
+		pthread_join(threads[i], NULL);
+
+	return 0;
+}

PA2_2020/2_barrier_using_condVariable/barrier.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "barrier.h"
+
+void barrier_init(struct barrier_t * barrier, int nthreads)
+{
+	/*
+		Todo
+	*/
+	barrier->count=0;
+	barrier->leaving=0;
+	
+	barrier->NTHREADS=nthreads;
+	pthread_mutex_init(&barrier->lock,NULL);
+	pthread_cond_init(&barrier->barrier_leaving,NULL);
+	pthread_cond_init(&barrier->barrier_reached,NULL);
+	return;
+}
+
+void barrier_wait(struct barrier_t *barrier)
+{
+	/*
+		Todo
+	*/
+	pthread_mutex_lock(&barrier->lock);
+//	printf("barrier reached before cond %d\n",barrier->count);
+	barrier->count++;
+	if(barrier->count==barrier->NTHREADS){
+		pthread_cond_broadcast(&barrier->barrier_reached);
+		barrier->count=0;			
+		}else{
+			pthread_cond_wait(&barrier->barrier_reached,&barrier->lock);
+		}
+	pthread_mutex_unlock(&barrier->lock);
+
+	pthread_mutex_lock(&barrier->lock);
+	barrier->leaving++;
+	if(barrier->leaving==barrier->NTHREADS){
+		pthread_cond_broadcast(&barrier->barrier_leaving);
+		barrier->leaving=0;			
+		}else{
+			pthread_cond_wait(&barrier->barrier_leaving,&barrier->lock);
+		}
+	pthread_mutex_unlock(&barrier->lock);
+	
+	
+	
+	return;
+}

PA2_2020/2_barrier_using_condVariable/barrier.h

+#include <pthread.h>
+#include<semaphore.h>
+
+struct barrier_t
+{
+	/*
+		Todo
+		Barrier related variables
+	*/
+	pthread_mutex_t lock;
+	pthread_cond_t barrier_reached;
+	pthread_cond_t barrier_leaving;
+	int leaving;
+	int count;
+	int NTHREADS;
+	
+};
+
+void barrier_init(struct barrier_t *b, int i);
+void barrier_wait(struct barrier_t *b);

PA2_2020/2_barrier_using_condVariable/cs_thread.h

+/*
+ * Should run under Unix/Linux/OS X. Just #include this header
+ * in your code and compile with the '-lpthread' flag, e.g.:
+ *    cc -o myBinary myCode.c -lpthread
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+// So we can hopefully ensure that locks and condition variables
+// are initialised before use.
+#define LOCK_COND_INIT_MAGIC 0x4a3acd94
+
+struct lock {
+	int init;
+	pthread_mutex_t mutex;
+};
+
+struct condition {
+	int init;
+	pthread_cond_t cond;
+};
+
+// Sush up -Wall if any of these are unused.
+static void lock_init(struct lock *lock) __attribute__((unused));
+static void lock_acquire(struct lock *lock) __attribute__((unused));
+static void lock_release(struct lock *lock) __attribute__((unused));
+static void cond_init(struct condition *cond) __attribute__((unused));
+static void cond_wait(struct condition *cond, struct lock *lock) __attribute__((unused));
+static void cond_signal(struct condition *cond, struct lock *lock) __attribute__((unused));
+static void cond_broadcast(struct condition *cond, struct lock *lock) __attribute__((unused));
+
+static void
+__assert(int satisfied, const char *message)
+{
+	if (!satisfied) {
+		fprintf(stderr, "FATAL ERROR: %s\n", message);
+		exit(1);
+	}
+}
+
+static void
+lock_init(struct lock *lock)
+{
+	lock->init = LOCK_COND_INIT_MAGIC;
+	pthread_mutex_init(&lock->mutex, NULL);
+}
+
+static void
+lock_acquire(struct lock *lock)
+{
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"lock_acquire used before lock was initialised!");
+	pthread_mutex_lock(&lock->mutex);
+}
+
+static void
+lock_release(struct lock *lock)
+{
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"lock_release used before lock was initialised!");
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"lock_release on unlocked lock!");
+	pthread_mutex_unlock(&lock->mutex);
+}
+
+static void
+cond_init(struct condition *cond)
+{
+	cond->init = LOCK_COND_INIT_MAGIC;
+	pthread_cond_init(&cond->cond, NULL);
+}
+
+static void
+cond_wait(struct condition *cond, struct lock *lock)
+{
+	// Assert the lock is already held. It should be held
+	// by this caller, so while this simple check won't 
+	// catch all bad invocations (somebody else could have
+	// locked it, rather than us) at least it's a start...
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_wait not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_wait used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_wait used before lock was initialised!");
+	pthread_cond_wait(&cond->cond, &lock->mutex);
+}
+
+static void
+cond_signal(struct condition *cond, struct lock *lock)
+{
+	// See comment in cond_wait().
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_signal not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_signal used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_signal used before lock was initialised!");
+	pthread_cond_signal(&cond->cond);
+}
+
+static void
+cond_broadcast(struct condition *cond, struct lock *lock)
+{
+	// See comment in cond_wait().
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_broadcast not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_broadcast used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_broadcast used before lock was initialised!");
+	pthread_cond_broadcast(&cond->cond);
+}

PA2_2020/3_barrier_using_semaphore/barrier.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "barrier.h"
+
+void barrier_init(struct barrier_t * barrier, int nthreads)
+{
+	/*
+		Todo
+	*/
+	barrier->count=0;
+	barrier->NTHREADS=nthreads;
+	pthread_mutex_init(&barrier->lock,NULL);
+	sem_init(&barrier->turn,0,0);
+	sem_init(&barrier->turn2,0,0);
+	return;
+}
+
+void barrier_wait(struct barrier_t *barrier)
+{
+	/*
+		Todo
+	*/
+	pthread_mutex_lock(&barrier->lock);
+	barrier->count++;
+	if(barrier->count==barrier->NTHREADS){
+		for(int i=0;i<barrier->NTHREADS;i++)
+			sem_post(&barrier->turn);
+		}
+	pthread_mutex_unlock(&barrier->lock);
+	
+	sem_wait(&barrier->turn);
+	
+	
+	pthread_mutex_lock(&barrier->lock);
+		barrier->count--;
+		if(barrier->count==0)
+			for(int i=0;i<barrier->NTHREADS;i++)
+				sem_post(&barrier->turn2);
+	pthread_mutex_unlock(&barrier->lock);
+	
+	sem_wait(&barrier->turn2);
+
+	
+	return;
+}

PA2_2020/3_barrier_using_semaphore/barrier.h

+#include <pthread.h>
+#include<semaphore.h>
+
+struct barrier_t
+{
+	/*
+		Todo
+		Barrier related variables
+	*/
+	pthread_mutex_t lock;
+	sem_t turn;
+	sem_t turn2;
+	int count;
+	int NTHREADS;
+	
+};
+
+void barrier_init(struct barrier_t *b, int i);
+void barrier_wait(struct barrier_t *b);

PA2_2020/3_race/Makefile

+# Default to debugging flags. Set to -O3 if you want optimisations
+# (either change it here, or type 'make CFLAGS=-O3' in the shell).
+CFLAGS?=-g -Wall -Wno-unused-value
+
+all: hare_tortoise
+
+hare_tortoise: hare_tortoise.c hare_tortoise_runner.c cs_thread.h
+	$(CC) $(CFLAGS) -o hare_tortoise hare_tortoise_runner.c -lpthread 
+
+clean:
+	$(RM) hare_tortoise
+	$(RM) -r *.dSYM
+
+run: hare_tortoise
+	./hare_tortoise test-file=Testcases/test1.txt
+	./hare_tortoise test-file=Testcases/test2.txt
+	./hare_tortoise test-file=Testcases/test3.txt

PA2_2020/3_race/Testcases/test1.txt

+10
+100
+200
+200
+1000
+10000
+3
+T 20 1000
+H 30 -100
+T 40 2000
+T
\ No newline at end of file

PA2_2020/3_race/Testcases/test2.txt

+1
+10
+20
+200
+1000
+10000
+3
+T 20 1000
+H 30 -100
+T 40 2000
+T
\ No newline at end of file

PA2_2020/3_race/Testcases/test3.txt

+1
+200
+200
+0
+100000
+1000
+0
+T
\ No newline at end of file

PA2_2020/3_race/Testcases/test_format.txt

+time between two successive prints
+tortoise speed per ms
+hare speed per ms
+hare sleep time in ms
+minimum distance between hare and turtle when turtle will sleep
+finish distance
+Number of time god intervene(N)
+N lines with "player time distance"
+winner
+
+1
+10
+200
+2
+1
+1000
+3
+T 2 100
+H 3 -10
+T 4 200
+H

PA2_2020/3_race/barrier.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "barrier.h"
+
+void barrier_init(struct barrier_t * barrier, int nthreads)
+{
+	/*
+		Todo
+	*/
+	barrier->count=0;
+	barrier->leaving=0;
+	
+	barrier->NTHREADS=nthreads;
+	pthread_mutex_init(&barrier->lock,NULL);
+	pthread_cond_init(&barrier->barrier_leaving,NULL);
+	pthread_cond_init(&barrier->barrier_reached,NULL);
+	return;
+}
+
+void barrier_wait(struct barrier_t *barrier)
+{
+	/*
+		Todo
+	*/
+	pthread_mutex_lock(&barrier->lock);
+//	printf("barrier reached before cond %d\n",barrier->count);
+	barrier->count++;
+	if(barrier->count==barrier->NTHREADS){
+		pthread_cond_broadcast(&barrier->barrier_reached);
+		barrier->count=0;			
+		}else{
+			pthread_cond_wait(&barrier->barrier_reached,&barrier->lock);
+		}
+	pthread_mutex_unlock(&barrier->lock);
+
+	pthread_mutex_lock(&barrier->lock);
+	barrier->leaving++;
+	if(barrier->leaving==barrier->NTHREADS){
+		pthread_cond_broadcast(&barrier->barrier_leaving);
+		barrier->leaving=0;			
+		}else{
+			pthread_cond_wait(&barrier->barrier_leaving,&barrier->lock);
+		}
+	pthread_mutex_unlock(&barrier->lock);
+	
+	
+	
+	return;
+}

PA2_2020/3_race/barrier.h

+#include <pthread.h>
+#include<semaphore.h>
+
+struct barrier_t
+{
+	/*
+		Todo
+		Barrier related variables
+	*/
+	pthread_mutex_t lock;
+	pthread_cond_t barrier_reached;
+	pthread_cond_t barrier_leaving;
+	int leaving;
+	int count;
+	int NTHREADS;
+	
+};
+
+void barrier_init(struct barrier_t *b, int i);
+void barrier_wait(struct barrier_t *b);

PA2_2020/3_race/cs_thread.h

+/*
+ * Should run under Unix/Linux/OS X. Just #include this header
+ * in your code and compile with the '-lpthread' flag, e.g.:
+ *    cc -o myBinary myCode.c -lpthread
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+// So we can hopefully ensure that locks and condition variables
+// are initialised before use.
+#define LOCK_COND_INIT_MAGIC 0x4a3acd94
+
+struct lock {
+	int init;
+	pthread_mutex_t mutex;
+};
+
+struct condition {
+	int init;
+	pthread_cond_t cond;
+};
+
+// Sush up -Wall if any of these are unused.
+static void lock_init(struct lock *lock) __attribute__((unused));
+static void lock_acquire(struct lock *lock) __attribute__((unused));
+static void lock_release(struct lock *lock) __attribute__((unused));
+static void cond_init(struct condition *cond) __attribute__((unused));
+static void cond_wait(struct condition *cond, struct lock *lock) __attribute__((unused));
+static void cond_signal(struct condition *cond, struct lock *lock) __attribute__((unused));
+static void cond_broadcast(struct condition *cond, struct lock *lock) __attribute__((unused));
+
+static void
+__assert(int satisfied, const char *message)
+{
+	if (!satisfied) {
+		fprintf(stderr, "FATAL ERROR: %s\n", message);
+		exit(1);
+	}
+}
+
+static void
+lock_init(struct lock *lock)
+{
+	lock->init = LOCK_COND_INIT_MAGIC;
+	pthread_mutex_init(&lock->mutex, NULL);
+}
+
+static void
+lock_acquire(struct lock *lock)
+{
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"lock_acquire used before lock was initialised!");
+	pthread_mutex_lock(&lock->mutex);
+}
+
+static void
+lock_release(struct lock *lock)
+{
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"lock_release used before lock was initialised!");
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"lock_release on unlocked lock!");
+	pthread_mutex_unlock(&lock->mutex);
+}
+
+static void
+cond_init(struct condition *cond)
+{
+	cond->init = LOCK_COND_INIT_MAGIC;
+	pthread_cond_init(&cond->cond, NULL);
+}
+
+static void
+cond_wait(struct condition *cond, struct lock *lock)
+{
+	// Assert the lock is already held. It should be held
+	// by this caller, so while this simple check won't 
+	// catch all bad invocations (somebody else could have
+	// locked it, rather than us) at least it's a start...
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_wait not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_wait used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_wait used before lock was initialised!");
+	pthread_cond_wait(&cond->cond, &lock->mutex);
+}
+
+static void
+cond_signal(struct condition *cond, struct lock *lock)
+{
+	// See comment in cond_wait().
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_signal not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_signal used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_signal used before lock was initialised!");
+	pthread_cond_signal(&cond->cond);
+}
+
+static void
+cond_broadcast(struct condition *cond, struct lock *lock)
+{
+	// See comment in cond_wait().
+	__assert(pthread_mutex_trylock(&lock->mutex) != 0,
+		"cond_broadcast not called with lock held!");
+	__assert(cond->init == LOCK_COND_INIT_MAGIC,
+		"cond_broadcast used before cond was initialised!");
+	__assert(lock->init == LOCK_COND_INIT_MAGIC,
+		"cond_broadcast used before lock was initialised!");
+	pthread_cond_broadcast(&cond->cond);
+}

PA2_2020/3_race/hare_tortoise.c

+#include "cs_thread.h"
+#include "barrier.c"
+struct Repositioning {
+	char player; 		// T for turtle and H for hare
+	int time; 		// At what time god interrupt's
+	int distance;		// How much does god move any of the player. 
+							// distance can be negetive or positive.
+							// using this distance if any of players position is less than zero then bring him to start line.
+							// If more than finish_distance then make him win.
+							// If time is after completion of game than you can ignore it as we will already have winner.
+};
+
+struct race {
+	
+	//	Don't change these variables.
+	//	speeds are unit distance per unit time.
+	int printing_delay;
+	int tortoise_speed;					// speed of Turtle
+	int hare_speed;						// speed of hare
+	int hare_sleep_time; 				// how much time does hare sleep (in case he decides to sleep)
+	int hare_turtle_distance_for_sleep; // minimum lead which hare has on turtle after which hare decides to move
+										// Any lead greater than this distance and hare will ignore turtle and go to sleep
+	int finish_distance;				// Distance between start and finish line
+	struct Repositioning* reposition;	// pointer to array containing Randomizer's decision
+	int repositioning_count;			// number of elements in array of repositioning structure
+	
+	//	Add your custom variables here.
+	int timeUnit;
+	int turtle_dist;
+	int hare_dist;
+	int turtle_prev_dist;
+	struct barrier_t  barrier_time;
+	struct barrier_t  barrier_loop;
+	int winner_decided;
+	pthread_mutex_t winner_lock;
+	pthread_mutex_t haredone_t;
+	int hareDone;
+	pthread_cond_t hareDoneCond;
+};
+
+
+void* Turtle(void *race);
+void* Hare(void *race);
+void* Randomizer(void *race);
+void* Report(void *race);
+
+char init(struct race *race)
+{
+	pthread_cond_init(&race->hareDoneCond,NULL);
+	pthread_mutex_init(&race->haredone_t,NULL);
+	//initializing shared data ,lock and barrier
+	pthread_mutex_init(&(race->winner_lock),NULL);
+	 barrier_init(&(race->barrier_loop),5);
+	barrier_init(&(race->barrier_time),5);
+	race->winner_decided=0;
+	race->turtle_prev_dist=0;
+	race->timeUnit=-1;
+	race->hare_dist=0;
+	race->turtle_dist=0;
+	race->hareDone=0;
+char win='-';
+	//creation of threads
+	pthread_t threads[4];
+	pthread_create(&threads[0],NULL,Turtle,(void *)race);
+	pthread_create(&threads[1],NULL,Hare,(void *)race);
+	pthread_create(&threads[2],NULL,Randomizer,(void *)race);
+	pthread_create(&threads[3],NULL,Report,(void *)race);	
+//	int loop=0;
+	int winner=0;
+	while(1){
+		pthread_mutex_lock(&(race->winner_lock));
+			if(race->turtle_dist>=race->finish_distance ){
+				race->winner_decided=1;
+				win='T';
+			}
+			else if(race->hare_dist>=race->finish_distance ){
+					race->winner_decided=1;
+					win='T';
+			}
+			winner=race->winner_decided;
+		pthread_mutex_unlock(&(race->winner_lock));
+		if(winner){
+
+			//printf("winner decided \n");
+			break;
+		}
+
+		race->timeUnit++;
+		race->hareDone=0;
+	//	printf("init generating  time \n");
+		barrier_wait(&(race->barrier_time));
+
+
+	//	printf("init waiting for loop \n");
+		barrier_wait(&(race->barrier_loop));
+
+
+	//	loop++;
+
+	}
+
+
+
+	pthread_join(threads[0],NULL);
+	pthread_join(threads[1],NULL);
+	pthread_join(threads[2],NULL);
+	pthread_join(threads[3],NULL);
+	return win; 
+}
+
+void* Turtle(void *arg)
+{	struct race *race=(struct race*)arg;
+
+	//int loop=0;
+	int winner=0;
+	while(1){
+		pthread_mutex_lock(&(race->winner_lock));
+		if(race->turtle_dist>=race->finish_distance ){
+				winner=1;
+			}
+		else if(race->hare_dist>=race->finish_distance ){
+			winner=1;
+			}
+		//winner=race->winner_decided;
+		pthread_mutex_unlock(&(race->winner_lock));
+		if(winner){
+			break;
+		}
+		
+		race->turtle_prev_dist=race->turtle_dist;
+		barrier_wait(&(race->barrier_time));
+	//	printf("turtle waiting for time \n");
+		pthread_mutex_lock(&race->haredone_t);
+			while(race->hareDone!=1)
+				pthread_cond_wait(&race->hareDoneCond,&race->haredone_t);
+		pthread_mutex_unlock(&race->haredone_t);
+		race->turtle_dist+= race->tortoise_speed;
+		printf("turtle waiting for loop \n");
+		barrier_wait(&(race->barrier_loop));
+
+
+	//	loop++;https://www.enterprisedb.com/edb-docs/d/edb-postgres-enterprise-manager/reference/online-documentation/7.8/pem_interpreting_graphical_query.html
+
+	}
+	return NULL;
+}
+
+void* Hare(void *arg)
+{
+struct race *race=(struct race*)arg;
+	//int loop=0;
+	int winner=0;
+	int sleep_remain;
+	while(1){
+		pthread_mutex_lock(&(race->winner_lock));
+			if(race->turtle_dist>=race->finish_distance ){
+			winner=1;
+			}
+		else if(race->hare_dist>=race->finish_distance ){
+				winner=1;
+			}
+			//winner=race->winner_decided;
+		pthread_mutex_unlock(&(race->winner_lock));
+		if(winner){
+			break;
+		}
+
+	//	printf("hare waiting for time \n");
+		barrier_wait(&(race->barrier_time));
+		if(sleep_remain>0){
+			sleep_remain--;
+	//		printf("hare sleeping");
+		}else
+		{	
+			//runs and this iteration also reduce sleeping time
+			if((race->turtle_prev_dist - race->turtle_dist ) >= race->hare_turtle_distance_for_sleep){
+				//handles if sleep time is zero
+				if(race->hare_sleep_time==0){
+					race->hare_dist+=race->hare_speed;
+	//				printf("hare runs because sleep zero\n");
+				}
+				sleep_remain=race->hare_sleep_time-1;
+			}else
+			{
+				//runs and then sleep
+	//			printf("hare runs \n and now going to sleep");
+				race->hare_dist+=race->hare_speed;
+				sleep_remain=race->hare_sleep_time;
+			}
+		
+		}
+		pthread_mutex_lock(&race->haredone_t);
+		race->hareDone=1;
+		
+		pthread_mutex_unlock(&race->haredone_t);
+		pthread_cond_signal(&race->hareDoneCond);
+		//printf("hare waiting for loop \n");
+		barrier_wait(&(race->barrier_loop));
+
+
+	//	loop++;
+
+	}
+
+
+	return NULL;
+}
+
+
+void* Randomizer(void *arg)
+{
+struct race *race=(struct race*)arg;
+	int rep_count=0;
+	//int loop=0;
+	int winner=0;
+	while(1){
+		pthread_mutex_lock(&(race->winner_lock));
+			if(race->turtle_dist>=race->finish_distance ){
+				winner=1;
+			}
+		else if(race->hare_dist>=race->finish_distance ){
+			winner=1;
+			}
+			//winner=race->winner_decided;
+		pthread_mutex_unlock(&(race->winner_lock));
+		if(winner){
+			break;
+		}
+
+	//	printf("rand waiting for time \n");
+		barrier_wait(&(race->barrier_time));
+		if(race->repositioning_count>rep_count){
+	//		printf("time to randomize %d\n",race->reposition[rep_count].time);
+			if(race->timeUnit == race->reposition[rep_count].time){
+	//			printf("repostining %d current timeunit %d \n",race->reposition[rep_count].time,race->timeUnit);
+				if(race->reposition[rep_count].player=='T'){
+					race->turtle_dist+=race->reposition[rep_count].distance;
+				}else{
+					race->hare_dist+=race->reposition[rep_count].distance;
+				}
+				rep_count++;
+			}
+			
+		}
+		
+
+	//	printf("rand waiting for loop \n");
+		barrier_wait(&(race->barrier_loop));
+
+
+		//loop++;
+
+	}
+
+	return NULL;
+}
+
+void* Report(void *arg)
+{
+struct race *race=(struct race*)arg;
+
+//int loop=0;
+	int winner=0;
+	while(1){
+		pthread_mutex_lock(&(race->winner_lock));
+		if(race->turtle_dist>=race->finish_distance ){
+			winner=1;
+			}
+		else if(race->hare_dist>=race->finish_distance ){
+		winner=1;
+			}
+			//winner=race->winner_decided;
+		pthread_mutex_unlock(&(race->winner_lock));
+		if(winner){
+			break;
+		}
+
+	//	printf("report waiting for time \n");
+		barrier_wait(&(race->barrier_time));
+
+		if((race->timeUnit % race->printing_delay)==0)
+			printf("Hare distance %d and turtle distance %d at time unit %d\n",race->hare_dist,race->turtle_dist,race->timeUnit);
+
+
+//		printf("report waiting for loop \n");
+		barrier_wait(&(race->barrier_loop));
+
+
+		//loop++;
+
+	}
+
+	return NULL;
+}
+

PA2_2020/3_race/hare_tortoise_runner.c

+#include <time.h>
+#include <errno.h>  
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <string.h>
+
+#include "hare_tortoise.c"
+
+
+char w;
+int parseInput(const char* filename, struct race * race) {
+    FILE* f = fopen(filename,"r");
+    if (f == NULL) {
+        printf("Couldn't open file at %s\n",filename);
+        return -1;
+    }
+    if (fscanf(f,"%d\n",&(race->printing_delay)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->tortoise_speed)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->hare_speed)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->hare_sleep_time)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->hare_turtle_distance_for_sleep)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->finish_distance)) != 1) { printf("wrong input file format\n"); return -1;};
+    if (fscanf(f,"%d\n",&(race->repositioning_count)) != 1) { printf("wrong input file format\n"); return -1;};
+    race->reposition = (struct Repositioning*) malloc(sizeof(struct Repositioning) * race->repositioning_count);
+    size_t i;
+    for (i = 0; i < race->repositioning_count; i++)
+    {
+        // printf("%d\n",fscanf(f,"%c %d %d\n",
+        //                 &((race->reposition)[i].player),
+        //                 &((race->reposition)[i].time),
+        //                 &((race->reposition)[i].distance)));
+        if (fscanf(f,"%c %d %d\n",
+                        &((race->reposition)[i].player),
+                        &((race->reposition)[i].time),
+                        &((race->reposition)[i].distance)) != 3) 
+            { printf("wrong input file format\n"); return -1;};
+    }
+
+    printf("+------------------------------+\n");
+    printf("| Printing delay  : %7d    |\n",race->printing_delay);
+    printf("| Turtle speed    : %7d    |\n",race->tortoise_speed);
+    printf("| Hare speed      : %7d    |\n",race->hare_speed);
+    printf("| Hare Sleep time : %7d    |\n",race->hare_sleep_time);
+    printf("| Hare-Turtle Dist: %7d    |\n",race->hare_turtle_distance_for_sleep);
+    printf("| Total distance  : %7d    |\n",race->finish_distance);
+    printf("+------------------------------+\n");
+    printf("| Repositioning Data           |\n");
+    printf("+--------+--------+------------+\n| player |  time  |  distance  |\n+--------+--------+------------+\n");
+    for (i = 0; i < race->repositioning_count; i++) {
+        printf("| %6c | %6d | %9d  |\n",
+                        ((race->reposition)[i].player),
+                        ((race->reposition)[i].time),
+                        ((race->reposition)[i].distance));
+    }
+    if (fscanf(f,"%c\n",&(w)) != 1) { printf("wrong input file format\n"); return -1;};
+    printf("+--------+--------+------------+\n");
+    printf("+--------- Race Begins --------+\n");
+    fclose(f);
+    return 0;
+}
+
+int main(int argc, char const *argv[])
+{
+    struct race *race = malloc(sizeof(struct race));
+    char* testFile  = "test-file=";
+    const char* inputFileName = NULL;
+
+    int i;
+    for (i=0;i<argc;i++){
+        if(!strncmp(testFile,argv[i],strlen(testFile)) && strlen(argv[i]) > strlen(testFile)){
+            inputFileName = (argv[i] + strlen(testFile));
+        }
+    }
+    if (inputFileName == NULL) {
+        printf("Invalid file format.\n");
+        return 0;
+    }
+    printf("Entered filename : %s\n",inputFileName);
+    if (parseInput(inputFileName, race)) {return 0;}
+    char winner = init(race);
+    printf("+---------- Race Ends ---------+\n");
+    if (winner == w) printf("Correct output.\n");
+    else            printf("Wrong output.\nExpected output was %c.\nYou output was %c.\n",w,winner);
+    return 0;
+}

PA2_2020/3_race/test.sh

+#!/bin/bash
+out=0
+for i in {1..100}
+do
+
+	if [ 3 -ne $(make run | grep Cor | wc -l) ]
+	then
+		echo 'invalid'
+	fi
+done

PA2_2020/Makefile

+# Default to debugging flags. Set to -O3 if you want optimisations
+# (either change it here, or type 'make CFLAGS=-O3' in the shell).
+CFLAGS?=-g -Wall -Wno-unused-value
+
+compile_nlocks:
+	$(CC) $(CFLAGS) -o nlocks nlocks.c -lpthread 
+
+clean_nlocks:
+	$(RM) nlocks
+
+run_nlocks: clean_nlocks compile_nlocks
+	./nlocks
+	./hare_tortoise test-file=Testcases/test2.txt
+	./hare_tortoise test-file=Testcases/test3.txt
+	
+	
+compile_threads:
+	$(CC) $(CFLAGS) -o threads threads.c -lpthread 
+
+clean_threads:
+	$(RM) threads
+
+run_threads: clean_threads compile_threads
+	./threads $(count)

PA2_2020/nlocks.c

+#include<stdio.h>
+#include<stdlib.h>
+#include<pthread.h>
+#include<unistd.h>
+/* 
+ * This is the data array which is to
+ * be incremented by all the threads created 
+ * by your program as specified in the problem state
+*/
+int data[10];
+pthread_mutex_t locks[10];
+
+void increment(void* arg){
+	int i=*(int*)arg;
+	//printf("thread %d\n",i);
+	int j=0;
+	while(j<1000){
+		pthread_mutex_lock(&locks[i]);
+		data[i]++;
+		pthread_mutex_unlock(&locks[i]);
+		j++;
+	}
+	//printf("thread %d exists\n",i);
+}
+
+int main(int argc, char const *argv[])
+{
+
+
+	/* Write you code to create 10 threads here*/
+	/* Increment the data array as specified in the problem statement*/
+	//initialize locks and data array
+	int i;
+	for( i=0;i<10;i++){
+		pthread_mutex_init(&locks[i],NULL);
+		data[i]=0;
+	}
+	pthread_t threads[10];
+	//initialize thread and pass thread i for locking
+	for(i=0;i<10;i++){
+		int* arg=(int*)malloc(sizeof(int));
+		*arg=i;
+		pthread_create(&threads[i],NULL,(void*)increment,(void*)arg);
+	}
+	int j=1000;
+	while(j>0){
+		j--;
+		i=0;
+		while(i<10){
+			pthread_mutex_lock(&locks[i]);
+				data[i]++;
+			pthread_mutex_unlock(&locks[i]);	
+		
+		
+			i++;
+		}	
+	}
+
+	/* Make sure you reap all threads created by your program
+	 before printing the counter*/
+	 	//join thread
+	for( i=0;i<10;i++){
+		pthread_join(threads[i],NULL);
+	}
+	
+	for (int i = 0; i < 10; ++i)
+	{
+		printf("%d\n", data[i]);
+	}
+	
+	sleep(10000);
+	return 0;
+}

PA2_2020/readme.txt

+Name : paras garg
+roll no :203050004
+
+(a) Compiling and running nlocks : make run_nlocks
+(b) compiling and  running  nthreads with arguments : make   count=value run_nthreads
+							ex : make count=55 run_nthreads
+							
+Refernces: 
+	man pages for pthread library
+	turnstile solution reference from little books of semaphore

PA2_2020/threads.c

+#include<stdio.h>
+#include<stdlib.h>
+#include<unistd.h>
+#include<pthread.h>
+
+/* 
+ * This is the counter value which is to
+ * be incremented by all the threads created 
+ * by your program
+*/
+int counter = 0;
+pthread_mutex_t mutex;
+void incrementCounter(){
+	pthread_mutex_lock(&mutex);
+	counter++;
+	pthread_mutex_unlock(&mutex);
+}
+
+int main(int argc, char const *argv[])
+{
+	/* Write you code to create n threads here*/
+	/* Each thread must increment the counter once and exit*/
+	 if(argc<2){
+	 	printf("Please pass No of thread as arguments\n");
+	 	return 0;
+	 }
+	pthread_mutex_init(&mutex,NULL);
+	
+	int n=atoi(argv[1]);
+	printf("n%d\n",n);
+	 pthread_t thread[n];
+
+	int i=0;
+	while(i<n){
+		pthread_create(&thread[i],NULL,(void*)incrementCounter,NULL);
+		i++;
+	}
+
+	i=0;
+	while(i<n){
+		pthread_join(thread[i],NULL);
+		i++;
+	}
+	/* Make sure you reap all threads created by your program
+	 before printing the counter*/
+	printf("%d\n", counter);
+	sleep(10000);
+	return 0;
+}