/**********************************************************
  File:          reader_writer.cc                              
  Description:   A program that simulates the reader_writer 
                 model for accessing a database.
                                                         
  Author:        Dana Vrajitoru                          
  Organization:  IUSB                                    
  Date:          December 2, 2002.                        
***********************************************************/

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

// Global variables
int database = 0;
int writer_nr = 0, waiting = 0, reader_nr=0;
pthread_mutex_t mutex, barrier_mutex;
const int NR_WCYCLES = 3, NR_RCYCLES = 10;
pthread_cond_t condition;

// Prototypes
void *Writer(void *ignored);
void *Reader(void *ignored);
void Read();
void Write();
void Create_threads(pthread_t *thread, int no_threads, 
		    void*(*function)(void*), void *arg);
// Waits for a random amount fo time between two limits.
void Wait(int low, int high);
// Waits for a random and relatively large amount of time.
void Long_wait();
// Waits for a random and relatively short amount of time.
void Short_wait();
void Initialize_all();
void Barrier(int thread_nr);

int main()
{
  int rnr, wnr, tnr;

  srand(time(NULL));

  Initialize_all();
  printf("Enter the number of readers\n");
  scanf("%d", &rnr);
  printf("Enter the number of writers\n");
  scanf("%d", &wnr);
  tnr = rnr + wnr;
  pthread_t *readers = new pthread_t[rnr];
  Create_threads(readers, rnr, Reader, (void *) (&tnr));

  pthread_t *writers = new pthread_t[wnr];
  Create_threads(writers, wnr, Writer, (void *) (&tnr));

  pthread_exit(NULL);
}

// Initializes all of the global mutex and condition variables.
void Initialize_all()
{
  pthread_mutex_init(&mutex, NULL);
  pthread_mutex_init(&barrier_mutex, NULL);
  pthread_cond_init(&condition, NULL);
}

// Creates several threads with the same function and argument.
void Create_threads(pthread_t *thread, int nr_threads, 
		    void*(*function)(void*), void *arg)
{
  for (int i=0; i<nr_threads; i++)
    if (pthread_create(&thread[i], NULL, function, arg) != 0)
      printf("Pthread_create fails\n");
}

// Reads from the database and communicates the result.
void Read()
{
  printf("Reading %d ", database);
  Short_wait();
}

// Writes to the database and communicates the result.
void Write()
{
  database = rand() % 100;
  printf("\nWriting %d\n", database);
  Short_wait();
}

// The reader thread.
void *Reader(void *tnr) 
{ 
  int good_to_go = 0;
  int thread_nr = *(int *) tnr;
  Barrier(thread_nr);
  for (int i=0; i<NR_RCYCLES; i++) { 
    good_to_go = 0; 
    while (!good_to_go) { 
      pthread_mutex_lock(&mutex); 
      if (writer_nr == 0 && waiting == 0) { 
        reader_nr ++; 
        good_to_go = 1; 
      } 
      pthread_mutex_unlock(&mutex); 
    } 
    Read(); 
    pthread_mutex_lock(&mutex); 
    reader_nr --; 
    pthread_mutex_unlock(&mutex); 
    Short_wait();
  } 
  Barrier(thread_nr);
  printf("done\n");
  return NULL;
} 

// The writer thread.
void *Writer(void *tnr) 
{ 
  int good_to_go = 0, signaled = 0; 
  int thread_nr = *(int *) tnr;
  Barrier(thread_nr);
  for (int i=0; i<NR_WCYCLES; i++) { 
    good_to_go = 0; 
    signaled = 0;   
    while (!good_to_go) { 
      pthread_mutex_lock(&mutex); 
      if (reader_nr == 0 && writer_nr == 0) { 
        writer_nr ++; 
	if (signaled)
	  waiting--; 
        good_to_go = 1; 
      } 
      else if (!signaled) { 
        signaled = 1; 
        waiting++; 
      } 
      pthread_mutex_unlock(&mutex); 
    } 
    Write(); 
    pthread_mutex_lock(&mutex); 
    writer_nr --; 
    pthread_mutex_unlock(&mutex); 
    Long_wait();
  } 
  Barrier(thread_nr);
  printf("done\n");
  return NULL;
}

// Waits for a random amount fo time between two limits.
void Wait(int low, int high)
{
  int cycles = low + rand()%(high - low);
  double j;
  for (int i=0; i<cycles; i++)
    j = cos(i);
}

// Waits for a random and relatively large amount of time.
void Long_wait()
{
  Wait(4000, 8000);
}

// Waits for a random and relatively short amount of time.
void Short_wait()
{
  Wait(1000, 2000);
}

// A barrier to synchronise the threads.
void Barrier(int thread_nr)
{
  static int count = 0;
  pthread_mutex_lock(&barrier_mutex);
  count++;
  if (count == thread_nr) {
    pthread_cond_broadcast(&condition);
    count = 0;
  }
  else
    pthread_cond_wait(&condition, &barrier_mutex);
  pthread_mutex_unlock(&barrier_mutex);
}