/* Programma di esempio dei semafori ....
 * Implementazione con il meccanismo semaforico del meccanismo
 * visto nel file condition.c
 */

#include <semaphore.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>

/* Numero di cicli di lettura/scrittura che vengono fatti dai thread */
#define CICLI 1
/* Lunghezza del buffer */
#define LUN 20
/* Numero di cicli di attesa a vuoto di uno scrittore */
#define DELAY_WRITER 200000
/* Numero di cicli di attesa a vuoto di uno scrittore */
#define DELAY_READER 2000000

/* Memoria Condivisa fra i thread ... */
struct {
  char scritta[LUN+1];
  /* variabili per la gestione del buffer */
  int primo, ultimo; 
  /* Variabili semaforiche */
  sem_t mutex, piene, vuote;
} shared;

/* Forward declaration */ 
void *scrittore1(void *);
void *scrittore2(void *);
void *lettore(void *);

int main(void) {
  pthread_t s1TID, s2TID, lTID;
  int res, i;

  /* Fase di inzializzazione delle strutture dati */
  for(i=0; i<LUN; i++) {
    shared.scritta[i] = 'x';
  }
  shared.primo = shared.ultimo = 0;
  /* Fine della fase di inizializzazione delle strutture dati */

  /* Fase di inizializzazione dei semafori */
  if (sem_init(&shared.mutex, 0, 1) == -1) 
    sys_err("Non sono riuscito ad inizializzare shared.mutex\n");

  if (sem_init(&shared.piene, 0, 0) == -1) 
    sys_err("Non sono riuscito ad inizializzare shared.piene\n");
	
  if (sem_init(&shared.vuote, 0, LUN) == -1) 
    sys_err("Non sono riuscito ad inizializzare shared.vuote\n");
	
  /* Setto il concurrency level a 3 */
  pthread_setconcurrency(3);
	
  /* A questo punto posso creare i thread .... */
  res = pthread_create(&lTID, NULL, lettore, NULL);
  if (res != 0) sys_err("Errore nella creazione del primo thread\n");

  res = pthread_create(&s1TID, NULL, scrittore1, NULL);
  if (res != 0) {
    printf("Errore nella creazione del secondo thread\n");
    /* Devo far terminare il thread che ho creato */
    pthread_kill(s1TID, SIGKILL);
    return -1;
  }

  res = pthread_create(&s2TID, NULL, scrittore2, NULL);
  if (res != 0) {
    printf("Errore nella creazione del terzo thread\n");
    pthread_kill(lTID, SIGKILL);
    pthread_kill(s1TID, SIGKILL);
    return -1;
  }

  /* A questo punto aspetto che i tre thread finiscano ... */
  pthread_join(s1TID, NULL);
  pthread_join(s2TID, NULL);
  pthread_join(lTID, NULL);

  printf("E' finito l'esperimento ....\n");
  return 0;
}

/* Codice del primo thread scrittore */
void *scrittore1(void *in)
{
  int i, j, k;

  for (i=0; i<CICLI; i++) {
    for(k=0; k<LUN; k++) {
      /* Controllo che il buffer non sia pieno */
      sem_wait(&shared.vuote);
      /* Acquisisco la mutua esclusione */
      sem_wait(&shared.mutex);
      /* Inserisco un carattere e aggiorno le strutture dati */
      shared.scritta[shared.ultimo] = '-';
      shared.ultimo = (shared.ultimo+1)%(LUN);
      /* Libero il semaforo di mutua esclusione */
      sem_post(&shared.mutex);
      /* Segnalo che ho aggiunto un carattere */
      sem_post(&shared.piene);
      /* ... perdo un poco di tempo */
      for(j=0; j<DELAY_WRITER; j++);	
    }
  }
  return NULL;
}

/* Codice del secondo thread scrittore */
void *scrittore2(void *in)
{
  int i, j, k;
	
  for(i=0; i<CICLI; i++) {
    for(k=0; k<LUN; k++) {
      /* Controllo che il buffer non sia pieno */
      sem_wait(&shared.vuote);
      /* Acquisisco la mutua esclusione */
      sem_wait(&shared.mutex);
      /* Inserisco un carattere e aggiorno le strutture dati */
      shared.scritta[shared.ultimo] = '+';
      shared.ultimo = (shared.ultimo+1)%(LUN);
      /* Libero il semaforo di mutua esclusione */
      sem_post(&shared.mutex);
      /* Segnalo che ho aggiunto un carattere */
      sem_post(&shared.piene);
      /* ... perdo un poco di tempo */
      for(j=0; j<DELAY_WRITER; j++);	
    }
  }
  return NULL;
}

/* Thread che legge i dati */
void *lettore(void *in)
{
  int i, j, k;
  /* Buffer locale in cui metto i caratteri mano a mano
   * che vengono letti.
   */
  char local[LUN+1];
	
  local[LUN] = 0;

  for (i=0; i<2*CICLI; i++) {
    for(k=0; k<LUN; k++) {
      /* Controllo che il buffer non sia vuoto */
      sem_wait(&shared.piene);
      /* Acquisisco la mutua esclusione */
      sem_wait(&shared.mutex);
      /* Aggiungo un carattere e aggiorno le strutture dati */
      local[k] = shared.scritta[shared.primo];
      shared.primo = (shared.primo+1)%(LUN);
      /* Libero il semaforo di mutua esclusione */
      sem_post(&shared.mutex);
      /* Segnalo che ho letto un carattere */
      sem_post(&shared.vuote);
      /* ... perdo un poco di tempo */
      for(j=0; j<DELAY_READER; j++);
    }
    printf("Stringa = %s \n", local);
  }
  return NULL;
}