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

// producer-consumer program illustrating pthread synchronization

// Shared circular queue for read/write.  It's declared globally for
// easy access by different threads.  Of course we can also pass pointers
// to shared structs, but that's just more code.

// Producer threads write to buffer and blocks when buffer is full.
// Consumer threads read from buffer and blocks when buffer is empty.

// globally shared 1K buffer:
#define QCAP 1024
int buffer[QCAP];

int front = 0; // index of first value in buffer (picture on left end)
int size = 0;  // current size of buffer.
int back() { return (front+size) % QCAP; } // index of last value+1
int right(int i) { return (i+1)%QCAP; }  // index to the "right" of index i
int left(int i) { return (i+QCAP-1)%QCAP; } // index to the "left" of i
void enqueue(int x) // add to back
{ buffer[back()] = x;  size++; }
int pop() // take from front
{ 
  int ax = (int)buffer[front];
  front = right(front);
  size--;
  return ax;
}


pthread_mutex_t synch;
pthread_cond_t consume;  // producers and consumers block on separate 
pthread_cond_t produce;  // conditions.

/*  
A thread has three principal states: running, blocked and ready.  Blocked
means the thread is waiting for some condition to become true.  Ready means
that the condition is met, and the thread now wants to run, but it may
not run immediately, usually because it hasn't acquired a mutex (passed
pthread_mutex_lock).

When a thread calls
  pthread_cond_wait(pthread_cond_t*,pthread_mutex_t*) 
the thread releases the specified mutex and "blocks" on the condition queue.
This call is equivalent to calling wait() inside a synchronized method in java,
except here the synchronization is controlled by the mutex.

When a thread calls
  pthread_cond_signal(pthread_cond_t*)
one thread that's blocked on the specified condition queue is placed in
the ready state, but will not run until it acquires the mutex that it
blocked on.  In other words, implicitly the released thread will call
pthread_mutex_lock again.  Usually, signal is called by a thread that already
holds the mutex (passed lock). Such a 
call is equivalent to calling notify() inside a synchronized method in java

pthread_cond_broadcast(pthread_cond_t*) unblocks all threads waiting on the
condition and equivalent to calling notifyAll() in java.

Usually, pthread_cond_wait/signal/broadcast is called while the thread is
holding a mutex (between pthread_mutex_lock and pthread_mutex_unlock): this
corresponds to calling the equivalent operations inside synchronized methods
in java.
 */

int runs = 10;  // number of times each producer and consumer will loop.
// producer simulation thread function
void * producetf(void * info)
{
  int id = *(int*)info; // thread id - as determined by software
  printf("producer %d started..\n",id);
  for(int r=0;r<runs;r++)
    {
      int n = random() % QCAP/2;  // random amount of info to produce
      pthread_mutex_lock(&synch);
      // the while loop is needed because broadcast is used instead of signal
      while (QCAP-size<n) // not enough space in buffer to write
	{ printf("producer %d waiting for %d slots to be available\n",id,n);
	  fflush(stdout);
	  pthread_cond_wait(&produce,&synch);
	}
      // write to buffer
      for(int i=0;i<n;i++) enqueue(id);
      printf("**producer %d wrote %d values\n",id,n); fflush(stdout);
      pthread_cond_broadcast(&consume); // signal all consumer threads
      pthread_mutex_unlock(&synch);
    }
}//producetf

// consumer simulation thread function
void * consumetf(void * info)
{
  int id = *(int*)info; // thread id - as determined by software
  printf("consumer %d started..\n",id);
  for(int r=0;r<runs;r++)
    {
      int n = random() % QCAP/2;  // random amount of info to consume
      pthread_mutex_lock(&synch);
      // the while loop is needed because broadcast is used instead of signal
      while (size<n)
	{ printf("consumer %d waiting for %d values\n",id,n);
	  fflush(stdout);
	  pthread_cond_wait(&consume,&synch);
	}
      // write to buffer
      for(int i=0;i<n;i++) pop();
      printf("****consumer %d consumed %d values\n",id,n); fflush(stdout);
      pthread_cond_broadcast(&produce); // signal all producer threads
      pthread_mutex_unlock(&synch);
    }
}//producetf



int main()
{
  pthread_mutex_init(&synch,NULL);
  pthread_cond_init(&consume,NULL);
  pthread_cond_init(&produce,NULL);

  pthread_t TID[6];
  int ids[6];
  int i = 0;
  while (i<6)
    {
      ids[i] = i; ids[i+1] = i+1;
      pthread_create(TID+i,NULL,producetf,ids+i);
      i++;
      pthread_create(TID+i,NULL,consumetf,ids+i);
      i++;
    }
    for(i=0;i<6;i++)
      pthread_join(TID[i],NULL);  // wait for threads to finish
  return 0;
}

// this program may not finish because some threads may still be waiting.