/*
 * Synchronization via condition variables.
 * Bounded buffer example.
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>

#define N 4
#define CAPACITY 10
int buffer[CAPACITY];
int tail, head;

pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER;    // protects buffer, head, tail;

pthread_cond_t items_avail = PTHREAD_COND_INITIALIZER;      // items available for consumption
pthread_cond_t slots_avail = PTHREAD_COND_INITIALIZER;      // buffer slots available for production

void produce(int item)
{
    pthread_mutex_lock(&buffer_lock);       // Enter monitor
    while ((tail + 1 - head) % CAPACITY == 0)
        // Leave monitor (release buffer_lock)
        // Add calling thread to 'slots_avail' queue
        // Block
        // Enter monitor (acquire buffer_lock)
        pthread_cond_wait(&slots_avail, &buffer_lock);  
    // invariant: (a) buffer_lock is held
    //            (b) slot is available

    printf("thread %p: produces item %d\n", (void *)pthread_self(), item);
    buffer[head] = item;                    // update buffer state
    head = (head + 1) % CAPACITY;
    pthread_cond_signal(&items_avail);      // wake up consumer (if any)
    pthread_mutex_unlock(&buffer_lock);     // Leave monitor
}

void consume()
{
    pthread_mutex_lock(&buffer_lock);       // Enter monitor
    while (head == tail)
        pthread_cond_wait(&items_avail, &buffer_lock);
    // invariant: (a) buffer_lock is held
    //            (b) item is available

    int item = buffer[tail];
    tail = (tail + 1) % CAPACITY;
    printf("thread %p: consumes item %d\n", (void *)pthread_self(), item);
    pthread_cond_signal(&slots_avail);      // wake up producer (if any)
    pthread_mutex_unlock(&buffer_lock);     // Leave monitor
}

static void *
producer(void *_items_to_produce)
{
    int n = *(int *)_items_to_produce;
    for (int i = 0; i < n; i++)
        produce(i);

    return NULL;
}

static void *
consumer(void *_items_to_consume)
{
    int n = *(int *)_items_to_consume;
    for (int i = 0; i < n; i++)
        consume();

    return NULL;
}

int
main()
{
    pthread_t t[N];
    int items [N] =             { 3,        2,        4,        1 };
    void * (*func [N])(void*) = { consumer, consumer, producer, producer };
    srand(getpid());

    for (int i = 0; i < N; i++)
        pthread_create(&t[i], NULL, func[i], items + i);

    for (int i = 0; i < N; i++)
        pthread_join(t[i], NULL);
    return 0;
}