CAPITOLO 23 PROBLEMA DEL BARBIERE NEGOZIO DEL BARBIERE (20 norma 50 clienti) La figura riporta una pianta della sala del barbiere e come si vede ipotizza che ci siano presenti tre sedie per il taglio e che tre barbieri operano nella sala, nella sala c è un divano di capienza di massimo quattro persone sedute e uno spazio per altre persone in piedi. Inoltre la sala è dotata di una cassa per effettuare i pagamenti. Il numero massimo di persone presenti nel negozio non può essere più di venti per via delle limitazioni di legge, ma si suppone che ci sia la possibilità di soddisfare fino a 50 clienti. Quando il negozio contiene il numero massimo di clienti, nessun nuovo cliente può entrare, l eccedenza è evidente che rimane in attesa fuori.. Quando entra un cliente se c è posto si siede sul divano, altrimenti rimane in piedi; quando un barbiere è libero, il primo ad essere servito è il cliente che ha atteso più a lungo sul divano e che quindi si porta ad una sedia barbiere libera. Ovviamente ogni volta che un cliente transita per passare dal divano ad una sedia barbiere, uno in piedi occupa il posto sul divano. Quando il barbiere termina informa di aver finito il cliente il quale essendo stato servito, va alla cassa per il pagamento. Poiché la cassa è unica, un solo cliente per volta può pagare. SIGNIFICATO DEI SEMAFORI La tabella riporta i semafori utilizzati per la gestione del problema del barbiere e il significato delle primitive wait e signal che agiscono sul semaforo stesso. Il semaforo capacita_max gestisce la capacità del negozio in termini di numero di clienti presenti. La primitiva wait(capacita_max) consente al cliente che aspetta che ci sia posto nel negozio di poter entrare, signal(capacita_max) consente invece ad un cliente che esce dal negozio di informare che ora c è un nuovo posto e quindi un nuovo cliente può entrare. 1
Il semaforo divano coordina il sedersi e l alzarsi dei clienti dal divano. wait(divano) consente ad un cliente in attesa di sedersi, signal(divano) è la primitiva con la quale chi si alza dal divano consente ad un cliente in piedi di accomodarsi. Il semaforo sedia_barbiere è utilizzato per l uso corretto delle tre sedie dei barbieri assicurando che non più di tre clienti alla volta siano serviti contemporaneamente. La primitiva wait(sedia_barbiere) fa si che un cliente che aspetta che si liberi una sedia del barbiere possa accomodarsi, invece signal(sedia_barbiere) fa si che un nuovo cliente si porti dal divano alla sedia per essere servito. Il semaforo cliente_pronto è necessario per assicurarsi che ci siano clienti seduti sulle sedie dei barbieri pronti per il taglio. Con la primitiva wait(cliente_pronto) il barbiere aspetta che ci sia un cliente seduto, con signal(cliente_pronto) il cliente avvisa il barbiere di essersi seduto. Il semaforo finito gestisce il tempo in cui il cliente rimane seduto per il taglio, con wait(finito) il cliente aspetta che il taglio sia terminato mentre con signal(finito) il barbiere avvisa quando il taglio è terminato. Il semaforo lascia_sedia_b serve al cliente per informare di aver lasciato la sedia e di conseguenza il barbiere lancerà signal( sedia barbiere). Un nuovo cliente si potrà accomodare mentre che il barbiere si porta alla cassa. Con la primitiva wait(lascia_sedia_b) il barbiere aspetta che il cliente si alzi, invece con signal(lascia_sedia_b) il cliente avvisa il barbiere quando si alza dalla sedia. Il semaforo pagamento è necessario per il pagamento del cliente al barbiere presso l unica cassa presente nel negozio, per cui il pagamento avviene un cliente alla volta. La primitiva wait(pagamento) permette che il cassiere aspetti che il cliente paghi invece con signal(pagamento) il cliente avvisa il cassiere che ha pagato. Il semaforo ricevuta è utilizzato al fine di rilasciare la ricevuta al cliente per il taglio effettuato. Dunque con la wait(ricevuta) il cliente aspetta una ricevuta, con signal(ricevuta) il cassiere segnala di aver ricevuto il pagamento. Infine poiché ai barbieri è affidato anche il compito di cassieri, il semaforo coord è utilizzato sia per il controllo dei barbieri che devono effettuare i tagli sia per le operazioni di cassa. Con wait(coord) si aspetta che il barbiere termini il taglio o che la cassa deve incassare il pagamento, con signal(coord) si segnala che c è un barbiere disponibile o che la cassa abbia ricevuto il pagamento e che può rilasciare la ricevuta. ALGORITMO DEL BARBIERE INGIUSTO program barbiere1; var capacita_max: semaforo (:=20); divano: semaforo (:=4); sedia_barbiere, coord: semaforo (:=3); cliente_pronto, finito, lascia_sedia_b, pagamento, ricevuta: semaforo (:=0); procedure cliente; wait(capacita_max); wait(divano); wait(sedia_barbiere); signal(divano); signal(cliente_pronto); wait(finito); signal(lascia_sedia_b); signal(pagamento); wait(ricevuta); esci dal negozio; signal (capacita_max); procedure barbiere; La slide presenta l algoritmo del barbiere ingiusto. Il codice presenta la definizione e l inizializzazione delle variabili semaforo. Il programma principale attiva 50 clienti, 3 barbieri e il processo cassiere. La procedura cliente coordinata tramite le primitive wait e signal effettua le seguenti operazioni: esci dal negozio. Ognuna di queste operazioni coinvolge delle risorse che devono essere gestite garantendone la mutua esclusione per cui è necessario l utilizzo di semafori che debbano precedere e seguire ognuna di queste operazioni. L azione entra nel negozio è preceduta da wait(capacita_max) per cui il cliente aspetta che ci sia posto nel negozio prima di entrare, altrettanto l operazione esci dal negozio è seguita da una signal(capacita_max) che avvisa il prossimo cliente di poter entrare. Una volta entrato nel negozio, il cliente ha necessità di sedersi sul divano per cui effettua una wait(divano) con cui il cliente aspetta che si liberi un posto sul divano una volta ottenuto si siede con siedi sul divano ed effettua una wait(sedia_barbiere) con cui aspetta che si liberi una sedia del barbiere. Ottenuta questa si alza dal 2
wait(cliente_pronto); taglia i capelli; signal(finito); wait(lascia_sedia_b); signal(sedia_barbiere); procedure cassiere; wait(pagamento); prendi il denaro; signal(ricevuta); (*programma principale*) par cliente; 50 volte; cliente; barbiere; barbiere; barbiere; cassiere; par end. divano con l operazione alzati dal divano ed effettua una signal(divano) con cui avvisa il prossimo cliente che aspetta di sedersi che un posto si è liberato. Il cliente a questo punto effettua l operazione siedi sulla sedia del barbiere ed esegue una signal(cliente_pronto) che avvisa il barbiere che il cliente si è seduto. Con wait(finito) il cliente aspetta che il taglio sia finito e segue l operazione di lascia la sedia del barbiere. Con la primitiva signal(lascia_sedia_b) il cliente avvisa il barbiere che si è alzato, successivamente effettua il pagamento, con l operazione paga, emette una signal(pagamento) con cui avvisa il cassiere che sta pagando ed esegue wait(ricevuta) con cui si pone in attesa che il cassiere segnali di aver accettato il pagamento. La procedura barbiere presenta in un ciclo infinito l operazione fondamentale di taglia i capelli, tale operazione è preceduta e seguita da una serie di primitive che gestiscono i vari semafori. Inizialmente viene effettuata la primitiva wait (cliente_pronto) con cui il barbiere aspetta che un cliente si sieda, successivamente con wait(coord) si coordina con gli altri barbieri e si porta ala taglio dei capelli. A questo punto avviene l operazione di taglia i capelli e successivamente vengono lanciate le primitive signal(coord) e signal(finito) con cui rispettivamente si segnala che c è un barbiere disponibile e con cui il barbiere avvisa il cliente che il taglio è terminato. Con wait(lascia_sedia_b) il barbiere aspetta che il cliente si alzi dalla sedia ed infine con signal(sedia_barbiere) avvisa che una propria sedia è vuota. La procedura cassiere effettua in un ciclo infinito l operazione di prendi il denaro, tale operazione è preceduta dalle primitive wait(pagamento) e wait(coord) con cui rispettivamente il cassiere aspetta che il cliente paghi e con cui si aspetta che un barbiere sia libero per fare il cassiere. L istruzione prendi il denaro è poi seguita da signal(coord) e signal(ricevuta) con cui rispettivamente si segnala che c è un barbiere disponibile e con cui il cassiere segnala di aver accettato il pagamento. TRATTAMENTO INGIUSTO DEI CLIENTI Supponiamo che tre clienti sono in attesa di finito, dovrebbero alzarsi nell'ordine in cui si sono seduti ma se uno dei tre finisce prima il suo signal finito, costringe l'altro che si è seduto prima ad uscire! Questo si è generato per mancanza di corrispondenza tra cliente e processocliente e di conseguenza tra barbiere e cliente. L algoritmo presentato provoca un trattamento ingiusto dei clienti a causa di un problema di temporizzazione. Supponiamo che ci siano tre clienti seduti su tre sedie per il taglio, secondo la politica First-In-First-Out con cui sono gestite le code di attesa attraverso la primitiva wait(finito) il primo cliente che ha occupato la sedia del barbiere deve essere il primo a lasciarla. Questo provoca il fatto che se un cliente ha terminato prima perché ha pochi capelli o perché il barbiere ha lavorato più velocemente non può alzarsi se il cliente che si è seduto prima di lui non ha terminato o nel caso ciò avvenga un cliente terminerebbe senza aver completato il taglio. 3
BARBIERE EQUO! Assegna un numero ad ogni cliente usando un contatore; Serializza l'accesso al contatore tramite il semaforo mutex1 ed il semaforo finito del caso precedente è ora sostituito da un array finito[numcli], il semaforo mutex2 si occupa invece della serializzazione del barbiere al cliente mentre che la varibile locale cliente_b fa corrispondere il numero del cliente al barbiere restituisca come numcli del wait(finito[numcli]). Il problema del barbiere ingiusto viene risolto introducendo ulteriori variabili e semafori. Ad ogni cliente che entra nel negozio viene associato un numero diverso dato dalla variabile intera contatore il cui accesso è protetto dal semaforo mutex1. Il semaforo finito viene sostituito da un array di 50 semafori per cui quando un cliente è seduto su una sedia esegue wait(finito[numcli]) con cui aspetta sul proprio semaforo e quando un barbiere finisce esegue signal(finito[numcli]) per liberare il giusto cliente. Il semaforo mutex2 è utilizzato invece per il coordinamento tra il barbiere e il cliente. E necessario dire che il barbiere conosce il numero del cliente grazie all utilizzo della coda incoda1 in cui ogni cliente inserisce il proprio numero subito prima di attivare il semaforo cliente_pronto. Quando un barbiere è pronto per il taglio decoda1(cliente_b) toglie un numero in cima alla coda e lo mette nella variabile locale del barbiere cliente_b. ALGORITMO DEL BARBIERE EQUO program barbiere2; var capacita_max: semaforo (:=20); divano: semaforo (:=4); sedia_barbiere, coord: semaforo (:=3); mutex1, mutex2: semaforo (:=1); cliente_pronto, lascia_sedia_b, pagamento, ricevuta: semaforo (:=0); finito: array [1..50] of semaforo (:=0); contatore: integer; procedure cliente; var numcli: integer; wait(capacita_max); wait(mutex1); contatore:=contatore+1; numcli:=contatore; signal(mutex1); wait(divano); wait(sedia_barbiere); signal(divano); wait(mutex2); incoda1(numcli); signal(cliente_pronto); signal(mutex2); wait(finito[numcli]); signal(lascia_sedia_b); signal(pagamento); wait(ricevuta); esci dal negozio; signal (capacita_max); procedure barbiere; var cliente_b:integer; La slide presenta l algoritmo del barbiere equo in cui è possibile osservare la definizione ed inizializzazione dei nuovi semafori mutex1 e mutex2, l array finito dei 50 semafori e il contatore intero dei clienti. All interno della programma principale il contatore dei clienti è inizializzato a zero. Nella procedura cliente quando il cliente entra nel negozio viene eseguita una wait(mutex1) che permette di serializzare l accesso al contatore che viene incrementato di una unità, dunque alla variabile locale numcli che indica il numero del cliente viene associato il valore del contatore. Dopo di che viene effettuata la primitiva signal(mutex1) con cui si avvisa che il semaforo è libero. Quando il cliente si siede sulla sedia del barbiere viene emessa la primitiva wait(mutex2) che serializza l accesso al barbiere, dunque il numero del cliente è inserito in una coda con l istruzione incoda(numcli). Al termine del taglio quando il cliente è pronto viene eseguita un signal(mutex2) e una wait(finito[numcli]). Nella procedura barbiere quando il cliente è pronto per il taglio viene eseguita la primitiva wait sul semaforo mutex2 e l istruzione decoda1(cliente_b) per estrarre il numero del cliente dalla coda, a questo punto avviene una signal(mutex2) e una volta terminato il taglio si segnala la 4
wait(cliente_pronto); wait(mutex2); decoda1(cliente_b); signal(mutex2); taglia i capelli; signal(finito[client_b]); wait(lascia_sedia_b); signal(sedia_barbiere); liberazione del cliente con signal(finito[cliente_b]). procedure cassiere; wait(pagamento); prendi il denaro; signal(ricevuta); (*programma principale*) contatore:=0; par cliente; 50 volte; cliente; barbiere; barbiere; barbiere; cassiere; par end. 5