/* $OpenBSD: pthread_rwlock.c,v 1.3 2014/05/20 01:25:24 guenther Exp $ */
/* PUBLIC DOMAIN Feb 2012 <guenther@openbsd.org> */

#include <sys/types.h>
#include <assert.h>
#include <err.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

/*
 * Set up an rwlock with a few reader threads, start a writer blocking,
 * then let go the reader threads one by one.  Verify that the writer
 * thread gets, gets out, and then the rwlock can be locked for reading
 * again.
 */

pthread_rwlock_t        rw;

pthread_mutex_t m;
pthread_cond_t c;
enum
{
        UNLOCKED,
        NUM_READERS = 6,
        WRITE_STARTED,
        WRITE,
        WRITE_DONE,
} state;
time_t write_started;

static void *
reader(void *arg)
{
        int     me = *(int *)arg;
        int diff;

        pthread_mutex_lock(&m);
        assert(state < NUM_READERS);
        pthread_rwlock_rdlock(&rw);
        state++;
        printf("reader %d locked, state = %d\n", me, state);
        pthread_cond_broadcast(&c);
        pthread_mutex_unlock(&m);

        pthread_mutex_lock(&m);
        while (state < WRITE_STARTED) {
                pthread_cond_wait(&c, &m);
                printf("reader %d woken, state = %d\n", me, state);
        }

        diff = difftime(time(NULL), write_started);
        if (diff < 2)
                sleep(3 - diff);

        pthread_rwlock_unlock(&rw);
        printf("reader %d unlocked\n", me);
        sleep(1);

        pthread_mutex_unlock(&m);

        pthread_mutex_lock(&m);
        while (state >= WRITE_STARTED) {
                pthread_cond_wait(&c, &m);
                printf("reader %d woken, state = %d\n", me, state);
        }
        state++;
        printf("reader %d trying again (%d)\n", me, state);
        pthread_rwlock_rdlock(&rw);
        printf("reader %d locked again (%d)\n", me, state);
        pthread_cond_broadcast(&c);
        while (state != NUM_READERS) {
                pthread_cond_wait(&c, &m);
                printf("reader %d woken, state = %d\n", me, state);
        }
        pthread_mutex_unlock(&m);
        pthread_rwlock_unlock(&rw);

        printf("reader %d exiting\n", me);
        return NULL;
}

static void *
writer(void *arg)
{
        pthread_mutex_lock(&m);
        printf("writer started, state = %d\n", state);
        while (state != NUM_READERS) {
                pthread_cond_wait(&c, &m);
                printf("writer woken, state = %d\n", state);
        }
        state = WRITE_STARTED;
        printf("writer starting\n");
        write_started = time(NULL);
        pthread_cond_broadcast(&c);
        pthread_mutex_unlock(&m);

        pthread_rwlock_wrlock(&rw);
        printf("writer locked\n");

        pthread_mutex_lock(&m);
        state = WRITE;
        pthread_cond_broadcast(&c);

        while (state == WRITE)
                pthread_cond_wait(&c, &m);

        printf("writer unlocking\n");
        pthread_rwlock_unlock(&rw);
        state = UNLOCKED;
        pthread_cond_broadcast(&c);
        pthread_mutex_unlock(&m);

        printf("writer exiting\n");
        return NULL;
}


int
main(void)
{
        pthread_t       tr[NUM_READERS], tw;
        int     ids[NUM_READERS], i, r;

        pthread_rwlock_init(&rw, NULL);
        pthread_mutex_init(&m, NULL);
        pthread_cond_init(&c, NULL);
        state = UNLOCKED;

        for (i = 0; i < NUM_READERS; i++) {
                ids[i] = i;
                if ((r = pthread_create(&tr[i], NULL, reader, &ids[i])))
                        errc(1, r, "create %d", i);
        }

        if ((r = pthread_create(&tw, NULL, writer, NULL)))
                errc(1, r, "create writer");

        pthread_mutex_lock(&m);
        while (state != WRITE)
                pthread_cond_wait(&c, &m);
        state = WRITE_DONE;
        pthread_mutex_unlock(&m);
        pthread_cond_broadcast(&c);

        pthread_join(tw, NULL);

        for (i = 0; i < NUM_READERS; i++)
                pthread_join(tr[i], NULL);
        return 0;
}