Sunteți pe pagina 1din 50

Sisteme de Operare

Sincronizarea proceselor partea I


Cristian Vidracu
http://www.info.uaic.ro/~vidrascu

1/50

Cuprins

Introducere Problema seciunii critice


Enunul problemei i cerinele de rezolvare Soluii pentru cazul a 2 procese Soluii pentru cazul a n >2 procese Soluii hardware Semafoare

Interblocajul i nfometarea Probleme clasice de sincronizare


Problema Productor-Consumator Problema Cititori i Scriitori Problema Cina Filozofilor Problema Brbierului Adormit

Monitoare
2/50

Introducere

Procesarea concurent este fundamentul sistemelor de operare multiprogramate Pentru a asigura execuia ordonat, sistemul de operare trebuie s ofere mecanisme pentru sincronizarea i comunicaia proceselor
3/50

race conditions:

Introducere

Uneori procesele cooperante pot partaja un spaiu de stocare pe care fiecare proces l poate citi i scrie (acest spaiu comun poate fi e.g. o zon n memoria principal, ori un fiier pe disc). n acest context, rezultatul final al execuiei acelor procese poate depinde nu numai de datele de intrare, ci i de cine execut exact ce anume i cnd anume (i.e. de ordinea exact de execuie a intruciunilor atomice ale acelor procese). Asemenea situaii sunt numite race conditions.
4/50

Introducere

Exemplu de race condition:


Dou procese A i B care partajeaz o variabil v, iniializat cu valoarea 0. Procesul A execut operaia v:=v+1 , iar B execut operaia v:=v-1. Rezultatul firesc al execuiei celor dou procese ar fi ca variabila v s aiba n final tot valoarea 0. Cele dou operaii constau de fapt din urmtoarele secvene de instruciuni atomice (n limbaj main): A: LD reg,adr_v INC reg ST reg,adr_v B: LD reg,adr_v DEC reg ST reg,adr_v

Dac ambele instruciuni Load sunt executate naintea ambelor instruciuni Store, atunci rezultatul final este eronat.
5/50

Introducere

Cum evitm race conditions ?


Ideea de evitare a acestor situaii, ce sunt nedorite n orice context ce implic memorie partajat, fiiere partajate, sau orice alt fel de resurs partajat, const n a gsi o cale de a mpiedica s avem mai mult de un singur proces, n acelai timp, care s citeasc sau s scrie resursa partajat.

6/50

Cum evitm race conditions ?

Introducere
(cont.)

Cu alte cuvinte, avem nevoie de excludere mutual, adic de o tehnic care s ne garanteze c dac un proces utilizeaz o resurs partajat, atunci toate celelalte procese vor fi mpiedicate s o utilizeze.
Not: alegerea operaiilor primitive adecvate pentru realizarea excluderii mutuale este o problem de proiectare major pentru fiecare sistem de operare, pe care o vom studia n continuare.

7/50

Problema Seciunii Critice Enunul problemei seciunii critice Cerinele de rezolvare Soluii pentru cazul a 2 procese Soluii pentru cazul a N procese Soluii concrete (cu instruciuni hardware specializate ) Semafoare

8/50

Problema Seciunii Critice


Enunul problemei seciunii critice:

Avem n procese Pi, i=0,...,n-1, cu viteze de execuie necunoscute Fiecare proces are o zon de cod, numit seciune critic (SC), n care efectueaz diverse operaii asupra unei resurse partajate Execuia seciunilor critice de ctre procese trebuie s se produc mutual exclusiv n timp: la orice moment de timp cel mult un proces s se afle n SC proprie Oprirea oricrui proces are loc numai n afara SC Fiecare proces trebuie s cear permisiunea s intre n seciunea lui critic. Secvena de cod ce implementeaz aceast cerere este numit seciunea de intrare Seciunea critic poate fi urmat de o seciune de ieire Restul codului din fiecare proces este seciunea rest
9/50

Problema Seciunii Critice


Soluia problemei seciunii critice trebuie s satisfac urmtoarele 3 cerine:
Excluderea mutual dac procesul Pi execut instruciuni n SC proprie, atunci nici un alt proces nu poate executa n propria SC. Progresul dac nici un proces nu execut n SC proprie, i exist unele procese care doresc s intre n propriile lor SC, atunci numai acele procese care nu execut n seciunile lor rest pot participa la luarea deciziei care va fi urmtorul proces ce va intra n SC proprie, iar aceasta selecie nu poate fi amnat la infinit. Ateptarea limitat trebuie s existe o limit a numrului de permisiuni acordate altor procese de a intra n SC proprii, ntre momentul cnd un proces a cerut accesul n propria SC i momentul cnd a primit permisiunea de intrare.

10/50

Opiuni de implementare a excluderii mutuale:

Problema Seciunii Critice

Dezactivarea ntreruperilor Soluii de ateptare ocupat


execut o bucl while de ateptare dac SC este ocupat folosirea unor instruciuni atomice specializate

(posibil doar pentru sistemele uniprocesor i eficient doar pentru secvene critice scurte)

Sincronizare blocant
sleep (inserarea n coada de ateptare) ct timp SC este ocupat

Primitivele de sincronizare (diverse abstracii, precum lactele pe fiiere), ce sunt puse la dispoziie de un sistem, pot fi implementate prin aceste tehnici sau prin combinaii ale unora dintre aceste tehnici.

11/50

Problema Seciunii Critice


Un ablon tipic de proces:

repeat seciunea seciunea seciunea seciunea forever

de intrare critic de ieire rest

12/50

Problema Seciunii Critice


Soluii pentru cazul a n=2 procese:
Dou procese P0 i P1 ce execut fiecare ntr-o bucl infinit cte un program ce const din dou seciuni: seciunea critic c0 , respectiv c1, i restul programului seciunea necritic r 0 , respectiv r1. Execuia seciunilor c0 i c1 nu trebuie s se suprapun n timp. Cnd se va prezenta procesul Pi, se va utiliza Pj pentru a ne referi la cellalt proces (j=1-i).
13/50

Problema Seciunii Critice


Soluia 1 (o prim idee de rezolvare)
Cele dou procese vor partaja o variabil ntreag comun turn iniializat cu 0 (sau cu 1). Dac turn = i , atunci procesul Pi este cel cruia i se permite s-i execute SC.

14/50

Problema Seciunii Critice


Soluia 1

repeat while turn i do nothing; seciunea critic turn := j; seciunea rest forever Ateptare ocupat
15/50

Soluia 1 este incomplet !

Problema Seciunii Critice

Motivul: aceast soluie satisface condiiile de excludere mutual i de ateptare limitat, n schimb cerina de progres nu este ndeplinit (e.g., dac turn=0
i procesul P1 este gata s intre n SC proprie, nu poate face aceasta, chiar dac procesul P0 este n seciunea sa rest).
P0: repeat while turn 0 do nothing; seciunea critic turn := 1; seciunea rest forever P1: repeat while turn 1 do nothing; seciunea critic turn := 0; seciunea rest forever
16/50

Problema Seciunii Critice


Soluia 2 (o a doua idee de rezolvare)
Variabila comun turn este nlocuit cu un tablou comun flag[], iniializat cu valoarea false: flag[0] = false , flag[1] = false . Prin flag[i] = true se indic faptul c procesul Pi dorete s-i execute SC.

17/50

Problema Seciunii Critice


Soluia 2

repeat flag[i] := true; while flag[j] do nothing; seciunea critic flag[i] := false; seciunea rest Ateptare ocupat forever
18/50

Problema Seciunii Critice


Solutia 2 este incomplet !
Motivul: condiiile de excludere mutual i de ateptare limitat sunt satisfacute, n schimb cerina de progres nu este ndeplinit [soluia e dependent de timing-ul (i.e. sincronizarea) proceselor]
P0: repeat flag[0] := true; while flag[1] do nothing; seciunea critic flag[0] := false; seciunea rest forever P1: repeat flag[1] := true; while flag[0] do nothing; seciunea critic flag[1] := false; seciunea rest forever
19/50

Problema Seciunii Critice


Soluia 3 (complet !) (Peterson '81)
Este o combinaie a soluiilor 1 i 2. Procesele partajeaz variabila turn i tabloul flag[]. Iniializri: flag[0] = flag[1] = false, turn = 0 (sau 1). Pentru a intra n SC, procesul Pi seteaz flag[i] = true i apoi i d voie celuilalt proces Pj s intre n propria sa SC, dac dorete acest lucru (turn = j). Dac ambele procese doresc s intre n acelai timp, valoarea lui turn va decide cruia dintre cele dou procese i este permis s intre primul n SC proprie. Istoric, prima soluie complet e cea datorat lui Dekker ('65)
20/50

Problema Sectiunii Critice


Solutia 3 repeat flag[i] := true; turn := j; while (flag[j] and turn=j) do nothing;

seciunea critic
flag[i] := false;

Ateptare ocupat

forever

seciunea rest
21/50

Problema Seciunii Critice


Soluia 3 este corect i complet ! Justificare:
Motivul #1: condiia de excludere mutual este satisfacut. ntr-adevr: Fiecare proces Pi intr n SC proprie doar dac fie flag[j]=false, fie turn=i. Dac ambele procese ar putea s execute n SC proprie n acelai timp, atunci am avea flag[0]=flag[1]=true. Aceasta nseamn c P0 i P1 nu ar fi putut s-i execute cu succes instruciunile while proprii n acelai timp.
22/50

Problema Seciunii Critice


Soluia 3 este corect i complet ! Justificare:
Motivul #2: condiiile de progres i de ateptare limitat sunt satisfcute. ntr-adevr:
P0: repeat flag[0] := true; turn := 1; while (flag[1] and turn=1) do nothing; seciunea critic flag[0] := false; seciunea rest forever P1: repeat flag[1] := true; turn := 0; while (flag[0] and turn=0) do nothing; seciunea critic flag[1] := false; seciunea rest forever
23/50

Soluia 3 este corect i complet ! Justificare:


Motivul #2 (cont.):

Problema Seciunii Critice

Un proces Pi poate fi mpiedicat s intre n SC (i.e., s progreseze) doar dac este blocat n bucla while. n acest caz, dac Pj nu-i gata s intre n SC, atunci flag[j]=false i Pi poate intra n SC proprie. Dac ns Pj a setat deja flag[j]=true i-i execut i el bucla while, atunci avem turn=i sau turn=j. Daca turn=i, atunci Pi va intra n SC. Dac ns turn=j, atunci Pj va intra n SC. Dup ce Pj va iei din SC, i va reseta flag[j] la false, permindu-i lui Pi s intre n SC. Aceasta deoarece, chiar dac apoi Pj seteaz flag[j] la true pentru a intra din nou n SC, el va seta de asemenea i turn=i. Astfel, Pi va termina bucla while i va intra n SC (progres) dup cel mult o intrare a lui Pj n SC (ateptare limitat).

24/50

Problema Seciunii Critice


Prima soluie corect i complet: Dekker '65
Iniial propus de Dekker ntr-un context diferit, a fost aplicat de Dijkstra pentru rezolvarea problemei SC. Dekker a adus ideea unui proces favorit i a permiterii accesului n SC a oricruia dintre procese n cazul cnd o cerere de acces este necontestat de cellalt n schimb, dac este un conflict (i.e. ambele procese vor s intre simultan n SC-urile proprii), unul dintre procese este favorizat, iar prioritatea se inverseaz dup execuia cu succes a SC. Procesele partajeaz variabila turn i tabloul flag[]. Iniializri: flag[0] = flag[1] = false, turn = 0 (sau 1).
25/50

Problema Seciunii Critice


repeat flag[i] := true; while (flag[j]) do if (turn=j) then begin flag[i] := false; while (turn=j) do nothing; flag[i] := true; Ateptare ocupat end

seciunea critic
turn := j; flag[i] := false;

Tem:
demonstrai corectitudinea acestui algoritm.
26/50

seciunea rest
forever

Problema Seciunii Critice


Soluii pentru procese multiple:
Trebuie dezvoltai algoritmi diferii de cei anteriori pentru a rezolva problema seciunii critice pentru cazul a n procese (n > 2)

27/50

Problema Seciunii Critice


Soluia 1 (Eisenberg & McGuire '72)
(Prima soluie corect, fiind o generalizare a soluiei lui Peterson)

Structurile de date comune (partajate de cele n procese) sunt variabila turn i tabloul flag[], cu turn {0,1,...,n-1}, flag[i] {idle, want-in, in-cs}, 0 i n-1. Iniializri: flag[i] = idle, 0 i n-1, i turn = 0 (sau orice valoare ntre 0 i n-1).
28/50

var k:0..n; repeat Soluia 1 repeat flag[i] := want-in; k := turn; while k i do if flag[k]=idle then k := (k + 1) mod n; else k := turn; flag[i] := in-cs; k := 0; while (k<n) and (k=i or flag[k]in-cs) do k := k + 1; until (kn) and (turn=i or flag[turn]=idle); turn := i; seciunea critic Tem: k := (turn + 1) mod n; demonstrai while (flag[k]=idle) do k := (k + 1) mod n; turn := k; corectitudinea flag[i] := idle; acestui algoritm. seciunea rest forever
29/50

Problema Seciunii Critice

Problema Seciunii Critice


Soluia 2 Algoritmul brutarului (Lamport '74)
La intrarea n magazin, fiecare client primete un numr de ordine. Clientul cu cel mai mic numr este servit primul. Dac Pi i Pj primesc acelai numr i dac i<j, atunci Pi este servit primul. Algoritmul este deterministic (numele proceselor sunt unice i total ordonate).

30/50

Problema Seciunii Critice


Soluia 2 Algoritmul brutarului (bakery alg.)
Structurile de date comune (partajate de cele n procese) sunt tablourile choosing[] i number[]. Iniializri: choosing[i] = false , number[i] = 0. Notaii: (a,b) < (c,d) dac a<c sau (a=c i b<d) ; max(a0,...,an-1) = un numr k astfel nct k ai, pentru i=0,...,n-1.

31/50

Problema Seciunii Critice


Soluia 2 Algoritmul brutarului (bakery alg.)
repeat choosing[i]:=true; number[i]:=max(number[0],...,number[n-1])+1; choosing[i]:=false; for j:=0 to n-1 do begin while choosing[j] do nothing; while number[j]0 and (number[j],j)<(number[i],i) do nothing; end

seciunea critic
number[i]:=0;

forever

seciunea rest
32/50

Problema Seciunii Critice


Soluii hardware (1)
Instruciunea atomic specializat Test-and-Set
Semantica ei (n pseudo-cod):

function Test-and-Set (var target: boolean): boolean; begin Test-and-Set := target; target := true; Exemplu: majoritatea arhitecturilor de calcul end; multiprocesor posed o instruciune de tipul
TSL reg,adr e.g. pentru P Intel x86 avem instruciunea lock bts op1,op2 33/50

Problema Seciunii Critice


Soluii hardware (1)

n procese; variabila comun lock, iniializat cu false.

repeat while Test-and-Set(lock) do nothing; seciunea critic lock := false; seciunea rest forever
34/50

Problema Seciunii Critice


Soluii hardware (2)
Instruciunea atomic specializat Swap
Semantica ei (n pseudo-cod):

procedure Swap (var a,b: boolean); var temp: boolean; begin Exemplu: pentru P Intel x86 avem temp := a; instruciunea a := b; xchg op1,op2 b := temp; unde operanzii sunt doi regitri, sau end; un registru i o adres de memorie.
35/50

Soluii hardware (2)

Problema Seciunii Critice

n procese; variabila comun lock, iniializat cu false. var key:boolean; // variabila local key repeat key := true; repeat Swap(lock,key); until key = false; seciunea critic lock := false; seciunea rest forever 36/50

Problema Seciunii Critice


Soluii hardware (3)
Not: soluiile anterioare satisfac condiiile de excludere mutual i de progres, dar nu ndeplinesc i cerina de ateptare limitat. O soluie complet folosind Test-and-Set (sau Swap) : n procese; variabila comun lock, iniializat cu false, i vectorul comun waiting[0..n-1] , iniializat cu false limita de ateptare: n-1
37/50

Problema Seciunii Critice


Soluii hardware (3)
var j:0..n-1; key:boolean; repeat waiting[i]:=true; Sau : ... do Swap(key,lock); key:=true; while waiting[i] and key do key:=Test-and-Set(lock); waiting[i]:=false; j:=i+1 mod n; while ji and not waiting[j] do j:=j+1 mod n; if j=i then lock:=false; Tem: else waiting[j]:=false; demonstrai seciunea rest corectitudinea forever acestui algoritm.
38/50

seciunea critic

Problema Seciunii Critice


Soluii concrete: Semafoarele

Concept introdus de E.W. Dijkstra Un semafor S este o variabil ntreag care este accesat (exceptnd operaia de iniializare) numai prin intermediul a dou operaii standard, atomice: operaia P sau wait() (proberen = a testa), i operaia V sau signal() (verhogen = a incrementa). Semantica operaiei wait(S) : while S0 do nothing; S:=S-1; Semantica operaiei signal(S) : S:=S+1;
39/50

Problema Seciunii Critice


Excluderea mutual implementat cu semafoare
Problema SC cu n procese; variabila comun mutex este un semafor binar (i.e, semafor iniializat cu 1).

repeat wait(mutex); seciunea critic signal(mutex); seciunea rest forever


40/50

Problema Seciunii Critice


Semafoare implementare la nivelul SO:
Semafoarele pot suspenda i reporni procese/thread-uri, pentru a evita ateptarea ocupat (i.e. risipa de cicli CPU) Semaforul se definete ca un articol:
typedef struct { int value; struct thread *ListHead; } semaphore;

Se consider urmtoarele 2 operaii: suspend() : suspend execuia thread-ului care-l apeleaz resume(T) : reia execuia unui thread T blocat anterior (printr-un apel suspend() )

41/50

Problema Seciunii Critice


Semafoare implementare la nivelul SO:
Cele 2 operaii atomice cu semafoare se definesc atunci astfel: 1) operaia wait(S):
S.value--; if (S.value < 0) { add this thread to S.ListHead; suspend(); }

2) operaia signal(S):

S.value++; if (S.value <= 0) { remove a thread T from S.ListHead; resume(T); }

42/50

Problema Seciunii Critice


Semafoare implementare la nivelul SO:

mai multe detalii de implementare n S.O.-urile moderne: a se citi, de exemplu, 6.5.2, pag. 227-230, din
Silberschatz: Operating System Concepts, ediia 8 [OSCE8]

La nivelul aplicaiilor, semafoarele pot fi simulate prin diverse entiti logice (e.g. fiiere, canale fifo,
semnale, .a. )

Biblioteca IPC (introdus n UNIX System V) permite lucrul cu semafoare n aplicaii (inclusiv n Linux)
43/50

Problema Seciunii Critice


Semafoare utilizare

Pot fi folosite pentru a rezolva diverse probleme de sincronizare ntre procese


Ex: execut B n P2 numai dup ce s-a executat A n P1 Soluie: folosim un semafor flag iniializat cu 0 P1 : ...... A signal(flag); ...... P2: ...... wait(flag); B ......

44/50

Problema Seciunii Critice


Semafoare utilizare (cont.)
Putem clasifica semafoarele n 2 tipuri: Semafoarele binare (i.e., semafoare iniializate cu valoarea 1) pot asigura excluderea mutual
(e.g., pot soluiona problema seciunii critice)

Semafoarele generale (i.e., semafoare iniializate cu valoarea n >1) pot reprezenta o resurs cu instane multiple (i.e., cu n instane)
(e.g., pot soluiona problema productor-consumator)
45/50

Interblocajul i nfometarea

Interblocajul (deadlock)
O situaie n care dou sau mai multe procese ateapt pe termen nelimitat producerea cte unui eveniment (e.g., execuia unei operaii signal pe un semafor), eveniment ce ar putea fi cauzat doar de ctre unul dintre celelalte procese ce ateapt. Aceste procese se spune c sunt interblocate.

Blocajul nelimitat sau nfometarea (starvation)


O situaie n care un(ele) proces(e) ateapt nelimitat (e.g., la un semafor: procesul ar putea sta suspendat n coada de ateptare asociat acelui semafor pe termen nelimitat).
46/50

Interblocajul si infometarea

Interblocajul (deadlock)
Exemplu: 2 procese folosesc 2 semafoare binare S i Q (i.e. iniializate cu 1) n ordinea de mai jos:
P1: wait(S); wait(Q); signal(S); signal(Q); P2: wait(Q); wait(S); signal(Q); signal(S);

Se observ c este posibil s apar interblocaj. n ce situaie apare? (specificai un scenariu de execuie care duce la interblocaj) Soluie: ambele programe ar trebui s execute operaiile wait() pe cele
dou semafoare n aceeai ordine !
47/50

Probleme clasice de sincronizare


Problema Productor-Consumator
(Producer-Consumer or Sender-Receiver problem)

Problema Cititori i Scriitori


(Readers and Writers problem)

Problema Cina Filozofilor


(Dining-Philosophers problem)

Problema Brbierului Adormit


(Sleeping Barber problem) (va urma)
48/50

Bibliografie

Bibliografie obligatorie capitolele despre sincronizarea proceselor din


Silberschatz : Operating System Concepts
(cap.6 din [OSCE8])

sau

Tanenbaum : Modern Operating Systems


(a treia parte a cap.2 din [MOS3])

49/50

Sumar

Introducere Problema seciunii critice


Enunul problemei i cerinele de rezolvare Soluii pentru cazul a 2 procese Soluii pentru cazul a n >2 procese Soluii hardware Semafoare

Interblocajul i nfometarea
(va urma)

Probleme clasice de sincronizare Monitoare


50/50

ntrebri ?