2.

Sincronizarea n sisteme distribuite

Am artat mai sus c una dintre cele mai mari probleme ale algoritmilor distribuii e aceea c pe
fiecare nod al sistemului, ceasul fizic local poate fi desincronizat de celelalte ceasuri fizice. De aceea, n
multe aplicaii de timp real n care ordinea n care se proceseaz evenimentele conteaz, este necesar
sincronizarea nodurilor.
2.1. Sincronizarea ceasurilor fizice. Algoritmul Cristian
Vom discuta mai nti despre ceasurile fizice aflate pe fiecare main de calcul. Problema
msurrii timpului este mai complicat dect pare, mai ales n cazurile n care este necesar o mare
precizie. n trecut, timpul se msura raportndu-se la micarea solar. Intervalul de timp dintre
momentele cnd soarele este la punctul su maxim pe cer se numete zi. O zi conine 24 de ore, fiecare
or conine 3600 de secunde, deci 1 secund solar este reprezint a 1/86400 a parte dintr-o zi solar. n
1940 s-a constatat c perioada de rotaie a Pamantului n jurul Soarelui nu este constant. Oamenii de
tiin susineau c, n urm cu 300 milioane de ani n urm, un an solar dura cu aproximaie 400 zile.
Pentru a compensa durata variabil a unei zile solare, s-a introdus conceptul de secund medie solar.
Astfel astronomii au luat duratele mai multor zile solare de-a lungul timpului, au fcut media lor, i
apoi 1/86400 din rezultatul obinut a fost aa numita secund medie solar.
n 1948 a aprul ceasul atomic. Inventarea ceasului atomic a permis msurarea timpului cu o
precizie mult mai mare. S-a definit, de ctre fizicieni de data aceasta, c durata unei secunde este
intervalul de timp n care atomul de cesiu 133 face exact 9 192 631 770 de tranziii. S-a ales aceast
valoare pentru ca rezultatul s coincid cu valoarea secundei medii solare calculat de astronimi la acea
dat. La ora actual n lume exist aproximativ 50 de laboratoare care dein ceasuri cu atomi de
cesiu133. Periodic toate cele 50 de laboratoare raporteaz cte secunde a numrat ceasul de cesiu de la
punerea sa n funciune. Prin medierea celor 50 de rezultate, se poate obine cu cea mai mare precizie,
cte secunde au trecut de la 1 Ianuarie 1958, data la care a intrat n funciune primul ceas atomic.
Metoda ceasurilor cu atomi de cesiu are ns o problem. Dup cum am spus n rndurile de mai
sus, o zi solar are o durat de timp variabil.Dac s-ar folosi ceasurile cu cesiu pentru raportarea
timpului, cum ele msoar secundele cu precizie mare, i cum durata unei zile solare este n scdere,
atunci de exemplu ora 12:00 ar fi din ce n ce mai aproape de zorii zilei dac ne raportm la momentul
cnd rsare soarele. De aceea, la timpul msurat cu ceasul atomic, s-au mai adugat nite corecii. Au
fost introduse nite aa numite secunde scurte. O secund scurt este mai scurt dect o secund
raportat de ceasul atomic. Rostul secundelor scurte este acela de a face, n mod controlat ca ceasul
atomic s raporteze un timp sincronizat cu poziia soarelui. Acest mod de a msura timpul se numete
timp UTC (Universal Coordinated Time).
Pentru a raporta timpul UTC echipamentelor care necesit precizie ridicat n msurarea
timpului se folosesc unde scurte radio. n Fort Collins Colorado, dar i n alte pri ale lumii exist staii
radio care la fiecare secund UTC, trimit un semnal radio ctre toate receptoarele. Totui din cauza
mediului de transmisiune, acest semnal poate ajunge la receptoare cu o variaie de pn la 10 ms. De
asemenea, o alternativ la staiile radio pot fi si sateliii geo-staionari.
n concluzie putem spune c sincronizarea unui echipament la timpul UTC este destul de
dificil. Este nevoie de un receptor radio care s recepioneze semnalul de la o staie cum e cea din Fort
Collins sau cum sunt sateliii geo-staionari. De asemenea, chiar dac echipamentul respectiv va avea
un receptor de acest fel, el va putea menine ceasul UTC cu o precizie de 10 ms.
Dup cum am vzut mai sus, exist foarte puine ceasuri atomice n lume, i acestea sunt foarte
scumpe. Pentru a face accesibil ceasul UTC la toat lumea, s-au folosit staii care emit periodic ora
exact. Chiar i aa, costul unui receptor WWV pentru ceasul UTC este destul de ridicat. De aceea, se
prefer ca ntr-un sistem distribuit o singur main s dein receptorul WWV, iar celelalte s i

sincronizeze ceasurile fizice dup aceast main. n continuare, vom discuta nite exemple de
algoritmi folosii pentru sincronizarea ceasurilor fizice.
Dup cum am spus mai sus, pentru meninerea ceasurilor fizice, se folosesc cristale de quartz.
Cnd sunt puse sub tensiune, cristalele oscileaz pe o anumit frecven care depinde de proprietile
fizice ale cristalului de quartz i de valoarea tensiunii la care este supus. Pe lnga cristalul de quartz, se
mai folosesc i doi regitrii, un numrtor i un registru n care se stocheaz valoarea iniial a
numratorului. La fiecare oscilaie a cristalului, numrtorul se decrementeaz. Cnd numrtorul
ajunge la valoarea 0, se genereaz o ntrerupere i numrtorul se va ncrca cu valoarea reinut de
registrul cu valoarea iniial, i procesul se reia. Astfel, prin alegerea cristalului i prin reglarea
tensiunii la care este supus, se poate face astfel nct sistemul s genereze ntreruperi cu o rat de 60 de
ori pe secund, sau orice alt frecven dorit. Fiecare ntrerupere generat poate fi considerat un tact
de ceas fizic. Cnd s-au realizat 60 de ntreruperi, se incrementeaz cu 1 registrul care ine ceasul afiat
utilizatorului. S notm cu C aceast valoare i cu t timpul real. n cazul ideal, ceasul afiat de
echipament este identic cu ceasul UTC, deci dC / dt = 1. n realitate, din cauza imperfeciunilor
cristalelor de quartz, din cauza variaei frecvenei de oscilaie a cristalelor de quartz cu temperatura, nu
toate mainile de calcul vor avea exact 60 de ntreruperi pe secund. De aceea, vor fi maini cu ceasuri
mai rapide dect ceasul ideal, sau cu ceasuri fizice mai lente dect ceasul ideal. Aceste cazuri sunt
afiate n figura de mai jos.

Fig 2.1 Ceas fizic ideal n comparaie cu ceasuri reale

Din figura de mai sus se observ faptul c, periodic, mainile de calcul trebuie s i actualizeze
ceasul fa de ceasul ideal de referin. Algoritmul Cristian se folosete de acest principiu. S
considerm un sistem distribuit n care o singur main de calcul va avea un receptor WWV. Acea
main va avea rolul de server de timp. Din cauz c celelalte maini au fenomenul de drift al ceasului,
ele vor avea o deviaie fa de ceasul ideal, conform formulei
dC
1
1
dt
(2.1)
2

unde este rata maxim de drift i este o constant pe care o afieaz productorul de cristale de quartz.
n cazul cel mai defavorabil, putem avea un nod de sistem distribuit care va avea un ceas mai rapid cu
i altul care s aib un ceas mai ncet cu Aceasta nseamn c ntr-o perioad de timp t, va aprea
o diferen de 2t ntre cele dou ceasuri fizice. De obicei un proiectant de sisteme distribuite trebuie
s garanteze c diferena dintre dou ceasuri fizice s nu depeasc o anumit valoare. Dac notm
aceast valoare cu rezult c ceasurile fizice ale nodurilor din sistemul distribuit trebuie
resincronizate la fiecare //2secunde.
Avnd n vedere cele spuse n paragraful de mai sus, n algoritmul lui Cristian maina care are
receptorul WWV va fi server de timp. Celelalte maini care au un drift de maxim , la fiecare //2
secunde vor iniia cte o cerere ctre serverul de timp. Serverul de timp, imediat ce primete cererea, se
activeaz o ntrerupere i raspunde cu un mesaj coninnd timpul de referin CUTC.

Maina client
t0

Maina server
Cerere
t1
timp rspuns
t2

t3

Rspuns

Fig 2.2 Algoritmul Cristian pentru sincronizarea ceasurilor fizice

Algoritmul descris mai sus are dou probleme. Prima ar fi c pot exista cazuri n care CUTC este
mai mic dect ceasul local de pe maina client care face cererea. n astfel de cazuri, timpul nu are voie
s fie dat napoi. De aceea, se prefer ca s se ncetineasc n mod voit ceasul fizic pe maina client.
Acest lucru se poate face n modul urmtor. S zicem c pe maina client, cnd cristalul de quartz
genereaz o ntrerupere, se incrementeaz ceasul fizic cu valoarea X msec. Ca s se ncetineasc ceasul
n mod voit, la fiecare ntrerupere se va incrementa ceasul cu Y<X msec. ntr-o manier asemntoare
se poate accelera viteza ceasului daca se constat c pe maina client ceasul fizic local este mai ncet
dect pe maina server.
A doua problem este ceuzat de ntrzierile pe reea. Proiectantul sistemului distribuit nu are
cum s estimeze dinainte ntrzierile pe canalul de comunicaie dintre mainile client i maina server.
O soluie este ca maina client s msoare intervalul de timp ntre momentul n care trimite cererea i
3

momentul n care primete rspunsul de la server, (T1 T0 ). Clientul ar trebui s mai adauge la CUTC
ntrzierea de la server la client. n algoritmul lui Cristian se pornete de la premiza c ntrzierea va fi
jumtate din intervalul de timp msurat, deci (T1 T0 )/2. Exist reele n care mesajele de cerere o iau
pe alt cale dect mesajele de rspuns. n aceste sisteme, metoda Cristian de sincronizare a ceasurilor
fizice nu este recomandat. Pentru a mai mbunti estimarea ntrzierii de la server la client,
algoritmul Cristian mai sugereaz s se fac mai multe msurtori (T1 T0 ) i s se fac media lor.
ntr-un sistem centralizat, problema sincronizrii nodurilor este mult mai simpl. Dac procesul A are
nevoie s afle timpul, face o cerere la sistemul de operare central i obine o valoare. Dac la un
moment ulterior procesul B dorete s afle timpul, procesul B va obine o valoare cel puin egal cu
valoarea primit de A.
2.2 Algoritmul Berkley de sincronizare a ceasurilor fizice
Un al doilea exemplu de algoritm de sincronizare a ceasurilor fizice este reprezentat n figurile de mai
jos.

Fig 2.3 Prima etap n algoritmul Berkley

Fig 2.4 A doua etap n algoritmul Berkley

Fig 2.5 A treia etap n algoritmul Berkley

Algortmul Berkley de sincronizare a ceasurilor fizice este reprezentat n cele trei figuri de mai sus.
Acest algoritm se potrivete mai mult pentru sistemele distribuite n care nu exist nicio main cu
receptor WWV, ci se dorete doar sincronizarea tuturor ceasurilor ntre ele, fr a se dori neaprat ca
ceasurile s se potriveasc cu UTC.
Spre deosebire de algoritmul Cristian, n care serverele stteau pasive i doar rspundeau la cereri, n
algoritmul Berkley lucrurile stau pe dos. Proiectantul sistemului distribuit este liber s aleag ce server
va folosi. n prima etap, descris n primul desen din cele trei de mai sus, serverul trimite un mesaj
ctre toate mainile n care pune valoarea ceasului fizic local, de pe propria main. n a doua etap,
reprezentat n a doua figur, fiecare main client rspunde la mesajul serverului cu cte un mesaj n
care spune cu ct difer ceasul local fa de ceasul serverului. De exemplu, maina Cl 1, are ceasul local
3:25 i de aceea rspunde cu un mesaj n care pune un decalaj de +25 ntre propriul ceas i ceasul
serverului. Maina Cl2 are ceasul 2:50 i trimite un mesaj n care scrie un decalaj de -10 ntre ceasul
propriu i ceasul serverului.
Dup ce primete toate mesajele de la toate mainile client, maina server calculeaz media tuturor
ceasurilor din sistem i i seteaz ceasul local la valoarea medie. Apoi procesul se reia cu etapa nti.

2.3 Ceasuri Logice

S considerm un sistem distribuit cu mai multe procese care lucreaz n paralel. Pe fiecare
proces are loc o secven de evenimente. n funcie de sistemul distribuit considerat, un eveniment
poate fi execuia unui subprogram, sau chiar execuia unei instruciuni. De asemenea, i faptul c un
proces trimite sau recepioneaz un mesaj se consider tot un eveniment. La prima vedere, se poate
spune ca evenimentul a s-a petrecut naintea evenimentului b dac timpul fizic asociat evenimentului a
este mai mic dect timpul fizic asociat evenimentului b. Dac se folosee aceast metod de a ordona
evenimentele, atunci trebuie ca n sistemul distribuit s se foloseasc ceasuri fizice pe toate nodurile.
Am vzut n paragrafele de mai sus c n sistemele distribuite, ceasurile fizice ale nodurilor, cu trecerea
timpului, se desincronizeaz. De asemenea, am vzut c metodele de sincronizare a ceasurilor fizice au
unele limitri i unele dezavantaje.
Pentru a evita problemele sincronizrii ceasurilor fizice, putem s folosim un alt mod de a
ordona evenimentele ntr-un sistem distribuit. n 1978 Leslie Lamport, n lucrarea sa [ 1 ] a introdus o
alt metod pentru a ordona evenimentele ntr-un sistem distribuit. El susine c nu e neaprat necesar
ca ntr-un sistem distribuit s se foloseasc ceasuri fizice, ci e suficient ca toate nodurile s cad de
acord asupra ordinii n care un eveniment s-a petrecut. Pentru aceasta, Lamport a introdus relaia de
cauzalitate (happened before), notat cu . Relaia ntr-un sistem distribuit trebuie s
satisfac urmtoarele trei condiii:
Dac a i b sunt evenimente n acelai proces al sistemului distribuit i a are loc naintea lui b,
atunci ab.
Dac a reprezint evenimentul de transmitere a unui mesaj pe un anumit nod, iar b este
evenimentul de recepie a aceluiai mesaj pe nodul destinaie, atunci ab.
Dac ab i bc, atunci ac.
Dou evenimente a i b sunt concurente dac ab i ba.
Este mai uor de neles relaia de , dac folosim o diagram spaiu-timp pentru a reprezenta
sistemul distribuit.

Fig 2.6 Diagram pentru reprezentarea unui sistem distribuit

Liniile orizontale reprezint nodurile sau procesele din sistemul distribuit. Timpul fizic crete de
la stnga spre dreapta. Cu bulinue sunt reprezentate evenimentele care se petrec n sistemul distribuit.
Cu sgeat sunt reprezentate mesajele de la un nod la altul. Se observ c pentru un mesaj, avem
eveniment i la transmiterea mesajului de ctre nodul surs, ct i la recepia mesajului la nodul
destinaie.
6

Avnd n vedere definiia relaiei de happened before dat de Lamport i folosind i diagrama
din figura de mai sus, putem spune c evenimentul a s-a petrecut naintea evenimentului b dac pe
diagrama reprezentat mai sus gsim un drum de la evenimentul a la evenimentul b mergnd doar pe
sgeile mesajelor si mergnd doar nainte. De exemplu, primul eveniment al nodului P1, s-a petrecut
naintea evenimentului al doilea al procesului P2, pentru c gsim pe diagram un drum de la primul
eveniment la al doilea. n schimb, primul eveniment al procesului P3 i al doilea eveniment al
procesului P2 , nu putem spune care s-a ntmplat mai devreme i care mai trziu.
Acum se poate defini noiunea de ceas logic. Ceasul logic este o funcie C:H->T, unde H este
mulimea tuturor evenimentelor din sistemul distribuit, iar T este mulimea tuturor valorilor numerice
pe care le poate lua un ceas logic. Funcia C asigneaz fiecrui eveniment din H un numr din mulimea
T. Vom nota funcia cu Ci(a), unde i este identificatorul procesului pe care are loc evenimentul, a este
evenimentul. Un astfel de ceas se poate implementa printr-un registru pe fiecare nod al sistemului
distribuit. Acest regstru, spre deosebire de ceasurile fizice, nu se va incrementa la fiecare oscilaie a
cristalului de quartz, ci se va incrementa dup alte reguli. Pentru a putea folosi aceast tip de ceas logic
la determinarea cauzalitii, trebuie respectat urmatoarea regul
Dac ab , atunci C(a)<C(b)
(2.2)
Avnd n vedere definiia relaiei de ab, putem enuna urmtoarele dou condiii pe care funcia C
trebuie s le respecte:
1. Dac a i b sunt dou evenimente pe acelai proces, atunci Ci(a)<Ci(b)
2. Dac a este evenimentul de trimitere a unui mesaj, i b este evenimentul de recepie, atunci
Ci(a)<Cj(b), unde Pi este procesul surs pentru mesaj, iar procesul Pj este procesul destinaie
pentru mesaj.
Pentru implementarea funciei C ntr-un sistem distribuit trebuie s se respecte urmtoarele dou

reguli de implentare:
1. Pe fiecare proces Pi, trebuie ca Ci s fie incrementat ntre oricare dou evenimente, fie
ele interne sau transmisia/recepia unui mesaj.
2. Dac procesul Pi trimite un mesaj m ctre procesul Pj, atunci mesajul m trebuie s conin
o tampil de timp Tm = Ci(a). La recepia mesajului m, procesul Pj trebuie s i actualizeze
ceasul astfel nct Cj(b) mai mare dect valoarea prezent i Cj(b) > Tm .
2.4. Metoda de sincronizare a ceasurilor logice scalare

Aceast metod a fost propus de ctre Leslie Lamport n 1978 n ncercarea sa de a ordona
evenimentele n sistemele distribuite. Domeniul de definiie T a valorilor ceasurilor interne este
mulimea numerelor ntregi ne-negative. Ceasul logic al procesului pi i viziunea local a acestui
proces asupra timpului global sunt puse n aceeai valoare, i anume Ci.
Regulile R1 i R2 de sincronizare a ceasurilor logice sunt:

R1: nainte de a executa un eveniment, (eveniment intern, de trimitere sau recepie de

mesaj), procesul pi execut urmtoarea corecie de ceas:
Ci=Ci+d, d>0
(2.3)

R2: Fiecare mesaj conine, pe lng informaiile utile, i o tampil de timp (timestamp)
Cmsg. Procesul de la recepie execut urmtoarea corecie.
o C i max(C i , C msg )
o Execut R1
7

o Trimite mesajul mai departe

Fig 2.7 Exemplu de sincronizare folosind ceasuri scalare

Se observ c proprietatea de consisten slab este respectat:

evenimentele a i b, a b C (a ) C (b) .
Ceasurile logice scalare pot fi folosite pentru a ordona evenimentele n sistemele distribuite.
Principala problem const n faptul c dou sau mai multe evenimente de pe procese diferite pot avea
tampile de timp identice. De exemplu, n figura de mai sus al treilea eveniment al procesului P1 i al
doilea proces al evenimentului P2 au ceasuri scalare identice. De aceea, este nevoie de o regul care s
defineasc care eveniment s-a petrecut mai devreme. Putem defini tampila de timp a unui eveniment
ca un cuplu (t,i) n care t reprezint valoarea ceasului logic, iar i reprezint identitatea procesului unde
s-a petrecut evenimentul. Relaia de ordonare total pentru dou evenimente x i y, avnd tampilele de
timp (h,i), respectiv (k,j) este definit n modul urmtor:
x y h k sau h=k i i<j
(2.4)
Cum dou evenimente care au acelai ceas logic sunt independente ntre ele, nseamn c ele pot fi
ordonate n orice mod.
Sistemul cu ceasuri scalare nu are totui o consisten puternic. Asta nseamn c, pentru dou
evenimente ei i ej
dac C(ei)<C(ej), nu neaprat c e i e j
(2.5)
De exemplu, n figura de mai sus, al treilea eveniment al procesului P1 are un timp logic asociat mai
mic dect cel al evenimentului al treilea al procesului P2. Totui, primul nu s-a petrecut naintea celui
de-al doilea.
2.5 Metoda de sincronizare cu ceasuri logice vectoriale
n sistemul cu ceasuri logice vectoriale domeniul valorilor T pe care le poate lua ceasul C e
reprezentat de mulimea vectorilor de dimensiune n cu elemente ntregi, ne-negative. Fiecare proces Pi
menine un vector vti[1n] , unde vti[i] reprezint valoarea local a ceasului logic pentru procesul Pi .
Vti[j] reprezint ceea ce estimeaz procesul Pi c ar fi ceasul logic local al procesului Pj. ntregul
vector de dimensiune n reprezint viziunea global a procesului Pi i estimarea sa asupra ceasurilor
8

logice locale proprii fiecrui proces din sistemul distribuit. Acest vector va fi ataat i la mesajele de la
un proces la altul ca i tampil de timp.
Procesul Pi folosete urmtoarele dou reguli pentru a-i corecta ceasul:
R1 nainte de execuia unui eveniment intern,
vt i [i ] vt i [i ] d
(2.6)
R2 Fiecare mesaj are ataat un timestamp cu ceasul logic vectorial al procesului care
trimite. La recpia acestul mesaj, procesul pi execut urmtoarea suit de aciuni
o i actualizeaz ceasul logic vectorial
1 k n, vti[k] =max (vti[k], vt[k])
o Execut regula R1
o Trimite mesajul mai departe
n figura de mai jos este reprezentat metoda vectorial:

(2.7)

Fig 2.8 Exemplu de sincronizare folosind ceasuri vectoriale

Pentru a compara dou ceasuri vectoriale se folosesc relaiile

vh vk x : vh[ x] vk[ x]
(2.8)
vh vk x : vh[ x] vk[ x]
(2.9)
vh vk vh vk si x : vh[ x] vk[ x]
(2.10)
vh || vk ! (vh vk ) i! (vk vh)
(2.11)

Am scris mai sus ca relaia introduce o ordonare parial a mulimii de evenimente

care sunt produse de un sistem distribuit. Dac evenimentele dintr-un sistem distribuit sunt
marcate cu tampile de timp folosind ceasuri vectoriale, avem urmtoarea proprietate
interesant. Dac dou evenimente x i y care au timestaps vh respectiv vk, atunci
x y vh vk
(2.12)
9

x || y vh || vk
(2.13)
Se poate observa c exist un izomorfism ntre mulimea de evenimente parial ordonate
produs de un sistem distribuit i calculul distribuit al tampilelor de timp asociate. Aceasta este
o proprietate foarte puternic a sistemelor de ceasuri logice vectoriale.
Dac se cunoate procesul care a generat un anumit eveniment, testul pentru a compara
dou tampile de timp poate fi simplificat n felul urmtor. Daca dou evenimente x i y s-au
petrecut la procesele pi respectiv pj, avnd tampilele de timp vh i vk, atunci
x y vh[i ] vk[i ]
(2.14)
x || y vh[i ] vk[i ] vh[ j ] vk[ j ]
(2.15)
Sistemul cu ceasuri logice vectoriale are proprietatea de consisten puternic. Astfel,
dac se examineaz tampila de timp pentru orice dou mesaje, putem determina dac
evenimentele au o relaie de cauzalitate.
Folosind ceasurile logice vectoriale se poate determina numrul de evenimente care
preced un anumit eveniment cu o anumit tampil de timp. Pentru procesul pi, numrul vti[i]
reprezint numrul de evenimente care s-au petrecut in cadrul procesului pi pn n acel
moment de timp. Dac un eveniment e are tampila de timp vh, vh[j] reprezint numrul de
evenimente executate de ctre procesul pi care preced evenimentul e. Deci, vh[j]-1 reprezint
numrul total de evenimente care preced evenimentul e i care sunt n relaie de cauzalitate cu e
din cadrul sistemului distribuit.

2.6 Metoda de sincronizare a ceasurilor logice folosind ceasuri matriciale

ntr-un sistem distribuit cu ceasuri logice matriciale, timpul este reprezentat de o mulime de
matrici de dimensiune n x n cu elemente avnd valori ntregi ne-negative. Un proces pi reine o matrice
mti[1,...n,1,..n] unde:

mti[i,i] reprezint ceasul logic al procesului pi i urmrete progresul calculrii

ceasului logic local la procesul pi.

mti[i,j] reprezint ceea ce procesul pi tie despre valoarea ceasului local al procesului
pj.

mti[j,k] reprezint ceea ce procesul pi tie c procesul pj tie despre valoarea ceasului
local al procesului pk.

ntreaga matrice mti reprezint imaginea local a procesului pi asupra timpului logic global.
tampila de timp care va fi ataat la un mesaj va avea ataat matricea care reprezint ceasul logic al
evenimentului de pe procesul care trimite mesajul.
Procesul pi folosete urmtoarele reguli pentru a face corecie de ceas:

R1 nainte de execuia unui eveniment, procesul pi face urmatoarea corecie de ceas

mt i [i, i ] mt i [i, i ] d , d>0
(2.16)
10

R2 Fiecare mesaj are ataat timpul logic matricial mt. Cnd procesul pi recepioneaz mesajul
(m, mt) de la procesul pj, pi efectueaz urmtoarea suit de aciuni
o i incrementeaz ceasul logic astfel

1 k n : mti[i,k] = max( mti[i,k], mt[j,k] )

(2.17)
adic i actualizeaz rndul mti[i,*] cu rndul corespunztor procesului pj din
tampila de timp a mesajului pe care l recepioneaz.

1 k, l n : mti[k,l] = max( mti[k,l], mt[k,l] )

(2.18)

o Execut R1
o Trimite messajul m mai departe
Ceasurile logice matriciale au toate proprietile pe care le au i ceasurile logice vectoriale. n
plus, ceasurile matriciale mai au i urmtoarea proprietate
Min (mti[k,l]) t implic faptul c procesul pi tie c orice alt proces pk tie c ceasul local al
procesului pls local time a ajuns pn la valoarea t.

Fig 2.9 Exemplu de sincronizare folosind ceasuri matriciale

2.7. Algoritmul Birman Schiper Stephenson (BSS)

Ceea ce este de dorit ntr-un sistem distribuit este ordonarea mesajelor dup cauzalitate. Pe scurt,
aceasta nseamn c dac avem dou mesaje, M1 si M2, i timpul la care a fost transmis M1 este mai
mic dect timpul la care a fost transmis M2, atunci i timpul la care este recpionat M1 trebuie s fie
mai mic dect M2.
dac Send(M1)Send(M2) Rec(M1)Rec(M2)
(2.19)
11

Din pcate, canalele de comunicaie din sistemul distribuit nu pot oferi aceast garanie. Din cauza
ncrcrii reelei, sau din cauza rutelor diferite pe care le pot lua pachetele, nu se poate garanta faptul c
timpul la care va fi recepionat primul mesaj va fi mai devreme dect timpul la care este recepionat al
doilea mesaj.
n figura de mai jos este reprezentat un caz n care ordonarea mesajelor dup cauzalitate este nerespectat

Fig 2.10 Exemplu n care ordonarea mesajelor dup cauzalitate nu este respectat

n figura de mai sus se observ c mesajul M1 este trimis primul, dar din cauza canalului de
comunicaie, el ajunge la nodul destinaie ultimul. ntre timp. mesajul M3, ajunge mai devreme la
destinaie. Se vede pe figur c mesajul Send(M1)Send(M2). De asemenea, Send(M2)Rec(M2).
Rec(M2)Send(M3) i Send(M3)Rec(M3)
Algoritmul BSS face ca ntr-un sistem distribuit, chiar dac reeaua sau canalul de comunicaie produc
ntrzieri de mesaje, totui s se respecte ordonarea mesajelor dup cauzalitate.
Totui, pe lng celelalte condiii, algoritmul BSS se poate aplica doar la mesajele de tip difuzare. Deci
pentru ca algoritmul s i fac efectul, trebuie ca un mesaj s fie trimis la toate celelalte noduri din
sistemul distribuit.
Algoritmul BSS cere ca pasul cu care se incrementeaz ceasurile vectoriale s fie 1. n rndurile
urmtoare este exemplificat algoritmul:
1. Fiecare proces Pi menine un ceas vectorial
2. nainte de a difuza un mesaj m ctre toate celelalte noduri, un nod Pi i incrementeaz ceasul
vectorial local vti[i] i ataeaz noul ceas vti[i] ca o tampil de timp a mesajului. Vom nota
tampila de timp a mesajului m cu vtm.
3. Cnd nodul Pj recepioneaz mesajul m, nti verific urmtoarele condiii:
12

a. vtj[i]=vtm[i]-1, ceea ce nseamn c toate mesaje anterioare trimise de ctre nodul Pi au

fost recepionate de ctre Pj
b. vtj[k] vtm[k], k {1,2,...n} k i, ceea ce nseamn c nodul Pj a recepionat toate
celelalte mesaje care au trecut pe la Pi (dar nu au fost emise de ctre Pi).
4. Dac una dintre cele dou condiii nu e ndeplinit, nodul Pj pune mesajul m ntr-o coad i va
testa tot aceste dou condiii mai trziu
5. Dac ambele condiii sunt ndeplinite, atunci procesul Pj difuzeaz mesajul m ctre toate
celelalte noduri din sistemul distribuit, mai puin Pi.
3.2 Specificaii ale simulatorului
n figura de mai jos este reprezentat o diagram FSM ce cuprinde arhitectura general a programului.
Cnd se pornete programul, utilizatorul ajunge n fereastra cu datele pentru simulare.
TINE

MINTE

SA

UPDATEZI

13

SCHEMA

Schimb tabul

Schimb tabul

BSS date
simulare

Comparaie
ceasuri fizice

Analiza
ncrcrii

Completare
manual
Scrie
MatrixEventInBSS.txt

Calcul matrici
auxiliare

Bloc calcul
matrice timp

Afiarea
rezultatelor
nchide
fereastra

nchide
fereastra
Completare
manual

Completare
aleatorie

Scrie fiierul
MatrixEventIn.txt

Calcul fara
sincronizare

START

Schimb tabul

Date
Simulare
nchide
fereastra

Generare
rezultate

Afiare
rezultate 1
metod

Completare
manual

Completare
aleatorie

Afiare
rezultate 3
metode

Scrie fiierul
MatrixEventIn.txt

Calcul matrice timp

Calcul cu
sincronizare

nchide
fereastra
Afiarea
rezultatelor

Fig 3.10 Diagram FSM cu

arhitectura general a programului

14

Afiarea
rezultatelor

nchide
fereastra

n figura de mai sus este reprezentat ca o diagram a unei maini cu stri finite, arhitectura de baz a
programului.
n blocul Fereastr simulare utilizatorul poate selecta ce metod de sincronizare dorete s simuleze.
Tot n aceeai fereastr, utilizatorul trebuie s defineasc secvena de evenimente care se vor petrece pe
fiecare nod al sistemului distribuit. Pentru aceasta, el va alege nti numrul de noduri din sistemul
distribuit, i apoi numrul de evenimente care vor fi simulate. Fiind alese aceste dimensiuni, n fereastra
de simulare utilizatorul trebuie s dea ca date de intrare sirul evenimentelor care se vor petrece pe
fiecare nod al sistemului distribuit.
Pentru cazul n care numrul de noduri din sistemul distribuit este mare i utilizatorul trebuie s
completeze un ir de evenimente prea vast, simulatorul va avea i opiunea de a completa aleator irul
de evenimente pe fiecare nod. De acest lucru se ocupa blocul Completare aleatorie a matricei din
figura de mai sus.
Dup ce utilizatorul a completat manual sau aleator i irul de evenimente, simulatorul transfer toate
aceste date ctre blocul Calcul matrice timp. Acest bloc, n funcie de metoda selectat, n funcie de
numrul de noduri i de evenimente, i n funcie de irul particular de evenimente care este dat spre
simulare, calculeaz valorile ceasurilor logice asociate fiecrui eveniment de pe fiecare nod i le
tranfer mai departe ctre urmtorul bloc.
Blocul Afiare rezultate preia att valorile ceasurilor logice pentru fiecare eveniment, ct i irul
evenimentelor de pe fiecare nod i afieaz pe ecran o diagram n care fiecrui eveniment din irul de
evenimente i corespunde o valoare a ceasului logic calculat de blocul Calcul matrice timp. Aceste
valori vor fi afiate pe ecran ntr-un mod ct mai uor de citit i de neles pentru utilizator.
Simulatorul va avea i o seciune n care se va face studiul ncrcrii suplimentare a reelei datorat
folosirii fiecrei dintre cele trei metode de sincronizare a ceasurilor logice.
Blocul Buton Generare rezultate se va folosi de mecanismul de generare aletorie a sevenei de
evenimente pe fiecare nod i va genera aleator un numr suficient de mare de evenimente. Apoi cu
ajutorul unei metode din mecanismul de calcul al rezultatelor, se va msura ncrcarea suplimentar
introdus de folosirea metodei respective de sincronizare. Metodele de sincronizare a ceasurilor logice
studiate n lucrarea de fa introduc o ncrcare suplimentar a reelei prin faptul c la fiecare mesaj
transmis de la un nod la altul, se ataeaz i o tampil de timp care va conine valoarea ceasului logic
al nodului de la emisie, la momentul trimiterii mesajului. Blocul Buton Generare rezultate va
parcurge sevena de evenimente generat aleator i va calcula o ncrcare la fiecare tact logic, i o
ncrcare medie.
Urmtoarele dou blocuri, Generare ncrcare toate cele trei metode i Generare ncrcare o singur
metod vor prelua datele calculate de blocul anterior i vor afia pe ecran grafice cu ncrcarea reelei.
n funcie de ce selecteaz utilizatorul, se poate afia pe acelai grafic o comparaie ntre ncrcarea
reelei datorat fiecrei dintre cele trei metode de sincronizare, sau se poate afia pe ecran un grafic care
cuprinde incrcarea datorat unei singure metode, dar s fie afiate mai multe detalii, cum ar fi evoluia
ncrcrii la fiecare tact de timp, sau evoluia medie a ncrcrii.
Dac utilizatorul trece n tabul pentru comparaie ntre situaia cu sincronizare Lamport i situaia n
care doar avem ceasuri fizice, situaia este reprezentat de blocul Comparaie ceasuri fizice. Aici este
o situaie similar cu cea prezentat n blocul Date simulare de la tabul de simulare. Utilizatorul poate
da manual secvena de evenimente de pe fiecare nod al sistemului distribuit sau poate alege ca secvena
de evenimente s fie completat aleator de ctre simulator. O diferen important fa de tabul de
simulare este aceea c n tabul de comparaie utilizatorul nu mai poate selecta metoda scalar,
vectorial sau matricial. Metoda folosit va fi implicit metoda scalar. O alt deosebire este aceea c
utilizatorul va putea regla perioada ceasului fizic pe fiecare nod al sistemului distribuit.
Dup ce datele date de ctre utilizator sunt scrise n fiierul text, spre deosebire de cazul din tabul
pentru simulare, aici n tabul de comparaie, aceleai date de intrare sunt prelucrate de dou blocuri de
15

calcul. Blocul Calcul fr sincronizare calculeaz ceasurile scalare pentri fiecare eveniment fr a
folosi algoritmul Lamport de sincronizare a ceasurilor. Ceasurile fizice pe fiecare nod vor progresa
dup perioada stabilit de utilizator. Blocul Calcul cu sincronizare va calcula ceasurile ataate
fiecrui eveniment folosing regulile Lamport de sincronizare.
Blocul Afiarea rezultatelor va afia pe ecran n paralel cele dou seturi de valori corespunztoare
secvenei de evenimente pentru care s-a realizat simularea. Rezultatele se vor afia pe o diagram astfel
nct s se poat citi i nelege uor de ctre utilizator.
Ultima seciune disponibil va fi implementarea algoritmului Birman-Schiper-Stephenson. Blocul
BSS Date simulare, ca i n cazul taburilor de comparaie si de simulare, va primi datele de intrare
de la utilizator. Spre deosebire de celelalte cazuri, nu va mai exista posibilitatea ca simulatorul s
completeze automat secvena de evenimente. De asemenea, utilizatorul va putea s regleze i
ntrzierea cu care un mesaj va ajunge la nodul destinaie. n cazul tabului BSS, utilizatorul nu va
putea schimba metoda de sincronizare, ci ea va fi setat implicit la metoda vectorial.
Blocul de calcul preia datele de intrare de la blocul anterior i calculeaz ceasurile ataate fiecrui
eveniment i eventualele informaii suplimentare necesare afiarii datelor.
Blocul Afiarea rezultatelor va prelua rezultatele calculate de blocul anterior i va afia pe ecran lista
eveniementelor simulate i rezultatele ceasurilor vectoriale ataate fiecrui eveniment. De asemenea, va
afia pe ecran i dac mesajul recepionat de un nod ndeplinete condiiile impuse de algoritmul
Birman-Schiper-Stephenson, i atunci este trimis mai departe, sau dac nu ndeplinete este pus ntr-o
coad.
3.3. Detalierea blocurilor din arhitectura general a simulatorului
n paragraful de mai sus am spus c simulatorul va putea genera secvena de evenimente pentru fiecare
nod ntr-un mod aleator.
n diagrama de mai jos este prezentat algoritmul de generare aleatoare a matricei cu secvena de
evenimente pentru fiecare nod al sistemului distribuit. Scopul acestui algoritm este de a genera aleator
fiecare coloan astfel nct s nu fie cazuri n care pentru un nod s existe mai multe evenimente n
aceeai perioad de ceas
3.3.1 Blocul de generare automat a secvenei de evenimente de la intrare
Generarea matricei se face pe coloane. Se ia prima coloan, se genereaz n numere aleatoare
pentru coloana respectiv (n fiind numrul de noduri din sistemul distribuit), iar apoi se valideaz irul.
Practic, se valideaz s nu existe mesaj de la nodul i tot la nodul i. Apoi se incearc ca pentru fiecare
nod, s nu existe mai multe evenimente simultane. Pentru aceasta, se folosete un ir numit dirty de
dimensiune n. De fiecare dat cnd se produce un eveniment pentru un nod i, se incrementeaz
elementul dirty[i] . Apoi se verific dac vreun element al lui dirty este mai mare dect 1. Dac da,
atunci nseamn c exist dou evenimente simultane. Dac nu, atunci nseamn c numerele aleatoare
respect validrile i se trece la urmtoarea coloan a matricei.

16

Generare a coloanei c[] cu numere

aleatorii
Initializarea vectorului de
n elemente dirty[] cu 0

i=0

i >= n?

c[i] =
ev intern

Da

Da

dirty[i]++
c[i]= mesaj
de la nodul
n1 la n2

dirty [i]
>=2
i++
.

Fig
4.2
Cum
poat
e
utiliz
dirty[n1]
atoru++
dirty[n2]++
l s
aleag
a
meto
da i
num
arul
de
linii
i = i0 de
colo
ane
ale
i >= n?
matri
cei

i++

Da

Da
Re-genereaz
aceeai col

17 de generare aleatoare a
Fig 3.11 Diagrama pentru algoritmul
Matricei de secven de evenimente

Se trece la
coloana
urmatoare

Fereastra care preia datele de la utilizator i fereastra care afieaz ceasurile calculate, sunt
definite pe dou fire de execuie. ntre cele dou fire de execuie am aplicat modelul de productor->
consumator pentru sincronizarea lor. Firul de execuie de productor, preia datele de la utilizator i le
scrie n fiierul MatrixEventIn.txt. Dup ce termin de completat fiierul, productorul i trimite un
mesaj de sincronizare consumatorului care citete datele din MatrixEventIn.txt i calculeaz ceasurile
logice, apoi le afieaz pe ecran. Dup ce utilizatorul inchide fereastra n care se afieaz rezultatele,
procesul de pe firul de execuie consumator ateapt de la productor un alt mesaj de sincronizare ca s
tie cnd s-au scris n fiierul MatrixEventIn.txt date noi.

Productor

Mesaj sincronizare

Consumator

MatrixEventIn.txt
Citete din

Scrie n

Fig 3.12 Modelul de productor-consumator folosit

3.3.2. Blocul de calcul al ceasurilor pentru Metoda Scalar

n figura de mai sus este afiat un exemplu de fiier de intrare cu metoda Scalar. Primul lucru
pe care l face blocul Calcul matrice timp este acela c se uit la al treilea numr de pe prima linie
din MatrixEventIn.txt n funcie de acest numr, va aplica diveri algoritmi pentru a calcula matricea de
Timp pentru fiecare eveniment.
n continuare vom nota matricea de intrare cu evenimente mEv1[][] si matricea timp cu
mT1[][]. n cazul metodei scalare elementele care constituie matricea de timp vor fi scalari. Elementul
de coordonate mT1[i][j] reprezint ceasul vectorial corespunztor evenimentului mEv1[i][j] din
matricea de evenimente. Pentru a putea lucra mai uor, s-a lucrat cu matricea de evenimente si matricea
de timp ambele transpuse. Astfel,
mEv mEv1T
mT mT 1T

(3.1)
n cadrul blocului Calcul matrice timp vom lucra cu mT i mEv transpuse. Deci pentru mEv, pe linia
1 vor fi evenimentele care au loc simultan n timpul primei perioade de ceas, pe linia 2 vor fi
evenimentele care au loc simultan n timpul celei de-a doua perioade de ceas, amd.
18

Un alt amnunt notabil este urmtorul. Matricea de evenimente, mEv, se completeaz ncepnd
de la indicii i=0 i j = 0, dar matricea de ceasuri are o linie n plus. Prima linie, cea cu indicii i=0, nu va
fi folosit n calcule i nici nu va fi afiat n fereastra cu afiarea rezultatelor. Deci liniile care se
afieaz la sfrit pentru matricea de ceasuri sunt cele ncepnd de la indicii i=1. De aceea, n diagrama
de mai jos, bucla for cu care se face parcurgerea matricelor ncepe de la i = 1.
n figura de mai jos este reprezentat diagrama blocului de Calcul matrice timp. Acest bloc
face parte din gruparea blocurilor de pe linia de execuie Consumator discutat mai sus. De aceea,
dup ce primete mesajul de sincronizare, se citesc valorile din fiierul MatrixEventIn.txt i se
stocheaz n matricea mEv1[ ] [ ]. Dup cum spuneam, ca s se poat parcurge mai uor, n urmtoarea
etap se transpune matricea de evenimente
mEv mEv1T
(3.2)
Dac mai sus am spus c elementul din matricea de timp mT1[i0][j0] reprezint ceasul Lamport
corespunztor evenimentului mEv1[i0][j0], aceeai proprietate se pstreaz i pentru matricile
transpuse, adic elementul din mT[i0][j0] reprezint ceasul Lamport corespunztor evenimentului
mEv[i0][j0].
n urmtorul pas se iniializeaz matricea mT cu zero.
mT [i ][ j ] 0 , i 0, nrCol , j 0, nrLin
(3.3)
nrLin i nrCol se citesc din prima linie a fiierului MatrixEventIn.txt i reprezint numrul de linii i de
coloane pentru matricea mEv1. Dar, dup cum am spus, lucrm cu matricea transpus i de aceea i, care
e primul indice e de la 0 la nrCol i j, al doilea indice e de la 0 la nrLin.
Dup stabilirea limitelor se ncepe parcurgerea matricelor. Aici este foarte important faptul c
matricea mEv se parcurge ncepnd de la prima linie, cea de index i=0, pe cnd matricea mT se
parcurge ncepnd de la a doua linie, cea de index i=1. De aceea, n buclele for, indicele i ncepe de la
valoarea 1, pe cnd indicele j ncepe de la valoarea 0. Pentru c matricea mEv se parcurge de la linia
0, din aceast cauz mEv se parcurge in bucla for cu mEv[i-1][j],iar mT cu mT[i][j].
n bucla for se ia elementul curent din mEv i se verific ce fel de eveniment este. Dac este un
eveniment neutru se face urmtorul lucru. Se ia valoarea de la linia precedent din mT i se stocheaz la
linia curent. Din aceast cauz matricea mT are prima linie, cea de indice i=0, n plus fa de celelalte
matrici. Pentru c n algoritmul implementat de mine n cazul evenimentului neutru, ceasul logic
ramne la valoarea anteriar. De aceea trebuie ca matricea mT s ia valoarea de pe linia precedent. De
aceea ncepe bucla for cu i=1, pentru ca atunci cnd iau valoarea ceasului precedent, adic cea de la
linia i-1, s gsesc valoarea de la linia i=0

19

Citete din MatrixEventIn.txt

n mEv1[ ][ ]
Fig 3.13 Diagram calcul metoda
Scalar
mEv [ ][ ] = mEv1[ ][ ] transpus

mT[ ] [ ] =0
i=1

j=0

i>nCol

Da

i++
j>nLin
j++
Urmtorul bloc
Afiarea Rez
mEv [i-1][j]=i?

mEv [i-1][j]=
n ?

mEv [i-1][j]=
mesaj ?

Da

Da

mT[i][j]<mT[i1][j] ?

Da

mT [i] [j] = mT[i-1][j] +

step

Da

mT [i] [j] = mT[i-1][j]

mT1[i] [j] = mT[i-1][j] +
step

mT[i] [mesaj] =
20
max(mT[i][j] ,mT[i-1][mesaj])+
+step

for (i = 1; i <= Ciorna5.getNoEvents(); i++) {

for (j = 0; j < Ciorna5.getNoThreads(); j++) {
int auxInt1 = (int) (matrixEvent1[i - 1][j] - '0');
if (matrixEvent1[i - 1][j] == 'i')
matrixTime1[i][j] = matrixTime1[i - 1][j] + step;
else if (matrixEvent1[i - 1][j] == 'n') {
if (matrixTime1[i][j] <= matrixTime1[i - 1][j])
matrixTime1[i][j] = matrixTime1[i - 1][j];
} else if (auxInt1 != j + 1) {
matrixTime1[i][j] = matrixTime1[i - 1][j] + step;
sequenceTime = matrixTime1[i][j];
matrixTime1[i][auxInt1 - 1] = Math.max(
matrixTime1[i - 1][auxInt1 - 1],
sequenceTime) + 1;
}
}
}

Dac valoarea curent a elementului din mEv este un eveniment intern, atunci programul ia valoarea de
la linia precent a lui mT i o incrementeaz cu un pas. Astfel se face incrementarea ceasurilor logice.
Dac valoarea curent a elementului din mEv este un mesaj de la un nod n1 la un nod n2, atunci se face
urmtoarea secven de pai. n paragrafele anterioare am spus c un mesaj este reprezentat n fiierul
matrixEventIn.txt cu o cifr. Cifra respectiv reprezint destinaia mesajului. Algoritmul lui Lamport
spune c n cazul unui mesaj, nti se incrementeaz ceasul logic corespunztor nodului surs. Pentru a
afla care este nodul surs programul se uit la ce linie i coloan se afl elementul curent din mEv. Apoi
se incrementeaz ceasul logic la nodul surs.
mT [i ][ j ] mT [i 1][ j ] step
(3.4)
Algoritmul lui Lamport spune ca la nodul destinaie, se compar ceasul ataat mesajului ( mesajul va
avea ceasul corespunztor nodului surs) cu ceasul local de pe nodul destinaie. Dac cumva ceasul de
pe nodul destinaie este mai mic dect ceasul de la nodul surs, atunci ceasul nodului destinaie se va
actualiza la valoarea ceasului ataat mesajului. De aceea, dup incrementarea ceasului logic la nodul
surs se execut urmtoarea linie de cod:
mT[i] [mesaj] = max(mT[i][j] ,mT[i-1][mesaj])+step
(3.5)
mesaj reprezint variabila n care se stocheaz nodul destinaie din fiierul matrixEventIn.txt. Se
observ c, dup ce se face actualizarea ceasului pe nodul destinaie, se adaug i pasul, pentru a se
respecta Algoritmul lui Lamport. n regulile lui Lamport, Regula a doua, spune c dup actualizarea
ceasului la nodul destinaie, se execut Regula 1. Adic dup ce nodul de la recepie preia mesajul,
procesarea mesajului recepionat reprezint un eveniment intern care incrementeaz ceasul logic cu un
pas.

21

3.3.3 Blocul de calcul pentru Metoda Vectorial

Pentru metoda vectorial principala diferen este datorat faptului c matricea de timp nu va mai fi
alctuit din scalari, ci va fi alctuit din vectori. n cazul metodei vectoriale, evenimentului de indice i
i j din matricea mEv i corespunde elementul de indice i i j din matricea mTv, cu meniunea c
elementul de indice i i j din matricea de timp va fi un vector cu nLin elemente, unde nLin este numrul
de noduri din sistemul distribuit.
Un ir de genul v[10] este usor de inchipuit, o matrice este de asemenea uor de reprezentat
m[10][10], dar un sir multidimensional este puin mai greu de neles. S considerm exemplul de mai
jos:
i j 0
0
0
1
1
2
2
3
3
4
4
5
5
6
5

1
0
0
0
3
3
5
5
k=0

2
0
0
0
0
0
0
0

i j 0
0
0
1
0
2
0
3
0
4
0
5
0
6
0

1
0
0
0
1
1
2
3
k=1

2
0
0
0
0
0
0
0

i j 0
0
0
1
1
2
1
3
1
4
1
5
1
6
1

1
0
0
0
1
1
1
1
k=2

2
0
1
1
1
2
2
3

Fig 3.14 Exemplu de matrice mTv[][][] cu trei dimensiuni folosit la metoda Vectorial

n tabelul de mai sus este reprezentat matricea mTv aa cum este ea calculat de blocul Calcul
matrice timp pentru cazul n care avem selectat metoda vectorial. Matricea de intrare
mEv1[][]pentru exemplul de mai sus este urmtoarea:
ni2i2n
nnnnni
1nnini
Fig 3.15 mEv1 pentru exemplul de mai sus

Prin transpunerea ei obinem matricea mEv[][]:

i j
0
1
2
3
4

0
n
i
2
i
2

1
n
n
n
n
n

2
1
n
n
i
n

Fig 3.16 Exemplu de matrice de intrare mEv

Avnd in vedere matricea mTv[][][] cu trei dimensiuni din figura de mai sus, putem explica mai usor
modul de indexare al elementelor. Pentru o matrice obinuit, cu 2 dimensiuni A[i][j], i reprezint
indicele liniei, j reprezint indicele coloanei. Pentru cazul n care avem trei dimensiuni, mTv[k][i][j],
putem spune ca avem k pagini, fiecare cu cte o matrice care are i linii i j coloane. Tabelul din figura
de mai sus ne ajut mai uor s gasim valoare mTv[k0][i0][j0] pentru k0, i0, j0 valori particulare. De
exemplu: mTv[0][3][2] = 0, mTv[1][6][1]=3, mTv[2][6][3]=3.
Folosindu-ne de conceptul de iruri multidimensionale expus mai sus, putem stoca ceasurile vectoriale
pentru evenimente in metoda Vectorial de sincronizare a ceasurilor logice ntr-o matrice cu trei
dimensiuni. Dac rulm exemplul cu matricea de intrare de mai sus in simulator i alegem metoda
Vectorial, vom obine rezultatele urmtoare:

22

Fig 3.17 Rezultate pentru metoda Vectorial folosite pentru a explica cum se folosete matricea multidimensional
mTv[][][]

Ceasurile vectoriale ataate fiecrui eveniment din figura de mai sus sunt stocate in matricea mTv[][][]
de mai sus. Pe acest exemplu, putem face proba. De exemplu, pentru evenimentul intern de la nceputul
celei de-a doua perioade de ceas avem afiat ceasul [2 0 1] . Vom vedea de unde i ia programul de
simulare datele din matricea multidimensional mTv[][][].
Pentru a gsi ceasul vectorial pentru un anumit eveniment, trebuie s gsim coordonatele pentru cele
trei numere.
Dac lucrm cu matricile de timp i de evenimente ambele transpuse, atunci pe linia i va corespunde
perioadei de ceas n care se petrece evenimentul, iar coloana j va reprezenta numrul nodului pe care se
petrece evenimentul.
De asemenea, pentru matricea de timp reprezentat n figura de mai sus, se poate observa c la linia i=0
toate valorile sunt 0. Linia i=0 nu este afiat la rezultate, este doar pentru iniializare i pentru
uniformitatea algoritmului de calcul. Linia i=1 corespunde datelor de la prima perioad de ceas, i=2
pentru datele de la a doua perioad de ceas, amd. Pe de alt parte, nu avem i coloane n plus, deci
toate coloanele sunt afiate la rezultate. Coloana cu j=0 corespunde nodului 1, coloana cu j=0
corespunde nodului 2, amd.
Primul eveniment intern al procesului P1 se petrece n timpul celei de-a doua perioade de ceas, deci
i = 2. Dac este vorba de primul proces din sistemul distribuit atunci nseamn c j = 0. Am identificat
cine e i, cine e j a mai rmas k. Ceasul vectorial pentru fiecare eveniment conine n numere, unde n este
numrul de noduri din sistemul distribuit. Prima valoare a ceasului vectorial se va afla la coeficientul
k=0, a doua la poziia k=1 n matricea mTv[][][], iar a treia valoarea a ceasului vectorial se va afla la
indicele k=2.
n cazul nostru, pentru a gsi ceasul logic pentru primul eveniment intern al procesului P1, afim din
matricea de timp valorile aflate la indicii:
k 0, n 1 , i = 2 (perioada de ceas la care se petrece), j = 0 (numrul nodului 1 )
(3.6)
Avnd n vedere explicaiile date mai sus cu modul de folosire a matricei multidimensionale mTv[][][],
algortimul de calcul al acestei matrici pentru metoda vectorial este mai uor de neles.

23

i=1
Fig 3.18 Diagram calcul
Metoda Vectorial

i++
i > nLin

Nu
mTv[k][i][jj]=max(mTv[k][i-1][jj], mTv[k][i][jj])
k , jj 0, nLin

j=0

Da

j > nCol

j++

Nu
Da

mEv[i-1][j]
= ev int

mTv[j][i][j] ++
Nu
Da

mEv[i1][j]=mj

mTv[j][i][j]++
mTv[k][i][msj]=max(mTv[k][i][msj], mTv[k][i][j]
k 0, nLin

mTv[msj][i][msj]++

24

Nu

for (i = 1; i <= Ciorna5.getNoEvents(); i++) {

for (k = 0; k < Ciorna5.getNoThreads(); k++)
for (int jj = 0; jj < Ciorna5.getNoThreads(); jj++) {
if (matrixTimeV[k][i][jj] <= matrixTimeV[k][i - 1][jj])
matrixTimeV[k][i][jj] = matrixTimeV[k][i - 1][jj];
}

for (j = 0; j < Ciorna5.getNoThreads(); j++) {

int auxInt1 = (int) (matrixEvent1[i - 1][j] - '0');
if (matrixEvent1[i - 1][j] == 'i') {
int verific = matrixTimeV[j][i - 1][j];
int verific2 = verific + 1;
matrixTimeV[j][i][j] ++;
} else if (matrixEvent1[i - 1][j] == 'n') {
} else if (auxInt1 != j + 1) {
matrixTimeV[j][i][j] = matrixTimeV[j][i - 1][j] + 1;
for (k = 0; k < Ciorna5.getNoThreads(); k++) {
matrixTimeV[k][i][auxInt1 - 1] = Math.max(
matrixTimeV[k][i][auxInt1 - 1],
matrixTimeV[k][i][j]);
}
matrixTimeV[auxInt1 - 1][i][auxInt1 - 1]++;
}
}

Mai sus este reprezentat diagrama logic pentru calculul lui mTv[][] . La fel ca n seciunea
precedent, nti se transpune matricea mEv1[][] . Apoi se parcurge mEv[][].
Un amnunt important este acela c de fiecare dat cnd se trece la un moment de timp nou, adic de
cte ori se incrementeaz variabila i, se copiaz toate elementele din matricea de timp de la linia i-1 la
linia noua linie i. Apoi se verific rnd pe rnd elementele matricei de evenimente.
n cazul unui eveniment neutru, nu se mai face nimic, deoarce deja s-au copiat valorile de timp de la
iteraia anterioar.
n cazul unui eveniment intern, se excut regula R1 Lamport cu linia de cod:
matrixTimeV[j][i][j] ++;

n cazul unui mesaj de la nodul j la nodul msj, nti se execut regula R1 Lamport la nodul surs. Acest
pas este ilustrat n secvena de cod de mai jos
matrixTimeV[j][i][j] = matrixTimeV[j][i - 1][j] + 1;

Apoi valoarea nou a ceasului pe nodul surs se compar cu valoarea ceasului vecctorial de pa nodul
destinaie. Dac este necesar, pe nodul destinaie se actualizeaz unul sau mai multe elemente ale
ceasului vectorial al nodului destinaie. Acest lucru se poate vedea n liniile de cod de mai jos
for (k = 0; k < Ciorna5.getNoThreads(); k++) {
matrixTimeV[k][i][auxInt1 - 1] = Math.max(
matrixTimeV[k][i][auxInt1 - 1],
matrixTimeV[k][i][j]);
}

n sfrit, dup actualizarea ceasului vectorial la nodul destinaie, se execut regula R1 pentru nodul
destinaie al mesajului cu linia de cod de mai jos:
matrixTimeV[auxInt1 - 1][i][auxInt1 - 1]++;

3.3.4. Blocul de calcul pentru Metoda Matriciala

n cazul metodei Matriciale, lcururile stau similar cu metoda Vectorial. Pentru matricea de timp, tot o
matrice cu trei dimensiuni vom folosi, mTm[k][i][j], doar c n cazul metodei matriciale, k va lua valori
de la 0 la n2. Cele n2 valori sunt valorile care mpreun formeaz ceasul matricial ataat unui eveniment.
25

n concluzie, pentru metoda Matricial, unui eveniment de coordonate i0 i j0 din matricea de

Evenimente mEv[i][j], i corespund n2 valori din matricea mTm[k][i][j], unde
k 0, n 2 ,
[0][0][0]=0
[0][0][1]=0
[0][0][2]=0
[0][1][0]=0
[0][1][1]=0
[0][1][2]=0
[0][2][0]=1
[0][2][1]=0
[0][2][2]=1
[0][3][0]=2
[0][3][1]=0
[0][3][2]=1
[0][4][0]=3
[0][4][1]=0
[0][4][2]=1
[0][5][0]=4
[0][5][1]=0
[0][5][2]=1
[0][6][0]=5
[0][6][1]=0
[0][6][2]=5

[1][0][0]=0
[1][0][1]=0
[1][0][2]=0
[1][1][0]=0
[1][1][1]=0
[1][1][2]=0
[1][2][0]=0
[1][2][1]=0
[1][2][2]=0
[1][3][0]=2
[1][3][1]=0
[1][3][2]=0
[1][4][0]=2
[1][4][1]=0
[1][4][2]=0
[1][5][0]=2
[1][5][1]=0
[1][5][2]=0
[1][6][0]=2
[1][6][1]=0
[1][6][2]=2

i=i0,
(3.7)

j=j0

[2][0][0]=0
[3][0][0]=0
[4][0][0]=0
[5][0][0]=0
[6][0][0]=0
[2][0][1]=0
[3][0][1]=0
[4][0][1]=0
[5][0][1]=0
[6][0][1]=0
[2][0][2]=0
[3][0][2]=0
[4][0][2]=0
[5][0][2]=0
[6][0][2]=0
[2][1][0]=0
[3][1][0]=0
[4][1][0]=0
[5][1][0]=0
[6][1][0]=0
[2][1][1]=0
[3][1][1]=0
[4][1][1]=1
[5][1][1]=0
[6][1][1]=0
[2][1][2]=0
[3][1][2]=0
[4][1][2]=0
[5][1][2]=0
[6][1][2]=0
[2][2][0]=0
[3][2][0]=0
[4][2][0]=0
[5][2][0]=0
[6][2][0]=0
[2][2][1]=0
[3][2][1]=0
[4][2][1]=1
[5][2][1]=0
[6][2][1]=0
[2][2][2]=0
[3][2][2]=0
[4][2][2]=0
[5][2][2]=0
[6][2][2]=1
[2][3][0]=0
[3][3][0]=0
[4][3][0]=2
[5][3][0]=0
[6][3][0]=0
[2][3][1]=0
[3][3][1]=0
[4][3][1]=2
[5][3][1]=0
[6][3][1]=0
[2][3][2]=0
[3][3][2]=0
[4][3][2]=0
[5][3][2]=0
[6][3][2]=1
[2][4][0]=0
[3][4][0]=0
[4][4][0]=2
[5][4][0]=0
[6][4][0]=0
[2][4][1]=0
[3][4][1]=0
[4][4][1]=3
[5][4][1]=0
[6][4][1]=0
[2][4][2]=0
[3][4][2]=0
[4][4][2]=0
[5][4][2]=0
[6][4][2]=1
[2][5][0]=4
[3][5][0]=0
[4][5][0]=2
[5][5][0]=0
[6][5][0]=1
[2][5][1]=0
[3][5][1]=6
[4][5][1]=3
[5][5][1]=0
[6][5][1]=0
[2][5][2]=0
[3][5][2]=0
[4][5][2]=0
[5][5][2]=0
[6][5][2]=1
[2][6][0]=4
[3][6][0]=0
[4][6][0]=2
[5][6][0]=0
[6][6][0]=1
[2][6][1]=0
[3][6][1]=6
[4][6][1]=3
[5][6][1]=0
[6][6][1]=0
[2][6][2]=4
[3][6][2]=0
[4][6][2]=2
[5][6][2]=0
[6][6][2]=5
Fig 3.19 Exemplu de matrice de timp pentru metoda Matricial

[7][0][0]=0
[7][0][1]=0
[7][0][2]=0
[7][1][0]=0
[7][1][1]=0
[7][1][2]=0
[7][2][0]=0
[7][2][1]=0
[7][2][2]=0
[7][3][0]=0
[7][3][1]=0
[7][3][2]=0
[7][4][0]=0
[7][4][1]=0
[7][4][2]=0
[7][5][0]=0
[7][5][1]=0
[7][5][2]=0
[7][6][0]=0
[7][6][1]=0
[7][6][2]=2

n exemplul de mai sus avem calculat matricea de timp pentru o matrice de intrare de forma:

Simulatorul va afia urmtoarele rezultate:

n3nin3
in1inn
inin1n

26

[8][0][0]=0
[8][0][1]=0
[8][0][2]=0
[8][1][0]=0
[8][1][1]=0
[8][1][2]=1
[8][2][0]=0
[8][2][1]=0
[8][2][2]=2
[8][3][0]=0
[8][3][1]=0
[8][3][2]=3
[8][4][0]=0
[8][4][1]=0
[8][4][2]=3
[8][5][0]=4
[8][5][1]=0
[8][5][2]=4
[8][6][0]=4
[8][6][1]=0
[8][6][2]=5

Fig 3.20 Exemplu de rezultate pentru metoda Matricial

Se poate observa c pentru fiecare eveniment avem afiate 9 valori sub form de matrice. De exemplu,
pentru ultimul eveniment al nodului P3, trebuie s scoatem elementele mTm[k][6][2], k 0,8 . Se
poate verifica faptul c toate elementele din matricea de timp corespund cu valorile ceasurilor afiate pe
ecran.
Diagrama logic pentru calculul matricei de timp n cazul metodei Matriciale este afiat mai jos:
Pentru c, luat n detaliu, diagrama logic pentru metoda Matricial este mai complicat, am preferat
s pun pe schema logic doar o descriere general a blocurilor urmnd ca mai trziu s detaliez rolul
fiecrui bloc.

27

mTm[k][i][j] = mTm[k][i-1][j]
k 0, nLin , j 0, nLin

i=0

i>nCol

Da

STOP

i++

j=0

j>nLin

e[i-1][j]
= i

e[i1][j]=m

Da

Da

increment
ceas local
mTi[i,i]

Da

increment ceas local al

nodului surs

completez TS mesaj

actualizez matricea la
nodul destinaie

incrementez ceas local nod

destinaie

28

Fig 3.21 Diagrama

logic pentru
metoda Matricial

n blocul cel mai de sus, se copiaz toate valorile ceasurilor vectoriale de la momentul de timp i-1 la
momentul curent, i. Acest pas este necesar deoarece, mai trziu, n cazul unui mesaj, trebuie sa
comparm valoarea ceasului local cu cea a tampilei de timp. Daca nu am fi fcut acest pas, la ceasul
local al nodului de recepie, pentru momentul de timp i, ar fi fost o valoare nedefinit sau valoarea 0.
Urmtoarele blocuri logice vor s reprezinte dou bucle for folosite pentru a parcurge matricea de
evenimente mEv[][]. Reamimtim faptul c i n cazul metodei Matriciale, ca i n cazul metodelor
precedente, lucrm cu matricea de timp i de evenimente transpus, deci, cu ajutorul buclelor for vom
parcurge matricea de evenimente avnd pe linii momentele de timp i pe coloane nodurile.
Dac evenimentul curent este un eveniment intern, atunci se incrementeaz ceasul scalar local pentru
nodul la care se petrece evenimentul. Reamintim faptul c, pentru nodul i n cazul metodei matriciale,
ceasul logic pentru nodul i este o matrice de dimensiunea n x n, unde n este numrul total de noduri.
Pentru nodul i, al i-lea element din cadrul liniei i din ceasul matricial corespunztor acestui nod
reprezint ceasul local. Al j-lea element din cadrul liniei i reprezint estimarea nodului i asupra a ct
este ceasul logic scalar pentru nodul j. De asemenea, tot pentru ceasul matricial de pe nodul i, celelalte
valori scalare de ordinul k de pe alte linii ji reprezint ct tie nodul i c ar ti nodul j c este ceasul
local scalar pe nodul k.
Pentru exemplul numeric din figura de mai sus, se observ c la final, nodul P3 are ceasul matricial
5 2 4
0 2 0

5 2 5
Fig 3.22 Exemplu de ceas matricial la nodul P3

Putem spune c ceasul scalar local pentru nodul P3 este valorea m[3,3]=5. Restul valorilor de pe linia a
3-a reprezint estimri. m[3,1] =5 reprezint pn la ce valoare tie nodul P3 c a progresat ceasul
scalar logic local de pe nodul P1, iar m[3,2]=2 reprezint ct tie nodul P3 c a progresat ceasul logic
local de pe nodul P2. Tot pentru nodul P3, valoarea m[1,1]=5 reprezint ct tie procesul P3 c tie
procesul P1 c ar fi ceasul local pe procesul P1. Pentru nodul P3, valoarea m[1,2]=2 reprezint ct tie procesul
P3 c tie procesul P1 c ar fi ceasul logic local pe nodul P2.
Dac evenimentul curent este eveniment intern, atunci blocul increment ceas local mTi[i,i] execut

urmtoarea secven de cod:

matrixTimeM[thrd * j + j][i][j]++;

unde thrd reprezint numrul total de noduri.

Dac evenimentul curent este un mesaj, nti se incrementeaz ceasul logic local al nodului surs cu
secvena de cod
matrixTimeM[thrd * j + j][i][j]++;

Dup ce s-a incrementat ceasul logic local, adic s-a executat regula R1 din algorimtul lui Lamport, am
stocat ntr-o matrice separat numita TS (time-stamp tampil de timp) valorile ceasului matricial de pe
nodul surs dup ce s-a executat R1. Practic aceast matrice va fi ataat la mesaj ca o tampil de timp.
Cnd mesajul ajunge la nodul destinaie, se face actualizarea ceasului matricial de la nodul destinaie.
tim din teorie c actualizarea ceasului matricial la destinaie se face in dou etape.
Prima etap
1 k n : mti[i,k] = max( mti[i,k], mt[j,k] )
iar a doua etap
1 k, l n : mti[k,l] = max( mti[k,l], mt[k,l] )
nti nodul recepie Pi i actualizeaz linia i cu linia j a tampilei de timp, apoi i actualizeaz restul
valorilor din matrice.
Prima etap este implementat cu ajutorul codului de mai jos
29

for (int inc = 0; inc < thrd; inc++)

matrixTimeM[thrd * Rx + inc][i][Rx] = Math.max(
matrixTimeM[thrd * Rx + inc][i][Rx],TS[Tx][inc]);

iar a doua etap este implementat de codul de mai jos

for (k = 0; k < thrd * thrd; k++)

matrixTimeM[k][i][Rx] = Math.max(
matrixTimeM[k][i][Rx], TS[k / thrd][k% thrd]);

n final, dup ce procesul destinaie a actualizat ceasul logic cu valorile din tampila de timp a
mesajului, se execut regula R1 la nodul destinaie dup cum se specific n algoritmul Lamport.
Incrementarea ceasului logic local la nodul destinaie se face su seciunea de cod
matrixTimeM[thrd * Rx + Rx][i][Rx]++;
unde Rx reprezint identificatorul procesului destinaie al mesajului, iar thrd

este numrul de noduri

din sistemul distribuit.
3.3.5. Analiza ncrcrii reelei
n aceast seciune vom prezenta cum s-a implementat tabul pentru analiza performanei.
Generare mEv aleatorie cu 1000 de coloane i
nLin linii

i=0; j=0;

sir[ j ] 0, j 0,999

spre blocul de calcul

urmtor

i > nLin

Nu

i++
Da

Fig 3.23 Diagrama

codului din spatele
butonului de
Generare
Rezultate

j > 1000

Nu

Nu

mEv[i][j]
= mesaj

Da

sir[j]++

30

j++

n diagrama de mai sus este reprezentat secvena de pai care este executat atunci cnd se apas
butonul de Generare rezultate. nti se genereaz o matrice de evenimente cu un numr mare de
coloane, adic de tacte de ceas simulate, 1000. irul sir va numra cte mesaje sunt pe fiecare tact de
ceas. Valoarea sir[i0] va reine cte mesaje sunt trimise pe parcursul tactului de ceas i0. Mai departe, se
testeaz ce metod de sincronizare a ceasurilor logice este folosit. Dac este folosit metoda scalar,
pentru fiecare mesaj se adaug cte un Octet la valoarea de ncrcare care va fi scris n fiierul text
pentru tactul de ceas respectiv. Dac este folosit metoda Vectorial, pentru fiecare mesaj, se adaug
cte nLin Octei la valoarea ncrcrii pentru un anumit tact de ceas. n sfrit, pentru metoda
Matricial, pentru fiecare mesaj se vor aduga nLin * nLin Octei. Acest lucru este reprezentat diagrama
de mai jos

Fig 3.24 Analiza ncrcrii

datorat metodei sincronizare

31

Folosind sirurile de date rezultate din metoda de mai sus, ele se scriu n nite fiiere text. Pe prima linie
este scris ncrcarea n fiecare period de ceas cnd se folosete metoda Scalar, pe a doua linie este
scris ncrcarea n fiecare perioad de ceas cnd se folosete metoda Vectorial, iar pe a treia linie este
scris ncrcarea n fiecare perioad de ceas cnd metoda folosit este Metoda Matiricial.
De asemenea, folosind datele de mai sus, se vor scrie i nite fiiere text cu numele
PerfOverheadAve_< nLin>Threads.txt. n aceste fiiere se calculeaz la fiecare tact de ceas evoluia
mediei eantioanelor trecute pentru ncrcare dup formula
(n 1) m n 1 ovh[n]
mn
n
(3.8)
unde mn reprezint media calculat la momentul de timp n, iar ovh[n] este valoarea ncrcrii la
momentul de timp n. Aces fiier este folosit pentru e afia pe acelai grafic i evoluia ncrcrii pentru
fiecare moment de timp, dar i evoluia medie a ncrcrii.
Avnd aceste date scrise n fiiere, utilizatorul poate s vizualizeze pe ecran grafice cu ncrcarea
pentru o anumit metod sau comparaie ntre ncrcarea meadie introdus de fiecare dintre cele trei
metode de sincronizare a ceasurilor logice studiate n lucrare.
3.3.6. Comparaie ntre un caz n care se aplic metode de sincronizarea a ceasurilor logice
i un caz n care nu se aplic nicio metod de sincronizare.
n urmtoarea seciune vom ncerca s demonstm utilitatea metodelor de sincronizare Lamport
folosind un exemplu realizat cu ajutorul simulatorului descris anterior. Pentru aceasta, am realizat un
scenariu n care exist o desincronizarea a ceasurilor pe nodurile din sistemul distribuit. Ceasurile din
exemplu pot fi considerate chiar ceasuri fizice.
Dup cum am prezentat i n partea teoretic, n sistemele distribuite vor exista cazuri n care ceasurile
fizice de pe nodurile sistemului vor fi desincronizate. n acest caz, dac un nod cu un ceas mai lent i
trimite mesaj unui nod cu ceas mai rapid, mesajul va avea ataat o tampil de timp mai veche, ceea ce
nu va duna algoritmului care ruleaz pe sistemul distribuit. Dac ns un nod cu ceas mai rapid i va
trimie mesaj unui nod cu ceasul mai lent, atunci se poate ntmpla ca mesajul s aib ataat o tampil
de timp mai nou dect ceasul pe nodul destinaie. Pentru nodul destinaie, acest mesaj este ca un mesaj
din viitor, ceea ce poate duna algoritmului care ruleaz pe sistemul distribuit. Dac se folosesc n
sistemul distribuit metode de sincronizare a ceasurilor logice, aceast situaie defavorabil poate fi
rezolvat.
Fereastra cu datele de intrare este similar cu situaia din tabul de simulare. Singura diferen este aceea
c utilizatorul nu mai poate selecta metoda de sincronizare simulat, ci ea va fi setat implicit pe
metoda scalar. O alt diferen este aceea c utilizatorul poate selecta perioada de ceas pe fiecare nod
din sistemul distribuit.
De aceea, pentru a ilustra comparativ rezultatele i pentru situaia in care se folosee metoda scalar de
sincronizare i pentru situaia n care nu se folosete nicio metod de sincronizare, au fost folosite dou
blocuri de calcul al rezultatelor, cte unul pentru fiecare caz.
Mai jost este reprezentat schema logic de calcul a matricei de timp pentru cazul n care avem
Lamport. Exist nite mici diferene fa de schema de la simulatorul pentru metoda Scalar pe care le
vom discuta n paginile urmtoare.

32

START

i=1

i>nCol

i++

Da

STOP

Nu
mT[i][j] = mT[i-1][j] + step[j]

j 1, nLin

j=0

Da

j++

j>nLin

Nu

mEv[i-1][j] = msj

Da

mT[i][msj] = max(mT [i][j], mT[i][msj])

+1
Fig 3.25 Schma de calcul cu
Lamport in cazul comparatiei

33

Nu

Prima diferen ntre schema de mai sus i simulatorul pentru metoda Scalar a lui Lamport este aceea
c n cazul de fa, ceasul se incrementeaz ca un ceas fizic, adic independent de ntmplarea sau nu a
unor evenimente. Tot ca n cazul metodei scalare, se lucreaz cu matricea de timp i matricea de
evenimente transpuse.
Incrementarea variabliei i reprezint venirea unui noi tact de ceas fizic global. Primul bloc reprezint
faptul c la fiecare tact nou de ceas global, ceasul pe nodul respectiv se incrementeaz i el cu o
valoare. Valoarea cu care se incrementeaz ceasul de pe fiecare proces este reinut n vectorul sir[inc].
O alt diferen ntre aceast schem i schema de la metoda Scalar este urmtoarea. Doar cazurile n
care se trimite mesaj de la un proces la altul sunt luate n calcul. n cazul n care avem eveniment intern,
nu se mai increnteaz ceasul, deoarece acesta s-a incrementat deja la nceputul trecerii pe o linie nou
n matricea de evenimente. Deci evenimentele interne pot fi folosite doar ca mijloace pentru ca ceasul
pe un anumit proces s fie afiat.
n cazul n care nu se folosete vreo metod de sincronizare, lucrurile stau mult mai simplu ca
implementare.
for (i = 1; i <= Ciorna6.getNoEvents(); i++) {
for (j = 0; j < Ciorna6.getNoThreads(); j++) {
matrixTime1[i][j] = matrixTime1[i - 1][j] + step1[j];
}
}
}

Se observ ca orice eveniment este complet neglijat, fie el eveniment intern sau mesaj, ci doar la fiecare
tact logic global se incrementeaz ceasul de pe fiecare nod. Valoarea cu care se incrementeaz nodul i
este stocat n variabila step1[i] din vectorul step[].
3.3.7. Algoritmul Birman Schiper Stephenson (BSS)
O alt aplicaie a ceasurilor logice este algoritmul Birman - Schiper Stephenson. Acest algoritm poate
fi folosit n sisteme distribuite pentru a ordona mesaje de tip difuzare care vin n alt ordine dect cea n
care au fost trimise.
Structura programului care implementeaz algoritmul este asemntoare cu cea de la simularea metodei
scalare, vectoriale, matriciale. Totui principala diferen este aceea c utilizatorul poate regla
ntrzierea cu care ajunge mesajul de la surs la destinaie. n cazul seciunii de simulare a metodelor de
sinronizare, acolo mesajele aveau implicit ntrziere 0, adic ajungeau la nodul destinaie pe parcursul
aceleiai perioad de ceas global. n cazul simulrii algoritmului BSS, un mesaj poate pleca de la nodul
surs la ceasul global x, i poate ajunge la nodul destinaie la ceasul gobal x + delta , unde delta este
ntrzierea.
Blocul BSS Date din diagrama FSM de la nceputul capitolului, are rolul de a transforma datele de
intrare introduse de ctre utilizator n nite date care pot fi procesate de ctre simulator. Pe lng
obinuita matrice a evenimentelor mEv, se vor mai folosi i nite matrici suplimentare. mDist va stoca
ntrzierea cu care va fi recepionat orice mesaj care este introdus n mEv. Apoi, pe baza lui mEv i a lui
mDist, se va completa i mRec. mRec are pe linia i i coloana j o valoare nenul numai dac la nodul j,
la momentul de timp global i, este recepionat un mesaj. Iar dac nu este recepionat niciun mesaj (fie
nu a fost trimis, sau dac a fost trimis n aceeai perioad de ceas global, el este ntrziat pe reea i va
ajunge n urmtoarele perioade de ceas global) atunci valoarea matricei este 0.
n urmtoarele pargrafe vom lua un exemplu numeric ca s nelegem mai uor cum se completeaz de
ctre programul simulator, matricile auxiliare.
S considerm c avem exemplul de mai jos. S presupunem c mesajul M1 are ntrziere de 0, mesajul
M2 are ntrziere de 3, iar mesajul M3 are ntrziere de 1.

34

Fig 3.26 Exemplu de mesaje ntrziate

Avnd n vedere cele spuse mai sus, coninutul lui mDist va fi:
0
0

3
0

1
0

0
0

0
0

n exemplul de mai sus avem mesaje doar ctre al doilea nod al sistemului distribuit. tiind nodul surs,
tiind momentul de timp la care mesajele sunt trimise, i tiind ntrzierea fiecrui mesaj, se poate
determina matricea mRec. Coninutul lui mRec pentru exemplul de mai sus este:
0
1

0
0

0
0

0
3

0
2

Dac analizm puin Fig3.26 i coninutul matricii mRec, putem vedea c indicele i al liniei care
conine valoarea nenul va fi nodul de recepie de pe grafic, iar indicele coloanei j care conine valoarea
nenul este momentul de timp global la care ajunge mesajul la nodul destinaie. De exemplu, la i = 2, j
= 4 avem 1 n matricea mRec, i vedem i pe diagram ca nodul P2 recepioneaz la tactul global 4,
mesajul M3. Deci simulatorul, bazndu-se doar pe coninutul matricei mRec, tie unde s afieze
recepionarea mesajelor.
Pentru algoritmul BSS trebuie s se compare valoarea cesurilor vectoriale de la nodul surs cu valoarea
tampilei de timp a mesajului. Pentru a reine tampilele de timp ale fiecrui mesaj care este transmis,
se folosete un alt ir auxiliar, sirTs[].
irTs[] conine valoarea tampilei de timp a mesajului, alturi de momentul de timp global la care a
fost trimis, i nodul surs al mesajului. Pentru exemplul de mai sus, sirTs[] va avea valorile:
1
0
tampila M1

1
i

0
j

2
0
tampila M2

2
i

35

0
j

3
0
tampila M3

3
i

0
j

i=0

Spre blocul urmtor

Da

i++

i > nLin

Nu
j=0
j++
j > nCol

Da

Nu
Citete din MatrixEventInBSS.txt

Fig 3.27 Detalierea

blocului de calcul al
matricilor auxiliare

Completeaz mEv
Completeaz mDist

n diagrama de mai sus este detaliat blocul de calcul al matricilor auxiliare. Matricile auxiliare sunt:
mEv, mDist, mRec, mBr. O parte sunt calculate aici, cealalt parte sunt folosite la blocul de calcul al
timpului i la blocul de afiare.
Blocul Completeaz mEv citete valoarea din fiierul text i n funcie de i i j, o stocheaz la
mEv[i][j]
Blocul Completeaz mDist citete ntrzierile setate de utilizator asociate fierui mesaj i le
stocheaz la mDist[i][j]. ntrzierea de la indicii i i j va fi asociat cu mesajul de la mEv[i][j].

36

i=0

i > nEv

Fig 3.28 Detalierea

blocului de calcul al
matricei de timp

Da
Spre blocul afiare date

Nu
i++

j=0

Da

j > nNod

Nu
Nu

Nu

coad nevid

Da

Nu

Nu

mRecTr >
0
Da

Da

Condiie BSS 1

Condiie BSS 1

Condiie BSS 2

Condiie BSS 2

C BSS1 i
C BSS 2
true

mEvTr =
mesaj

indexRec ++

mRecTr[i+dist][j]=indexRec

Regula 1 Lamport

Da

indexTs ++

R1 Lamport
Scrie n mBrTr

Completeaz
sirTs[indexTs]
Regula 2 Lamport

Da

C BSS1 i C
BSS 2 true

Scrie n mBrTr

Nu

Pune mesaj n coad

37

j++

n figura de mai sus este reprezentat schema detaliat a blocului de calcul al matricei de timp. Este de
notat faptul c se lucreaz cu toate matricile transpuse. Deci numrul de linii va fi egal cu numrul de
evenimente pentru un nod, iar numrul de coloane va fi egal cu numrul de noduri din sistemul
distribuit.
Dup ce blocul anterior a completat matricea mEv cu evenimente i matricea auxiliar mDist, acum se
parcurge matricea mEvTr care este transpusa matricei mEv. Dac evenimentul la care a ajuns
parcurgerea este un mesaj, atunci se completeaz matricea de recepie mRecTr. n funcie de ntrzierea
care este stocat n matricea mDistTr, se stabilesc indicii i i j la care se completeaz matricea mRecTr.
indexRec ++ ;
mRecTr[(i-1) + mDistTr[i-1][j]][auxInt1-1] = indexRec;

Apoi blocul Regula 1 Lamport aplic prima regula de sincronizare a ceasurilor vectoriale pentru
nodul surs al mesajului
matrixTimeV[j][i][j] = matrixTimeV[j][i - 1][j] + 1; //R1

Apoi, att ceasul vectorial ct i indicii i i j cureni se stocheaz n irul sirTs pentru a se ine minte
tampila de timp pentru fiecare mesaj.
for(int kk = 0; kk<Ciorna7.getNoThreads(); kk++){
sirTs[ indexMesaj*(Ciorna7.getNoThreads()+2) + kk] =
matrixTimeV[kk][i][j];
}

sirTs[indexMesaj*(Ciorna7.getNoThreads()+2)+Ciorna7.getNoThreads()]=i;
sirTs[indexMesaj*(Ciorna7.getNoThreads()+2)+Ciorna7.getNoThreads()+1]=j;
indexMesaj++;

Dac evenimentul curent de la mEvTr[i][j] nu este mesaj, atunci se face verificarea dac mRec[i][j] >
0. Am vzut mai sus, c dac mRec[i][j] are o valoare nenul, atunci nseamn c la nodul j, la
momentul de ceas global i, avem evenimentul de recpie al unui mesaj. Dac avem recepia unui mesaj,
se verific cele dou condiii ale algoritmului BSS pentru a vedea dac mesajul primit poate fi difuzat
ctre celelalte noduri sau nu. Cele dou condiii ale algoritmului sunt enunate la partea teoretic.
Implementarea primei condiii este n urmtoarele linii de cod:
if(mTimeV[jBun][i-1][thdDest] == sirTs[(mRecTr[i-1][j]1)*(Ciorna7.getNoThreads()+2)+jBun]-1 )
BUN1 =1;

Implementarea celei de-a doua condiii a algoritmului BSS este n liniile de mai jos
for(int k=0; k<Ciorna7.getNoThreads();k++){
if (k==jBun)
{}
else{
if(matrixTimeV[k][i-1][thdDest]>=sirTs[(mRecTr[i-1][j]1)*(Ciorna7.getNoThreads()+2)+k])
BUN2=1;
else
BUN2=0;
}
}

Dac ambele condiii sunt ndeplinite, atunci se execut i a doua regul Lamport i se difuzeaz
mesajul.
Mai jos avei scris codul care execut a doua regul Lamport asupra ceasului vectorial al nodului
destinaie
38

if(BUN1==1 && BUN2==1){

mBroadTr[i-1][j]=1;
for(int kk=0; kk<Ciorna7.getNoThreads();kk++) {
matrixTimeV[kk][i][j] = Math.max(matrixTimeV[kk][i][j],
sirTs[(mRecTr[i-1][j]-1)*(Ciorna7.getNoThreads()+2)+kk]);
}
matrixTimeV[j][i][j]++;
}

Dac nu se ndeplinete cel puin una dintre cele dou condiii de mai sus, atunci mesajul nu este
difuzat, ci este stocat ntr-o coad de ateptare.
Dac pe parcursul parcurgerii matricei mEvTr, la indicii i i j nu avem nici mesaj n mEvTr, i nici nu
avem eveniment de recepie de mesaj la indcii i i j ai matricei mRecTr, atunci se verific i dac vreun
mesaj din coada de ateptare de care am vorbit mai sus poate fi difuzat acum ctre celelalte noduri. Am
spus mai sus c dac la recepia unui mesaj cel puin una dintre cele dou condiii ale algoritmului BSS
nu este ndeplinit, atunci mesajul este pus ntr-o coad. Dac ntr-o anumit perioad de ceas global
viitoare nodul destinaie nu mai primete niciun mesaj, atunci el poate verifica pe rnd mesajele din
coad dac pot fi trimise acum ctre celelalte noduri. Pentru aceasta, se fac exact aceleai verificri de
la algoritmul BSS; doar c acum se vof verifica aceleai valori ale ceasului vectorial din tampila de
timp cu valorile actuale ale nodului destinaie. Dac ambele condiii sunt ndeplinite, atunci se
difuzeaz mesajul ctre celelalte noduri, dac nu, atunci se trece la urmtorul moment de timp logic i.

39

3. Ghid de utilizare a aplicaiei

n acest capitol se va ilustra modul de utilizare al aplicaiei. Se va explica ce face fiecare buton
din interfaa grafic a programului i se va explica i cum s se analizeze informaia care este afiat pe
ecran de ctre program.
4.1. Seciunea de simulare a metodelor de sincronizare
n figura de mai joa avei reprezentat fereastra cu meniul principal al simulatorului.

Fig 4.1 Fereastra principal a programului

Cu ajutorul butoanelor de tip Radio Button utilizatorul poate s aleag metoda dorit, numrul de
coloane i de linii pentru matricea Evenimentelor de intrare.

40

Dup ce a selectat numrul de coloane i de linii, utilizatorul poate s introduc manual matricea de
intrare n program completnd campul de mai jos:

Fig 4.3 Unde se poate completa manual matricea de intrare

Am definit trei tipuri de evenimente care se pot petrece la un nod:

Eveniment intern notat cu i n matricea datelor de intrare
Eveniment neutru notat cu n n matricea datelor de intrare
Mesaj ctre un alt nod al sistemului distribuit notat cu o cifr care reprezint nodul
destinaie pentru mesaj

Fig 4.4 Tipurile de evenimente i notaiile lor n simulator

n figura de mai jos este reprezentat un exemplu de matrice cu succesiunea de evenimente pentru 5
noduri timp de 5 perioade de ceas.

Fig 4.5 Cum se completeaz matricea de intrare

Mai jos este reprezentat afiarea rezultatelor pentru matricea de intrare din figura de mai sus:
Pentru a se afia rezultatele, utilizatorul, trebuie mai nti s completeze:
1. Metoda folosit
41

2. Numrul de noduri i de tacte de ceas simulate

3. Matricea cu succesiunea de evenimente
4. Dup ce a completat toate elementele de mai sus se apas butonul finish

Fig 4.6 Exemplu de cum se reprezint evenimentele

Se observ pentru nodul P1, care e primul nod, c succesiunea evenimentelor afiate respect datele de
intrare din matrice: Primul eveniment este un mesaj ctre nodul 3, apoi al doilea eveniment este un
mesaj ctre nodul 5, al treilea mesaj este un eveniment intern, al patrulea i al cincilea mesaj sunt
ambele evenimente neutre.
De asemenea, se poate observa i faptul c la afiarea grafic a evenimentelor si a valorii
ceasului logic ataat, se folosesc culori diferite n funcie de tipul de eveniment. Pentru evenimentele
interne se folosete culoarea albastr, iar pentru evenimentele de tip mesaj se folosete culoare roie.

Fig 4.7 Culori cu care sunt afiate evenimente interne i mesaje

Un alt amnunt important este i acela c rezultatele simulrii cu ceasurile pentru fiecare proces
sunt afiate secvenial, adic se afieaz cte o perioad de ceas la fiecare click. Perioadele de ceas sunt
delimitate de linii verzi dup cum se vede n figura de mai jos. Din cauz ca am folosit matrici pentru
simularea nodurilor din sistemul distribuit, de aceea evenimentele simulate vor avea un caracter
sincron. Practic, mesajele care pornesc de la noduri diferite, dar care sunt poziionate pe aceeai
42

coloan n matricea evenimentelor de intrare, acele mesaje vor pleca n acelai timp. De aceea, am
desenat cu verde nite linii care delimiteaz evenimentele care se petrec ntr-o anumit coloan din
matricea evenimentelor. De asemenea, am afiat pe ecran tot cu verde un contor care arat a cta
coloan din matricea evenimentelor este desenat.

Fig 4.8 Delimitri ale tactelor logice

Din cauza faptului c programul afieaz rezultatele ntr-un mod sincron, exist unele limitri cu
privire la datele de intrare. Nu orice combinaie de evenimente pentru un anumit nod va da rezultate
afiate corect de program. S lum urmtorul exemplu. Matricea cu secvena evenimentelor este cea de
mai jos, iar rezultatele afiate sunt sub matrice.

3ni
n3n
inn

43

Fig 4.9 Limitri ale programului

Se observ faptul c n acelai timp, adic la nceptului simulrii, n primul tact de ceas, nodul 1
i trimite mesaj nodului 3, iar nodul 3 are eveniment intern. Din cauza mecanismului de afiare, n
primul tact de ceas se afieaz doar o singur valoare de ceas. Aa c n primul tact de ceas, pentru
nodul 3, se afieaz doar ceasul rezultat n urma evenimentului intern, nu i ceasul rezultat n urma
mesajului recepionat de la nodul 1. Aceast limitare apare de fiecare dat cnd se ntmpl ca, pentru
acelai nod, ntr-un singur interval de ceas, s se ntmple dou evenimente simultane.
Exist cazuri n care matricea cu secvena de evenimente poate avea dimensiuni foarte mari.
Dac ar trebui ca utilizatorul s completeze manual matricea, ar fi o sarcin foarte grea. n plus, riscul
de a pica n limitarea pe care am prezentat-o mai sus crete n cazul n care avem multe noduri n
sistemul distribuit. De aceea, s-a implementat un buton numit Random. Dup ce utilizatorul
selecteaz metoda (scalar, vectorial, matricial) i dup ce se alege i numrul de noduri i de ceasuri
logice, utilizatorul poate selecta butonul Random. n acel moment, se genereaz automat matricea cu
secvena de evenimente. De asemnea, se pun nite validri astfel nct s nu existe cazuri n care pentru
acelai nod s existe dou evenimente simultane n aceeai perioad de ceas.
4.2. Seciunea de ncrcare a reelei pentru cele trei metode
A doua parte a programului de simulare o constituie partea n care se face analiza performanei.
Dup cum se poate vedea, cele trei metode de sincronizare a ceasurilor logice difer ntre ele prin
dimensiunea tampilelor de timp. Pentru fiecare mesaj trimis, este necesar ca nodul care trimite mesajul
s ataeze tampila de timp ca un header al pachetului trimis. Asta nseamn c metodele de
sincronizare a ceasurilor logice introduc o ncrcare suplimentar a reelei. Prin programul de simulare
se realizeaz un studiu al ncrcrii reelei introduse de algoritmii Lamport.
Se consider urmtoarele ipoteze: fiecare nod, cnd trebuie s trimit un mesaj, ataeaz la
sfrit tampila de timp. Dac se folosete metoda scalar, se ataeaz un scalar, dac se folosete
metoda vectorial se ataeaz un vector de dimensiune n iar dac se folosete metoda matricial se
ataeaz o matrice.
Pentru a face analiza se folosete funcionalitatea de generare aleatare a matricei de intrare.
Pentru analiza performanei se face urmtorul lucru: Se folosete butonul de Random pe care
l-am explicat mai sus. Se genereaz automat o matrice cu 1000 de evenimente. Pe aceast matrice se
numr cte mesaje exist de la un nod la altul i n funcie de metoda de sincronizare folosit se ofer
o statistic privitoare la ncrcarea reelei.
Se consider urmtoarele ipoteze:
44

Nu se ia n considerare cantitatea de informaie din mesaj, ci doar ncrcarea produs de faptul

c la mesaj se adaug tampila de timp cu valoarea ceasului.
Se consider c fiecare numr din structura de date care reprezint valoarea ceasului logic
ataat unui mesaj se reprezint pe 1 Octet. De exemplu, tampila de timp de ceas scalar 1 se
reprezint pe 1 Octet. tampila de timp de ceas vectorial [1,2] se reprezint pe 2 Octei, etc.
Pentru a accesa partea cu analiza performanei, se apasa butonul din tabul de sus al ferestrei
meniului principal:

Fig 4.10 Accesarea tabului de performan

Fig 4.11 Meniul seciunii de analiza performanelor pentru programul simulator dup ce utilizatorul a apsat
butonul de Generare Rezultate

Se observ c la nceput doar butonul de Generare Rezultate este activ, restul butoanelor fiind
inactive. Dup ce utilizatorul apas pe butonul de Generare Rezultate, n directorul n care este instalat
programul vor aprea mai multe fiiere text cu numele PerfOverhead_< nLin>Threads.txt, unde nLin
= 3,8 .
Coninutul unui astfel de fiier este afiat n figura de mai jos

Fig 4.12 Coninutul uni fiier PerfOverhead_< nLin>Threads.txt , nLin=5

Pe prima linie este scris ncrcarea n fiecare period de ceas cnd se folosete metoda Scalar, pe a
doua linie este scris ncrcarea n fiecare perioad de ceas cnd se folosete metoda Vectorial, iar pe a
treia linie este scris ncrcarea n fiecare perioad de ceas cnd metoda folosit este Metoda
Matricial.
De asemenea, folosind datele de mai sus, se vor scrie i nite fiiere text cu numele
PerfOverheadAve_< nLin>Threads.txt. n aceste fiiere se calculeaz la fiecare tact de ceas evoluia
mediei eantioanelor trecute pentru ncrcare dup formula
45

(n 1) m n 1 ovh[n]
n
(4.1)
unde mn reprezint media calculat la momentul de timp n, iar ovh[n] este valoarea ncrcrii la
momentul de timp n. Aces fiier este folosit pentru a afia pe acelai grafic i evoluia ncrcrii pentru
fiecare moment de timp, dar i evoluia medie a ncrcrii.
Dup ce utilizatorul apas pe butonul de Generare Rezultate i fiierele text se genereaz, celelalte
butoane de pe pagin se activeaz. Cu ajutorul butoanelor utilizatorul poate selecta ce statistic dorete
s vad.
Dac utilizatorul apas pe butonul ncrcarea medie pentru toate cele trei metode, nr fix de noduri, se
ia numrul de noduri date de utilizator n interfaa grafic, i cu numrul de noduri se aleg doar fiierele
PerfOverhead_< nLin>Threads.txt i PerfOverheadAve_< nLin>Threads.txt care au numrul
selectat din interfaa grafic. Datele din aceste fiiere vor fi afiate pe acelai grafic dup cum se vede
n figura de mai jos:
mn

Fig 4.13 Rezultatul apsrii butonului ncrcarea medie pentru toate cele trei metode, nr fix de noduri

Se vede n figura de mai sus c s-au luat datele din fiierul PerfOverheadAve_ 6Threads.txt de pe
toate liniile i s-au afiat pe ecran.
Dac utilizatorul apas pe butonul Afiare ncrcare pentru o anumit metod, nr fix de noduri, n
funcie de metoda selectat se ia doar o linie din fiierul PerfOverhead_< nLin>Threads.txt i doar o
linie din fiierul PerfOverheadAve_< nLin>Threads.txt.

46

Fig 4.14 Rezultatul apsrii butonului Afiare ncrcare pentru o anumit metod, nr fix de noduri pentru Metoda
Vectorial, 7 noduri

n exemplul de mai sus s-a selectat metoda Vectorial, 7 noduri n sistemul distribuit. n cazul acesta
programul a luat datele de pe a doua linie din fiierul PerfOverhead_7Threads.txt i le-a reprezentat
cu linia roie, i a luat datele de pe a doua linie din fiierul PerfOverheadAVE_7Threads.txt
reprezentndu-le cu linia albastr.
Din graficele afiate se pot trage nite concluzii. ncrcarea reelei este mai mare n cazul metodelor
matriciale i vectoriale dect n cazul metodei scalare. Este un lucru normal deoarece n cazul metodei
scalare, le fiecare mesaj se ataeaz doar un scalar care ncape ntr-un octet. n cazul metodei Vectoriale
la fiecare mesaj se ataeaz un vector cu nLin elemente, unde nLin este numrul de noduri din sistemul
distribuit. Din aceast cauz, ncrcarea pe reea crete, fiecare element al vectorului ocupnd cte un
Octet, deci nLin Octei pentru fiecare mesaj. n sfrit, metoda care cauzeaz cea mai mare ncrcare pe
reea este metoda matricial. n cazul acestei metode, la fiecare mesaj trimis se ataeaz o matrice cu
nLin x nLin elemente. Fiecare element al matricei este reprezentat pe 1 Octet, deci la fiecare mesaj
trimis se produce o ncrcare de nLin2 Octei.
Se poate concluziona c ncrcarea medie pentru cele trei metode se afl ntr-o progresie geometric cu
raia nLin. Cea mai mic este ncrcarea pentru metoda scalar, apoi urmeaz ncrcarea pentru metoda
vectorial de nLin ori mai mare, i cea mai mare fiind ncrcarea pentru metoda matricial care este de
nLin2 ori mai mare dect n cazul metodei scalare. Acest lucru se poate observa din graficul din Fig4.14.
Acolo avem un caz particular n care avem 6 noduri n sistem. ncrcarea medie datorat metodei
scalare este de 2.5 Octeti / perioad de ceas, ncrcarea medie pentru metoda Vectorial este de 12.5
Octei / perioad de ceas, deci de aproximativ 6 ori mai mult. n sfrit, ncrcarea n cazul metodei
matriciale este de 62 Octeti / perioad de ceas, adic de aproximativ 36 ori mai mult dect n cazul
metodei scalare.

47

4.3. Seciunea de Comparaie cu situaia n care avem doar ceasuri fizice desincronizate
n urmtoarea seciune vom ncerca s demonstm utilitatea metodelor de sincronizare Lamport
folosind un exemplu realizat cu ajutorul simulatorului descris anterior. Pentru aceasta, am realizat un
scenariu n care exist o desincronizarea a ceasurilor pe nodurile din sistemul distribuit. Ceasurile din
exemplu pot fi considerate chiar ceasuri fizice.

Fig 4.15 Exemplu n care cresc ceasurile fizice

Mai sus avem ilustrat o figur n care avem trei noduri. La fiecare tact de ceas global, fiecare nod i
incrementeaz ceasul cu o valoare. Este de menionat faptul c ceasul reprezentat n figur poate fi
considerat chiar ca un ceas fizic. Al doilea i al treilea proces, la fiecare tact de ceas global, i
incrementeaz ceasul cu cte 100 de uniti. Aceste uniti pot fi considerate ca reprezentnd nanosecunde, milisecunde, sau orice alt unitate de msur pentru timp. Se observ faptul c primul nod are
ceasul desincronizat fa de celelalte noduri. Ceasul nodului 1 progreseaz mai ncet fa de celelalte. n
timp ce celalte noduri i incrementeaz ceasul cu cte 100 de uniti la fiecare tact global, nodul 1 are
ceasul mai ncet i i incrementeaz ceasul doar cu 50 de uniti.

Fig 4.16 Ceasuri desincronizate mesaj de la ceas ncet la ceas mai rapid

n cazul reprezentat n figura de mai sus, avem mesaje doar de la noduri cu ceas ncet ctre noduri cu
ceas mai rapid. Acest caz este unul fericit deoarece nu are un impact negativ asupra algoritmului
distribuit care ruleaz pe fiecare nod. Singurul element negativ este acela c mesajul pare s fi avut o
ntrziere ma mare pe canalul de comunicaie dect n realitate.
48

Fig 4.17 Ceasuri desincronizate, mesaj de la ceas rapid la ceas ncet

n figura de mai sus avei reprezentate i cazuri defavorabile. Unul dintre ele este acela n care se
trimite un mesaj de la un nod cu ceas rapid ctre un nod cu ceas ntrziat. Atunci apare un eveniment
ne-dorit, n care mesajul are tampila de timp la plecare mai mare dect timpul la recepie, i apare ca i
cum mesajul ar fi venit din viitor n trecut. Aceste cazuri sunt mpotriva logicii i sunt foarte duntoare
ntr-un sistem distribuit. Un alt caz nefavorabil este urmtorul. n simulatorul implementat de mine,
nrzierea mesajelor de la un nod la altul este neglijabil n comparaie cu durata unui tact global. n
cazul n care avem mesaj ntre dou noduri care au ceasurile sincronizate, atunci poate aprea cazul n
care mesajul are aceeai tampil de timp i la emisie i la recepie. Acest caz este reprezentat tot n
figura de mai sus, la momentul de timp 4 cnd se trimite un mesaj de ctre nodul 3. Mesajul are
tampila de timp 400, i ajunge la nodul 2, tot cu tamplia de timp 400.
Aplicarea Algoritmului Lamport rezolv ambele probleme descrise n paragraful de mai sus. La fiecare
recepionare de mesaj, nodul de la recepie compar tampila de timp a mesajului cu valoarea ceasului
local. Dac valoarea ceasului local e mai mic dect tampila de timp, atunci nodul de la recepie i
incrementeaz ceasul local la o valoare mai mare dect cea a tampilei de timp.

49

Fig 4.18 Comparaie cu / fara algoritmul Lamport aplicat nodurilor

Meniul pentru completarea aplicaiei este similar cu cel de la Simularea algoritmilor lui Lamport. El e
afiat n figura de mai jos:

50

Fig 4.19 Meniul principal pentru Comparaie Cu / fara Lamport

Dup cum se poate observa, meniul pentru Comparaie Cu / fara Lamport are multe componente
identice cu cele de la tabul de simulare. n partea de sus a feresrei sunt 2 butoane de tip Drop Down
cu care utilizatorul poate selecta numrul de coloane i de linii ale matricei de intrare. Apoi n partea
dreapta centru exist o caset de text n care utilizatorul poate introduce matricea de intrare dup
aceleai reguli dup care s-a fcut i matricea evenimentelor la simularea metodelor scalar, vectorial,
matricial. De asemenea, exist buton de Finish i de Random. Butonul de Random completeaz
matricea evenimentelor de intrare dup acelai algoritm ca cel prezentat la capitolul despre simularea
metodei scalare, vectoriale, matriciale.
Ce apare n plus n meniul pentru Comparaie cu / far Lamport este grupul de butoane Drop Down
din dreapta. Cu ajutorul acestor butoane, utilizatorul poate controla ct de rapid sau de ncet s fie
ceasul pe fiecare din nodurile din sistemul distribuit. n exemplul din figura de mai sus, nodul 1 are
ceasul mai ncet, deoarece la fiecare tact logic global ceasul su se incrementeaz cu 50 de uniti de
timp, pe cnd nodurile doi i trei i incrementeaz ceasurile la ficare tact logic global cu cte 100 de
uniti de timp.
Ce este mai complicat la acest meniu, este faptul c numrul butoanelor Drop Down cu care
utilizatorul schimba perioada ceasului pe fiecare nod depinde de numrul nodurilor din sistemul
distribuit. Dac utilizatorul schimb numrul de noduri, atunci i numrul butoanelor de tip Drop
down se schimb.

4.4. Simularea algoritmului Birman Schiper Stephenson

Ca o aplicaie a metodei vectoriale de sincronizare a ceasurilor logice am gsit un algoritm care se
folosete de ceasurile vectoriale pentru a ordona mesajele de difuzare ntr-un sistem distribuit.
51

Mai jos este reprezentat fereastra cu meniul principal al programului.

Fig 4.20 Meniul simulatorului algoritmului BSS

Dup cum se vede, fereastra este similar celei de la simularea metodelor de sincronizare. Cea mai
mare deosebire este aceea c, pe lng faptul c utilizatorul poate defini mesaje de la un nod la altul, el
poate regla i ntrzierea cu care se simuleaz c va ajunge la nodul destinaie. De aceea, n matricea
mEv din figura de mai sus, utilizatorul va completa n cazul unui eveniment de tip mesaj, dou cifre.
Prima cifr este nodul destinaie, iar a doua cifr este ntrzierea cu care va ajunge mesajul la nodul
destinaie.

20
n

23
n

21
n

n
n

n
n

n
n

n
n

Fig 4.21 Exemplu de date de intrare pentru algoritmul BSS

n
n

Din exemplul de matrice de evenimente de mai sus se nelege c la primul tact global nodul 1 i trimite
mesaj nodului 2 cu ntrziere de 0 tacte. Apoi tot nodul 1 i trimite nodului 2 alt mesaj, de data aceasta
cu o ntrziere de 3 tacte globale. n final, nodul 1 i trimite nodului 2 un mesaj care ajunge la destinaie
cu o ntrziere de 1 tact logic.
Dup ce utilizatorul a completat datele de intrare, se apas butonul Finish i simulatorul va afia
rezultatele simulrii.

52

Fig 4.22 Rezultatele simulrii algoritmului BSS

n figura de mai sus se observ c nodul 1 respect secvena de evenimente dat n matricea de intrare.
De asemenea, se respect i ntrzierile aplicate pentru fiecare mesaj. Pentru a fi mai uor de identifat,
fiecare mesaj din sistmeul distribuit primete cte un nume diferit. n cazul acesta particular avem
mesajele M1, M2, i M3.
Se observ c la nodul destinaie, de fiecare dat cnd ajunge un mesaj, se verific cele dou condiii
ale algoritmului BSS. Reamintim din teorie care sunt paii algoritmului BSS:
1. Fiecare proces Pi menine un ceas vectorial
2. nainte de a difuza un mesaj m ctre toate celelalte noduri, un nod Pi i incrementeaz ceasul
vectorial local vti[i] i ataeaz noul ceas vti[i] ca o tampil de timp a mesajului. Vom nota
tampila de timp a mesajului m cu vtm.
3. Cnd nodul Pj recepioneaz mesajul m, nti verific urmtoarele condiii:
a. vtj[i]=vtm[i]-1, ceea ce nseamn c toate mesaje anterioare trimise de ctre nodul Pi au
fost recepionate de ctre Pj
b. vtj[k] vtm[k], k {1,2,...n} k i, ceea ce nseamn c nodul Pj a recepionat toate
celelalte mesaje care au trecut pe la Pi (dar nu au fost emise de ctre Pi).
4. Dac una dintre cele dou condiii nu e ndeplinit, nodul Pj pune mesajul m ntr-o coad i va
testa tot aceste dou condiii mai trziu
5. Dac ambele condiii sunt ndeplinite, atunci procesul Pj difuzeaz mesajul m ctre toate
celelalte noduri din sistemul distribuit, mai puin Pi.
Cele dou condiii care sunt verificare la fiecare recepionare a unui mesaj sunt notate cu a i b n paii
de mai sus.
Se observ c n cazul mesajului M1, cele dou condiii sunt respectate, deci mesajul M1 este difuzat de
ctre nodul 2 imediat dup recepionarea mesajului.
n cazul mesajului M3, se observ c el este transmis de nodul 1 dup transmiterea mesajului M2, dar
din cauza canalului de comunicaie, mesajul M2 ajunge mai trziu la destinaie dect mesajul M3. Cnd
nodul 2 recepioneaz mesajul M3, el verific dac se ndeplinesc condiiile algoritmului BSS. Se poate
observa dac se fac nlocuirile n formul c nu se ndeplinete prima condiie a algoritmului BSS i de
aceea mesajul M3 este trecut n coada nodului 2.
Se observ c la urmtorul tact global (tactul 5) c ajunge la destinaie i mesajul M2. Nodul 2 verific
i n cazul acesta cele dou condiii ale algoritmului BSS. n cazul mesajului M2, cele dou condiii
sunt respectate i de aceea mesajul M2 este difuzat.
n urmtorul tact global (tactul 6), nodul 2 nu mai recepioneaz niciun mesaj i de aceea ncearc dac
poate treimite vreun mesaj din coada local de ateptare. De aceea iar testeaz cele dou condiii n
cazul mesajului M2. Dac se fac nlocuirile se vede c de data aceasta sunt ndeplinite condiiile
algoritmului BSS i mesajul M2 este scos din coad i difuzat.
53

4.5. Limitri ale simulatorului algoritmului Birman Schiper Stephenson

Din pcate implementarea algoritmului BSS a fost mai delicat din cauza numrului mare de matrici
auxiliare i de aceea a fost nevoie de aplicarea unor limitri. Nu se poate simula chiar orice combinaie
de mesaje i de ntrzieri a mesajelor.
Cea mai important limitare este aceea c se pot simula doar dou noduri. Nodul 1 va fi ntotdeauna
nodul care trimite mesaje, iar nodul 2 va fi permanent nodul care recepioneaz mesaje. Utilizatorul nu
poate trimite mesaje de la nodul 2 la nodul 1, ci doar de la nodul 1 la nodul 2.
O alt limitare important a simulatorului e similar cu cea de la simularea metodelor scalar,
vectorial, matricial. Datele nu sunt valide dac se ntmpl mai mult de dou evenimente n aceeai
perioad de ceas global la acelai nod. S considerm exemplul de mai jos care are matricea de intrare

23
n

n
n

21
n

n
n

Fig 4.23 Limitare a simulatorului pentru algoritmul BSS

Se observ c la tactul 4, se ntmpl dou evenimente diferite la acelai nod, nodul P2. Simulatorul
detecteaz acest lucru i afieaz mesajul de eroare de mai jos. Totui el reprezint grafic evenimentele
pentru ca utilizatorul s vad mai uor unde este limitarea.
4.6. Analiza perfomanei ca timp de calcul. Comparaie ntre cele trei metode de
sincronizare a ceasurilor logice
Pe lng analiza ncrcrii suplimentare introdus de cele trei metode de sincronizare, este util s
studiem i timpul de calcul pe care l consum fiecare metod de sincronizare n parte. Timpul de calcul
este o mrime demn de luat n seam atunci cnd se proiecteaz un sistem distribuit. Un timp de calcul
mare face ca mainile s raspund greu la cereri, face ca transferul de mesaje pe canalul de comunicaie
s se realizeze greu.
Pentru a msura timpul de procesare, am folosit metoda System.currentTimeMillis(). Aceast
metod returneaz timpul raportat de sistemul de operare, in milisecunde. Pentru a msura timpul de
calcul, am introdus liniile de cod
startTime = System.currentTimeMillis();
endTime = System.currentTimeMillis();
time = endTime-startTime;

54

Linia cu startTime am introdus-o la inceputul seciunii de cod care calculeaz matricea de timp, linia
cu endTime, am introdus-o la finalul seciunii de cod. Facnd diferena dintre cele dou, am obinut
intervalul de timp ct a durat calculul matricei de timp.
Pentru a obine nite rezultate concludente, am facut urmtorii pai. Cu ajutorul metodei descrise la
nceputul capitolului 5 am generat o matrice de evenimente cu valori aleatoare. Am observat c pentru
valori normale ale dimensiunilor matricei, timpul de calcul era sub 1 ms. De aceea, am generat o
matrice de evenimente cu dimensiuni foarte mari, pentru ca s se vad mai bine diferena ntre cele trei
metode de sincronizare. Pentru determinarea timpului de procesare am folosit o matrice de evenimente
cu 8 linii si 5000 de coloane. Am folosit metoda descris la nceputul capitolului 5 pentru a completa
automat matricea.
Apoi am deschis programul, am introdus prima realizare particular a matricei, am calculat matricea de
timp cu metoda scalar i am obinut prima valoare a timpului de procesare. Apoi iar am inchis
programul, l-am deschis din nou, i am mai generat inca o data o matrice cu 8 linii si 5000 de coloane.
Bineneles c aceasta a fost o alt realizare particular a matricei generat aleator. Am rulat simularea
i pentru aceast matrice i am obinut o alt valoare pentru timpul de calcul. n total, am repetat paii
descrii anterior de 10 ori pentru fiecare metod de sincronizare. n final, am obinut urmtoarele
rezultate:
Timpul de calcul

1000
900
800

Metoda Scalara
Metoda Vectoriala
Metoda Matriciala

Durata [ms]

700
600
500
400
300
200
100
0
1

5
6
Matrice de intrare particulara

Fig 4.24 Timpii de calcul

10

Pe axa oX sunt reprezentate cele 10 realizri particulare a matricei de intrare generat aleator. Pe axa
oY este reprezentat timpul, msurat in milisecunde. Se observ c pentru metoda Scalar, durata medie
de execuie a fost de aproximativ 30 ms, pentru metoda Vectorial, de aproximativ 300 ms, iar pentru
metoda Matricial timpul de procesare a fost cel mai mare, ajungnd la valoarea de 900 ms. Aceste
msurtori confirm estimarea c, la fel ca n cazul ncrcrii pe reea, timpul de procesare este mai
mare n cazul metodelor matricial i vectorial dect n cazul metodei scalare.

55