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

#define BUF_SIZE 10
#define NUM_PRODUCED 20

int buf[BUF_SIZE]; /* A buffer of limited size. */

/* At each instant, represents number of items produced but not yet consumed. */
int numItemsInBuffer = 0;

/* Condition variable to signal that a slot has emptied in the buffer. */
pthread_cond_t slotAvailableCond = PTHREAD_COND_INITIALIZER;

/* Condition variable to signal that a new item has been put in the buffer. */
pthread_cond_t itemAvailableCond = PTHREAD_COND_INITIALIZER;

/* A mutex to control access to global variables. */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void * producerFunction (void *arg)
{
	int i, firstEmptySlot = 0, nextProduced;
	for (i=0; i<NUM_PRODUCED; i++) {
		nextProduced = 5*i;
		printf("Producing %d\n", nextProduced);
		fflush(NULL);
		/* Lock the mutex. */
		pthread_mutex_lock(&mutex);
		/* If buffer is full, wait until a slot is emptied. */
		while (numItemsInBuffer >= BUF_SIZE)
			pthread_cond_wait(&slotAvailableCond,&mutex);
		/* Put next produced item in the buffer. */
		buf[firstEmptySlot] = nextProduced;
		/* Adjust variables. */
		firstEmptySlot = (firstEmptySlot + 1) % BUF_SIZE;
		++numItemsInBuffer;
		/* Notify that there is at least one item available in the buffer. */
		pthread_cond_signal(&itemAvailableCond);
		/* Unlock the mutex. */
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}

void * consumerFunction (void *arg)
{
	int i, firstAvailableItem = 0, nextConsumed;
	for (i=0; i<NUM_PRODUCED; i++) {
		/* Lock the mutex. */
		pthread_mutex_lock(&mutex);
		/* If buffer is empty, wait until an item is produced. */
		while (numItemsInBuffer <= 0)
			pthread_cond_wait(&itemAvailableCond,&mutex);
		/* Read next available item. */
		nextConsumed = buf[firstAvailableItem];
		/* Adjust variables. */
		firstAvailableItem = (firstAvailableItem + 1) % BUF_SIZE;
		--numItemsInBuffer;
		/* Notify that there is at least one empty slot in the buffer. */
		pthread_cond_signal(&slotAvailableCond);
		/* Unlock the mutex. */
		pthread_mutex_unlock(&mutex);
		printf("Consuming %d\n",nextConsumed);
		fflush(NULL);
	}
	return NULL;
}


int main()
{
	pthread_t producer, consumer;

	/* creating threads */
	if (pthread_create(&producer,NULL,producerFunction,NULL) != 0) {
		fprintf(stderr,"Creating producer thread failed!");
		return 1;
	}
	if (pthread_create(&consumer,NULL,consumerFunction,NULL) != 0) {
		fprintf(stderr,"Creating consumer thread failed!");
		return 1;
	}

	/* joining threads (== waiting for them to exit) */
	if ( pthread_join(producer,NULL) != 0 ) {
		fprintf(stderr,"Joining producer thread failed!");
		return 1;
	}
	if ( pthread_join(consumer,NULL) != 0 ) {
		fprintf(stderr,"Joining consumer thread failed!");
		return 1;
	}

	return 0;
}