Procese

Procese
n funcionarea unui sistem de operare apare un anumit grad de nedeterminism, datorit faptului c multe funcii sau servicii ale sistemului sunt solicitate ca rspuns la anumite evenimente, care ns apar la momente de timp imprevizibile i cu o frecven de asemenea imprevizibil. Aceste evenimente constau n cereri din partea proceselor de alocare a unor blocuri de memorie, iniierea unui proces de comunicare ntre procese, sincronizarea proceselor, cereri de ocupare pentru o perioad nedeterminat a unor periferice, cereri de schimb ntre memoria intern i memoria extern (aflat pe un suport extern), solicitarea sistemului de ctre utilizatorii de la terminale, apariia unor excepii software sau hardware. Pentru a se putea satisface cererile de tipurile de mai sus, a fost introdus conceptul de proces, fiind insuficient ntr-un context dinamic, nedeterminist, conceptul de program, n accepiunea lui obinuit (o secven de instruciuni). Un proces (task) este un calcul care poate fi executat concurent (n paralel) cu alte calcule, fiind considerat ca un program n execuie. Crearea unui proces este condiionat de existena a trei factori: 1. un set de instruciuni care trebuie executat, cu rolul de descriere a unui calcul (algoritm); 2. un procesor care s poat executa aceste instruciuni; 3. un mediu (memorie, periferice) asupra cruia s acioneze procesorul, conform celor precizate n setul de instruciuni. 1

Procese

Exist deci o deosebire major ntre proces i program. Procesul are un caracter dinamic, el precizeaz o secven de activiti n curs de execuie, iar programul are un caracter static, el numai descrie aceast secven de activiti.

Reprezentarea n memorie a unui proces

n general (indiferent de sistemul de operare), reprezentarea n memorie a unui proces cuprinde urmtoarele zone: contextul procesului; codul programului; zona datelor globale (statice); zona heap; zona stivei. Contextul procesului conine informaiile referitoare la localizarea n memoria intern i informaiile de stare a execuiei procesului: legturi exterioare cu sistemul de operare: - numele procesului; - directorul curent n structura de directoare; - variabile de mediu, etc. 2

Procese

pointeri ctre nceputurile zonelor de cod, date, stiv i heap i, eventual, lungimile acestor zone; starea curent a execuiei procesului (valorile registrilor PC Program Counter, care reprezint adresa urmtoarei instruciuni de executat i respectiv SP Stack Pointer, care reprezint pointerul spre vrful stivei); zone de salvare a regitrilor generali, de stare a sistemului de ntreruperi, etc.
Contextul procesului PC SP Cod Date Heap

Stiva

Fig. Reprezentarea n memorie a unui proces Zona de cod conine instruciuni main ale programului asociat procesului (programul lansat n execuie). n aceast zon se ncarc succesiv instruciuni din cadrul programului executat, registrul PC indicnd, n fiecare moment, adresa urmtoarei instruciuni ce va fi executat de procesor. 3

Procese

Zona datelor globale conine constantele i variabilele vizibile de ctre toate instruciunile programului (globale). n cazul constantelor/variabilelor globale iniializate n cadrul programului, valorile lor iniiale sunt ncrcate n locaiile de reprezentare din zona datelor globale n momentul ncrcrii programului n memorie. Zona heap (zona variabilelor dinamice) conine spaii de memorare a variabilelor alocate dinamic, cu durat de via stabilit de ctre programator (prin operaii de creare/distrugere). Zona stiv este utilizat pentru executarea apelurilor de proceduri/funcii: n momentul apelului unei proceduri/funcii, se depun n vrful stivei o serie de informaii: parametrii efectivi; adresa de revenire n cadrul programului apelant; spaii pentru memorarea variabilelor locale declarate n cadrul procedurii/funciei. La terminarea execuiei procedurii/funciei, spaiul din vrful stivei ocupat la momentul apelului este eliberat. n cazul proceselor cu mai multe thread-uri (entiti de execuie n cadrul procesului) exist mai multe zone de stiv, cte una pentru fiecare thread. De asemenea, fiecare thread va avea propriul context. Conceptul de thread, sau fir de execuie, a aprut din necesitatea de a defini entiti de calcul independente, n cadrul aceluiai proces. Un thread se definete ca o entitate de execuie din interiorul unui proces, care poate fi ntrerupt pentru a permite procesorului s execute instruciunile altui thread. Practic, n cadrul thread-ului se execut o secven dat de instruciuni, ncapsulate n funcia thread-ului, n cadrul unui proces, concurent cu alte thread-uri. Operaiile cu thread-uri sunt furnizate cu ajutorul unor biblioteci de programe (care respect eventual standardul POSIX), sau cu ajutorul unor apeluri sistem. 4

Procese

n ceea ce privete reprezentarea n memorie a thread-urilor, trebuie menionat c fiecare thread are asociat propriul context (cu elemente comune procesului printe) i propria zon stiv:
Contextul procesului printe (P) Cod (P) Date (P) Heap (P)

Context thread 1 PC SP Context thread 2 PC SP

Stiva thread 1

Stiva thread 2

Fig. Un proces cu dou thread-uri 5

Procese

Concuren i paralelism
Dou procese se pot executa n paralel dac procesele respective nu sunt condiionate unul de cellalt, nu colaboreaz ntre ele, execuia unuia dintre ele nu este n nici un moment dependent de rezultatele pariale ale celuilalt. Spunem despre dou procese c se execut concurent atunci cnd n execuia lor simultan se intercondiioneaz reciproc. Putem considera n cele ce urmeaz termenii de concuren i paralelism ca fiind sinonimi, urmnd ca distincia s o facem atunci cnd vom discuta problemele specifice programrii concurente. Dou procese Pi respectiv Pj avnd momentele de nceput Bi, respectiv Bj i momentele de sfrit Ei, respectiv Ej sunt executate n paralel n cadrul unui sistem de calcul dac: max(Bi, Bj) < min(Ei, Ej) Dac presupunem c Bi<Bj<Ei<Ej, atunci timpul de concuren este dat de intervalul (Bj, Ei). Dac sistemul de calcul este multiprocesor, este posibil un paralelism efectiv, n sensul c ambele procese se pot afla simultan n starea RUN. Pe un sistem monoprocesor, se vor executa alternativ grupuri de instruciuni din cele dou procese, dup cum sistemul de operare comut procesele ntre strile RUN i READY. 6

Procese

Dou instruciuni succesive S1 respectiv S2 pot fi executate n paralel dac efectul lor asupra mediului este acelai, indiferent de ordinea n care sunt executate i indiferent de momentele lor de nceput sau de sfrit. Considerm urmtoarea secven de instruciuni: S1: S2: S3: S4: scanf("%d", &a); scanf("%d", &b); c = a + b; printf("%d\n", c);

Fig. Citirea a dou valori, nsumarea lor i afiarea rezultatului Instruciunile S1 i S2 pot fi executate n paralel. Instruciunea S3 se execut numai dup ce se termin att S1 ct i S2, iar instruciunea S4 se execut dup ce s-a executat S3. Aceste condiii de preceden se pot descrie elegant i sugestiv cu ajutorul grafurilor de preceden.

Procese

Grafuri de preceden
Un graf aciclic G=(X,U) este graf de preceden asociat unei secvene de instruciuni dac X este mulimea instruciunilor respective, iar mulimea arcelor U este definit astfel: U = {(Si, Sj) XxX | Sj urmeaz imediat dup Si i se poate executa numai dup ce Si a fost executat complet}. Pentru exemplul de mai sus, graful de preceden este urmtorul: S1 S3 S4 Fig. Graful de preceden corespunztor secvenei de program din fig. 3.3 Pentru o instruciune Si, notm cu R(Si) = {r1, r2, ..., rm} mulimea tuturor variabilelor referite n instruciunea Si, ale cror valori nu sunt modificate de ctre Si i notm cu W(Si) = {w1, w2, ..., wn} mulimea tuturor variabilelor referite n instruciunea Si i modificate n cadrul instruciunii respective. Berstein a stabilit condiiile necesare i suficiente pentru ca dou instruciuni vecine s poat fi executate n paralel: 8 S2

Procese

Teorema (Berstein, 1966) Dou instruciuni vecine S1 i S2 pot fi executate n paralel dac i numai dac ndeplinesc urmtoarele trei condiii: 1. R(S1) W(S2) = 2. W(S1) R(S2) = 3. W(S1) W(S2) = Pentru exemplul din figura anterioar, avem: R(S1) = W(S1) = {a} R(S2) = W(S2) = {b} i conform teoremei lui Berstein, instruciunile S1 i S2 pot fi executate n paralel. Deoarece: R(S3) = {a, b} R(S3) W(S1) = {a} i R(S3) W(S2) = {b} rezult c instruciunea S3 nu poate fi executat n paralel nici cu S1 i nici cu S2.

Mecanisme de specificare a concurenei

Dei grafurile de preceden reprezint un model matematic comod pentru concuren, ele nu pot fi folosite n mod direct pentru a descrie concurena n limbajele de programare. Prezentm n continuare cteva construcii care pot fi implementate n cadrul limbajelor de programare, n vederea specificrii concurenei/paralelismului. 9

Procese

Construciile FORK-JOIN-QUIT Reprezint primele construcii de concuren din limbajele de programare, fiind introduse de Conway (1963) i perfecionate de ctre Denning i van Horn (1966). Instruciunea FORK are sintaxa: FORK label; Are ca efect crearea unui nou proces (proces fiu) care se execut n paralel cu procesul printe. Practic, ca urmare a executrii unei instruciuni FORK, avem dou procese n care se execut n paralel secvene diferite de instruciuni, n cadrul unui proces executndu-se instruciunile secvenei care ncepe la eticheta label, iar n cadrul celuilalt executndu-se instruciunile ce urmeaz dup instruciunea FORK. Instruciunea JOIN are sintaxa: JOIN n, label; Aceast instruciune recombin un numr de n procese care se execut n paralel. Dac a fost executat de k ori, cu 1 k n-1, se trece la execuia instruciunii care urmeaz dup JOIN (n general, aici se va afla o instruciune QUIT). Atunci cnd este executat a n-a oar, se face saltul la instruciunea etichetat cu label. Instruciunea JOIN se execut n mod indivizibil (nu poate fi ntrerupt), iar execuia paralel a dou instruciuni JOIN este echivalent cu execuia lor serial, ntr-o ordine nedefinit. Instruciunea QUIT are sintaxa: QUIT Are ca efect terminarea procesului care o execut, n general fiind plasat imediat dup o instruciune JOIN. 10

Procese

Dei foarte puternic, mecanismul FORK-JOIN-QUIT intr n conflict cu principiile programrii structurate, prin inducerea salturilor la instruciuni etichetate (similar instruciunii GOTO). Totui, sistemul de operare UNIX preia, ntr-o form modificat, acest mecanism, i-l implementeaz sub forma unui apel sistem pentru crearea proceselor. S1 S1 ; nr := 3; FORK L1; S2 ; S6 ; goto L3 S3 ; FORK L2 S4 goto L3 S5 JOIN nr, L4 QUIT S7

S3 S2 S4 S5 L1 :

S6 S7

L2 : L3 : L4 :

Fig. Descrierea FORK-JOIN-QUIT a unui graf de preceden 11

Procese

Mecanismul PARBEGIN-PAREND Numele mecanismului vine de la PARalel BEGIN PARalel END i a fost introdus de Dijkstra n 1965. Sintaxa construciei este: S0; PARBEGIN S1 | S2 | ... | Sn PAREND; Sn+1; i corespunde grafului de preceden urmtor: S0 S1 S2

Sn+1

Sn

Fig. Graful de preceden pentru PARBEGIN-PAREND 12

Procese

Semantica construciei este urmtoarea: instruciunile S1, S2, ..., Sn sunt lansate n execuie simultan i sunt executate concurent, terminarea grupului avnd loc dup terminarea instruciunii care dureaz cel mai mult. Relum exemplele anterioare, prezentnd descrierile PARBEGIN-PAREND corespunztoare: PARBEGIN scanf("%d", &a) | scanf("%d", &b) PAREND; c = a + b; printf("%d\n", c); S1; PARBEGIN begin S3; PARBEGIN S4 | S5 PAREND; end; | begin S2; S6; end; PAREND; S7; 13

Procese

Completarea unor limbaje cu structur de bloc (Pascal, A, Ada) cu construcia PARBEGINPAREND pare natural, iar lizibilitatea programelor nu are de suferit. Trebuie totui menionat c avantajul claritii mecanismului PARBEGIN-PAREND este oarecum estompat de lipsa de flexibilitate. Spre exemplu, graful de preceden din fig. 3.8 poate fi descris cu FORK-JOIN-QUIT, dar nu i cu PARBEGIN-PAREND. S1

S2

S3 S4 S5 S7 S6

Fig. Graf de preceden care nu poate fi descris cu PARBEGIN-PAREND

14

Procese

Conceptul de semafor Introdus de Dijkstra, conceptul de semafor cunoate o larg acceptare n lumea sistemelor de operare, ca mecanism de sincronizare a proceselor/firelor de execuie. Un semafor s este o pereche (v(s), c(s)) unde v(s) este valoarea semaforului, iar c(s) este coada de ateptare a semaforului. Valoarea v(s) este un numr ntreg, i este iniializat cu v0(s) valoarea iniial a semaforului. Coada de ateptare conine referine la procesele care ateapt la semaforul s. Iniial, coada este vid, iar disciplina cozii este stabilit de sistemul de operare. Asupra semafoarelor se pot efectua dou operaii indivizibile P (WAIT) i V (SIGNAL). Indivizibilitatea operaiilor nseamn c asupra unui semafor s se poate executa la un moment dat cel mult o operaie P(s) sau o operaie V(s). Executarea operaiei P(s) de ctre un proces A nseamn: v(s) := v(s) 1; if v(s) < 0 then begin Stare(A) := WAIT; c(s) <= A; /* procesul A intr n coada de ateptare */ Se trece controlul la dispecer; end 15

Procese

else Se trece controlul la procesul A; Fig. Definiia operaiei P Executarea operaiei V(s) de ctre un proces A nseamn: v(s) := v(s) + 1; if v(s) <= 0 then begin c(s) => B; /* procesul B este scos din coada de ateptare */ Stare(B) := READY; /* procesul B este gata pentru execuie */ Se trece controlul la dispecer; end else Se trece controlul la procesul A; Fig. Definiia operaiei V Exemplu Fie G1 i G2 dou gri legate prin n linii paralele, pe care se circul numai de la G1 spre G2. Presupunem c n G1 intr mai mult de n linii. Procesul trecerii trenurilor va fi dirijat cu ajutorul unui semafor s astfel: 16

Procese

n n+1

G1
P(s)

1 2

G2
V(s)

n+k

Fig. Dirijarea trenurilor cu ajutorul unui semafor Valoarea iniial a semaforului este v0(s) = n; Orice tren care ncearc s treac de gara G1 va executa urmtoarea secven de operaii: la intrarea n gara G1, apeleaz P(s); trecerea de semafor implic existena a cel puin unei linii libere (din cele n care leag cele dou gri); trenul ocup o astfel de linie liber i se deplaseaz spre G2; la ieirea din G2, apeleaz V(s) pentru a semnala eliberarea liniei. 17

Procese

Pentru un semafor s, notm cu np(s), nv(s) numrul de primitive P(s) respectiv V(s) efectuate pn la un moment dat, iar cu nt(s) numrul proceselor care au trecut de semaforul s. Teorem Au loc urmtoarele proprieti: 1. v(s) = v0(s) + nv(s) np(s); 2. dac v(s) < 0 atunci n c(s) exist (referine la) v(s) procese; 3. dac v(s) 0, atunci v(s) procese pot trece succesiv de semaforul s fr s fie blocate; 4. nt(s) = min { v0(s) + nv(s), np(s) }.

Probleme specifice programrii concurente

n continuare vom prezenta exemple de intercondiionare a proceselor, introducnd astfel concepte ca: seciune critic, excludere mutual, sincronizarea proceselor, impas, etc. Seciune critic, resurs critic, excludere mutual S presupunem c dou procese P1 i P2 au dreptul s incrementeze o aceeai variabil v, concurent i de un numr neprecizat de ori: PARBEGIN P1 : ... v := v + 1; ... | P2 : ... v := v + 1; ... PAREND; 18

Procese

Presupunnd c sunt necesare mai multe instruciuni main pentru incrementarea variabilei v, cele dou procese pot interfera nedorit n procesul de incrementare concurent a variabilei respective. Pentru exemplificare, presupunem c pentru incrementarea variabilei v se utilizeaz un registru r al mainii, pentru care exist instruciunea main de incrementare INC r (are ca efect r := r + 1). Presupunem deci c secvena de instruciuni main pentru incrementarea variabilei v este de forma: r := v; INC r; v := r; Dac procesului Pi i se aloc pentru incrementare registrul main ri, i=1,2, atunci putem considera urmtoarele scenarii: P1 : r1:= v; INC r1; v := r1; P2 : P1 : r1:= v; INC r1; v := r1; P2 : r2 := v; INC r2; v := r2;

r2:= v; INC r2; v := r2;

a) dubl incrementare corect

b) dubl incrementare incorect 19

Procese

n tabelul de mai sus, dou instruciuni aflate pe acelai rnd sunt executate simultan, sau succesiv ntr-o ordine nedefinit. Presupunnd c valoarea iniial a variabilei v este 10, n urma executrii secvenelor de instruciuni aferente cazului a), variabila v va avea valoarea 12. n cazul dublei incrementri corespunztoare cazului b), se observ c la final valoarea variabilei v este 11, dei a fost incrementat de ctre ambele procese! Pentru ca cele dou procese s nu interfere nedorit n procesul de incrementare a variabilei v, se impune restricia ca instruciunea v := v + 1 s nu poat fi executat simultan de ctre ambele procese. n general, prin seciune critic nelegem o secven de instruciuni care nu poate fi executat simultan de ctre mai multe procese, iar o resurs se va numi resurs critic dac nu poate fi accesat simultan de mai multe procese. Existena seciunilor/resurselor critice n cadrul unor procese impune excluderea reciproc (mutual) a acestor procese n vederea accesului exclusiv la o seciune/resurs critic. Problema seciunii critice a suscitat un interes deosebit n istoria sistemelor de operare i se poate enuna astfel: - la un moment dat, cel mult un proces este n seciunea critic; n cazul n care un proces solicit accesul la o seciune critic ocupat, l va primi numai dup ce procesul care o ocup va termina de executat instruciunile seciunii critice (excludere mutual); - vitezele relative de execuie ale proceselor nu sunt cunoscute; - oprirea oricrui proces are loc numai n afara seciunii critice; - nici un proces nu va atepta indefinit pentru a intra n seciunea critic. 20

Procese

Presupunem c dou procese P1 i P2 solicit accesul la o seciune critic n mod repetat, de un numr nedefinit de ori: PARBEGIN P1: repeat ... seciune critic; ... until false | P2: repeat ... seciune critic; ... until false PAREND; Excluderea mutual a celor dou procese, n vederea execuiei exclusive a instruciunilor seciunii critice se realizeaz elegant cu ajutorul unui semafor s. Soluia prezentat n continuare are avantajul c poate fi generalizat cu uurin pentru un numr oarecare de procese:

21

Procese

var s: semaphore; v0(s) := 1; PARBEGIN P1: repeat ... P(s); seciune critic; V(s); ... until false | P2: repeat ... P(s); seciune critic; V(s); ... until false PAREND; Deoarece v(s) 1, indiferent de numrul proceselor care execut secvena: P(s); seciune critic; V(s); 22

Procese

rezult c la un moment dat un singur proces poate trece de semaforul s fr a fi blocat. Orice alt proces care ncearc ocuparea seciunii critice va fi blocat, pn la eliberarea acesteia de ctre procesul care a ocupat-o, print-un apel V(s). Eliberarea seciunii critice face ca toate procesele din coada semaforului s intre n competiie n vederea ocuprii seciunii. Alegerea ctigtorului se stabilete prin politica sistemului de operare. Semaforul s utilizat n rezolvarea problemei seciunii critice se numete semafor de excludere mutual. Sincronizarea proceselor Vom enuna problema sincronizrii proceselor astfel: un proces P1 nu poate trece de un anumit punct A al execuiei sale dect dup ce un alt proces P2 ajunge ntr-un punct B al execuiei. Pentru rezolvarea acestei probleme, se utilizeaz un semafor s cu valoare iniial 0, adic v0(s) = 0: var s: semaphore; v0(s) := 0; PARBEGIN P1: repeat ... A: P(s); ... until false | P2: repeat ... B: V(s); ... until false PAREND; 23

Procese

Procesul P1 va atepta n punctul A (prin operaia P(s)) pn n momentul n care procesul P2 va efectua n punctul B operaia V(s). Sincronizarea este o operaie fundamental n programarea concurent, iar n cadrul sistemelor de operare regsim i alte construcii care pot fi utilizate n rezolvarea problemelor de sincronizare (mutexuri, obiecte eveniment, variabile de condiie, etc). Problema productorului i a consumatorului Presupunem c exist unul sau mai multe procese numite productoare i unul sau mai multe procese numite consumatoare care opereaz asupra unui acelai buffer cu n intrri pentru n articole. Un proces productor va ncerca s depun cte un articol n buffer, iar un consumator va scoate cte un articol din buffer. Problema const n a sincroniza accesul la buffer al proceselor productoare respectiv consumatoare astfel nct: accesul la buffer se face n manier exclusiv; productorii ateapt cnd bufferul este plin (toate cele n intrri conin articole); consumatorii ateapt cnd bufferul este gol (nu exist nici un articol n buffer). Pentru rezolvare, se utilizeaz trei semafoare, gol, plin i exclus: var plin, gol, exclus : semaphore; v0(plin) := 0; 24

Procese

v0(gol) := n; v0(exclus) := 1; PARBEGIN Productor: repeat produce articol; P(gol); P(exclus); depune articol n buffer; V(exclus); V(plin); until false | Consumator: repeat P(plin); P(exclus); extrage articol din buffer; V(exclus); V(gol); consum articol; until false PAREND; 25

Procese

Semaforul exclus este un semafor de excludere mutual, care asigur accesul exclusiv la buffer. n orice moment, valoarea semaforului gol (v(gol)) reprezint numrul intrrilor libere (goale) din buffer iar valoarea semaforului plin (v(plin)) reprezint numrul articolelor existente n buffer (intrri ocupate). Regiuni critice condiionate Reprezint construcii structurate de concuren, introduse pentru a veni n sprijinul programatorilor, deoarece permit un control riguros asupra nclcrii regulilor de concuren. Programele care exploateaz aceste construcii vor fi mai robuste i mai sigure, eliminndu-se problemele care pot s apar din utilizarea defectuoas a operaiilor cu semafoare. O regiune critic condiionat nglobeaz ntr-un mod elegant conceptele de seciune critic i resurs critic, cu posibilitatea (eventual) de a executa regiunea numai dac este indeplinit o anumit condiie. Fiecrei regiuni critice i se asociaz o resurs constnd din toate variabilele care trebuie protejate n regiunea respectiv. Declararea resursei se face astfel: resource r :: v1, v2, ..., vn unde r este numele resursei, iar vi, i = 1, ...,n sunt numele variabilelor de protejat. O regiune critic condiionat se definete astfel: region r [when B] do S 26

Procese

unde r este numele unei resurse declarate anterior, B este o expresie boolean, iar S este secvena de instruciuni corespunztoare regiunii critice. Dac este prezent opiunea when, atunci secvena S este executat numai dac B este adevrat. Variabilele din resursa r pot fi folosite numai de ctre instruciunile din secvena de instruciuni S. Execuia secvenei de instruciuni S se face n manier exclusiv (seciune critic), astfel c variabilele protejate n cadrul regiunii critice sunt accesate la un moment dat exclusiv de ctre un singur proces (resurse critice). Problema citirilor i a scrierilor Problema a fost formulat n 1971 de ctre Courtois, Heymans i Parnas. Presupunem c exist dou tipuri de procese: cititor i scriitor, care partajeaz o aceeai resurs, pentru simplitate s considerm c aceasta este un fiier. Problema const n a sincroniza accesul la resursa partajat, astfel ca: un proces scriitor poate modifica coninutul fiierului, dar numai n acces exclusiv; un proces cititor poate consulta (citi) informaiile din fiier simultan cu alte procese cititor; procesele scriitor sunt prioritare fa de procesele cititor, astfel c un proces cititor poate atepta indefinit accesul la fiier. O rezolvare a acestei probleme este prezentat n continuare: 27

Procese

(1) resource f :: ...; (2) resource c :: nr, nw : integer; nr := 0; nw := 0; procedure cititor; begin region c when nw = 0 do nr := nr + 1; (3) read ...; (4) region c do nr := nr 1; (5) end; procedure scriitor; begin region c do nw := nw + 1; region c when nr = 0 do; (6) region f do write ...; (7) region c do nw := nw 1; end;

28

Procese

unde: (1) se declar resursa partajat f (un fiier); (2) resursa c conine dou variabile: nr numrul proceselor cititor active; nw numrul proceselor scriitor active; (3) procesul cititor ateapt terminarea tuturor proceselor scriitor active; (4) procesul cititor efectueaz o consultare (citire) eventual n mod partajat cu alte procese cititor; (5) procesul cititor i semnaleaz ncetarea execuiei (scade numrul proceselor cititor active); (6) procesul scriitor ateapt terminarea tuturor proceselor cititor active; (7) regiune critic care implementeaz accesul exclusiv n scriere al proceselor scriitor active. De remarcat c serverul de baze de date MySQL utilizeaz o astfel de politic de acces n cazul utilizrii tabelelor MyISAM (utilizeaz blocaj la nivel de tabel). Problema impasului Considerm urmtorul scenariu, n care dou procese P1 i P2 execut operaii WAIT asupra a dou semafoare x i y: var x, y : semaphores; v0(x) := 1; 29

Procese

v0(y) := 1; PARBEGIN P1 : | P2 : PAREND

... ...

P(x); P(y);

... ...

P(y); P(x);

... ...

Dac procesul P1 trece de P(x), dar nainte ca el s treac de P(y) procesul P2 reuete s treac de P(y), atunci procesul P1 va atepta la semaforul y, iar procesul P2 va atepta la semaforul x. Practic, cele dou procese ateapt reciproc operaii SIGNAL i nu mai avanseaz nici unul. Acest fenomen este cunoscut sub mai multe denumiri: impas, interblocare, deadlock, etc. Impasul poate s apar i n situaia n care procesele solicit, n diverse stadii ale execuiei, ocuparea unor resurse nepartajabile. S presupunem c procesele P1 i P2 au ambele nevoie, pe parcursul execuiei, de dou resurse nepartajabile R1 i R2. Putem imagina urmtorul scenariu de evoluie n timp a execuiei celor dou procese: 1. Procesele P1 i P2 sunt lansate n execuie, iar resursele R1 i R2 sunt ambele libere; 2. Procesul P1 solicit i ocup resursa R1; 3. Procesul P2 solicit i ocup resursa R2; 4. Procesul P1 solicit resursa R2 i intr n starea de ateptare, deoarece resursa R2 este deja ocupat de ctre procesul P2; 5. Procesul P2 solicit resursa R1 i intr n starea de ateptare, deoarece resursa R1 este deja ocupat de ctre procesul P1. 30

Procese

Din acest moment, ambele procese se afl n starea de interblocare (impas), din care teoretic nu vor mai putea iei. Coffman, Elphic i Shoshani au indicat patru condiii necesare pentru apariia impasului: 1. condiia de excludere mutual: procesele solicit controlul exclusiv asupra resurselor pe care le cer; 2. condiia de wait for: procesele pstreaz resursele deja ocupate atunci cnd ateapt alocarea altor resurse; 3. condiia de nepreempie: resursele nu pot fi eliberate din procesele care le in ocupate, pn cnd ele nu sunt utilizate complet; 4. condiia de ateptare circular: exist un lan de procese n care fiecare dintre ele ateapt dup o resurs ocupat de alt proces din lan. Impasul este o stare grav care poate duce la un blocaj al sistemului de operare sau la distrugerea unor procese. Pentru a preveni impasul, sistemul ar trebui s controleze, nainte de fiecare alocare a unei resurse, dac nu cumva este posibil apariia impasului. Pentru aceasta, este necesar ca SO s aib o eviden clar, pentru fiecare proces, privind resursele ocupate, respectiv resursele solicitate dar neprimite. Un model adecvat pentru rezolvarea problemei l reprezint graful alocrii resurselor. Notm cu Rj, j = 1, ..., m resursele sistemului i cu Pi, i = 1, ..., n procesele din sistem. Se construiete un graf orientat bipartit (avnd ca noduri procesele i resursele, iar arcele sunt numai ntre procese i resurse) G = (X, U) astfel:

31

Procese

X = {P1, P2, ..., Pn, R1, R2, ..., Rm) iar (Rj, Pi) U dac procesul Pi a ocupat resursa Rj (Pi, Rj) U dac procesul Pi ateapt s ocupe resursa Rj. n acest graf, dac exist un ciclu, atunci apare impasul. n consecin, dac n urma alocrii unei resurse se ajunge la un graf ciclic, alocarea este anulat i procesul solicitant este pus n ateptare pn la eliberarea unei resurse, dup care se ncearc din nou alocarea resursei solicitate. Detectarea ciclicitii unui graf se poate face cu urmtorul algoritm: Ct timp x X cu proprietatea c nu y X astfel nct (x, y) U, eliminm vrful x din X mpreun cu toate arcele (z, x) U. Dac n urma aplicrii acestui algoritm se ajunge la graful vid, atunci graful iniial este aciclic (deci nu exist impas). Dac graful obinut nu este vid, n ceea ce a rmas dup aplicarea algoritmului se afl procesele i resursele care au provocat (ar provoca) impasul.

32