Sistemi operativi

SEMAFORI

Oltre ai lock mutex, esistono meccanismi più potenti, detti semafori, che di fatto includono il lock mutex.

Un semaforo è una variabile condivisa s maggiore o uguale a 0, non può assumere valori negativi. Tale variabile viene "prenotata" e "rilasciata" venendo incrementata e decrementata di 1 dai processi che la utilizzano. Questi incrementi e decrementi sono atomici, non possono essere interrotti. Quando vale 0, si può soltanto incrementare, quindi un processo che intende eseguire un decremento si blocca.

Esistono due tipi di semafori:

• Semaforo binario: Assume solo valore 0 o valore 1. Il semaforo può essere incrementato di 1, quando vale 0, o decrementato di 1, quando vale 1. Il comportamento è simile ai lock mutex:
• acquire() = decremento
• release() = incremento

I semafori binari si utilizzano per proteggere la sezione critica o per mettere in ordine la sequenza di più istruzioni.

processo che desidera

• utilizzare una risorsa -> decrementa il valore del semaforo;
• Ogni processo che rilascia una risorsa -> incrementa il valore del semaforo;
• Ogni il semaforo vale 0, i processi che lo richiedono devono sospendersi sul semaforo.
• QuandoSemaforo contatore:Un semaforo contatore assume un qualsiasi numero intero maggiore o uguale a 0.La variabile, anche in questo caso, viene incrementata e decrementata.Il semaforo contatore viene associato a delle risorse con dei limiti di utilizzo: i processipossono utilizzare le risorse fin quando il valore del semaforo è > 0Ogni processo che vuole utilizzare una risorsa condivisa decrementa il valore del semaforo di 1.Ogni processo che rilascia una risorsa condivisa incrementa il valore del semaforo di 1.Quando il semaforo vale 0 i processi che lo richiedono devono sospendersi su di esso.

UTILIZZO DEI SEMAFORIAnalizziamo le funzioni relativa ai semafori S:init(S,k) : inizializza il semaforo S al valore k

• Il semaforo

può partire da 0 ma posso anche settare un valore iniziale, purché sia >=0

La funzione permette di inizializzare un semaforo a qualunque valore, da questo il semaforo può essere incrementato o decrementato.

wait(S) : decrementa il semaforo di 1, solo se il valore corrente è >=0.

• Corrisponde alla acquire() dei lock mutex.

Aspetta fino a quando S non risulta > 0: a quel punto può essere decrementata.Se la variabile S è 0, aspetta fin quando qualche altro processo la incrementi.

Signal(S) : incrementa il semaforo di 1

• UTILIZZO DEI SEMAFORI: per la gestire la SEZIONE CRITICA

Per la gestione di una sezione critica si utilizza un semaforo binario, come un lock mutex.

Il semaforo viene inizializzato a 1.

Se un processo deve entrare nella sezione critica:

Ci sarà una wait(S) prima della sezione critica;

INHS 1) ' ,, Se il semaforo è a 0:

Il processo si blocca, vuol dire che qualcun altro staacquisisce - usando la sezione

• Problema del produttore-consumatore che condividono un buffer con dimensione limitata.
• Problema dei lettori-scrittori.

PRODUTTORE-CONSUMATORE: blocco dati

Abbiamo due processi generici che condividono un blocco dati e quindi hanno una sola variabile incomune (intero, float, stringa, gilè, un vettore).

Un processo, detto produttore, scrive una sola informazione nel blocco dati condiviso.

L'altro processo, il consumatore, legge ciò che il produttore ha scritto.

Questo meccanismo permette a due processi di scambiarsi informazioni: il flusso delle operazioni è a senso unico, dal produttore verso il consumatore.

-Il produttore non può scrivere sul blocco dati condiviso in qualunque istante:

Ogni volta che il produttore scrive, deve attendere che il consumatore abbia letto l'informazione precedente, altrimenti, se il consumatore non

legge il valore, il produttore lo sovrascrive. Il produttore può scrivere nella variabile condivisa solo se il consumatore ha letto il valore scritto precedentemente.

Il consumatore deve leggere soltanto quando è sicuro che il produttore abbia scritto. Non appena il produttore scrive nella variabile condivisa, il consumatore può leggere.

I due vincoli sono:

1. Il produttore può scrivere nella variabile condivisa solo se il consumatore ha letto il valore precedente.
2. Il consumatore può leggere dalla variabile condivisa solo se il produttore ha scritto qualcosa.

Il problema produttore-consumatore si risolve con due semafori binari: Write e Read. Il semaforo viene sempre inizializzato a 1, VERO se si utilizzano i lock mutex. WRITE è inizializzato a 1.

Il produttore esegue una wait() sul semaforo Write prima di scrivere sul blocco dati. La wait() ha successo perché il semaforo è posto a 1 e con essa si decrementa il valore.

di sincronizzarei due processi, assicurando che il produttore possa nuovamente scrivere sulla variabile condivisa dopo che il consumatore ha letto il valore scritto in precedenza

wait(cpeao)

dettati-- Analizziamo ora le operazioni col semaforo read. Quando partono i due processi bisogna assicurarsi che il produttore abbia scritto qualcosa affinché il consumatore possa leggerla. Il consumatore potrà leggere soltanto quando il produttore avrà fatto la prima scrittura: Bisogna fare in modo che il PRODUTTORE effettui una wait(Read) bloccando la lettura del consumatore prima che avvenga la prima scrittura. Con la wait(READ) eseguita dal produttore prima che il CONSUMATORE parta rende il mutex occupato. Il semaforo READ deve essere inizializzato a 0, in tal modo, quando il consumatore esegue la wait(READ) si blocca, non può decrementare la variabile. Il produttore, dopo aver scritto sul blocco dati, effettua una signal() sul semaforo READ, rilasciando il lock mutex,

incrementando la variabile semaforo. A questo punto, il consumatore può procedere con la wait() SU Read, perché il semaforo è stato rilasciato dal produttore, il suo valore incrementato, quindi con la wait() è possibile acquisire il lock mutex, decrementando la variabile. Il consumatore può finalmente leggere il dato.

Il sincronismo sta nel fatto che il produttore, dopo che ha scritto, sblocca il consumatore affinché possa leggere ciò che ha scritto.

Flusso di esecuzione

I semafori sono settati ad 1 di default.

1. Il semaforo Read viene posto a 0 all'inizio dal produttore tramite la wait(Read) per bloccare il consumatore.
2. Il produttore esegue una wait(Write), vede disponibile il mutex, lo acquisisce, ponendo a 0 il semaforo Write.
3. Il produttore scrive sul dato condiviso.
4. Il produttore esegue una signal(Read), incrementando il semaforo Read a 1 e sbloccando il mutex affinché il consumatore possa leggere ciò che ha scritto.
5. il

consumatore è sbloccato, acquisisce il mutex decrementando il semaforo READ a 0 e procede con la lettura. Dopo aver completato la lettura, il consumatore esegue una signal(Write) sbloccando il produttore per una nuova scrittura.

SEMAFORO SEMAFORO default inizializzatidi>eREAD nane adR 1WPRODUTTORE CONSUMATORE" con"✗ )semaforo /)WAIHR Waltil R R>acquisisce> >) "SWAHIW semaforo Wilacquisisce> " eleggesiascrive ✗✓ )) Signale /( semaforo/ R WRrilascia ilSigna > ISbloccare✗

SEMAFORI in LINUX

La libreria PTHREAD POSIX rende disponibili:

• mutex orientati ai threads;
• Semafori generici per processi e threads;

Esiste un'altra implementazione di semafori generici, basata sullo standard SystemV:

• permette la condivisione di semafori tra processi imparentati e tra processi indipendenti;
• permette di gestire array di semafori;

Questa libreria si applica solo ai processi, non ai threads.

I Semafori systemV permettono la