kapitel 7: deadlocks

Silberschatz, Galvin and Gagne ©2009Operating System Concepts – 8th Edition,

Kapitel 7: Deadlocks

1.2 Silberschatz, Galvin and Gagne ©2009Operating System Concepts – 8th Edition

Deadlock-problemet

Ett system består av en begränsad mängd resurser som ska fördelas mellan ett antal processer

Deadlock - En mängd blockerade processer som var och en håller en resurs och väntar på att få en resurs som hålls av en annan process i mängden

Exempel

Systemet har 2 diskar

P1 och P2 håller var sin disk och behöver den andra disken bägge två

Exempel

semaforerna A och B, initialiserade till 1

P0 P1

wait (A); wait(B)

wait (B); wait(A)


Systemmodell

Resurstyper: R1, R2, . . ., Rm

CPU-cykler, minne, I/O-enheter

Varje resurstyp Ri har Wi instanser

Varje process använder en resurs på följande sätt:

request

processen får vänta om resursen är upptagen

use

Release

Oftast programmerarens ansvar, speciellt viktigt vid utveckling av multitrådade program


Villkor för deadlock

Mutual exclusion: en resurs kan bara användas av en process i taget

Hold and wait: en process håller minst en resurs och väntar på resurser som hålls av andra processer

No preemption: en resurs kan bara släppas frivilligt av den process som håller den

Circular wait: det finns en mängd {P0, P1, …, P0} väntande processer så att P0 väntar på en resurs som hålls av P1, P1 väntar på en resurs som hålls av P2, …, Pn–1 is väntar på en resurs som hålls av Pn, och P0 väntar på en resurs som hålls av P0.

Deadlock kan uppstå om fyra villkor är uppfyllda samtidigt


Resursallokeringsgraf

V är uppdelad I två typer:

P = {P1, P2, …, Pn}, mängden av alla processer i systemet

R = {R1, R2, …, Rm}, mängden av alla resurstyper I systemet

Begäran-pil – Pi Rj

Tilldelnings-pil – Rj Pi

Deadlocks kan beskrivas mer precist med en riktad graf

- består av en mängd noder V och en mängd pilar E.


Resursallokeringsgraf (forts)

Process

Resurstyp med 4 instanser

Pi begär en instans av Rj

Pi håller en instans av Rj

Pi

Pi

Rj

Rj


Exempel resursallokeringsgraf


Resursallokeringsgraf med en deadlock


Graf med cykel men utan deadlock


Slutsats

Om grafen inte innehåller någon cykel ingen deadlock

Om grafen innehåller en cykel Om det bara finns en instans av varje

resurstyp - deadlock

Om det finns flera instanser av varje resurstyp - kanske eller kanske inte deadlock


Metoder för att hantera deadlocks

Använda ett protokoll som förebygger eller undviker deadlock

Använda ett protokoll som upptäcker och återhämtar systemet från en deadlock

Ignorera problemet och låtsas som om deadlock inte kan inträffa; används av de flesta OS, inklusive UNIX och Windows


Förebygga deadlock

Mutual Exclusion – måste vara uppfyllt för resurser som inte är delbara (t ex skrivare)

Hold and Wait

Antingen får en process alla resurser från början eller så får den bara begära resurser när den inga har

Lågt resursutnyttjande; starvation möjligt

Se till att något av villkoren inte kan uppfyllas:


Förebygga deadlock (forts)

No Preemption –

Kan användas för resurser såsom CPU-register och minne, men svårare för andra resurser, t ex skrivare

Circular Wait – ge ett nummer till alla resurstyper och kräva att processerna begär resurser i stigande nummerordning


Undvika deadlock

Enklaste modellen – varje process deklarerar det maximala antalet resurser av varje typ den kommer att använda

En algoritm undersöker sen dynamiskt tillståndet på resursallokeringen

Tillståndet definieras av antalet tillgängliga och allokerade resurser och processernas max-krav

Systemet har mer information om hur resurser kommer att efterfrågas


Säkert tillstånd (Safe State)

När en process begär en tillgänglig resurs måste systemet bestämma om systemet hamnar i ett säkert tillstånd om resursen allokeras till processen

Säkert tillstånd – systemet kan allokera resurser till varje process i någon ordning och ändå undvika deadlock

Om ingen sådan ordning finns så befinner sig systemet i ett osäkert tillstånd – deadlock kan inträffa


Safe, Unsafe , Deadlock State



En resursallokeringsgraf kan användas när en enda instans av varje resurstyp finns

En streckad pil Pi Rj indikerar att process Pj kan komma att begära resurs Rj

Konverteras till en begäran-pil när processen begär en resurs

Begäran kan uppfyllas om ingen cykel finns i grafen – säkert tillstånd

Konverteras till en tilldelnings-pil när resursen allokeras till processen


Osäkert tillstånd i en Resursallokeringsgraf


Banker’s Algorithm

Används när flera instanser av varje resurstyp finns

Varje process deklarerar max antal av varje resurstyp

När en process begär en resurs kollar systemet först om allokeringen kommer att lämna systemet i ett säkert tillstånd


Datastrukturer för Banker’s Algorithm

Available: Vektor av längden m. antal instanser av varje resurs

Max: matris med storleken n x m

Allocation: matris med storleken n x m

Need: matris med storleken n x m

Need [i,j] = Max[i,j] – Allocation [i,j]

n = antal processer, m = antal resurstyper.


Algoritm för säkert tillstånd

1. Låt Work och Finish vara vektorer med längderna m and n. Initialisera:

Work = Available

Finish [i] = false för i = 0, 1, …, n- 1

2. Hitta ett index i så att både:

(a) Finish [i] = false

(b) Needi Work

Om inget sådant i existerar, gå till steg 4

3. Work = Work + Allocationi

Finish[i] = truegå till steg 2

4. Om Finish [i] == true för alla i är systemet i ett säkert tillstånd


Algorithm för begäran av resurser

Request = vektor för process Pi. Om Requesti [j] = k vill process Pi ha k instanser av resurstyp Rj

1. Om Requesti Needi gå till steg 2. Om ej, felmeddelande

2. Om Requesti Available, gå till steg 3. Om ej måste Pi vänta

3. Låtsas att allokera de begärda resurserna till Pi genom att göra följande:

Available = Available – Request;

Allocationi = Allocationi + Requesti;

Needi = Needi – Requesti;

Om säkert allokera resurserna till Pi

Om osäkert Pi måste vänta


Exempel på Banker’s Algorithm

5 processer P0 till P4;

3 resurstyper:

A (10 instanser), B (5 instanser), och C (7 instanser)

Tillstånd vid tiden T0:

Allocation Max Available

A B C A B C A B C

P0 0 1 0 7 5 3 3 3 2

P1 2 0 0 3 2 2

P2 3 0 2 9 0 2

P3 2 1 1 2 2 2

P4 0 0 2 4 3 3


Exempel (forts)

Innehållet i matrisen Need definieras som Max – Allocation

Need

A B C

P0 7 4 3

P1 1 2 2

P2 6 0 0

P3 0 1 1

P4 4 3 1

Systemet är i ett säkert tillstånd eftersom ordningen < P1, P3, P4, P2, P0> uppfyller kriterierna


Exempel: P1 begär (1,0,2)

Kolla att Request Available (dvs, (1,0,2) (3,3,2) true

Allocation Need Available

ABC A B C A B C

P0 0 1 0 7 4 3 2 3 0

P1 3 0 2 0 2 0

P2 3 0 1 6 0 0

P3 2 1 1 0 1 1

P4 0 0 2 4 3 1

Algoritmen visar att ordningen < P1, P3, P4, P0, P2> uppfyller villkoren

Kan en begäran av (3,3,0) av P4 beviljas?

Kan en begäran av(0,2,0) av P0 beviljas?


Upptäcka deadlock

Algoritm när alla resurstyper bara har en instans:

Använd en wait-for graf

Noderna är processer

Pi Pj om Pi väntar på Pj

Med jämna mellanrum söker algoritmen efter cykler i grafen. Om en cykel finns är systemet i deadlock

Hur ofta ska grafen genomsökas?


Resursallokeringsgraf och Wait-for graf

Resursallokeringsgraf motsvarande wait-for graf


Återhämtning från deadlock: Process-terminering

Avsluta alla processer i deadlock

Avsluta en process åt gången tills deadlock-cykeln försvinner

I vilken ordning skall vi avsluta processerna?

Processens prioritet

Hur länge processen har exekverat, hur länge den har kvar

Resurser som processen har använt

Resurser som processen behöver

Hur många processer som behöver avslutas

Är processen interaktiv eller batch?

kapitel 7: deadlocks

Documents