Deadlock

Definizione
! Sequenza di utilizzo dei processi che utilizzano risorse
! Richiesta
! Se non pu essere immediatamente soddisfatta, il processo deve attendere

! Utilizzo ! Rilascio

! DEADLOCK Un insieme di processi in deadlock quando ogni processo in attesa di un evento che pu essere causato da un processo dello stesso insieme
2

Esempio di deadlock

! Traffico solo in una direzione ! Ponte = risorsa condivisa

! Se c deadlock, si pu risolvere mandando indietro una macchina (preemption + rollback) ! Possibile che pi macchine debbano essere spostate ! Starvation possibile
3

Esempio di deadlock
! P e Q in competizione per due risorse A e B
! P e Q devono utilizzare A e B in modo esclusivo
Processo P get A get B release A release B Processo Q get B get A release B release A 4

Esempio di deadlock
! Traiettoria delle risorse
! 6 possibili sequenze di richiesta/rilascio
Deadlock dipende dalla dinamica della esecuzione

Condizioni necessarie
1.! Mutua esclusione
! Almeno una risorsa deve essere non condivisibile

2.! Hold and Wait

! Deve esistere un processo che detiene una risorsa e che attende di acquisirne unaltra, detenuta da un altro

3.! No preemption
! Le risorse non possono essere rilasciate se non volontariamente dal processo che le usa

4.! Attesa circolare

! Deve esistere un insieme di processi che attendono ciclicamente il liberarsi di una risorsa

Devono essere vere contemporaneamente

! Se una non si verifica, non si ha deadlock

Modello astratto (RAG)

! RAG = Resource Allocation Graph: G(V,E)
! V = nodi
! Cerchi = processi (CPU, I/O, memoria) ! Rettangoli = risorse ! Nei rettangoli vi sono tanti quante sono le istanze della corrispondente risorsa

! E = archi
! Da processi a risorse: processo richiede risorsa ! Da risorse a processi: processo detiene risorsa

RAG - esempio
! V = {{P1,P2},{R1}} ! Einiziale = {(R1,P2)} Efinale = {(R1,P1),(R1,P2)}

RAG e deadlock
! Se il RAG non contiene cicli, non ci sono deadlock ! Se contiene cicli:
! se si ha una sola istanza per risorsa allora si deadlock ! se ci sono pi istanze, dipende dallo schema di allocazione
P2" P1" P3" P2" P3" DEADLOCK! P1" P4" NO DEADLOCK!

Gestione dei deadlock - alternative

! Prevenzione statica
! Evitare che si possa verificare una delle quattro condizioni

! Prevenzione dinamica (avoidance) basata su allocazione delle risorse

! Mai usata poich richiede conoscenza troppo approfondita delle richieste di risorse

! Rivelazione (detection) e ripristino (recovery)

! Permettere che si verifichino deadlock ! Prevedere metodi per riportare il sistema al funzionamento normale

! Algoritmo dello struzzo

! Non fare nulla, i deadlock sono rari e gestirli costa troppo

10

Prevenzione statica
! Obiettivo:
! Impedire che si verifichi una delle 4 condizioni che devono essere vere contemporaneamente perch si verifichi un deadlock

11

Prevenzione statica
! Mutua esclusione
! E irrinunciabile per certi tipi di risorsa ! Non possiamo toglierla

12

Prevenzione statica
! Hold and wait
! Soluzioni
! Un processo alloca allinizio tutte le risorse che deve utilizzare ! Un processo pu ottenere una risorsa solo se non ne ha altre

! Problemi
! Basso utilizzo delle risorse ! Possibilit di starvation (richiesta di molte risorse molto popolari) ! Conoscenza del numero di risorse richieste?

13

Prevenzione statica
! No preemption
! Soluzioni
! Un processo che richiede una risorsa non disponibile deve cedere tutte le altre risorse che detiene ! In alternativa, pu cedere risorse che detiene su richiesta di un altro processo

! Problemi
! Fattibile solo per risorse il cui stato pu essere facilmente ristabilito (CPU, registri, semafori, file) ! Non per stampanti, nastri, !

14

Prevenzione statica
! Attesa circolare
! Soluzione
! Assegnare una priorit (ordinamento globale) ad ogni risorsa ! Un processo pu richiedere risorse solo in ordine crescente di priorit ! Quindi lattesa circolare diventa impossibile poich: ! Priorit deve seguire il normale ordine di richiesta (Es:. disco prima di stampante)
! Se P0!R0!P1!!!Rn-1!Pn!Rn!P0 ! Allora F(R0) < F(R1) < ! < F(Rn) < F(R0) Impossibile! ! F: R ! N ! F(R0) < F(R1) < ! < F(Rn)

15

Prevenzione dinamica
! Le tecniche di prevenzione statica possono portare a un basso utilizzo delle risorse perch mettono vincoli sul modo in cui i processi possono accedere alle risorse

16

Prevenzione dinamica
! Obiettivo:
! Prevenzione in base alle richieste
! Analisi dinamica del grafo delle risorse per evitare situazioni cicliche

! Requisito:
! Conoscenza del caso peggiore (bisogna conoscere il massimo numero di istanze di una risorsa richieste per processo)
17

Prevenzione dinamica stato safe

! Stato di una risorsa calcolato come:
! numero di istanze allocate ! numero di istanze disponibili

! Il sistema si trova in uno stato sicuro (safe)

! se esiste una sequenza safe, ovvero ! se usando le risorse disponibili, pu allocare risorse ad ogni processo, in qualche ordine, in modo che ciascun di essi possa terminare la sua esecuzione
18

Sequenza safe
! Una sequenza di processi (P1,...,PN) safe se, per ogni Pi, le risorse che Pi pu richiedere possono essere esaudite usando:
! le risorse disponibili ! quelle detenute da Pj, j < i (attendendo che Pj termini)

! Se non esiste tale sequenza, siamo in uno stato unsafe

! Non tutti gli stati unsafe sono stati di deadlock, ma da stato unsafe posso andare in deadlock
19

Spazio degli stati

20

10

Stato safe e unsafe Esempio

! Supponiamo di avere:
! 3 processi: P0, P1, P2 ! 12 istanze di 1 risorsa
! 3 istanze libere
Richieste P0 P1 P2 10 4 9 Possedute 5 2 2

! Siamo in uno stato safe?

! Si, esiste sequenza safe: < P1, P0, P2 >
! P1 prende e rilascia, poi P0 infine P2

! Se ora P2 richiede 1 risorsa e gli viene assegnata, siamo ancora in uno stato safe?
! No, si entra in uno stato unsafe!
! ! ! ! Rimangono solo 2 risorse P1 pu eseguire, ma quando termina sono disponibili solo 4 istanze P0 ne chiede 5, P2 ne chiede 6! Deadlock P2 "! P0

21

Prevenzione dinamica
! Idea:
! Utilizzare algoritmi che lasciano il sistema sempre in uno stato safe
! Allinizio il sistema in uno stato safe ! Ogni volta che P richiede R, R viene assegnata a P sse si rimane in uno stato safe

! Svantaggio:
! Lutilizzo delle risorse minore rispetto al caso in cui non uso tecniche di prevenzione dinamica
22

11

Prevenzione dinamica
! Due alternative:
! Algoritmo con RAG
! Funziona solo se c una sola istanza per risorsa

! Algoritmo del banchiere

! Funziona qualunque sia il numero di istanze

23

Algoritmo con RAG

! Funziona solo se ho unistanza per ogni risorsa ! Il RAG viene aumentato con archi di reclamo:
! Pi ! Rj se Pi pu richiedere Rj in futuro ! Indicati con freccia tratteggiata

! Allinizio, ogni processo deve dire quali risorse vorrebbe usare durante la sua esecuzione ! Una richiesta viene soddisfatta sse lallocazione della risorsa non crea un ciclo nel RAG ! Serve un algoritmo per la rilevazione cicli
! Complessit O(n2) (dove n = n di processi) 24

12

Algoritmo con RAG esempio

R1 P1 R2 P2

! Siamo in uno stato sicuro ! Se, ad un certo punto, P2 richiede R2, la richiesta non viene accettata perch lo stato diventerebbe unsafe
25

R1 P1 R2 P2

Algoritmo del banchiere

! Meno efficiente dellalgoritmo con RAG! ! ! ma funziona con pi istanze delle risorse ! Idea:
! Il banchiere non deve mai distribuire tutto il denaro che ha in cassa perch altrimenti non potrebbe pi soddisfare successivi clienti

26

13

Algoritmo del banchiere

! Ogni processo dichiara la sua massima richiesta ! Ogni volta che un processo richiede una risorsa, si determina se soddisfarla ci lascia in uno stato safe ! Costituito da:
! Algoritmo di allocazione ! Algoritmo di verifica dello stato

! Strutture dati per n processi e m risorse:

int int int int available[m]; max[n][m]; alloc[n][m]; need[n][m]; /* n di istanze di Ri disponibili */ /* matrice delle richieste di risorse */ /* matrice allocazione corrente */ /* matrice bisogno rimanente ovvero need[i][j] = max[i][j] - alloc[i][j]*/

27

Richieste void request(int req_vec[]) { del processo Pi if (req_vec[] > need[i][]) error(); /* superato il massimo preventivato */ if (req_vec[] > available[]) wait(); /* attendo che si liberino risorse */ available[] = available[] - req_vec[]; simulo alloc[i][] = alloc[i][] + req_vec[]; lassegnazione need[i][] = need[i][] - req_vec[]; if (!state_safe()) {/* se non safe, ripristino il vecchio stato */ available[] = available[] + req_vec[]; rollback alloc[i][] = alloc[i][] - req_vec[]; need[i][] = need[i][] + req_vec[]; wait(); } }
28

Algoritmo di allocazione (Pi)

14

O(m*n2)

int state_safe(){ int work[m] = available[]; boolean finish[n] = (FALSE,...,FALSE); Ho gi sottratto int i; le richieste di Pi ! while (finish != (TRUE,...,TRUE)) { /* cerca Pi che NON abbia terminato e che possa completare con le risorse disponibili in work */ for (i=0; (i<n)&&(finish[i]||(need[i][]>work[]); i++); if (i==n) return FALSE; /* non c ! unsafe */ Sono arrivato else { in fondo, work[] = work[]+alloc[i][]; senza trovare finish[i] = TRUE; finish[i]=FALSE } Lordine non ha importanza. Se + processi e need[i][ ] <= work[ ] } return TRUE; possono eseguire, ne posso scegliere uno a caso, gli altri eseguiranno dopo, visto }
che le risorse possono solo aumentare

Algoritmo di verifica dello stato

29

Algoritmo del banchiere - esempio

! 5 processi: P0,P1,P2,P3,P4 ! 3 risorse:
! A (10 istanze) B (5 istanze) C (7 istanze)

! Fotografia al tempo T0:

Allocation ABC 010 200 302 211 002 Max ABC 753 322 902 222 433 Available ABC 332 Need ABC 743 122 600 011 431

P0 P1 P2 P3 P4

30

15

Algoritmo del banchiere - esempio

! Al tempo T0 il sistema in stato safe: ! Al tempo T1, P1 richiede (1,0,2)
Allocation ABC 010 302 302 211 002 Max ABC 753 322 902 222 433

! <P1, P3, P4, P2, P0> una sequenza safe ! Request_1 " Available? (1,0,2) " (3,3,2) # OK ! Nuova situazione:
P0 P1 P2 P3 P4 Available ABC 230 Need ABC 743 020 600 011 431

31

Algoritmo del banchiere - esempio

! Siamo ancora in uno stato safe? Verifichiamolo:
! work = (2,3,0) ! i=0 finish=FALSE, need[0] = (7,4,3) > work ! i=1 finish=FALSE, need[1] = (0,2,0) < work
! work = work + (3,0,2) = (5,3,2) ! finish[1] = TRUE

! i=2 ! i=3

finish=FALSE, need[2]=(6,0,0) > work finish=FALSE, need[3]=(0,1,1) < work

! work = work + (2,1,1) = (7,4,3) ! finish[3] = TRUE

! ... ! Sequenza safe finale: <P1, P3, P4, P0, P2> 32

16

Algoritmo del banchiere - esempio

! Al tempo T2, P0 richiede (0,2,0)
! Request_0 " Available? (0,2,0) " (2,3,0) # OK ! Nuova situazione
Allocation ABC 030 302 302 211 002 Max ABC 753 322 902 222 433 Available ABC 2 1 0 Need ABC 723 020 600 011 431

P0 P1 P2 P3 P4

33

Algoritmo del banchiere - esempio

! Siamo ancora in uno stato safe? Verifichiamolo:
! work = (2,1,0) ! i=0 finish=FALSE, need[0]=(7,2,3) > work ! i=1 finish=FALSE, need[1]=(0,2,0) > work ! i=2 finish=FALSE, need[2]=(6,0,0) > work ! i=3 finish=FALSE, need[3]=(0,3,1) > work ! i=4 finish=FALSE, need[4]=(4,3,1) > work

! Stato unsafe!
34

17

Rilevazione deadlock & ripristino

! Prevenzione statica e dinamica sono conservativi e riducono eccessivamente lutilizzo delle risorse ! Due approcci alternativi:
! Rilevazione e ripristino tramite RAG ! Algoritmo di rilevazione

35

Rilevazione e ripristino con RAG

! Funziona solo con una risorsa per tipo ! Analizzare periodicamente il RAG, verificare se esistono deadlock (detection) ed iniziare il ripristino (recovery)
! Vantaggi
! Conoscenza anticipata delle richieste non necessaria ! Utilizzo migliore

! Svantaggio
! Costo del recovery
36

18

Algoritmo di rilevazione
! Basato sullesplorazione di ogni possibile sequenza di allocazione per i processi che non hanno ancora terminato ! Se la sequenza va a buon fine (safe), non c deadlock ! Strutture dati simili ad algoritmo del banchiere:
int available[m]; /* n di istanze di Ri disponibili */ int alloc[n][m]; /* matrice allocazione corrente */ int req_vec[n][m];/* matrice delle richiesta */

37

O(m*n2)

int work[m] = available[m]; bool finish[] = (FALSE,...,FALSE), found = TRUE; while (found) { found = FALSE; for (i=0; i<n && !found; i++) { /* cerca un Pi con richiesta soddisfacibile */ if (!finish[i] && req_vec[i][] <= work[]){ /* assume ottimisticamente che Pi esegua fino al termine e che quindi restituisca le risorse */ work[] = work[] + alloc[i][]; Se non cos finish[i]=TRUE; il possibile deadlock verr evidenziato found=TRUE; alla prossima } esecuzione dellalgoritmo } } /* se finish[i]=FALSE per un qualsiasi i, Pi in deadlock */

Algoritmo di detection

38

19

Rilevazione - esempio
! 5 processi: P0,P1,P2,P3,P4 ! 3 tipi di risorsa:
! A (7 istanze), B (2 istanze), C (6 istanze)

! Fotografia al tempo T0:

Allocation ABC 010 200 303 211 002 Request ABC 000 202 000 100 002 Available ABC 000

P0 P1 P2 P3 P4

39

Rilevazione - esempio
! Siamo in una situazione di deadlock? Verifichiamolo:
! work = (0,0,0) ! i=0 req[0]=(0,0,0) <= work OK work = work + (0,1,0) = (0,1,0) finish[0] = true P0! ! i=1 req[1]=(2,0,2) <= work NO ! i=2 req[2]=(0,0,0) <= work OK work = work + (3,0,3) = (3,1,3) finish[2] = true P2 ! ! i=3 req[3]=(1,0,0) <= work OK work = work + (2,1,1) = (5,2,4) finish[3] = true P3 ! ! !

! La sequenza <P0, P2, P3, P1, P4> d finish[i] = true per ogni i 40

20

Rilevazione - esempio
! Supponiamo invece che P2 richieda unulteriore istanza della risorsa C
Allocation ABC 010 200 303 211 002 Request ABC 000 202 001 100 002 Available ABC 000

P0 P1 P2 P3 P4

41

Esempio
! Siamo in una situazione di deadlock? Verifichiamolo
! work = (0,0,0) ! i=0 req[0]=(0,0,0) <= work OK work = work + (0,1,0) = (0,1,0) finish[0] = true P0! ! i=1 req[1]=(2,0,2) <= work NO ! i=2 req[2]=(0,0,1) <= work NO ! i=3 req[3]=(1,0,0) <= work NO ! i=4 req[4]=(0,0,2) <= work NO

! DEADLOCK formato da P1, P2, P3, P4

42

21

Ripristino
! Quanto spesso chiamare lalgoritmo di rilevazione?
! Dopo ogni richiesta ! Ogni N secondi ! Quando utilizzo della CPU scende sotto una soglia T

! Cosa fare?
! Uccisione processi coinvolti ! Prelazione delle risorse dai processi bloccati nel deadlock
43

Uccisione processi coinvolti

! Uccisione di tutti i processi
! Costoso
! Tutti i processi devono ripartire e perdono il lavoro svolto

! Uccisione selettiva fino alla scomparsa del deadlock

! Costoso
! Invoca lalgoritmo di rilevazione dopo ogni uccisione

! In che ordine?
! Priorit, tipi di risorse allocate, quante risorse mancavano, quanto tempo mancava alla fine, interattivo o batch, il processo del capo?

44

22

Prelazione delle risorse

! A chi toglierle e in quale ordine?
! Problema
! Il processo che subisce la prelazione non pu continuare normalmente

! Soluzione
! Rollback in uno stato safe, e ripartenza da questo stato

! Eventualmente total rollback (cio riparto da zero) ! Problema

! Starvation possibile, se tolgo le risorse sempre agli stessi processi

! Soluzione
! Considerare il numero di rollback nei fattori di costo

45

Conclusione
! Ognuno dei tre approcci visti ha vantaggi e svantaggi ! Nessuno sempre superiore agli altri ! Soluzione combinata:
! Partizionare le risorse in classi ! Usare una strategia di ordinamento tra classi di risorse (priorit) ! Allinterno di una classe, usare lalgoritmo pi appropriato per quella classe
46

23

Conclusione
! Partizionare e ordinare le risorse in classi:
1.! Risorse interne (usate dal sistema, es.: PCB, I/O) 2.! Memoria 3.! Risorse di processo (es. File) 4.! Spazio di swap (blocchi su disco)

47

Conclusione
! Algoritmi specifici:
1.! Prevenzione tramite ordinamento delle risorse 2.! Prevenzione tramite prelazione
! Un job pu in genere essere swappato

3.! Prevenzione dinamica

! Richiesta massima di risorse tipicamente nota a priori

4.! Prevenzione tramite preallocazione (v. hold & wait)

! Richiesta massima di memoria tipicamente nota a priori

48

24

Conclusione
! Possibile anche la soluzione pi semplice
! STRUZZO
! Es.: UNIX

! In fin dei conti:

! I deadlock si verificano poche volte! ! La prevenzione costosa! ! Il recovery costoso! ! Gli algoritmi spesso sono sbagliati!
A. Tannenbaum

49

25