/*
 * Semaphore-based implementation of readers/writers.
 *
 * Gives priority to readers, so writers could starve.
 *
 * (Solution from Wikipedia.)
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <semaphore.h>

#include "test-readers-writers.h"
#include "readers-writers.h"

/* global variables for synchronization */
sem_t reader_mutex;
sem_t writer_mutex;
int reader_count = 0;

void init_synch(void) {
    sem_init(&reader_mutex, 0, 1);
    sem_init(&writer_mutex, 0, 1);
}

void end_synch() {
    sem_destroy(&reader_mutex);
    sem_destroy(&writer_mutex);
}

void simulate_read_with_synch(const int readerID, const int delay) {
    sem_wait(&reader_mutex);
    reader_count += 1;
    if (reader_count == 1) {
        sem_wait(&writer_mutex);
    }
    sem_post(&reader_mutex);

    simulate_read(readerID, reader_count, delay);

    sem_wait(&reader_mutex);
    reader_count -= 1;
    if (reader_count == 0) {
        sem_post(&writer_mutex);
    }
    sem_post(&reader_mutex);
}

void simulate_write_with_synch(const int writerID, const int delay) {
    sem_wait(&writer_mutex);

    simulate_write(writerID, delay);

    sem_post(&writer_mutex);
}