Documente Academic
Documente Profesional
Documente Cultură
i canalul lui pi ctre pi+1 este etichetat cu 1 (stnga, sensul acelor de ceasornic); canalul lui pi ctre pi-1 este etichetat 2 (dreapta, sensul invers al acelor de
ceasornic).
P0
Inele anonime: procesoarele nu au un identificator unic care s fie folosit de algoritm (oricare procesor este reprezentat de aceeai main cu stri).
n descrierea algoritmului recipienii mesajelor pot fi specificai numai n termenii etichetrii canalelor: vecinul din stnga, vecinul din dreapta.
Dac n=numrul procesoarelor din inel nu este cunoscut de procesoare atunci avem algoritmi uniformi: algoritmul este acelai pentru orice valoare a lui n. Altfel, algoritmi
neuniformi: acelai algoritm pentru fiecare procesor dar care poate fi diferit pentru diferite valori ale lui n.
Vom demonstra inexistena unui algoritm de alegere a leaderului ntr-un inel anonim, sincron i neuniform (adic n cele mai tari condiii; cu att mai mult va
rezulta pentru cazul uniform; ca att mai mult va rezulta pentru cazul asincron).
Teorema. Nu exist algoritmi neuniformi anonimi pentru alegerea liderului n inele sincrone.
Demonstraie.Fie un inel oarecare de dimensiune n>1. Presupunem c exist a algoritm anonim de alegere a liderului. Cum inelul este sincron i exist doar o singur
configuraie iniial rezult c exist o unic execuie admisibil a lui A pe R. Pentru orice rund k o execuie admisibil a lui A pe R, starea oricrui proces este aceeai
la sfritul rundei k (inductie evident).
13. Inele asincrone
Fiecare procesor are un identificator unic, ntreg nenegativ oarecare (starea procesorului pi are o component idi iniializat cu identificatorul lui pi). Un algoritm (neanonim)
este uniform dac pentru orice identificator exist o main cu stri i indiferent de dimensiunea inelului algoritmul este corect (atunci cnd procesorul asociat mainii cu stri
corespunde identificatorului su) (exist doar un program local pentru un procesor cu un identificator dat, indiferent de numrul procesoarelor).
Un algoritm (neanonim) este neuniform dac pentru
n i pentru
.
Un algoritm cu MC=O(nlog n)
Aceeai idee: mesajul procesorului cu identificatorul maxim traverseaz
inelul i se ntoarce la acest procesor, care se declar lider.
k-vecintatea procesorului pi este mulimea procesoarelor aflate la distan
mai mic sau egal cu k de pi pe inel (la stnga i la dreapta). k-vecintatea unui
procesor are 2k+1 procesoare.
Algoritmul lucreaz n dou faze. n faza l un procesor ncearc s devin lider
temporar n 2
l
-vecintatea sa. Liderii (temporari) din faza l continu faz l+1.
- n faz 0, fiecare procesor trimite un mesaj <probe> coninnd identificatorul su n 1-vecintatea sa, adic la cei 2 vecini. Dac un procesor primete un mesaj <probe>
compar identificatorul primit cu al su i numai dac cel primit este mai mare rspunde cu un mesaj <reply>. Un procesor ce primete ambele rspunsuri devine lider
temporar i trece la faza 1.
- n faza l un procesor pi, devenit lider temporar, n faza precedent trimite mesaje probe la stnga i la dreapta n 2
l
-vecintatea sa secvenial.Fiecare din cele dou mesaje
traverseaza 2
l
-vecintatea ntr-o directie; dac nu-i cumva nghiit n aceast traversare, ajunge la capt. Acest ultim procesor trimite un mesaj <reply> lui p i. Dac pi
primete reply din ambele direcii, devine lider temporar pentru faza l i trece la faza l+1.
Pentru implementare, mesajele <probe> au trei cmpuri: identificator, numr de faz, numr de hopuri. Numrul de hopuri este iniializat cu 0 i incrementat cu 1 ori de cte
ori este transmis mai departe. Un procesor este ultimul dintr-o 2
l
vecintate dac primete un mesaj cu numrul de hopuri egal cu 2
l
.
Algoritm asincron de alegere a liderului.
Iniial asleep=true
1: la primirea niciunui mesaj:
2: if asleep then
3: asleep:=false
4: send <probe, id, 0,0> la stnga i la dreapta
5: la primirea unui mesaj <probe, j,l,d> din stnga (respectiv dreapta):
6: if j=id then terminate as the leader
7: if j>id and d<2
l
then //transmite mesajul
8: send <probe, j, l, d+1> la dreapta (respectiv stnga)
9: if j>id and d =2
l
then
10: send <reply, j, l> la stnga (respectiv dreapta)
11: la primirea unui mesaj <reply, j, l> din stnga (respectiv dreapta)
12: if j
+
+
+
1 n log
1 l
1 l
l
0 faza
n log n 8 n
1 2
n
2 4 n 4
Teorema 2 Exist un algoritm asincron de alegere a liderului ntr-un inel neanonim astfel nct MC=O(nlogn).
O margine inferioar de ) n log n (
Demonstrm c algoritmul prezentat este asimptotic optimal: orice algoritm ce alege liderul ntr-un inel asincron trimite cel puin ) n log n ( mesaje. Marginea
inferioar este pentru algoritmi uniformi.
Presupunem c avem un algoritm uniform A care rezolv problema alegerii liderului (procesorul cu identificatorul maxim se declar lider i transmite identificatorul su
tuturor celorlali care vor fi nealei).
Demonstrm c exist o execuie admisibil a lui A n care se trimit ) n log n ( mesaje.
Ideea: se consider o execuie a algoritmului pe inele de dimensiune
n /2 si se combina doua astfel de executii pe un inel de dimensiune n obinut din cele dou inele mici. De fapt vom lucra cu planificri pentru c n execuii avem configuraii,
n care sunt evideniate strile tuturor celor n procesoare.
Definiie. O planificare a lui A pentru un inel este deschis dac exist o muchie e n inel astfel nct n nu este trimis nici un mesaj pe muchia e (indiferent de direcie); e
este muchia deschis a lui .
Observaie .
1. Nu este obligatoriu ca o planificare deschis s fie admisibil; ea poate fi finit i procesoarele s nu fi terminat.
2. Vom presupune c n este o putere a lui 2 pentru evitarea unor detalii tehnice.
Teorema 3 Pentru orice n i orice mulime de n identificatori exist un inel ce folosete ac identif care are o planificare deschis pentru A n care se primesc cel puin M(n)
mesaje, unde M(2)=1 i
,
_
+ 1
2
n
2
1
)
2
n
( M 2 ) n ( M , n>2.
Observaie Rezolvarea recurentei pentru M(n) conduce la M(n)=(nlog n )
Demonstraie Prin inducie dupa n.
Baza n=2
Presupunem
x identificatorul lui po si y identificatorul lui p1.
Fie o execuie admisibil a lui A pe acest inel. Cum A este corect, odat i odat p1 va scrie x n . Cel puin un mesaj este primit n .
Fie cel mai scurt prefix al planificrii cu proprietatea c p1 primete un mesaj de la p0:
va fi o planificare deschis cu muchia deschis cealalt dect cea pe care se primete mesajul.
Pasul inductiv Fie S o mulime de n identificatori. Partiionm S n S1 i S2 de dimensiunea n/2. Din ipoteza inductiv rezult c exist Ri inel ce folosete identificatorii din Si,
care are o planificare deschis i a lui A n care se primesc cel puin M(n/2) mesaje (i=1,2). Fie ei muchia deschis a lui Ri. ei=piqi. Considerm inelul R obinut astfel
1 urmat de 2 este o planificare pentru A n R. (Se consider apariia
evenimentului din 1 ncepnd cu o configuraie iniial a lui R; cum
procesoarele din R1 nu pot distinge n timpul acestor evenimente dac R1 este un inel
independent sau subinel al lui R, ele execut 1 exact ca i cum R1 ar fi fost independent. n
continuare se execut 2). Deci 12 este o planificare pentru R cu cel puin 2M
,
_
2
n
mesaje primite.
Form n continuare algoritmul s primeasc
,
_
1
2
n
2
1
mesaje suplimentare blocnd sau ep sau eq, dar nu amndou.
Considerm orice planificare finit de forma 123 n care ep i eq rmnd deschise. Dac exist una cu cel puin
,
_
1
2
n
2
1
mesaje primite 3, lema este demonstrat.
Dac nu exist o astfel de planificare exist o planificare 123 care va rezulta o execuie ce ajunge ntr-o stare mut: nu exist nici un ir de evenimente de calcul din acea
stare, care s nu mai transmit vreun mesaj. Procesoarele nu vor trimite nici un mesaj pn nu vor mai primi unul. O configuraie este mut n raport cu ep sau eq, dac nu
exist mesaje n tranzit cu excepia muchiilor deschise ep i eq i orice procesor este ntr-o stare mut.
po p1
R1
R2 R1 R2 R
e
q
P
Q
e
p
Presupunem c procesorul cu identificator maxim este n R1. Cum nici un mesaj nu-i livrat din R1 lui R2, procesoarele din R2 nu cunosc identificatorul liderului i nici un
procesor din R2 nu poate termina la sfritul lui 123. n orice execuie admisibil extinznd 123 orice procesor din R2 trebuie s primeasc un mesaj adiional nainte de
terminare (pentru a afla identificatorul liderului). Deci pe R trebuie s fie primite
,
_
2
n
mesaje adiionale.
Putem demonstra c este suficient s deblocm doar una din ep sau eq i nc s form primirea a
,
_
2
n
mesaje.
Exist un segment finit de planificare 4 n care
,
_
1
2
n
2
1
mesaje sunt primite i astfel nct 1234 este o planificare n care ep sau eq este deschis.
Fie 4
este o planificare admisibil. Toate mesajele sunt livrate pe ep sau eq i toate procesele se termin. Cel puin
2
n
mesaje sunt primite n 4
pn
A se termin. Fie 4
,
_
1
2
n
2
1
. Presupunem c P. Fie 4 subirul lui 4
care conine
numai evenimente referitoare la procesoarele lui P. Cum n 4
nu exist comunicare ntre procesoarele din P i Q rezult c 1234 este o planificare. n aceast planificare
sunt primite cel puin
,
_
1
2
n
2
1
mesaje n 4 i n plus din construcie nici un mesaj nu este trimis pe eq. Deci 1234 este planificarea deschis cerut.
14. Inele sincrone.
Demonstratia c marginea inferioar de ( ) n log n pentru alegerea liderului n inele asincrone s-a bazat pe ntrzierea mesajelor pentru perioade arbitrar de mari.
n modelul sincron ntrzierea mesajelor e fixat i deci se pot obine rezultate mai bune. Mai mult, n acest model se poate obine informatie nu numai din primirea
mesajelor dar i din neprimirea lor ntr-o anumit rund.
Un algoritm neuniform
Liderul = procesorul cu identificator minim.
Algoritmul lucreaz n faze, fiecare format din n runde (n = numrul procesoarelor din inel).
n faza i (i0) dac exist un procesor cu identificatorul i, el este ales ca lider i algoritmul se termin.
(faza i are rundele ni+1, ni+2, , ni+n; la nceputul fazei i dac un identificator al unui procesor este i i acest procesor nu s-a terminat, el trimite un mesaj de-a lungul
inelului i termin ca lider. Dac identificatorul procesorului nu este i i primete un mesaj n faza i, trimite un mesaj mai departe i se termin ca nelider).
Exact n mesaje sunt trimise (n faza n care liderul este gsit). Numrul de runde depinde de identificatorul minim din inel: dac acesta este i atunci avem n(i+1) runde.
Observaie.
Inelul poate fi si unidirecional; algoritmul presupune cunoaterea lui n, iar startul este sincron.
Un algoritm uniform.
Nu va fi necesara dimensiunea inelului. n plus vom avea o versiune puin mai general pentru un sistem sincron: nu-i necesar ca procesoarele s nceap alg simultan. Un
procesor sau se activeaz spontan ntr-o rund oarecare sau la primirea unui mesaj.
Problema: O mulime de procesoare se activeaz spontan i devin candidai. Dintre ele, cel cu identificatorul minim este ales lider.
Celelalte proc vor fi activate la primirea primului mesaj, dar ele nu vor participa la procesul de alegere: sunt pasive!
In soluia pe care o dm apar doua idei noi:
- mesajele ce pornesc de la diferite procesoare sunt transmise mai departe cu viteze diferite. Dac un mesaj provine de la un procesor cu identificatorul egal cu i el este
ntrziat 2
i
-1 runde la fiecare procesor care l primete, nainte de a fi transmis mai departe n sensul acelor de ceasornic.
-pentru depistarea startului nesincronizat se adaug o faz preliminar de deteptare. n aceast faz un procesor care se activeaz spontan trimite un mesaj de trezire pe
inel; acest mesaj este transmis fr ntrziere.
Deci un mesaj poate fi n prima faz pn ntlnete un procesor activ (n acest timp parcurge inelul cu viteza 1); dup ntlnirea primului procesor activ mesajul intr n faza
a II a n care este transmis mai departe cu viteza 2
i
(fiecare procesor activ l ntrzie cu 2
i
-1 runde).
Dup n runde de la activarea primului procesor vor rmne numai mesaje n faza a II a i liderul este ales dintre procesoarele participante.
Algoritm sincron de alegere a liderului n inele
Iniial waiting este vid i asleep este true
1: Fie R mulimea mesajelor primite n ac. ev. de calc
2: S:=0 //mesajele cer vor fi trimise
3: If asleep then
4: asleep:=false
5: if R is empty then
6: min:=id //participant la alegere
7: adaug <id> la S
8: else min:=
9: for each<m> in R do
10: if m<min then
11: devine neales
12: adaug <m> la waiting i ine minte cnd <m> a fost adugat
13: min:=m
14: if m=id then devine ales //dac m>min, m va fi nghiit
15: for each <m> in waiting do
16: if (<m> a fost primit 2
m
-1 runde mai nainte) then
17: scoate <m> din waiting i adaug-l la S
18: send S n reea.
Notm idi identificatorul procesorului pi; <idi> mesajul transmis de pi.
Lema. Numai procesorul cu cel mai mic identificator printre participanii la alegere i primete napoi mesajul.
Demonstraie: Fie pi participantul la alegere cu identificatorul minim. (Trebuie s fie mcar unul). Nici un procesor nu-l va nghii pe <idi>. Cum fiecare procesor va ntrzia
<idi> cel mult i
id
2
runde, pi va primi odat i odat mesajul napoi.
Dac ar mai exista pj cu j
i care primete napoi mesajul <idj>, acesta trebuie s treac pe la toate pe la toate inclusiv pe la pi, care nu-l va transmite. Contradicie.
Numrul de mesaje trimis ntr-o execuie admisibil a algoritmului.
Un mesaj este:
a. n prima faz.
b. n faza 2
a
trimis nainte ca mesajul viitorului lider s intre n faza a 2
a
.
c. n faza 2
a
trimis dup ce mesajul viitorului lider a intrat n faza 2
a
.
Lema 1 Numrul mesajelor din categoria a) este cel mult n.
Demonstraie Orice procesor transmite mai departe cel mult un mesaj n prima faz. Presupunem c pi transmite mai departe dou mesaje n prima faz <idj> i <idk> de la pj
respectiv pk. Presupunem c n sensul acelor de ceas avem pk-pj-pi. <idk> trece de pj nainte de a ajunge la pi. Dac <idk> ajunge n pj dup ce acesta s-a trezit i a trimis <idj>
atunci <idk> va continua ca un mesaj n faza 2
a
la viteza k
id
2
; altfel, pj nu particip la alegere i <idj> nu este trimis. Deci sau <idk> ajunge n pi n faza 2
a
sau <idj> nu este
trimis. Contradicie.
Fie r prima rund n care se trezesc un grup de procesoare i fie pi unul dintre ele. Urmtoarea lem arat c n runde dup ce primul procesor starteaz execuia algoritmului,
toate mesajele sunt n faza a II a.
Lema 2 Dac pj este la distana k (n sensul acelor de ceas) de pi, atunci pj primete un mesaj n faza I
a
cel trziu n runda r+k.
Demonstraie: Inducie dup k.
Baza: k=1 Evident: vecinul lui pi primete mesaj n runda r+1
Pas inductiv: Procesorul ce precede pi este la distana k-1 n rund r+k-1 a primit deja un mesaj n faza I
a
. Dac este deja treaz a trimis mesajul de trezire lui pi, altfel n runda
urmtoare pi va primi mesajul de la acesta.
Lema 3 Numrul mesajelor din categoria b) este cel mult n.
Demonstraie Dup runda r+n nu mai avem mesaje de categoria I
a
(conform lemei 1). Conform lemei 2 mesajul viitorului lider intr n faza 2
a
cel mult dup n runde dup
primul mesaj trimis de algoritm. Mesajele din categoria b) sunt trimise numai n cele n runde ce urmeaz rundei cnd primul s-a trezit. Mesajul <i> n faza a 2
a
e ntrziat 2
i
-1
runde nainte de a fi transmis mai departe. Deci i este trimis cel mult de
i
2
n
ori n aceast categorie. Cum mesajele cu identificatori mici sunt transmise cu viteza mai mare,
numrul maxim de mesaje se obine cnd toate procesoarele particip la alegere i cnd identificatorii sunt ct mai mici cu putin: 0,1,,n-1.
Mesajele viitorului lider (n cazul nostru 0). Deci numrul mesajelor din categoria b) este n
2
n
1 n
1 i
i
.
Fie pi procesorul cu identificator minim; nici un procesor nu va mai transmite mai departe un mesaj dup ce trimite mai departe <idi>.
Lema 4
Nici un mesaj nu este trimis mai departe dup ce <idi> se ntoarce la pi.
Lema 5
Numrul mesajelor din categoria c) este cel mult 2n.
Demonstraie Fie pi viitorul lider i pj alt procesor participant la alegeri. Conform lemei precedente nu exist mesaje n inel dup ce pi i primete mesajul napoi. Cum <idi>
este ntrziat cel mult i
id
2
runde la fiecare procesor, cel mult i
id
2 n
runde sunt necesare pentru ca <idi> s se ntoarc la pi. Deci mesajele din categoria c) sunt trimise
numai n timpul a cel mult i
id
2 n
runde. n aceste runde <idj> este retransmis de cel mult
j i
i
j
id id
id
id
2 n 2 n
2
1
ori.
Numrul total de mesaje din aceast categorie este
1 n
0 j
id id
i j
2
n
Ca n demonstraia lemei 3 acesta este n 2
2
n
1 n
0 k
k
Teorema 4
MC a algoritmului precedent este
n 4
.
TC=O(n2
i
), i = identificatorul liderului.
O margine inferior de (nlogn) pentru algoritmi neuniformi sincroni care folosesc identificatorii numai pentru comparaii.
Algoritmii cu MC=O(n) au folosit id. pentru a decide ct de mult poate fi ntrziat un mesaj. Numrul de runde depinde de mrimea identificatorului care poate fi imens in
comparaie cu n.
Vom specifica inelul R prin lista identificatorilor n ordinea parcurgerii inelului n sensul acelor de ceasornic, ncepnd cu identificatorul cel mai mic.
exec(R) va reprezenta execuia admisibil a unui algoritm pe inelul R (ntruct configuraia iniial este fixat chiar de listarea identificatorilor).
Date dou inele R1 si R2 pi procesor n R1 si pj procesor n R2; pi si pj sunt cuplate dac ocup aceeai poziie n respectiva specificare a fiecrui inel (sunt la aceeai distan
fa de procesorul cu identificator minim; distana se consider pe inel, n sensul acelor de ceas).
Intuitiv, un algoritm este bazat pe comparaii dac se comport la fel pe inele care au acelai pattern de ordine a identificatorilor.
Dou inele Xo, X1,...,Xn-1 si Y0,Y1,...,Yn-1 sunt echivalente din punct de vedere al ordinii dac oricare ar fi i, j Xi<Xj <=> Yi<Yj. Aceast noiune se poate extinde la K-
vecinti.
Fie R1 si R2 dou inele, pi din R1, pj din R2 si dou execuii 1si 2 ale algoritmului A pe R1 respectiv R2.
Comportarea lui pi n 1 este similar n runda k cu comportarea lui pj n 2 (n aceeai rund) dac:
- pi trimite un mesaj vecin din stnga (dreapta) n runda k n 1 <=> pj trimite un mesaj vecin stnga (dreapta) n runda k n 2.
- pi termin ca lider n runda k a lui 1 <=> pj termin ca lider n runda k a lui 2 .
pi are comportare n 1 similar comportarii lui pj n 2 <=> ele sunt similare n oricare rund k
0
.
Un algoritm este bazat pe comparaii dac pentru orice pereche de inele echivalente din punct de vedere al ordinii R1 i R2, orice pereche de procesoare cuplate au
comportri similare n exec(R1) i exec(R2).
Inexistena unui mesaj ntr-o anumit rund r este folositoare pentru procesorul pi numai dac ar fi putut primi un mesaj n ac rund ntr-un inel diferit dar echivalent
din punct de vedere al ordinii.
O rund r este activ n o execuie pe un inel R dac mcar un procesor trimite un mesaj n runda r a execuiei. Pentru inelul R vom nota cu r k indicele celei dea k
a
runde active.
Observaii.
1. Dac R1 i R2 sunt echivalente din punct de vedere al ordinii, o rund este activ n exec(R1) <=> e activ n exec(R2).
2. n k runde un mesaj poate traversa k procesoare pe inel; rezult c starea unui procesor dup k runde depinde numai de k-vecintatea sa. Aceast proprietate se extinde n
Lema 6
Fie R1 i R2 dou inele echivalente din punct de vedere al ordinii i pi n R1 i pj n R2 dou procesoare cu k-vecinti identice. Atunci irul de tranziii urmat de pi n rundele 1
-- rk ale lui R1 este acelai cu cel urmat de pj n rundele 1 -- rk ale lui R2.
Demonstraie Informal, trebuie artat c dup k runde active un procesor poate afla doar informaia despre procesoarele aflate la distana cel mult k de el. Formal, inducie
dup k (k=0, au acelai identificator i deci sunt n aceeai stare, pasul inductiv evident).
Proprietatea de poate extinde la procesoare cu k-vecinti echivalente din punct de vedere al ordinii, cu condiia ca inelul s fie spaiat: un inel de dimensiune n este spaiat
dac oricare ar fi x un identificator al su, identificatorii x-1, x-2, , x-n nu apar n inel.
Lema 7. Fie R spaiat i pi i pj dou procesoare cu k-vecinti echivalente din punct de vedere al ordinii. Atunci pi i pj au comportamente similare n rundele 1,, rk ale lui
exec(R).
Demonstraie Construim un inel R (R se poate construi pentru c R este spaiat) care satisface:
- R echivalent din punct de vedere al ordinii cu R
- pj din R este cuplat cu pi din R
- k-vecintatea lui pj n R este identic cu k-vecintatea lui pi din R
- identificatorii lui R sunt unici
Aplicm Lema 6 i faptul c algoritmul este bazat pe comparaii.
Teorema 5
8 n
putere a lui 2, exist un inel Sn de dimensiune n astfel nct pentru orice algoritm sincron bazat pe comparaii pentru alegerea liderului A, n orice execuie
admisibil a lui A sunt trimise (nlogn) mesaje.
Demonstraie Fie A un algoritm sincron bazat pe comparaii pentru alegerea liderului. Construim
] 1 n .. 0 [ i R
rev
n
, idi al lui pi este rev(i)=ntregul cu
reprezentare binar folosind log n bii egal cu inversa repezentrii binare a lui i.
n=8
Considerm orice partiie a lui
rev
n
R
n segmente de lg j, j putere a lui 2. Se poate arta c toate aceste segmente
sunt echivalente din punct de vedere al ordinii.
Sn este o versiune spaiat a lui
rev
n
R
: nmulim fiecare identificator cu n+1 i adunm n. Aceste schimbri nu
afecteaz echivalena din punct de vedere al ordinii segmentelor.
8
n
k < i oricare ar fi N o k-vecintate a lui Sn, exist mai mult de
) 1 k 2 ( 2
n
+
k-vecinti ale lui Sn care sunt
echivalente din punct de vedere al ordinii cu N.
Numrul rundelor active n exec(Sn) este
8
n
(altfel, se demonstreaz c pe lng lider mai este ales i alt procesor).
Cel puin
) 1 k 2 ( 2
n
+
mesaje sunt trimise n cea de-a k
a
rund activ a lui exec(Sn),
8
n
k 1 , k
MC n Sn este
+
8 n
1 k
8 n
1 k
) n log n (
8
n
ln
6
n
6
n
) 1 k 2 ( 2
n
.
P0 0002=0
P1 1002=4 P7 1112=7
P6 0112=3
P5 1012=5
P4 0012=1
P3 1102=6
P2 0102=2
10
95
93
94
92
75
91
90
60
30
20
40
40
90
75
100
15. Sisteme distribuite cu memorie partajat.
Problema excluderii mutuale.
ntr-un sistem distribuit cu memorie partajat, procesoarele comunic via o zon de memorie comun care conine o mulime de variabile partajate numite i
regitri. Vom considera numai sisteme asincrone. Cazul sincron este studiat n modelele PRAM ale calculului paralel.
Sistemul conine n procesoare p0, p1, ..., pn-1 i m regitri R0, R1, ..., Rm-1. Fiecare registru are un tip care specific: valorile ce pot fi luate de registru, operaiile ce pot
fi executate, valorile returnate de fiecare operaie i noua valoare a registrului care rezult dup fiecare operaie. Pentru fiecare registru poate fi specificat o valoare iniial.
O configuraie este un vector C = (q0, ..., qn-1, 0, ..., m-1) unde qi este o stare a lui pi, iar j este o valoare a registrului Rj.
Folosim notaia mem (C) = (0, ..., m-1).
Configuraie iniial: procesoarele sunt n stare iniial i regitrii conin valori iniiale.
Evenimente: pai de calcul ai procesoarelor specificai prin indexul procesorului.
n fiecare pas al procesorului pi se execut:
1. pi alege o variabil partajat pentru a o accesa cu ajutorul unei operaii specifice, pe baza strii sale curente;
2. se execut operaia asupra variabilei partajate
3. pi i schimb starea conform funciei de tranziie pe baza strii curente i a valorii returnate de operaia de la 2.
Segment de execuie: C0, 1, C2, 2, ..., Ck-1, k, Ck, ...
cu Ck configuratie i k eveiment. Seminificaie:
Dac k=i, atunci Ck se obine din Ck-1 prin modificarea unei singure variabile partajate Rj determinat de pi pe baza strii sale din Ck-1 i, de asemenea, Ck difer de Ck-1 prin
starea procesorului pi, care se obine cu ajutorul funciei de tranziie din starea lui pi din Ck-1 i valoarea returnat de operaii asupra lui Rj.
Executie: segment de execuie ce ncepe cu o configuraie iniial.
Executie adminisibil: fiecare procesor are un numr infinit de pai de calcul.
Planificare: ir de indici de procesoare.
P-planificare: P o mulime de procesoare P {p0, ..., pn-1}; irul de indici se refer numai la procesoarele din P.
Stri terminale ca la sistemele distribuite de tip MP. Un procesor aflat ntr-o stare terminal nu va face nici o modificare a variabilelor partajate.
Algoritmul se termin cnd toate procesoarele sunt n stare terminal
Dac C este o configuratie si = i1, i2, .... o planificare, ele determina
Exec (C, ).
C' este accesibil din C dac exist o planificare finit astfel nct C' = (C), unde (C) este configuratia final a lui Exec (C, ).
C este similar lui C' n raport cu mulimea de procesoare P, '
~C C
P
dac fiecare procesor din P are aceeai stare i n C i n C' i mem(C) = mem(C').
Msuri de complexitate
C.Timp ?
C. Spaiu Cantitatea de memorie partajat necesar pentru a rezolva problema. Se poate considera
a) Numarul de variabile partajate sau
b) Cantitatea de spaiu partajat (=nr de bii= numrul de valori distincte) necesar.
Problema excluderii mutuale
Aceast problem se refer la un grup de procesoare care, ocazional, necesit accesul la o resurs ce nu poate fi folosit de mai mult de un singur procesor.
Fiecare procesor dorete s execute un segment de cod numit seciunea critic astfel nct la orice moment de timp cel mult un procesor se afl n seciunea critic
(excludere mutual) i dac unul sau mai multe procesoare ncearc s intre n seciunea critic atunci unul din ele o va face (odat i odat) atta timp ct nici un procesor
nu rmne la nesfrit n seciunea critic (lipsa interblocajului = no deadlock).
O proprietate mai puternic dect n lipsa interblocajului este: dac un procesor dorete s intre n seciunea critic, atunci el va reui atta timp ct nu exist nici un
procesor care s rmn la nesfrit n seciunea critic (no lockout = no starvation).
Se pot impune i condiii mai puternice: nici un procesor nu va ncerca mai mult de un numr fixat de ori ca s intre n seciunea critic.
Problema este uzual n proiectarea S.O., n programarea concurent i soluia obinuit necesit primitive de sincronizare speciale (monitoare, semafoare). Vom
prezenta soluii distribuite.
Vom presupune c programul fiecrui procesor e mprit n urmtoarele seciuni:
Entry (trying): codul ce se execut pentru pregtirea intrrii n seciunea
critic.
Critical: codul ce trebuie protejat de execuii concurente.
Exit: codul ce se execut dup prsirea seciunii critice.
Remainder: restul codului.
Fiecare procesor cicleaz: (remainder, entry, critical i exit ).
Un algoritm pentru problema excluderii mutuale const din cod pentru entry i exit.
Ipoteze:
- nici un procesor nu rmne n seciunea critic la nesfrit.
- variabilele locale sau partajate accesate n seciunea entry i exit nu sunt accesate n seciunile critical i remainder.
- un pas al procesoruui din seciunea remainder e urmat de un pas n
seciunea entry.
- un pas al procesorului din seciunea critical e urmat de un pas n seciunea
exit.
O execuie este admisibil dac pentru oricare procesor pi, pi executa o infinitate de pai sau se termin n seciunea remainder.
Un algoritm pentru un sistem cu memorie partajat rezolv problema excluderii mutuale fr deadlock (sau fr lockout) dac
Excludere mutual: n orice configuraie a oricrei execuii cel mult un procesor se afl n seciunea critic.
No deadlock: n orice execuie adminisibil dac un procesor se afl n seciunea entry ntr-o configuraie exist o configuraie ulterioar n care un procesor este
n seciunea critic.
No lockout: n orice execuie admisibil dac un procesor se afl n seciunea entry ntr-o configuraie exist o configuraie ulterioar n care acel procesor este
n seciunea critic.
Obs: Seciunile exit vor fi coduri fr bucle i deci nu va exista posibilitatea ca un procesor s rmn n seciunea de ieire la nesfrit. Prin urmare nu vom impune
condiii speciale.
Excludere mutual folosind primitive puternice
Registri binari Test & Set
O variabil test & set este o variabil binar care suport dou operaii atomice: test&set i reset.
test&set (V:memory adress) ntoarce valoare binar;
temp:=V
V:=1 // citete i actualiz.variab., atomic
Return (temp)
Reset (V:memory adress)
V:=0 // este n fapt un write.
Algoritm de excludere mutual folosind registru test&set:
(codul pentru orice procesor)
Initial V este 0
<Entry>:
1: wait until test&set (V) = 0
<Critical section>
<Exit>:
2: reset (V)
<Remainder>.
n seciunea entry procesorul pi testeaz repetat V pn obine 0; ultimul test asigneaz lui V valoarea 1 cauznd obinerea lui 1 pentru orice test urmtor i interzicnd
altui procesor intrarea n seciunea critic. n seciunea exit procesorul pi reseteaz pe V la valoarea 0 i unul din procesoarele care ateapt n seciunea de intrare va
putea intra n seciunea critic.
Algoritmul asigur excluderea mutual (demonstraia este imediat prin reducere la absurd).
Algoritmul asigur inexistena deadlock-ului (cum excluderea mutual are loc, se poate demonstra prin inducie c V=0 nici un procesor nu se afl n seciunea
critic).
Concluzie:
Teorema. Algoritmul asigur excluderea mutual fr deadlock foloind un singur registru test&set.
Observaie: Nu e asigurat no lockout.
Registri R-M-W
RMW (V memory address, f: function) ntoarce o valoare;
temp: = V
V: = f (V)
return (temp)
Un registru read-modify-write V este o variabil care permite procesorului s citeasc valoarea curent a variabilei, calculeaz o nou valoare ca o funcie de
valoarea curent i scrie noua valoare n variabil. Toate acestea formeaz o instruciune atomic.
Obs: 1. tipul i dim lui V nu-s relevante i nu s-au trecut
2. Operaia test&set e un caz particular al operaiei RMW, cu f (V) = 1, V.
Alg de exclud mutual folosind un registru RMW
(codul pentru orice procesor)
Initial V = <0,0>
<Entry>:
1: position = RMW (V, <V.first, V.last+1>)
2: repeat
3: queue: = RMW (V,V)
4: until (queue.first = position.last)
<critical section>
<Exit>
5 RMW (V, <V.first+1, V.last>)
<Remainder>
Algoritmul organizeaz procesoarele ntr-o coad, permind procesorului din capul cozii s intre n seciunea critic. Fiecare procesor are dou variabile locale position i
queue. Variabila RMW are dou cmpuri, first i last coninnd "tichete " ale primului, respectiv ultimului procesor din coad. La intrarea n seciunea <entry> un procesor
"citete" valoarea lui V i mrete V.last cu o unitate ntr-o operaie atomic. Valoarea lui V.last servete ca tichetul su: ateapt pn cnd V.first este egal cu tichetul su.
Atunci procesorul intr n seciunea critic. Dup prsirea seciunii critice, procesorul iese din coad mrind V.first, permind urmtorului procesor din coad s intre n
seciunea critic.
Numai procesorul din capul cozii poate intra n seciunea critic i el rmne n capul cozii pn ce prsete seciunea critic. Algoritmul asigur, deci, excluderea
mutual. n plus, disciplina cozii i ipoteza c procesoarele nu stau la nesfrit n seciunea critic, asigur proprietatea no lockout, care implic no deadlock.
Nu pot exista mai mult de n procesoare n coad n acest timp. Deci toate calculele se pot face mod n i valoarea maxim a ambelor cmpuri V.first i V.last este n-
1. Deci V necesit 2[log n] bii.
Teorema 2. Algoritmul asigur excluderea mutual fr lockout folosind un registru RMW cu 2[log2 n] bii.
O margine inferioar asupra numrului de stri de memorie.
n soluia precedent numrul stri de memorie este O (n). Vom arta c dac algoritmul nu permite ca un procesor s tot fie ales ca s intre n seciunea critic de
un numr nemrginit de ori n defavoarea altuia atunci sunt necesare cel puin n stri de memorie.
Definiie. Un algoritm de excludere mutual asigur k-mrginirea dac n orice executie nu exist un procesor care s accead seciunea critic mai mult de k ori n timp ce
altul ateapt n seciunea entry.
(proprietatea de k-mrginire + proprietatea de neexisten a deadlock-ului asigura inexistena lockout-ului).
Teorema3: Dac un algoritm rezolv excluderea mutual fr deadlock i cu k-mrg (pentru un anumit k), atunci algoritmul folosete cel puin n stri de memorie
distincte .
Demonstraie. Vom numi o configuratie linitit, dac toate procesoarele sunt n seciunea remainder.
Fie C configuraia iniiala (deci, ea este linitit). Fie 0' o p0 - planificare infinit. Cum exec (C, 0') este admisibil i nu exist deadlock exist 0 un prefix finit
al lui 0' astfel nct p0 este n seciunea critic n C0 = 0(C). Inductiv, construim pentru i 1 i n-1 o planificare i astfel nct pi este n seciunea entry n Ci = i (Ci-1). Deci p0
e n seciunea critic i p1, ..., pn-1 sunt n seciunea entry n Cn-1=01...n-1(C).
Presupunem prin reducere la absurd c exista mai putin de n stri de memorie partajata distincte. Rezulta ca Ci, Cj 0< i< j n cu stri de memorie partajata
identice: mem (Ci) = mem (Cj). Din constructie, p0, ..., pi nu executa nici un pas n i+1,...j i deci Ci si Cj sunt {p0, ..., pi}-similare. Deci n Ci i Cj p0 e n seciunea critic i
p1, ..., pi sunt n seciunea entry. Aplicm o {p0, ..., pi}- planificare infinit ' lui Ci. Exec (Ci , ') este admisibil, deci din faptul c algoritmul este fr deadlock, rezult c
l, 0 l i a.. pl intr n seciunea critic de o infinitate de ori. Fie un prefix finit al lui ' n care pl intr de k+1 ori n seciunea critic. Cum Ci si Cj sunt {p0, ..., pi}-similare
i este un {p0, ..., pi} - segment rezult c pl intr n seciunea critic de k+1 ori n exec(Cj, ). Cum pj este n seciunea entry n Cj i pl intr n seciunea critic de k+1 ori, se
violeaz condiia de k-mrginire.
Excludere mutual folosind regitri read/write
Algoritmul brutriei.
Structuri de date partajate:
- Number: tablou de n ntregi; componenta i pstreaza numrul
(de ordine) al lui pi
- Choosing: tablou boolean de dimensiune n; componenta i este true n timpul n care pi este n procesul de obinere a numrului su (de ordine).
Fiecare procesor pi care dorete s intre n seciunea critic, ncearc s-i aleag cel mai mic numr mai mare dect numerele celorlalte procesoare i-l scrie n
Number [i]. Este posibil ca mai multe procesoare s-i aleag acelai numr, datorit citirii concurente a variabilei Number. Pentru a avea o ordine total se foloseste ca tichet
perechea (Number [i], i) i se consider ordinea lexicografic.
Dup alegerea unui numar, procesorul pi ateapt pn ce tichetul su devine cel mai mic. Compararea se face dup ce procesoarele i aleg numerele.
Algoritmul brutriei
Iniial Number [i] = 0 i Choosing [i] = false i
<Entry>:
1: Choosing [i]: = true
2: Number [i]: = max (Number [0], ..., Number [n-1]) +1
3: Choosing [i]: = false
4: for j:=1 to n (ji) do
5: wait until Choosing [j]: = false
6: wait until Number [j] = 0 or (Number[j], j) > (Number[i], i)
<Critical Section>
<Exit>:
7: Number [i]: = 0
<Remainder>
Fie o executie fixat a algoritmului.
Lema 1: n orice config C a lui , dac procesorul pi este n seciunea critic i pentru k i Number [k] 0, atunci (Number [k], k) > (Number [i], i).
Lema 2: Dac pi e n seciunea critic atunci Number [i] > 0.
Din lema 1 i lema 2 rezula:
Teorema 4: Algoritmul brutriei asigur excluderea mutual.
Teorema 5: Algoritmul brutriei este fr lockout.
Demonstraie: Un procesor nu poate fi blocat n timp ce i alege numrul su. Fie pi procesorul cu cel mai mic ticket (Number [i], i) care este inut la nesfrit n afara
seciunii critice.
Toate procesoarele ce i aleg numrul dup ce pi i l-a ales, nu vor mai putea s intre n seciunea critic naintea lui pi. Din algoritmul lui pi, toate procesoarele cu
tickete mai mici vor intra n seciunea critic odat i odat. n acest moment pi vor trece toate testele de intrare n seciunea critic.
Obs: Pentru sistemele reale implementarea algoritmului trebuie s rezolve problema c numerele pot crete orict de mult.
Excluderea mutual cu variabile R/W mrginite.
A. Cazul a dou procesoare
Un algoritm de excludere mutual cu variabile mrginite pentru dou procesoare (care permite lockout)
Initial Want [i] = 0 , i = 0, 1
codul pentru p0 codul pentru p1
<Entry>: <Entry>:
1: Want [1]: = 0
2: wait until (Want [0] = 0)
3: Want [0]: = 1 3: Want [1]: = 1
4: if (Want [0]: = 1) then goto 1;
5: wait until (Want [1]: = 0)
<Critical section> <Critical section>
<Exit>: <Exit>:
6: Want [0]: = 0 6: Want [1]: = 0
<Remainder> <Remainder>
Clar, n orice configuraie a unei execuii, dac pi este dup linia 3 i naintea liniei 6 (inclusiv n seciunea critic) atunci Want [i]: = 1.
pi ridic steagul (Want [i]: = 1) i inspecteaz steagul celuilalt (citete Want [1-i]).
Cnd un procesor vede c steagul celuilalt e ridicat, atunci nu intr n seciunea critic.
Soluia e asimetric: p1 e totdeauna politicos; cedeaz intrarea lui p0; este posibil apariia lockoutului pentru p1.
Modificam algoritmul a.. fiecare procesor s dea prioritate celuilalt dup prsirea seciunii critice (e rndul tu acum).
Algoritmul de excludere mutual cu variabile mrginite pentru dou procesoare fr lockout
Iniial Want [i]: = 0 (i = 0,1) i Priority = 0
codul pentru pi (i = 0,1 )
<Entry>:
1: Want [i]: = 0
2: wait until (Want [1-i]: = 0 or Priority = i)
3: Want [i]: = 1
4: if Priority = 1-i then
5: if Want [1-i]: = 1 then goto 1:
6: else wait until Want (1-i) = 0
<Critical Section>
<Exit>:
7: Priority: = 1-i
8: Want (i) = 0
<Remainder>
Obs: Procesorul priority joac rolul lui p0 din algoritmul precedent.
Teorema 5. Algoritmul asigur excluderea mutual fr lockout.
Dem: Se arat succesiv asigurarea excluderii mutuale, inexistena deadlockului i apoi a lockoutului.
Un algoritm de excludere mutual cu variabile R/W mrginite pentru n procesoare.
Procesoarele : p0, p1, ..., pn.
Fie
1
1 log n k Consideram arborele binar complet cu 2
k
frunze (i 2
k+1
-1 noduri). Numerotare: rdcina 1; copilul stng al lui v este 2v i copilul drept 2v+1.
Frunzele arborelui 2
k
, 2
k
+1, ..., 2
k+1
-1 :
Nodului v ii asociem (
[ ] 0
v
ant
W
,
[ ] 1
v
ant
W
, Priority
v
) cu valorile iniiale 0.
Pentru a ncepe competiia pentru seciunea critic procesorul pi execut
]
( ) 2 mod , 2 / 2 i i Node
k
+
(starteaz recursia).
Algoritmul de excludere mutual pentru n procesoare
Procedure Node(v:integer; side:0..1)
1: Want
v
[side]:=0;
2: wait until (Want
v
[1-side]=0 or Priority
v
=side)
3: Want
v
[side]:=1;
4: if (Prority
v
=1-side) then
5: if (Want
v
[1-side]=1) then goto 1:
6: else wait until (Want
v
[1-side]=0)
7: if (v=1) then
8: <Critical Section>
9: else Node(
]
2 / v , v mod 2)
10: Priority
v
:=1-side
11: Want
v
[side]:=0
end procedure
Fiecrui nod i se asociaz o "seciune critic": (liniile 7 - 9) care include codul pentru entry (liniile 1 - 6) executat la toate nodurile de pe drumul de la printele nodului la
rdcin, seciunea critic real i codul exit (liniile 10 - 11) executat la toate nodurile de pe drumul de la rdcin la printele nodului.
Excludere mutual rapid
Algoritmul brutriei i algoritmul precedent au defectul c numarul de pai pe care un procesor l execut cnd ncearc s intre n seciunea critic depinde de n
chiar n absena competiiei pentru accesarea seciunii critice.
n sistemele reale este de ateptat ca n cazul competiiei pentru seciunea critic (accesul la un dispozitiv partajat de i/0, de ex) numarul competitorilor s fie relativ
mic n comparaie cu n.
Un algoritm de excludere mutual este rapid dac orice procesor intr n seciunea critic ntr-un numr constant de pai n cazul cnd el este singurul care ncearc
s intre n seciunea critic.
Algoritm de excludere mutual rapid
Initial Fast-lock i Slow-lock sunt 0 i Want [i] este false i {0, 1, ..., n-1}
(codul pentru proc. pi)
<Entry>:
1: Want [i]: = true
2: Fast-lock : = i
3: if Slow-lock 0 then
4: Want [i]: = false
5: wait until Slow-lock = 0
6: goto 1
1
2 3
4 5 6 7
p
0
p
1
p
2
p
3
p
4
p
5
p
6
p
7
7: Slow-lock: = i
8: if Fast-lock i then // altfel, intr pe calea rapida
9: Want [i]: = false
10: for j, wait until Want [j]: = false
11: if Slow-lock i then // altfel, intr pe calea lent
12: wait until Slow-lock = 0
13: goto 1
<Critical Section>
<Exit>:
14: Slow-lock : = 0
15: Want [i]: = false
<Remainder>.
Un algoritm rapid necesit folosirea variabilelor partajate cu scriere multipl; dac fiecare variabil ar fi scris numai de un singur procesor, atunci un procesor care
ar dori s intre n seciunea critic trebuie s verifice cel puin n variabile pentru posibila competiie.
Algoritmul combin dou mecanisme: unul pentru a obine intrare rapid n seciunea critic cnd numai un singur procesor dorete s accead seciunea critic i
altul pentru a asigura inexistena deadlockului cnd exist competiie.
Un procesor poate intra n seciunea critic sau gsind Fast-lock = i (linia 8) sau gsind Slow-lock = i (linia 11).
Dac nici un procesor nu este n seciunea critic sau n seciunea entry, slow-lock = 0 i Want este false pentru toate componentele. Atunci cnd doar un singur
procesor pi trece n seciunea entry, pune Want [i] pe true i Fast-lock pe i. Apoi verif Slow-lck care este 0. Apoi verif Fast-lock i cum nici un procesor nu-i n seciunea
critic, l gsete i i deci pi intr n seciunea critic pe calea rapid executnd 3 write i 2 read.
Nici un alt procesor nu poate intra n seciunea critic pe calea rapid pn pi nu iese din seciunea critic i reseteaz Slow-lock (linia 14).
Dac Fast-lock i atunci pi ateapt pn ce toate steagurile Want sunt coborte. Dup ce un procesor execut bucla for din linia 10, valoarea lui Slow-lock rmne
neschimbat pn ce un anumit procesor prsete seciunea critic i-l reseteaz. Deci cel mult un singur procesor pj poate gsi Slow-lock = j i acest procesor intr n
seciunea critic pe drumul lent.
Se poate verifica uor c dac un procesor pi intr n seciunea critic pe calea rapid, nici un alt proceosr py nu poate intra n seciunea critic pe o cale lent.
Observatii 1. Algoritmul nu garanteaz lipsa lockout-ului.
2. Se poate arta c orice algoritm pentru excluderea mutual care asigur lipsa deadlockului folosind variabilele R/W trebuie s foloseasc cel puin n variable partajate
indiferent de mrimea lor. Evident, se permite ca variabilele partajate s fie cu multi-write (altfel, marginea inferioar anunat e evident).