Sistemele multiprocesor: calculele sunt repartizate mai multor procesoare fizice.

n aceste sisteme multiprocesor, comunicarea ntre procesoare are loc fie prin zone de memorie comune (partajate), fie prin canale. Algoritmi de calcul paralel (care determin soluia unei probleme prin descompunerea ei n subprobleme independente, rezolvabile n paralel pe procesoare distincte); de exemplu este evident c suma a doi vectori, calculat prin:
for i:=1 to n do c[i]:=a[i]+b[i]

se efectueaz mai rapid dac avem la dispoziie n procesoare, fiecare capabil s efectueze o adunare.

Ce este programarea concurent ?

Considerentele de mai sus sunt aplicabile mai ales n cazul n care aciunile care urmeaz s se execute concomitent sunt independente ntre ele. imprimant s apar amestecate ieirile programelor mai multor utilizatori). Vom numi proces un program secvenial n curs de executare; drept urmare, la fiecare moment de timp este executat cel mult o instruciune a sa. Vom denumi program concurent un program care n timpul executrii sale creaz mai multe procese care se execut ntr-un paralelism abstract, adic nu neaprat pe procesoare distincte. n permanen trebuie ns gndit ca i cnd fiecrui proces i este asociat n mod univoc un procesor fizic; desigur c i implementarea trebuie gndit astfel nct s permit acest lucru. Aproape ntotdeauna, executarea concurent a proceselor cere o anumit cooperare ntre ele, deci sunt necesare anumite mecanisme care s asigure comunicarea i sincronizarea ntre procese. Este nevoie de un alt mod de gndire, de alte "unelte", de alt nelegere a noiunii de program corect (deci i de alte metode de verificare a corectitudinii). Conform celor de mai sus, putem considera c fiecare proces este executat de cte un procesor ("calculator" ce are unitate central, memorie, canale pentru operaiile de intrare/ieire). Programarea concurent este menit s rezolve interaciunile dintre procese. Atenia principal este ndreptat deci asupra modalitilor n care pot fi realizate interaciunile dorite i mai puin asupra a ceea ce realizeaz programele secveniale ce constituie fiecare proces n parte. Natura problemelor este diferit de cea ntlnit n programarea secvenial. Sunt tratate n special probleme de simulare a unor situaii concurente reale i nu probleme care urmresc obinerea unui rezultat numeric. Iat dou exemple tipice de probleme ntlnite n programarea concurent: 1) Problema rezervrii biletelor: Fiecare terminal al unei reele de calculatoare este plasat ntr-un punct de vnzare a biletelor pentru un anumit spectacol. Se cere s se gseasc o modalitate de a evita vnzarea a dou bilete pentru acelai loc. 2) Problema Productor Consumator: Productorul fabric articole de un

2 1. INTRODUCERE N PROGRAMAREA CONCURENT

anumit tip i le plaseaz pe o band. Consumatorul ia cte un obiect de pe band i l "consum". Se cere s se simuleze aceste activiti, evitndu-se ncercrile productorului de a plasa un articol pe band cnd aceasta este plin, precum i ncercrile consumatorului de a lua un obiect de pe band cnd aceasta este goal (dificultatea const deci n realizarea unei sincronizri).

Executarea proceselor concurente

n vederea asigurrii portabilitii, dar i a posibilitii ca unui procesor fizic s i fie ataate mai multe procesoare logice, nu se va face nici o presupunere asupra vitezei de lucru a procesoarelor. Cu alte cuvinte, orice supoziii asupra raportului vitezelor a dou procesoare, ca i asupra ritmicitii executrii instruciunilor n cod main din cadrul aceluiai proces, sunt neavenite (nu ne ocupm aici de sistemele concurente n timp real). Singura ipotez relativ la timp pe care ne vom baza atunci cnd scriem sau/i analizm programe concurente i care este esenial pentru nelegerea acestui tip de programare este urmtorul: "pentru fiecare proces i pentru fiecare dou instruciuni main consecutive ale sale, intervalul de timp ntre executarea lor este neprecizat, dar finit". Vom considera aceast ipotez ca fiind condiia fundamental a executrii concurente a programelor. Un caz limit este cel al unui singur procesor fizic. Acesta trebuie s aloce "felii" de timp proceselor concurente astfel nct s fie satisfcut condiia enunat mai sus. Modul n care se realizeaz acest lucru (prin generare aleatoare sau prin alegerea unei anumite structuri ca de exemplu o coad, o coad cu prioritate etc.) va fi precizat la fiecare modalitate de abordare a concurenei. Programarea concurent rezerv o serie de surprize informaticianului obinuit cu programarea secvenial. Prezentm n continuare cteva dintre ele. 1) n programarea secvenial, urmtoarea secven de instruciuni:
i:=1; i:=2

este echivalent cu a doua instruciune. n programarea concurent secvena de mai sus nu are nimic redundant. ntr-adevr, n intervalul de timp dintre executarea celor dou instruciuni (n cadrul aceluiai proces) este posibil ca celelalte procese s execute diferite instruciuni care s foloseasc efectiv faptul c un anumit interval de timp (asupra lungimii cruia nu putem face nici o ipotez) valoarea lui i este egal cu 1.
if i=1 then j:=j+i

2) Efectul instruciunii:

n cazul n care valoarea lui i era 1 la nceputul executrii acestei instruciuni condiionale nu const neaprat n mrirea cu o unitate a valorii lui j, deoarece ntre momentul efecturii comparaiei i momentul efecturii atribuirii valoarea lui i poate fi eventual modificat de un alt proces. Analog, dac ntr-un proces apare secvena de instruciuni: i:=1; if i=1 then instr atunci pe de o parte nu este neaprat adevrat c este ndeplinit condiia i=1 din instruiunea if, iar pe de alt parte nu este neaprat adevrat c n momentul executrii instruciunii instr valoarea lui i este egal cu 1; n schimb afirmaia valoarea lui i a fost egal cu 1 la un moment de timp anterior" este adevrat i poate fi util (de exemplu n a demonstra c procesul are o anumit evoluie).

Este uor de observat c aceste comportri "anormale" din punctul de vedere al programrii secveniale i au cauza n utilizarea de ctre mai multe procese a unei arii (comune) de memorie. De aceea, aa cum vom vedea n capitolele urmtoare, multe abordri ale programrii concurente evit comunicarea ntre procese prin intermediul variabilelor globale, nlocuind-o cu alte mecanisme. Programarea concurent se mai deosebete de programarea secvenial i prin faptul c programele pot avea comportare nedeterminist: "la executri diferite pentru acelai set de date de intrare, rezultatele nu vor fi neaprat aceleai". Pentru executarea proceselor concurente s-a ales modelul aleator, care const n repetarea ciclic a urmtoarelor aciuni de ctre fiecare procesor fizic: 1) alege aleator unul dintre procesele concurente crora nu le este asociat un procesor fizic; 2) execut, pe parcursul unui interval de timp ales aleator, instruciuni ale sale.

Noiunea de seciune critic

Problema rezervrii biletelor. Reamintim c problema const n simularea activitii mai multor terminale conectate la un calculator central, terminale de la care se pot face rezervri de bilete pentru un anumit spectacol; bineneles c trebuie evitat vnzarea a dou bilete pentru acelai loc. Considerm urmtoarea modalitate prin care un proces face rezervarea, n ipoteza c mai exist locuri libere i c fiecare persoan ce acceseaz un terminal are anumite preferine pentru locurile din sal, dar este hotrt s cumpere un bilet:
repeat rez:=false; repeat

{ sosete un nou client } { pn cnd clientul cere un loc liber }

expune planul slii

read(loc_client); { citete locul cerut de client } if sala[loc_client]=1 { locul este liber } then begin sala[loc_client]:=0; rez:=true;

elibereaz bilet
end else write('Alta optiune: ') until rez forever

Este uor de observat c aceast modalitate este incorect. Vom numi seciune critic o secven de instruciuni a cror executare trebuie s se supun urmtoarei reguli: n momentul n care un proces P ncepe executarea primei instruciuni din secven, toate celelalte procese i ntrerup temporar activitatea pn la terminarea executrii ultimei instruciuni din secven de ctre procesul P. n aceste condiii spunem c are loc o excludere reciproc (cel mult un proces se poate afla ntr-o seciune critic). S observm c dac n codul de mai sus ataat instruciunii if primele patru aciuni (linii de cod) ar forma o seciune critic, atunci modalitatea de rezervare de mai sus ar fi corect.

4 1. INTRODUCERE N PROGRAMAREA CONCURENT

Problema grdinilor ornamentale. Intrarea n grdinile ornamentale ale unui ora oriental se face prin dou pori. Se pune problema inerii evidenei numrului de persoane care au intrat n grdin. Se introduce variabila global n, a crei valoare curent reprezint numrul persoanelor ce au intrat n grdini. Fiecrei pori i se asociaz n mod natural un proces, cele dou procese urmnd a fi executate concurent. n cadrul fiecrui proces valoarea variabilei n este mrit cu o unitate de fiecare dat cnd o persoan intr n grdini pe poarta asociat procesului. La fiecare executare a lui rezultatul va fi altul! Explicaia const n primul rnd n faptul c instruciunea n:=n+1 nu este nedivizibil (nu este o aciune "atomic"), iar n al doilea rnd n modul de executare al programelor concurente. ntr-adevr, instruciunea n:=n+1 este n realitate format din trei instruciuni n cod main:
LOAD n,r INC r STORE r,n

{ ncarc n n registrul r al CPU } { incrementeaz valoarea lui r cu 1 } { salveaz valoarea registrului n n }

Fie r1 i r2 registrele unitii centrale folosite de cele dou procese. Atunci n cazul n care pe fiecare poart intr trei persoane, este posibil urmtoarea succesiune de aciuni: Pentru exemplificare, s considerm cazul a dou pori (procese) P1 i P2. Fie r1 i r2 registrele unitii centrale folosite de cele dou procese. Atunci n cazul n care pe fiecare poart intr trei persoane, este posibil (printre multe altele) urmtoarea succesiune de aciuni (urmtorul scenariu): Aciune
P1 ncarc P1 incrementeaz P2 ncarc P2 incrementeaz P2 salveaz P2 ncarc P2 incrementeaz P2 salveaz P1 salveaz 2 1 1 1 2 total 0 0 1 0 1 r1 r2

urmat de o succesiune analoag n care se interschimb P1 cu P2. Rezultatul final va fi 2, mai mic chiar dect numrul persoanelor ce intr prin fiecare poart! S observm c dac instruciunea n:=n+1 (mai corect spus cele trei instruciuni main n care se descompune) ar forma o seciune critic, programul ar fi corect.

Modelul aleator
Fiecare procesor: 1) alege aleator un proces "liber" 2) execut un interval de timp aleator instruciuni ale sale 3) goto 1)

Excludere reciproc
Forma fiecrui proces Pi :
repeat

protocol_intrarei SCi protocol_ieirei SNCi

until false

// se folosesc resurse comune // nu se folosesc resurse comune

ER (exclucere reciproc propriu-zis) cel mult un proces este n SC a sa CC (competiie constructiv) dac mai multe procese vor s intre in SC a lor, nu se mpiedic unul pe altul CL (conexiune liber) dac un proces "ntrzie" n SNC a sa, celelate nu sunt mpiedicate s intre de oricte ori n SC a lor ============ === ===== Varianta_1
process P1; repeat while ales=2 do; SC1 ales:=2; SNC1 until false end; ales:=1; { P1; P2 } process P2; repeat while ales=1 do; SC2 ales=1; SNC2 until false end;

Obs. ER, CC, dar nu CL

=====================================================

Varianta_2
process P1; process P2;

6 1. INTRODUCERE N PROGRAMAREA CONCURENT repeat while ind2 do; ind1:=true; SC1 ind1:=false; SNC1 until false end; ind1:=false; ind2:=false; { P1; P2 } repeat while ind1 do; ind2:=true; SC2 ind2:=false; SNC2 until false end;

Obs. CL, CC, dar nu ER Varianta_3

======================================================

process P1; repeat ind1:=true; while ind2 do; SC1 ind1:=false; SNC1 until false ind1:=false; ind2:=false; { P1; P2 }

process P2; repeat ind2:=true; while ind1 do ; SC2 ind2=false; SNC2 until false

Obs. ER, CL, dar nu CC (procese prea egoiste)

======================================================

Varianta_4
process P1; repeat ind1:=true; while ind2 do begin ind1:=false; ind1:=true end; SC1 ind1:=false; SNC1 until false ind1:=false; ind2:=false; { P1; P2 } process P2; repeat ind2:=true; while ind1 do begin ind2:=false; ind2:=true end; SC2 ind2:=false; SNC2 until false

Obs. ER, CL, dar nu CC (procese prea politicoase)

Algoritmul Lamport pentru dou procese

S C Registru

Prima form (greit) Variabile globale:

n1 : numrul de ordine al primei persoane (iniial = 0); n2 : numrul de ordine celei de a doua (iniial = 0);

Procesul P1
repeat n1 n2+1; while (n2<>0) and (n2<n1) do ; SC1 n1 0 SNC1 until false

Procesul P2
repeat n2 n1+1; while (n1<>0) and (n1<=n2) do ; SC2 n2 0 SNC2 until false

Observaii: - Se poate ntmpla ca n1=n2=1, deci ca ambele procese s aib acelai numr de ordine (de exemplu dac nti se calculeaz membrii drepi ai atribuirilor); - Se poate ntmpla ca ambele procese s intre n SC a lor: P2 : calculeaz membrul drept=1; P1 : calculeaz membrul drept =1 P2 : n2 1 i intr n SC2 P1 : n1 1 intr n SC1 (datorit faptului c P1 "gndete mai greu"). A doua form (corect)
calcul1 prima persoan i calculeaz numrul de ordine (iniial false); calcul2 a doua persoan i calculeaz numrul de ordine (iniial false).

Adugm variabilele globale:

8 1. INTRODUCERE N PROGRAMAREA CONCURENT

Procesul P1
repeat calcul1 true; n1 n2+1; calcul1 false; while calcul2 do ; while (n2<>0) and (n2<n1) do ; SC1 n1 0 SNC1 until false

Procesul P2
repeat calcul2 true; n2:=n1+1; calcul2 false; while calcul1 do ; while (n1<>0) and (n1<=n2) do ; SC2 n2 0 SNC2 until false

CC : Dac ambele vor s intre n SC a lor, nseamn c n1 0 i n2 0. Atunci una dintre condiiile n2<n1 i n1 n2 este ndeplinit. CL : Cnd P1 ntrzie n SNC1, avem n1=0 i calcul1=false . Atunci cele dou instruciuni while din P2 sunt echivalente cu instruciunea vid i P2 poate trece de oricte ori prin SC2. Cealalt situaie este analoag. ER : Doar una dintre condiiile n2<n1 i n1 n2 este ndeplinit.

Algoritmul Lamport pentru np procese

Fie np numrul de procese, tabloul nr(np) al numerelor de ordine i tabloul calcul(np) al valorilor booleene; elementele celor dou tablouri sunt iniializate cu 0, respectiv false. Vom mai folosi funcia max, cu rezultat ntreg, care calculeaz 1 + maximul dintre elementele lui calcul, precum i funcia cu rezultat boolean:
function preferat(i,j):boolean; if (nr[i]=0) or (nr[i]>nr[j]) then preferat false else if nr[i]<nr[j] then preferat true else preferat i<j end;

care stabilete dac procesul i este preferat procesului j; aceasta se ntmpl n situaiile: - 0<nr[i]<nr[j] ; - 0<nr[i]=nr[j] i i<j .

Procesul Pi
repeat calcul[i] true; nr[i] max; calcul[i] false; for j:=1 to np do while calcul[j] do ; while preferat(j,i) do ; end; SCi nr[i] 0 SNCi until false