Sisteme de Operare

Curs nr. 4

3.5. Gestiunea proceselor

3.5.1. Sincronizarea proceselor :

Pentru execuie procesele au nevoie de acces la resursele sistemului : CPU,memorie, disc etc. Aceste resurse pot fi locale sau globale, private sau comune(partajabile). Toate resursele sunt critice (accesibile numai unui proces la un momentdat). Procesele concureaz pentru obinerea accesului la resurse.

Definiie: Sincronizarea este aciunea ce permite modificarea strii unuiproces.

Exemplu: Un proces P1 nu poate trece de un anumit punct A dect dup ce unalt proces P2 ajunge ntr-un punct B (eliberarea unei anumite resurse de ctre procesulP2)

Definiie: Zona de program prin care se apeleaz o resurs critic se numeteseciune critic (SC).

Accesul unor procese la resursele critice se face printr-un protocol deexcludere mutual(EM) ce presupune o sincronizare ce permite modificarea striiproceselor i eventual comunicaii.

Ipoteza de la care se pleac este existena unei seciuni critice (SC).Exist trei etape : intrarea n seciunea critic, tratarea resursei critice din

seciunea critic i ieirea din seciunea critic.

Condiiile pentru realizarea excluderii mutuale ntr-o seciune critic sunt :1. Un singur proces la un moment dat trebuie s execute instruciunile din

seciunea critic ;2. Dac mai mult de un proces sunt blocate la intrarea n seciunea critic i

nici un alt proces nu execut instruciunile din seciunea critic, ntr-untimp finit unul din procesele blocate se deblocheaz i va intra n seciuneacritic (pe rnd vor intra i celelalte).

3. Blocarea unui proces n afara seciunii critice s nu mpiedice intrarea altuiproces n seciunea critic.

4. S nu existe procese privilegiate (mecanismul s fie echitabil pentru toateprocesele).

Implementarea excluderii mutuale se poate face cu : semafoare, ateptare pecondiie (ateptare activ), monitoare, bariere.

Sincronizarea cu semafoare :

Noiunea de semafor a fost introdus de Dijkstra n 1968.Semafoarele se caracterizeaz prin: valoare val(s) i coad de ateptare Q(s) i

sunt de dou tipuri : binare (lucreaz cu valori de 0 i 1) sau ntregi (lucreaz cu valorintre -n i n).

Cozile de ateptare sunt de tip FIFO. Operaiile pentru manipulareasemafoarelor sunt :

- creare

Sisteme de Operare

- distrugere- operaia de intrare n seciunea critic : p(s), p = cerere de intrare n S.C.- operaia de ieire din seciunea critic : v(s), v = cerere de ieire n S.C.

Semaforul poate deveni el nsui seciune critic.

P(s) :val(s) = val(s)-1 ;if(val(s) < 0)

{//trece procesul n coada de ateptare a semaforului respectiv// schimb starea procesului n blocat}

V(s):val(s) = val(s) +1 ;if(val(s) 0)

{//scoate primul proces din coada de ateptare a semaforului // schimb starea procesului n gata de execuie}

Exist o ordine de gestionare a cozii semaforului: FIFO sau LIFO, dar deobicei FIFO.

Semafoarele realizeaz o excludere mutual.

Exemplu pentru 2 procese:Fiind s=1, primul proces l face 0, apoicelelalte nu mai pot intra, sunt blocate. Laieirea unuia se incrementeaz s i intr altproces cnd este momentul potrivit.

V(s) = V0(s)+nv(s) np(s),

unde V(s) este valoarea unui semafor la unmoment dat; np este numarul de treceri prinP(s) i nv este numrul de treceri prin V(s)Dac V(s) >0 , acest numr ne d numrul deprocese ce pot executa instruciunile dinseciunea critic.

Daca V(s)

Sisteme de Operare

P1 avanseaz la P(s) -> s = -1 -> P1 blocat. Pncnd P2 nu ajunge la condiie i execut V(s)procesul P1 rmne blocat.

n proiectarea semafoarelor trebuie avute n vedere urmtoarele situaii :1) Seciunile critice trebuie ncadrate de P i V ceea ce uneori este mai greu de

urmrit ;2) Un proces nu poate fi distrus n SC ;3) Verificarea corectitudinii programelor nu este uoar ;4) Gestiunea cozii poate duce la apariia unor probleme de proiectare.

O alt form de sincronizare cu ajutorul semafoarelor este aa-numitulrendez-vous:

Procesul P1 se blocheaz la P(s1).Procesul P2 deblocheaz procesul P1 prinV(s1) i se blocheaz la P(s2). Ca urmareprocesul P1 avanseaz i va executa V(s2)deblocnd procesul P2.

Semafoarele ntregi se folosesc pentru a gestiona un nr. de resurse identice(componentele unei zone tampon i resurse fizice). Resursele se aloc la cerere i seelibereaza dupa folosirea lor. Cnd nu mai exist copii disponibile procesele seblocheaz.

int s=0 P1: while( ) {

.

.

.

.P(s)

RC

V(s)..

}

P2: while( ) {

.

. if (cond)

V(s)..

}SC

Fig. 3.5.1-2 Semafor privat

int s1=0, s2=0; P1: while( ) {

.

.P(s1)V(s2).

}

P2: while( ) {

.

.V(s1)P(s2).

}

Fig. 3.5.1-3 rendez-vous

Sisteme de Operare

Exemplu : Presupunem ca avem 3 resurse identice un semafor i 3 procese:

int s = 3; p1() p2() p3() { { {

P(s); P(s); P(s); (*) se ocupa prima SC (*) se ocupa prima SC (*) se ocupa prima SC P(s); P(s); P(s); (*) se ocupa a II-a SC (*) se ocupa a II-a SC (*) se ocupa a II-a SC V(s); V(s); V(s); V(s); V(s); V(s);

} } }

ncep s se execute instruciunile de la p1. P(s) foloseste o prim resurs critic i stin (*). La fel p2 i p3 iau cte o resurs i ajung n (*). Observam ca nici un proces nupoate trece mai departe n executie (blocaj). Deci nu numai V este resurs critic ci iexecutia primitivelor P este critic.

Soluie: se introduce o seciune mai mare i un nou semafor iniializat cu 2astfel nct sa ncadrm aceti P i V.

int s =3, s1 =2; p1() {

P(s1); P(s); // se ocupa prima RC P(s); // se ocupa a II-a RC V(s); V(s); V(s1); }

Sisteme de Operare

Sisteme de Operare

Sincronizarea prin ateptare activ:

n cazul sincronizrii prin metoda ateptrii active pornim de la urmtoarelecondiii: exist variabile comune care sunt testate; testul i modificarea variabilelor sfie operaii indivizibile. Exemplu : dac avem 2 procese (programe) p_i i p_j atunci putem scrieurmatoarea form de sincronizare cu variabile comune:

SC are 3 componente : protocolul de intrare corpul protocolul de iesire

boolean flag [2];int turn;void P0( ){ while (true) {

flag [0] = true;turn = 1;while (flag [1] && turn == 1);

/* RC */;flag [0] = false;.

}}

void P1( ){ while (true) {

flag [1] = true;turn = 0;while (flag [0] && turn == 0);

/* RC */;flag [1] = false;.

}}

protocolul de intare

corpul RCprotocolul de ieire

Execuia normal se poatedesfura n paralel, darregiunile critice suntserializate

Fig. 3.5.1-4 Exemplu de execuie a 3 procese

Sisteme de Operare

Fiecare proces va ajunge n seciunea critic. Dac dorete accesul la seciuneacritic procesul seteaz flagul corespunztor i astept ndeplinirea condiiilor. Acestalgoritm se mai numeste algoritmul lui Peterson .

n cazul general alalgoritmului lui Peterson, pentru unproces P_j vom nlocui i cu j.

Problema se poate extinde lamai multe procese

Un alt algoritm care rezolv problema seciunii critice cu ateptare activ estealgoritmul lui Dekker.

Fig. 3.5.1-5. Algoritmul lui Peterson cazul general

int flag[2]={false, false}; int turn;P_i( );{while (true) { flag[i] = true; turn = j; while (flag[j] and turn == j ) { }; // Seciunea Critic flag[i] = false; . }}

boolean flag [2]; int turn;void P_i(){ while (true) {

flag[i] = true; while( flag[j]) if (turn = = j) {

flag[i] = false;while (turn = = j) {};flag[i] = true;

} //Seciunea Criticturn = j;flag[i] = false;

}}

Sisteme de Operare

Pentru cazul cu dou procese P0 i P1 avem:

Un alt algoritm este algoritmul lui Lamport ( bakery algorithm)

Un client la intrarea n magazin primete un tichet cu un numr. Clientul cunumrul cel mai mic este servit primul. Algoritmul nu garanteaz c dou procese nuvor primi acelai numr. Dac Pi i Pj primesc acelai numr i i < j atunci Pi esteprimul servit. Deoarece numele proceselor sunt unice i ordonate, algoritmul vafnciona. Vom folosi pentru identificarea proceselor perechea (number[i], i).

Variabile comune: int number[n]; boolean choosing[n];number[i] = max(number[0], number[1], number[n-1])+1 ;

Procesele trebuie s tie c este posibil ca altcineva s primeasc un numr maimic.

choosing[i] = true;number[i] = max(number[0], number[1], number[n-1])+1 ;

choosing[i] = false;

Dac procesul Pi este n seciunea critic i Pk ncerc s intre n seciuneacritic, procesul Pk execut bucla while pentru j=i i gsete c number[i] 0 i(number[i], i) < (number[k], k) i va continua execuia buclei pn cnd Pi va iei dinseciunea critic

boolean flag [2]; int turn;flag [0] = false; flag [1] = false;turn = 1;void P0( ){ while (true) {

flag [0] = true;while (flag [1])

if (turn == 1) { flag [0] = false; while (turn == 1)

{ }; flag [0] = true; } // Seciunea Criticturn = 1;flag [0] = false;.

}}

void P1( ){ while (true) {

flag [1] = true;while (flag [0]) if (turn == 0) {

flag [1] = false;while (turn == 0){ };flag [1] = true;

}// Seciunea Criticturn = 0;flag [1] = false;.

}}

Sisteme de Operare

Dezavantaje: inconvenientul principal pentru asteptarea pe condiie (activ)este consumarea inutil de timp CPU pentru un proces care ateapt.

Exist 2 operaii care trebuie realizate: testarea i modificarea flag (de aceea afost introdus flag i turn). Un alt dezavantaj al ateptarii active este gradul ridicat dedificultate n elaborarea protocoalelor de intrare i iesire lucru ce poate duce pe lngneclariti i la apariia de erori.

Observaie: multe din problemele de sincronizare implementate cu ajutorulateptrii active sunt rezolvate de semafoare.

Sincronizarea folosind monitoare

Monitoarele au fost introduse de C.A.R. Hoare n 1974.Un monitor reprezint o structur de date format din: variabile de

sincronizare numite i variabile condiii, resurse partajate i proceduri de acces laresurse.. Procedurile pot fi: externe sau interne.

Variabilele locale ale unui monitor nusunt vizibile dect pentru procedurile lui.Procedurile unui monitor sunt puncte de intrare(pot fi accesate din exterior) i ele se executaprin excludere mutual. Primitivele desincronizare sunt:

- wait suspend procesul care execut waitpe o variabil de condiie i face disponibilmonitorul pentru un alt apel;

- signal reactiveaz un proces n ateptarepe o variabil de condiie.

while(1)}

;0][S

})));],[()],[&((&)0]![((while

]);[(while{ );;0(for

;][;1])1[],1[],0[max(][

;][{ do

Process

LLL

K

=

Sisteme de Operare

Procese n ateptare laintrarea n monitor

C1 C2 Cn suspendatsuspendat

wait (coad procesen ateptare)

signal (coadprocese suspendate)

Fig. 3.5.1-7. Cozile de ateptare ale unui monitor

Fig. 3.5.1-6. Structura unui monitor

Sisteme de Operare

Fiecare variabil ci are ataat o coad i odat accesat o procedur amonitorului, un proces n ateptare pe o condiie va ceda accesul unui alt proces nateptare la intrarea n monitor.

Procesele suspendate dup execuia lui signal (ci .signal) nu elibereaz excludereamutuala n monitor deoarece

1. fie exist un proces n execuie a unei proceduri n monitor, eventual nateptare pe o condiie;

2. fie este acelai proces care-si continu execuia cnd nu mai sunt altele dereactivat.Coada proceselor suspendate este mai prioritara fa de aceea de la intrarea n

monitor i a cozilor de ateptare pe condiieDin momentul n care se acceseaz o procedur a monitorului un proces trece

prin urmtoarele stri:- ateptare n coada de intrare a monitorului ;- ateptare ntr-o coad pe o variabil de condiie (wait) ;- suspendarea prin execuia signal, care reactiveaz un proces n ateptare pe

o variabil de condiie ;- execuia normal a instruciunilor unei proceduri din monitor.

Pe scurt un monitor poate fi definit astfel :monitor = variabile de condiie + proceduri;

Sincronizarea folosind bariere

Strile proceselor n cazul sincronizrii folosind bariere :- toate procesele mai puin unul ajung la barier i sunt blocate;- ultimul proces ajunge la barier;- toate procesele i continu execuia mai departe

Dezavantaj: se consum timp CPU inutil dac nu este echilibrat ncrcareaproceselor.

Fig. 3.5.1-8. Sincronizarea folosind bariere

Sisteme de Operare

Sincronizarea prin transmiterea de mesaje

Aceast metod permite schimbarea de mesaje ntre procese pentrusincronizare. Mesajele pot avea dimensiune fix sau nu. Dac dou procese P i Q vors transmit mesaje trebuie s stabileasc o legtur ntre ele. Detalii de implementarei gestionare a comunicaiilor sunt lsate n grija sistemului de operare. Sistemul detransmitere a mesajelor trebuie s ofere funcii de tip send(destinaie, mesaj) ireceive(surs, mesaj). Att procesul care trimite mesajele, ct i cel care le primetepot fi blocate sau nu i avem urmtoarele cazuri :

- Send / receive blocante: ambele procese sunt blocate pn la terminareacomunicrii ;

- Send neblocant, receive blocant : procesul ce execut send i continuexecuia imediat ce a trimis mesajul, iar procesul ce execut receive esteblocat pn la sosirea mesajului ;

- Send / receive neblocante: nici un proces nu atept terminarea operaiilorde comunicaie;

Adresarea poate fi : - direct : n acest caz, funciile send / receive includ identificatorul

procesului destinaie ;- indirect : n acest caz mesajele sunt trimise unei structuri de date partajate

ce constau n cozi numite mailbox (casue potale)

mailbox

P1

Pn

Q1

Qn

P1

Pn

Q1port

.

.

.

.

.

.

header

Corpulmesajului

Fig. 3.5.1-9. Structura unui mesaj

Sisteme de Operare

Excluderea mutual folosind mesaje :

Paradigme ale programrii concurente:

I) Cina celor 5 filosofiCinci filosofi i petrec viaa gndind sau mncnd. Pentru a mnca filosofii

trebuie s intre ntr-o camer unde este o mas nconjurat de 5 scaune. n centrulmesei este un castron cu spaghetti, iar pe mas sunt aezate 5 farfurii i 5 furculie.Cind unui filosof i se face foame intr n camer, se aeaz la mas i ncearc sfoloseasc 2 furculie, una din stinga i una din dreapta. Filosoful nu poate ridicasimultan ambele furculie i nu poate lua furculia care se afl deja n mna unuiadintre vecini. Ct timp mnnc, filosoful nu las furculiele din mini, iar cndtermin le las pe mas. Se cere gsirea unei soluii pentru ca toi filosofii s poatmnca.

Resurse: furculiteProcese: filosofi.

Soluii posibile: - se mai cumpr 5 furculie - nvm filosofii s mnncespaghetti cu o singur furculi

O soluie ar fi s folosimpentru fiecare furculi cte unsemafor. Filosoful ncearc s ia ofurculi executnd P sau o las pemas executnd V.

n acest caz funcia pentrufilosof ar arta astfel:

const int n /* number of processes */;void P(int i){

message msg;while (true){ receive (mutex, msg); /* critical section */; send (mutex, msg); /* remainder */;}

}void main(){ create_mailbox (mutex); send (mutex, null); parbegin (P(1), P(2), . . ., P(n));}

Sisteme de Operare

Chiar dac se asigur o condiie de

excludere mutual (nu vor mnca niciodat nacelai timp doi vecini) soluia nu poate fiacceptat deoarece poate aprea situaia ncare dac la toi filosofii li se face foame nacelai timp i fiecare reuete s ia furculiadin stnga sa, toate elementele vectorului forkar fi 0 i oricare ar ncerca s apuce furculiadin dreapta ar atepta la infinit.

Pentru rezolvarea acestei probleme putem avea mai multe soluii care impunanumite restricii :

- angajm un valet care s permit accesul n sala a numai 4 filosofi n acelaitimp:

int fork[5] = {1,1,1,1,1}; int valet = 4; int i ; void philosopher(int i) {

while (true) {

P(valet); // intr in camer P(fork[i]); // ridic furculia stnga P( fork[( i + 1) % 5]); // ridic furculia dreapta // mnnc V(fork[i]); // elibereaz furculia stnga V( fork[( i + 1) % 5]); // elibereaz furculia dreapta V(valet); // iese din camer

} }

- unui filosof i se permite s ia o furculi doar atunci cnd ambele sunt libere (sepoate implementa sub form de seciune critic)

- se asociaz fiecrui filosof cte un numr i se impune filosofilor cu numrimpar s ridice mai nti de pe mas furculia din stnga i apoi pe cea din dreapta, iarfilosofilor cu numr par s ridice mai nti furculia din partea dreapt i apoi pe ceadin stnga (soluie asimetric).

II) Problema productor consumator

Modelul problemei productor consumator implementeaz un protocol decomunicaie ntre 2 sau mai multe procese care utilizeaz 2 sau mai multe resurseduale (locaiile ocupate sau libere dintr-un buffer). Unul sau mai muli productoriintroduc datele n buffer; un singur consumator extrage datele din buffer.

semaphore fork[5] = {1,1,1,1,1};int i;void philosopher(int i){

while(true){ think( ); P(fork[i]);

P(fork[(i+1) mod 5]); eat( ); V(fork[(i+1) mod 5]); V(fork[i]);

}}

Sisteme de Operare

Dac buffer-ul este circular cu n locaii; elementele din buffer sunt citite deconsumator n aceeai ordine n care sunt scrise de productor i nici un element nutrebuie pierdut sau introdus n plus. Aceste condiii sunt statice.

Avem 2 constante: io locaia unde este un mesaj care se poate citi; il locaia de la care putem scrie.

Condiii de sincronizare:- dac buffer-ul este gol consumatorul se blocheaz pn cnd exist cel

puin un mesaj.- dac buffer-ul este plin producatorul se blocheaz pn cnd exist cel

puin o locaie liber..

Pentru situaia 1 productor - 1 consumator:

Consumatorul avanseaz pn la P(ocupat) unde se blocheaz, apoi avanseazproductorul care face P(liber), d mesajul, incrementeaz cursorul, executV(ocupat) care d impuls consumatorului care se deblocheaz cu V(liber).

Productorul i consumatorul i trimit informaii prin intermediul buffer-ului.Presupunem c avem k procese productori i l procese consumatori. n acest cazil este resurs critic pentru productori i vom introduce un semafor liber pe care liniializm cu n. La fel io resurs critic pentru consumatori si introducem semaforulocupat iniializat cu 0. Semaforul s asigur accesul la seciunea critic i esteiniializat cu 1.

ilio

10 2 n-1

int io =il =0;int liber =n, ocupat =0;int buf[n];void producator (int mes){. P(liber); buf [il] =mes; //adaug mesaj il= (il +1) %n; V(ocupat);}

int consumator(){.. P(ocupat); mes=buf [io]; //citete mesaj io = (io +1) %n; V(liber);. consuma(mes);}

int io = il=0;int liber =n, ocupat =0, s =1;void producator(int mes){. P(liber); P(s); buf[il] =mes; // adaug mesaj il =(il +1) %n; V(s); V(ocupat);..}

int consumator(){.. P(ocupat); P(s); mes=buf[io]; //citete mesaj io =(io +1) %n; V(s); V(liber); consuma(mes);}

Sisteme de Operare

n cazul n care buffer-ul este infinit avem nevoie de un semafor s pentru arealiza excluderea mutual asupra buffer-ului; avem nevoie de un semafor n pentru asincroniza productorul i consumatorul asupra dimensiunii buffer-ului :

Rezolvarea cu monitoare :Avem dou tipuri de procese: productor i consumator, sincronizarea fiind

definit n interiorul monitorului. Funciile de adugare i citire din buffer vor fi ninteriorul monitorului. Dac funciile sunt corecte, sincronizarea va funciona pentrutoate procesele.

void consumator(){ while (true)

{ P(n); P(s); mes=buf[io]; //citete mesaj io =(io +1) %n; V(s); consume();}

}

int n = 0, s = 1; //semafoareint io = il =0;void productor (){ while (true)

{ produce(); P(s);

buf[il] =mes; // adaug mesaj il =(il +1) %n; V(s); V(n);}

}

Consumator( ){ while (true) { citete(v); consume v; }}

Productor( ){ while (true) { produce v; adaug(v); }}

Monitor buffer_circular{ char buffer[k]; int nextin =0, nextout=0, count=0; //count = nr de elemente din buffer boolean notfull, notempty;

adaug(v){ if (count = k) wait(notfull); //buffer plin buffer[nextin] = v; nextin = (nextin+1)% k; count++; //nc un element n buffer signal(notempty); //eliberare buffer pentru accesul cititorului } citete(v){ if (count = 0) wait(notempty); // buffer gol v= buffer[nextout]; nextout = nextout+1 mod k; count--; //scoatere element din buffer signal(notfull); // eliberare buffer pentru accesul scriitorului }}

Sisteme de Operare

Rezolvarea cu transmitere de mesaje:

const int capacity = /* buffering capacity */ ;null = /* empty message */ ;int i;void producer(){ message pmsg; while (true) {

receive (mayproduce, pmsg);pmsg = produce();send (mayconsume, pmsg);

}}

void consumer(){ message cmsg; while (true) {

receive (mayconsume, cmsg);consume (cmsg);send (mayproduce, null);

}}

void main(){ create_mailbox (mayproduce); create_mailbox (mayconsume); for (int i = 1; i