Impiego del costrutto monitor

Impiego del costrutto monitor

X) Si implementi il problema dei lettori/scrittori utilizzando il costrutto monitor.

Descrizione: Il costrutto monitor rappresenta un meccanismo di alto livello per implementare una risorsa gestore. In generale occorre definire, oltre alla risorsa da gestire, una struttura dati supplementare che contenga informazioni sullo stato della risorsa gestita. Una o più variabili di tipo condition vengono poi utilizzate per bloccare o sbloccare selettivamente i processi che competono per il controllo della risorsa, ciascuno in funzione della verifica (o meno) di una opportuna condizione di sincronizzazione. Il programma seguente implementa il problema dei lettori/scrittori evitando che l'una o l'altra categoria di processi possa andare in starvation:

Ogni processo che voglia accedere al monitor deve farlo in mutua esclusione con gli altri processi.

Un lettore che voglia leggere il contenuto del buffer di memoria condivisa (non deve farlo in mutua esclusione con gli altri lettori!) rimane in attesa sulla variabile condition SOSPESI_LETTORI solo nel caso in cui vi siano scrittori attivi o scrittori già in attesa.

Uno scrittore che voglia scrivere sul buffer rimane in attesa sulla variabile condition SOSPESI_SCRITTORI solo se vi sono lettori attivi o scrittori attivi.

Quando un lettore riesce ad ottenere l'accesso al buffer, tutti gli altri in attesa passano a valanga.

Uno scrittore che riesca ad ottenere l'accesso al buffer, una volta terminata la scrittura, sblocca tutti gli eventuali lettori in attesa.

 Semafori.H (L'implementazione è quella indicata per il programma I)

#include <sys/types.h> 

#include <sys/ipc.h>

#include <sys/sem.h>

void Init_Sem(int, int);          //Inizializza Semaforo

void Wait_Sem(int, int);        //Wait su Semaforo

void Signal_Sem(int, int);     //Signal su Semaforo

int Awaiting_Sem(int, int);    //Restituisce il numero di processi in attesa su Semaforo

 Monitor.H

#include <stdio.h>

#include <sys/wait.h>

#include "semafori.h"

typedef struct Monitor;

//Definizione di MACRO per l'accesso ai semafori del Monitor

#define MUTEX 0                    //Il primo semaforo è sempre il Mutex

#define INITIALIZE(M,S,V) Init_Sem(M->ID_Sem,S,V)

#define WAIT(M,S) Wait_Sem(M->ID_Sem,S)

#define SIGNAL(M,S) Signal_Sem(M->ID_Sem,S)

#define AWAITING(M,S) Awaiting_Sem(M->ID_Sem,S)

#define ENTER_MONITOR(M) WAIT(M,MUTEX)                       //Implementazione della Entry

#define LEAVE_MONITOR(M) SIGNAL(M,MUTEX)

void Create_Monitor(Monitor*, int);  //Semaforo Mutex e variabili Conditions vengono allocati

void Destroy_Monitor(Monitor*);                            //Semaforo Mutex e variabili Conditions vengono deallocati

void Wait_Cond(Monitor*, int);                               //Emula la Wait su una variabile Condition

void Signal_Cond(Monitor*, int);                             //Emula la Signal su una variabile Condition

 Monitor.C

#include "monitor.c"

void Create_Monitor(Monitor* M, int N_Conditions)

void Destroy_Monitor(Monitor* M)

void Wait_Cond(Monitor* M, int ConditionID)

void Signal_Cond(Monitor* M, int ConditionID)

 Lett_Scrit_Monitor.H

#include "monitor.h"

typedef struct Buffer;

void Init_Buffer(Buffer*);       //Inizializza il Buffer

void Start_Monitor(Monitor*);           //Inizializza il Monitor

void Stop_Monitor(Monitor*);            //Elimina il Monitor

void Inizio_Lettura(Monitor*, Buffer*);                   //Acquisizione del buffer in lettura

char Lettura(Buffer*); //Lettura del buffer

void Fine_Lettura(Monitor*, Buffer*);                     //Rilascio del buffer dopo una lettura

void Inizio_Scrittura(Monitor*, Buffer*);                //Acquisizione del buffer per la scrittura

void Scrittura(char, Buffer*);  //Scrittura del buffer

void Fine_Scrittura(Monitor*, Buffer*);                  //Rilascio del buffer dopo una scrittura

 Lett_Scrit_Monitor.C

#include "lett_scritt_monitor.h"

#define SOSPESI_LETTORI 1

#define SOSPESI_SCRITTORI 2

int Lettori_Sospesi;

void Init_Buffer(Buffer* B)

void Start_Monitor(Monitor* M)

void Stop_Monitor(Monitor* M)

void Inizio_Lettura(Monitor* M, Buffer* B)

char Lettura(Buffer* B)

void Fine_Lettura(Monitor* M, Buffer* B)

void Inizio_Scrittura(Monitor* M, Buffer* B)

void Scrittura(char value, Buffer* B)

void Fine_Scrittura(Monitor* M, Buffer* B)

 Programma X.C

#include "lett_scrit_monitor.h"

#define DIM sizeof(Buffer) //Dimensione dell'area di memoria condivisa

#define NUM_LETT 5   //Numero di processi lettori

#define NUM_SCRIT 5                                  //Numero di processi scrittori

void main()

Ptr_Buf=(Buffer*)shmat(ID_Buf, 0, 0); //Il segmento allocato viene annesso al segmento dati

//del processo al primo indirizzo disponibile così come

//specificato dal sistema

if (Ptr_Buf==(Buffer*)-1)

Init_Buffer(Ptr_Buf); //Inizializzazione del Buffer

//----- CREAZIONE DEL MONITOR -----

Monitor M;

Start_Monitor(&M);

//----- GENERAZIONE FIGLI SCRITTORI -----

for(i=0; i<NUM_SCRIT; i++) else if (!pid)

Inizio_Scrittura(&M, Ptr_Buf);

Scrittura(value, Ptr_Buf);

Fine_Scrittura(&M, Ptr_Buf);

exit(0); //Il figlio Scrittore termina correttamente

}

} //End For NUM_SCRIT

//----- GENERAZIONE FIGLI LETTORI -----

for(i=0; i<NUM_LETT; i++) else if (!pid)

} //End For NUM_LETT

//----- SINCRONIZZAZIONE DEL PADRE CON I FIGLI -----

for(i=0; i<NUM_SCRIT+NUM_LETT; i++)

//----- DISTRUZIONE DEL MONITOR -----

Stop_Monitor(&M);

//----- RILASCIO BUFFER DI MEMORIA CONDIVISA -----

shmctl(ID_Buf, IPC_RMID, 0);