SEMAFORI DI DIJKSTRA:

Dijkstra popone 2 primitive che permettono la soluzione di qualsiasi problema di

interazione tra processi e sono:
 La primitiva P(S) che riceve in ingresso un numero intero S che viene usato per
accedere alla risorsa.
 La primitiva V(S) che riceve anche questa in ingresso un numero S ma che
viene utilizzato per rilasciare la risorsa.
Solitamente quando S=0, la risorsa è occupata e quando S=1 la risorsa è libera.
Una primitiva è una routine di sistema, che è molto affidabili e siamo certi che non
si blocca.
----------------------------------------------------------------------------------------------------------------
Un interruzione è un evento di natura asincrona che interrompe il processo, il
processore salva solamente il PSW(Process Status Word) e il Program Counter
(contente l’indirizzo dell’istruzione successiva, quindi è un registro).
----------------------------------------------------------------------------------------------------------------

STALLO:
Uno stallo è una situazione in cui due o più processi si ostacolano a vicenda
impedendo reciprocamente di portare a termine il proprio lavoro.
Uno stallo si può verificare solo quando si avverano 4 condizioni:
1. Le risorse non sono condivisibili;
2. Non si può forzare il rilascio di una risorsa;
3. è in corso il “Possesso e attesa”, un processo ha delle risorse e ne richiede
delle altre;
4. è presente l’attesa circolare: cioè ci sono almeno 2 processi e ciascuno di essi
è in attesa di una risorsa occupata dall’altro.
---------------------------------------------------------------------------------------------------------------
Lo stallo si può individuare con uno strumento il grafico di Holt.
--------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------
Una risorsa è un elemento di tipo hardware o software che fa evolvere il processo.
----------------------------------------------------------------------------------------------------------------

AFFRONTARE LO STALLO:
Una volta individuato lo stallo l’unico modo per affrontarlo direttamente è quello del
“Detection e recovery” cioè individuare e ripristinare.
Quindi biosgna far terminare i processi uno alla volta, viene forzato forzato il
prerilascio di una risorsa da parte di uno dei processi in stallo in modo che questa
risorsa possa essere acquisita da un processo (anche se questo procedimento non
può essere effettuato in certe risorse come la stampante). E dev’essere fatto un
salvataggio su disco dello stato dei processi in determinati momenti definiti.

EVITARE LO STALLO:
in questo caso si fa riferimento “all’algoritmo del banchiere di Dijkstra”:
protagonista di questo esempio è un banchiere che ha un capitale fisso e deve
gestire un gruppo di clienti che richiedono del credito. In questo caso la soluzione di
dijkstra è quella di far chiedere al cliente un prestito al banchiere, ma questo deve
controllare se questa operazione può portare la banca ad uno stato sicuro. Per la
banca si considera uno stato sicuro la situazione in cui i soldi rimanenti in cassa,
permettono di soddisfare la richiesta successiva da un altro cliente.

PREVENIRE LO STALLO:
- si eliminano le risorse seriali: come nella stampante mediante gli spool, dove
ogni processo crede di avere una stampante ma in realtà si trova in una
situazione di attesa;
- si elimina il possesso e attesa: questo è attuabile con un’allocazione totale,
cioè si impone che un processo richieda tutte le risorse all’inizio della
computazione;
- eliminare l’attesa circolare: è possibile farlo tramite il concetto di allocazione
gerarchica delle risorse, attribuendo ad ognuna di queste dei valori di priorità
e imponendo che ogni processo in ogni istante possa allocare solamente
risorse di priorità superiore a quella che già possiede, invece se ha bisogno di
 una risorsa con priorità inferiore deve prima rilasciare tutte le risorse con
priorità uguale o superiore a quella desiderata.

IGNOARARE IL PROBLEMA:
Lo si può fare quando questa è una situazione che non si verifica sempre o quando i
processi coinvolti non sono vitali.

FILOSOFI A CENA:
Un problema che viene molte volte ricordato è quello dei “filosofi a cena”, in questo
problema ci sono 5 piatti di spaghetti per i 5 filosofi e 5 forchette, ma i filosofi ne
devono usare 2 per mangiare gli spaghetti. Questo problema è risolvibile attraverso
l’allocazione totale, quindi quando un filosofo mangia i 2 che gli sono adiacenti non
possono mangiare, una volta che avrà finto quelli adiacenti potranno mangiare.