Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Dezvoltarea algoritmilor folosind variabile

partajate (MIMD)
Problema centrala: sincronizarea intre procese
pentru excluderea mutual i orchestrarea proceselor
cooperante.
Cteva mecanisme simplificatoare dezvoltate:
- semafoare,
- regiuni critice,
- monitoare.
Prezentam cteva probleme "clasice
- partajarea resurselor
- productori-consumatori,
- cititori-scriitori
a caror rezolvare se bazeaza pe tipare diferite de utilizare a
semafoarelor

Algoritmi Paraleli si distribuiti 1

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Partajarea resurselor si sectiunile critice

Problema: fiecare proces P(i) al unei colectii de procese P[i:1..n]
executa ciclic o sectiune critica, in care are acces exclusiv la
anumite resurse partajate, urmata de o sectiune necritica in care
foloseste doar resurse locale.
Solutia bazata pe operatii atomice controleaza intrarea in
sectiunea critica, folsind o variabila s care are valoarea:
1 daca nici un proces nu este in sectiunea critica
0 daca un proces este in sectiunea critica
Pentru a intra in sectiunea critica, un proces executa operatia
<await (s>0) s = s-1;>
Ce se intampla daca s>0 si mai multe procese incearca sa intre in
sectiunea critica ?
La iesirea din sectiunea critica, procesul executa operatia
<s = s+1>

Algoritmi Paraleli si distribuiti 2

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Varianta cu operatii atomice

int s = 1;
process P[i=1 to n]{
while (true){
<await (s>0) s = s-1;>;
/*acaparare sect critica*/
Sectiune critica;
<s = s+1>;
/*eliberare sect critica*/
Sectiune necritica;
}
}

Algoritmi Paraleli si distribuiti 3

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Solutia cu semafoare
Notatie: se introduc doua operatii primitive P si V si variabila s de
tip semafor
P(s) :: <await (s>0) s = s-1;>
V(s) :: <s = s+1>

Soluie excludere mutuala:

variabila semafor are valori intregi si poate fi folosita doar in
operatiile P si V
exista doua tipuri de semafoare
semafoarele binare admit doar valorile 0 si 1
semafoarele generale admit valori >= 0

Algoritmi Paraleli si distribuiti 4

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Folosire P si V pentru excludere mutuala

sem mutex = 1; /* mutex accepta doar op. P si V */
process P[i=1 to n]{
while (true){
P(mutex);
/*acaparare sect critica*/
Sectiune critica;
V(mutex);
/*eliberare sect critica*/
Sectiune necritica;
}
}
Algoritmi Paraleli si distribuiti 5
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Producatori si consumatori
Problema: M producatori si N consumatori comunica printr-un
tampon partajat care are un singur element.
Trebuie asigurat ca valorile sa nu fie supra-scrise si sa nu fie citite
din tampon de mai multe ori.
Constrangeri ale accesului la tampon
producatorii au acces doar cand tamponul este gol
consumatorii au acces doar cand tamponul este plin
cand un producator pune o valoare in tampon marcheaza tampon plin
un alt producator nu poate supra-scrie tamponul
cand un consumator ia o valoare din tampon marcheaza tampon gol
un alt consumator nu poate citi aceeasi valoare ca precedentul
un singur semafor nu este suficient pentru a controla accesul!
Solutia controlul accesului poate fi asigurat doar de 2 semafoare
gol, pentru accesul producatorilor
plin, pentru accesul consumatorilor

Algoritmi Paraleli si distribuiti 6

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Producator - solutia
typeT buf;
sem gol = 1, plin = 0; /* sem. binare */
process Producator [i= 1 to M]{
typeT v; /* variabila locala */
while (true){
v = produce (); /* produ o valoare v */
/* asteapta buf gol */
P(gol);
buf = v;
/* marcheaza buf plin */
V(plin)
}
}

Algoritmi Paraleli si distribuiti 7

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Consumator solutia
typeT buf;
sem gol = 1, plin = 0; /* sem. binare */

process Consumator [i= 1 to N]{

typeT w; /* variabila locala */
while (true){
/* asteapta buf plin */
P(plin);
w = buf; /* preia valoarea din buf */
/* marcheaza buf gol */
V(gol);
consuma (w);
}
}
Algoritmi Paraleli si distribuiti 8
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Comunicare intre un producator si un consumator

prin tampon limitat
Tamponul este un tablou de k elemente, care permite pastrarea
mai multor valori la un moment dat
Consecinte:
se pot pune mai multe valori in tampon fara a se citi vreo valoare
se pot citi mai multe valori din tampon fara a se scrie vreo valoare
care este numarul maxim ?
semafoarele binare nu sunt suficiente
Solutia folosire semafoare generale
semafoarele gol, plin au valori de la 0 la k
valorile initiale sunt ???
gol = k, plin = 0

Algoritmi Paraleli si distribuiti 9

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Comunicare intre un producator si un consumator

prin tampon limitat
Tamponul are dimensiunea k si este circular
Trebuie asigurat ca valorile nu sunt suprascrise si nu sunt citite
din tampon de mai multe ori
Ordinea in care valorile sunt consumate sa fie cea in care valorile
sunt produse;
Solutia: ordinea este controlata de doua variabile
prim - pozitia valorii ce trebuie consumata
ultim pozitia unde trebuie pusa urmatoarea valoare produsa

1 2 3 k

ultim prim
Algoritmi Paraleli si distribuiti 10
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Tampon limitat - producatorul

typeT buf [1:k];
sem gol= k; plin= 0; /* buf are k pozitii goale */
process Producator {
typeT v;
int ultim = 1; /*pozitia de scriere initiala*/
while (true){
v = produce ();
/*acapareaza un loc gol*/
P(gol);
/*scrie v si actualizeaza ultim*/
buf[ultim] = v; ultim = ultim mod k + 1;
/*incrementeaza numar valori din tampon*/
V(plin);
}
}
Algoritmi Paraleli si distribuiti 11
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Tampon limitat - consumatorul

typeT buf [1:k];
sem gol= k; plin= 0; /*sem. generalizate*/
process Consumator {
typeT w;
int prim = 1; /*primul elem din tampon*/
while (true){
/*acapareaza un loc plin*/
P(plin);
/*preia valoarea si actualizeaza prim*/
w = buf[prim]; prim = prim mod k + 1;
/*incrementeaza nr pozitii goale din tampon*/
V(gol);
consuma (w);
}
}
Algoritmi Paraleli si distribuiti 12
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Comunicare intre mai multi producatori si mai multi

consumatori prin tampon limitat
Solutia este o extindere a celei precedente
Trebuie asigurat ca valorile nu sunt suprascrise si nu sunt citite
din tampon de mai multe ori
Ordinea in care valorile sunt consumate sa fie cea in care valorile
sunt produse; ordinea este controlata prin variabilele prim si ultim
Mai multi producatori pot avea valori de plasat in acelasi timp
pentru a evita supra-scrierea in acelasi loc, plasarea unei valori si
modificarea variabilei ultim se fac in regim de excludere mutuala
intre producatori, folosind semaforul mutexP
Mai multi consumatori pot incerca accesul la valorile produse
pentru a evita citirea aceleiasi valori, preluarea unei valori si
modificarea variabilei prim se fac in regim de excludere mutuala
intre consumatori, folosind semaforul mutexC

Algoritmi Paraleli si distribuiti 13

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Producatorii
typeT buf[1:k];
sem gol = k, plin = 0; /*sem. generalizate*/
int prim = 1, ultim = 1; /*variabile partajate*/
sem mutexP = 1, mutexC = 1;

process Producator[i = 1 to M]{

typeT v;
while (true){
v = produce ();
P(gol); /*acapareaza un loc gol*/
P(mutexP); /*intra sectiune critica producatori*/
buf[ultim]=v; ultim = ultim mod k + 1;
V(mutexP);
V(plin);
}
}
Algoritmi Paraleli si distribuiti 14
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Consumatorii
typeT buf[1:k];
sem gol = k, plin = 0; //sem generalizate
int prim = 1, ultim = 1;
sem mutexP = 1, mutexC = 1;
process Consumator[i = 1 to N]{
typeT w;
while (true){
P(plin); /*acapareaza un loc plin*/
P(mutexC); /*intra sectiune critica consumatori*/
w = buf[prim]; prim = prim mod k + 1;
V(mutexC);
V(gol);
consuma (w);
}
}
Algoritmi Paraleli si distribuiti 15
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Problema cititorilor si scriitorilor

Problema: exista doua tipuri de procese, cititori si scriitori care
impart o resursa.
Mai multi cititori pot avea acces simultan la resursa comuna daca
nici un scriitor nu o modifica in acelasi timp.
Un singur scriitor poate modifica resursa daca ea nu este accesata
de alte procese.
Solutia: un semafor rw pentru excluderea mutuala intre procese
rw=1 resursa nu este utilizata
rw=0 resursa utilizata de un scriitor sau de unul sau mai multi cititori
Scriitorii executa P(rw) pentru intrare in sesiunea critica si V(rw) pentru
iesire
Cititorii pot folosi in paralel sectiunea critica
tin evidenta numarului de cititori aflati in sectiunea critica
doar primul cititor care intra in sectiunea critica executa P(wr)
doar ultimul cititor care iese din sectiunea critica executa V(rw)

Algoritmi Paraleli si distribuiti 16

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Procesul cititor
sem rw = 1;
sem mutexR = 1; /*accesul la nr este exclusiv ptr. cititori*/
int nr = 0;
process Cititor [i = 1 to m]{
while (true){
P(mutexR); /*necesara pentru accesul exclusiv la nr*/
nr = nr+1;
if (nr == 1) P(rw); /*daca prim cititor*/
V(mutexR);
citeste din resursa comuna;
P(mutexR)
nr = nr-1;
if (nr == 0) V(rw); /*daca ultim cititor*/
V(mutexR);}
}

Algoritmi Paraleli si distribuiti 17

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Procesul scriitor
sem rw = 1, mutexR = 1;
int nr = 0;

process Scriitor [j = 1 to n]{

while (true){
P(rw);
scrie in resursa comuna;
V(rw);}
}

Algoritmi Paraleli si distribuiti 18

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Alte politici de citire si scriere

Neajuns solutia precedenta: starvation prin intarziere la nesfarsit a

scriitorilor de catre cititori
Alta solutie prioritate pentru scriitori
Impune regulile urmatoare:
1.noile cereri de la cititori sunt intarziate daca un scriitor este in
sectiunea critica sau asteapta sa intre in sectiunea critica
2.un cititor intarziat este trezit din asteptare doar daca nu exista un
scriitor in asteptare sau in sectiunea critica.
3.un scriitor este intarziat daca un alt scriitor sau un cititor se afla
deja in sectiunea critica

Algoritmi Paraleli si distribuiti 19

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Conditii si semafoare
Pentru specificarea conditiilor se definesc
int nr = 0; /*nr cititori care folosesc resursa */
int nw = 0; /*nr scriitori care folosesc resursa */
int dr = 0; /*nr cititori intarziati */
int dw = 0; /*nr scriitori intarziati */

conditia 1 cititor intarziat daca nw>0 OR dw>0

conditia 2 cititor trezit daca nw=0 AND dw=0
conditia 3 scriitor intarziat daca nr>0 OR nw>0

Pentru controlul accesului definim semafoarele

sem r = 0; /*intarzie cititori daca nw>0 OR dw>0*/
sem w = 0; /*intarzie scriitori pana cand nw=0 AND nr=0*/

Algoritmi Paraleli si distribuiti 20

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Semafoarele s si w sunt folosite in sectiunile decide din

procesele Cititor si Scriitor
process Cititor [i = 1 to m]{
while (true){
decide intrare in sectiunea critica sau intarzierea;
citeste din resursa comuna;
decide daca si cine intra in sectiunea critica;
sectiune necritica;
}
}

process Scriitor [j = 1 to n]{

while (true){
decide intrare in sectiunea critica sau intarzierea;
scrie in resursa comuna;
decide daca si cine intra in sectiunea critica;
sectiune necritica;
}
}
Algoritmi Paraleli si distribuiti 21
 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Toate procesele trec prin aceste sectiuni de decizie

Executia sectiunilor trebuie sa fie atomica (exclusiva)
Pentru realizarea excluderii mutuale si luarea deciziilor, se
foloseste si un al treilea semafor

sem e = 1; /*intrare in sectiune atomica */

Iar utilizarea celor trei semafoare (r, w, e) se face conform unui

tipar numit split binary semaphore

Algoritmi Paraleli si distribuiti 22

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

Split binary semaphore

Semafoarele e, r si w formeaza impreuna un semafor
"splitat" (split binary semaphore)
- cel mult un semafor este 1 la un moment dat: 0<=e+r+w<=1
- fiecare cale de executie incepe cu un P si se termina cu un singur
V aplicat unuia din cele trei semafoare
- instructiunile aflate intre P si V se executa in excludere mutuala.
Tehnica se numeste "pasarea stafetei":
- initial un semafor este 1 si un proces poate prelua stafeta printr-o
operatie P asupra semaforului
- cand un proces detine stafeta (se executa intr-o sectiune critica si
toate semafoarele sunt 0), el poate pasa stafeta altui proces
printr-o operatie V asupra unuia din cele trei semafoare.

Algoritmi Paraleli si distribuiti 23

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

process Cititor [i = 1 to m]{

while (true){
P(e);
if (nw>0 or dw>0){
dr = dr+1; V(e); P(r); /*intarzie cititorul*/
}
nr = nr+1;
if (dr>0) {dr = dr-1; V(r);} /*trezeste in alt cititor*/
else if (dr==0) V(e);
citeste din resursa comuna;
P(e);
nr = nr-1;
if (nr == 0 and dw>0){
dw = dw-1; V(w);} /*trezeste un scriitor*/
else if (nr>0 or dw==0) V(e);
sectiune necritica;
}
}

Algoritmi Paraleli si distribuiti 24

 Universitatea Politehnica Bucureti - Facultatea de Automatic i Calculatoare

process Scriitor [j = 1 to n]{

while (true){
P(e);
if (nr>0 or nw>0){
dw = dw+1; V(e); P(w);} /*intarzie scriitorul*/
nw = nw+1;
V(e);
scrie in resursa comuna;
P(e);
nw = nw-1;
if (dr>0 and dw==0){
dr = dr-1; V(r);} /*trezeste un cititor*/
else if (dw>0){dw = dw-1; V(w);} /*trezeste un scriitor*/
else if (dr==0 and dw==0) V(e);
sectiune necritica;
}
}
Algoritmi Paraleli si distribuiti 25