#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h> 

/*-----------------------------------------------------------------------*/
#define TAILLE 5   /* taille du buffer */
#define NB_PROD  2   /* nombre de producteurs */
#define NB_CONS  2   /* nombre de consommateurs */
/*-----------------------------------------------------------------------*/
void *produire(void *);
void *consommer(void *);
/*-----------------------------------------------------------------------*/
typedef struct {
 pthread_t prodLid;  /* identite de la thread productrice */
 int num; /* numero de l'objet produit par cette thread */
} ELEM;
sem_t *occupe;    /* semaphore <-> nombre d'emplacements occupes */
sem_t *libre;     /* semaphore <-> nombre d'emplacements libres */

pthread_mutex_t mutex; /* mutex pour acces au buffer et aux variables */

int ecrire = 0;    /* premier emplacement libre */
int lire = 0 ;    /* prochain emplacement a lire */

ELEM buffer[TAILLE]; /* le buffer */

pthread_t prod[NB_PROD]; /* identite des threads productrices */
pthread_t cons[NB_CONS]; /* identite des threads consommatrices */
/*-----------------------------------------------------------------------*/
int main(){
  int loop;
  /* Creation et initialisation des deux semaphores occupe et libre */
  sem_unlink&#40;"/sem_occupe"&#41;; 
  sem_unlink&#40;"/sem_libre"&#41;;
  occupe = sem_open("/sem_occupe", O_CREAT, 0666, 0);
  if (occupe == (sem_t *) -1){
      printf("erreur occupe\n");
      return 0;
      }
  libre = sem_open("/sem_libre", O_CREAT, 0666, TAILLE);
  if (libre == (sem_t *) -1){
      printf("erreur libre\n");
      return 0;
      }
  srand(getpid()); /* initial;isation du generateur de nombres */
  /* initialisation du mutex */
  pthread_mutex_init(&mutex;, NULL);
  /* creation des threads productrices */
  for(loop = 0; loop < NB_PROD; loop++)
     pthread_create(prod + loop, NULL, produire, NULL);
  /* creation des threads consommatrices */
  for(loop = 0; loop < NB_PROD; loop++)
     pthread_create(cons + loop, NULL, consommer, NULL);
  /* mettre toutes les threads en concurrences */
  pthread_setconcurrency(NB_PROD+NB_CONS);
  pause();
}
/*-----------------------------------------------------------------------*/
/* fonction executee par les threads productrices */
void *produire(void *arg){
   int valeur = 0; /* variable locale a la thread : numero d'objet produit */
   pthread_t monId = pthread_self(); /* identite de la thread courante */
   ELEM objet;
   objet.prodLid = monId;
   while(1){
      sleep(1 + rand() % 3); /* temps de production */
      objet.num = valeur++;
      sem_wait(libre); /* y-a-t-il un emplacement libre ? */
      pthread_mutex_lock(&mutex;); /* prendre le mutex */
      printf("***** producteur %d depose %d\n", objet.prodLid, objet.num);
      buffer[ecrire] = objet; /* deposer l'objet */
      ecrire = (ecrire + 1) % TAILLE; /* prochain emplacement de depot */
      pthread_mutex_unlock(&mutex;); /* liberer le mutex */
      sem_post(occupe); /* signaler un emplacement occupe de plus */
   }
}
/*-----------------------------------------------------------------------*/
/* fonction executee par les threads productrices */
void *consommer(void *arg){
   pthread_t monId = pthread_self(); /* identite de la thread courante */
   while(1){
      sleep(rand() % 6);
      sem_wait(occupe); /* y-a-t-il un objet a extraire ? */
      pthread_mutex_lock(&mutex;); /* acquerir mutex */
      printf("          ***** consommateur %d lit %d produit par %d\n",
          monId, buffer[lire].num, buffer[lire].prodLid);
      lire = (lire + 1) % TAILLE; /* prochain emplacement a lire */
      pthread_mutex_unlock(&mutex;); /* liberer mutex */
      sem_post(libre); /* signaler un emplacement libre de plus */
   }
}