cyclic_b.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <stdbool.h>

const int buffer_size = 4;
int buffer[buffer_size];

int in = 0;
int out = 0;

bool status = true;

typedef struct
{
    int value;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
} my_semaphore;

void sema_init(my_semaphore *sem, int value)
{
    sem->value = value;
    pthread_mutex_init(&sem->mutex, NULL);
    pthread_cond_init(&sem->cond, NULL);
}

void sema_wait(my_semaphore *sem)
{
    pthread_mutex_lock(&sem->mutex);
    while (sem->value == 0)
    {
        pthread_cond_wait(&sem->cond, &sem->mutex);
    }
    sem->value--;
    pthread_mutex_unlock(&sem->mutex);
}

void sema_signal(my_semaphore *sem)
{
    pthread_mutex_lock(&sem->mutex);
    sem->value++;
    pthread_cond_signal(&sem->cond);
    pthread_mutex_unlock(&sem->mutex);
}

int get_value(my_semaphore *sem)
{
    int value;
    pthread_mutex_lock(&sem->mutex);
    value = sem->value;
    pthread_mutex_unlock(&sem->mutex);
    return value;
}

my_semaphore full, empty, sema0;
void producer(void *ID)
{
    int producer_number = *((int *)ID);
    bool b = true;
    while (b || status)
    {
        b = false;
        int items_produced = (rand() % 100) + 1;

        sema_wait(&empty);
        sema_wait(&sema0);

        if (in == out && buffer[in] != 0)
        {
            sema_signal(&empty);
            sema_signal(&sema0);
            return;
        }

        buffer[in] = items_produced;
        in++;
        in %= buffer_size;

        printf("producer %d produced %d\n", producer_number, items_produced);

        for (int i = 0; i < buffer_size; ++i)
        {
            printf("%d ", buffer[i]);
        }
        printf("\n");

        sema_signal(&sema0);
        sema_signal(&full);

        sleep((rand() % 5) + 1);
    }
}

void consumer(void *ID)
{
    int consumer_number = *((int *)ID);

    bool b = true;
    while (b || status)
    {
        b = false;
        sema_wait(&full);
        sema_wait(&sema0);

        if (buffer[out]==0)
        {
            sema_signal(&full);
            sema_signal(&sema0);
            return;
        }

        int items_consumed = buffer[out];
        buffer[out] = 0;
        out++;
        out%=buffer_size;

        printf("consumer %d consumed %d\n", consumer_number, items_consumed);
        for (int i = 0; i < buffer_size; ++i)
        {
            printf("%d ", buffer[i]);
        }
        printf("\n");

        sema_signal(&sema0);
        sema_signal(&empty);
        sleep((rand() % 5) + 1);
    }

    sema_signal(&empty);
}

int main()
{
    int n1 = 5;
    int n2 = 5;

    sema_init(&empty, buffer_size);
    sema_init(&full, 0);
    sema_init(&sema0, 1);

    pthread_t pro[n1], cons[n2];

    int producer_arr[n1];
    int consumer_arr[n2];
    for (int i = 0; i < n1; i++)
    {
        producer_arr[i] = i;
    }
    for (int i = 0; i < n2; i++)
    {
        consumer_arr[i] = i;
    }

    for (int i = 0; i < n1; i++)
    {
        pthread_create(&pro[i], NULL, (void *(*)(void *))producer, (void *)&producer_arr[i]);
    }
    for (int i = 0; i < n2; i++)
    {
        pthread_create(&cons[i], NULL, (void *(*)(void *))consumer, (void *)&consumer_arr[i]);
    }

    sleep(5);
    status = false;

    for (int i = 0; i < n1; i++)
    {
        pthread_join(pro[i], NULL);
    }
    for (int i = 0; i < n2; i++)
    {
        pthread_join(cons[i], NULL);
    }

    return 0;
}