Sunteți pe pagina 1din 12

Cauzalitate i timp

n sistemele distribuite asincrone nu se dispune de o modalitate de msurare a timpului real. Pentru a cunoate ordinea relativ n care au loc evenimentele se studiaz relaiile de cauzalitate dintre ele. Vom considera n continuare sisteme distribuite asincrone de tip MP. Evenimentele vor fi numai de calcul (dac nu se specific altceva). Definiie: Fie o execuie fixat a sistemului i 1, 2 dou evenimente ale sale. Spunem c 1 se ntmpl naintea lui 2 (happens before) i notm 1 2 , dac are loc una din condiiile: 1.1 i 2 sunt evenimente ale aceluiai procesor i 1 apare n naintea lui 2. 2.1 trimite un mesaj m de la procesorul pi la procesorul pj, iar 2 este evenimentul de primire al mesajului m de la pi (2 este primul eveniment de calcul al lui pj care apare n dup livrarea lui m). 3. un eveniment a.. 1 i perechea , 2 satisface condiia 1 sau 2 (cu n locul lui 1). Observatie: este o ordine parial ireflexiv. Definiie: Dac =exec(C, ) este un segment de execuie, un amestec cauzal (causal shuffle) al lui este orice permutare a lui care satisface: -i= 0, n 1 , i=i (i noteaz subirul lui care se refer doar la procesorul pi). -Dac un mesaj m este trimis n n evenimentul al lui pi, atunci n precede livrarea lui m. Lema 1: Fie =exec(C, ). Orice ordonare total a evenimentelor lui care e consistent cu relaia este un amestec cauzal al lui . Lema 2: Fie = exec(C, ). Fie un amestec cauzal al lui . Atunci =exec(C, ) este un segment de execuie similar lui . Pentru a observa relaia dintr-o execuie, procesoarele pot aduga un tag numit logical timestamp pentru fiecare eveniment (de calcul). Aceast asociere trebuie s fie a.. 1 2 LT(1)<LT(2). Un algoritm de construcie a timestamp-urilor este urmtorul: Fiecare procesor pi pstreaz o variabil local ntreag LTi numit ceas logic, iniial 0. Fiecare eveniment de calcul este extins cu o nou operaie care atribuie lui LTi max (valoarea curent a lui LTi, valoarea maxim a unui timestamp primit n acel eveniment)+1. Fiecare mesaj trimis ntr-un eveniment, este tampilat cu valoarea nou a lui LTi.

Timestampul unui eveniment este valoarea lui LTi calculat n timpul acelui eveniment. Relaia de ordine ntre timestampuri este relaia de ordine din N. Teorema 1: Fie o execuie i 1, 2 dou evenimente din . Dac 1 2 atunci LT(1)<LT(2). Observatie: Dac LT(1)LT(2) ( 1 2). Este ns posibil ca LT(1)<LT(2) i totui (1 2). Necauzalitatea nu-i surprins deoarece N este total ordonat, iar este o ordine parial. Vom folosi vectori cu componente ntregi pentru a surprinde necauzalitatea. Definiie: : Spunem c 1 i 2 sunt concurente (1 2 ) n , dac ( 1 2) ( 2 1). Din lemele 1 i 2 rezult c dac 1 2 atunci exist 1 i 2 similare cu a.. 1 1 2 i 2 2 1. Considerm urmtorul algoritm: fiecare procesor pi pstreaz un tablou n-dimensional VCi (ceasul vectorial), cu componente ntregi, iniial 0. fiecare eveniment de calcul este extins cu urmtoarele operaii: VCi [i]:= VCi [i]+1 ji VCi [j]:=max(VCi [j], cea mai mare component j a timestampurilor primite n acest eveniment) mesaj trimis este tampilat cu noua valoare a lui VCi. Observatie: 10.VCj(i) este o estimare a lui VCi[i] inut de pj (numrul de pai executat de pi pn n acest moment). 20.Pentru pj, n orice configuraie accesibil VCj[i]VCi[i] i (ntruct numai pi mrete valoarea lui VCi[i]). Pe mulimea vectorilor definim relaia de ordine parial v1v2 i= 1, n v1[i]v2[i]. v1<v2v1v2, v1v2. Urmrind definiia relaiei i modul de construcie a ceasurilor vectoriale rezult: Teorema 2: Fie o execuie i 1, 2 evenimente ale lui . 1 2 VC(1)<VC(2). Observatie: Rezult c 12VC(1) i VC(2) sunt incomparabile (timestampurile vectoriale surprind (captureaza) concurena). Defectul major al acestui mecanism este c se mrete enorm complexitatea de comunicare. Din pcate are loc: Teorema 3: Dac VC este o funcie care asociaz fiecrui eveniment al unei execuii oarecare un vector din Rk a.. concurena s fie capturat, atunci kn. Dem.: Considerm un sistem distribuit cu topologia un graf complet i execuie n care fiecare procesor pi trimite secvenial mesaje la toate celelalte, cu excepia lui pi-1 n ordinea: pi+1, pi+2,, pn-1, p0,, pi-2. Dup ce toate mesajele au fost primite, fiecare pi primete secvenial mesajele transmise lui n ordine descresctoare a indicelui transmitorului, ncepnd cu pi-1: pi-1, pi-2, , p0,pn-1, , pi+2 (pi nu primete mesaj de la pi+1). Pentru fiecare procesor pi notm cu ai primul eveniment de trimitere i cu bi ultimul eveniment de primire. Cum n un procesor trimite toate mesajele sale nainte de a primi unul rezult c relaia de cauzalitate este simpl i nu include relaii derivate de tranzitivitate. Cum nu mesaj de la pi+1 la pi i lipsa tranzitivitii n patternul de trimitere descris de , obtinem (*)i 0 i n-1, ai+1bi. Pe de alt parte, pjpi, primul eveniment de trimitere al lui pi+1 influeneaz cauzal un anumit mesaj de primire al lui pj. Rezult (**)i,j 0ijn-1 ai+1bj.

(Pentru j=i+1, ai+1 i bj=bi+1 apar la acelai procesor, deci ai+1 bj. Pentru ji+1, cum ji, pi+1 trimite un mesaj lui pj n execuie; ai+1 este sau acest eveniment sau se ntmpl naintea trimiterii mesajului de la pi+1 lui pj. Primirea de la pi+1 este sau egal cu bj sau se ntmpl naintea lui bj.) Fixm i 0in-1. Din (*) ai+1bi. Cum VC captureaz concurena rezult c VC(ai+1) i VC(bi) sunt incomparabile. Deci, o component r a.. VC[r](bi)<VC[r](ai+1). Notm acest indice cu l(i). Am definit o funcie l:{0, , n-1}{0, , k-1}. Dac artm c l este injectiv teorema este demonstrat. Presupunem c i,j: l(i)=l(j)=r. Din definiia funciei l, rezult VC[r](bi)<VC[r](ai+1) i VC[r](bj)<VC[r](aj+1). Conform (**),rezult ai+1 bj, deci VC(ai+1)VC(bj). Am obtinut VC[r](bi)<VC[r](ai+1) VC[r](bj)<VC[r](aj+1) care contrazice (**) pentru j=i i i=j+1! Definiia relaiei pentru sisteme cu memorie partajat: Fie o execuie ntr-un sistem distribuit cu memoria partajat. Atunci 1 2 dac: 1.1 i 2 au aceeai valoare (se refer la acelai procesor pi) i 1 apare n naintea lui 2. 2. 1 i 2 sunt elemente conflictuale: acceseaz amndou aceeai variabil partajat, unul dintre ele este un write i 1 apare naintea lui 2 n . 3. un eveniment a.. 1 i perechea , 2 satisface condiia 1 sau 2 (cu n locul lui 1 ). Mai departe totul se poate adapta ca si in cazul sistemelor de tip MP. Tieturi ntr-un sistem distribuit nu exist un observator care s nregistreze un instantaneu al strii sistemului. Aceasta ar fi necesar pentru rezolvarea unor probleme ca: restaurarea sistemului dup o cdere, determinarea existenei unui deadlock sau detectarea terminrii. Se poate obine un instantaneu aproximativ prin cooperarea procesoarelor. Pentru simplificarea expunerii vom presupune c fiecare eveniment de calcul primete cel mult un mesaj (se poate implementa o coad local a mesajelor sosite i procesnd un singur mesaj la fiecare pas). Fie o execuie fixat. Pentru fiecare procesor se pot numra evenimentele de calcul. O tietur a execuiei este un vector k=(k0, , kn-1) de ntregi pozitivi. Pentru fiecare tietur se poate construi o mulime de stri ale procesoarelor: starea procesorului p i este starea sa din imediat dup evenimentul de calcul numrul ki din pi. Tietura k a lui este consistent dac pentru i,j evenimentul de calcul numrul ki+1 al lui pi n nu se ntmpl naintea evenimentului kj al procesorului pj din (evenimentul numrul kj din al procesorului pj nu depinde de nici o aciune luat de alt procesor dup tietur). Vom presupune c fiecare canal livreaz mesajele ntr-o ordine FIFO. Determinarea unei tieturi consistente maximale Pentru tietur k i execuie , o tietur consistent k1<k. O tietur consistent maximal ce precede k este o tietur consistent k1<k a.. k tietur k1<k<k, k nu este consistent. Se poate demonstra c tietura consistent maximal ce precede k este unic. Presupunem c avem un algoritm A ce se execut pe un sistem distribuit asincron de tip MP. La un moment dat procesor primete o aceeai tietur k. Fiecare procesor trebuie s calculeze componenta sa din tietura maximal ce precede k. (Nu discutm modul n care se primete tietura; problema este real i apare n restaurarea unui sistem distribuit dup o cdere). Pentru realizarea acestui task procesoarele pot memora extra-informaie, pot tampila mesajele lui A cu extra-informaii i pot trimite mesaje adiionale. Descriem o metod ce necesit suplimentarea mesajelor lui A cu O(n) informaii. Ideea e foarte simpl: fiecare mesaj al lui A este tampilat cu VC. Pentru aceasta: -fiecare procesor pi are un tablou (nemrginit) storei a..storei[l] pstreaz ceasul vectorial VC asociat evenimentelor de calcul numrul l al lui p i. -atunci cnd pi primete intrarea k, ncepe s parcurg napoi storei, ncepnd cu storei[ki] pn gsete primul indice l, cu proprietatea c storei[l]<k. -rspunsul calculat de pi este l. Determinarea unui instantaneu distribuit n timp ce procesoarele execut un algoritm A, fiecare procesor dintr-o anumit mulime S primete indicaia c procesoarele trebuie s nceap calculul unei tieturi consistente care include starea cel puin a unui procesor din S la momentul n care a primit indicaia de start. (O astfel de tietur se numete instantaneu distribuit). Prezentm un algoritm pentru rezolvarea acestei probleme prin trimiterea unor mesaje adiionale numite markere. Cum problema este obinerea unui instantaneu pentru execuia algoritmului A, primirea mesajelor marker nu trebuie s influeneze calculul tieturii. fiecare procesor pi are o variabil local ansi, iniial nedefinit care la sfrit pstreaz rspunsul (intrarea lui pi n tietura consistent dorit). la primirea unui mesaj marker de la un vecin, sau la primirea indicaiei s nceap algoritmul, pi execut : dac ansi nu a fost deja setat atunci atribuie lui ansi numrul mesajelor primite de la algoritmul A pn n acel moment i trimite un mesaj marker tuturor vecinilor (inundare). Algoritm de determinare a unui instantaneu distribuit (codul pentru procesorul pi): Iniial, ans= i num=0. La primirea unui mesaj al algoritmului A: 1: num:=num+1 2: execut aciunile algoritmului A La primirea unui mesaj marker sau a indicaiei s ia un instantaneu: 3: if ans= then 4: ans:=num 5: send marker tuturor vecinilor. Teorem: Algoritmul de mai sus calculeaz un instantaneu distribuit folosind O(m) mesaje adiionale. Dem.: Fie k rspunsul calculat de algoritm. Fie pf primul procesor care primete o indicaie de start. Clar, kf va avea valoarea lui numf din momentul primirii indicaiei de start. Presupunem c pi i pj a.. evenimentul de calcul kj al lui pj (n algoritmul A) depinde de evenimentul ki+1 al lui pi (n algoritmul A).

Exist un ir de mesaje ale algoritmului A de la pi la pj: m1, m2, , ml a.. m1 e trimis de pi lui pi2 dup tietura din pi, m2 este trimis de pi2 lui pi3 dup primirea lui m1 .a.m.d. iar ml este trimis de pil lui pj dup primirea lui ml-1 i primit de pj nainte de tietura din pj. Exist deci un mesaj mh care e trimis de pih dup tietur i primit de pih+1 naintea tieturii. Dar cum pih este trimis dup tietur pih a trimis deja mesajul marker lui pih+1 naintea trimiterii lui mh. Cum canalele sunt organizate FIFO i mesajul marker este primit de pih+1 naintea lui mh i deci mh n-a fost primit naintea tieturii. Observatie: Cei doi algoritmi ignor coninutul canalelor (stivelor de mesaje). O soluie e s presupunem c strile locale ale procesoarelor ptreaz ce mesaje au fost primite i trimise. Atunci informaia despre canale se obine din colecia strilor procesoarelor. Soluia este nepractic datorit volumului de memorie local necesar. O alt soluie se obine dup cum urmeaz: Algoritm de determinare a tieturilor maximale consistente: n tabloul store fiecare component conine i numrul de mesaje primite de procesor de la vecinii si pe lng VC. Atunci cnd trebuie calculat o tietur maximal consistent, fiecare procesor pi parcurge tabloul su store nainte, ncepnd cu prima component, i simuleaz o reluare a mesajelor pe care le-ar fi trimis. Procesul se termin cu ultima intrare, l, din storei a..VC din storei[l] este k (tietura dat). Considerm un vecin pj oarecare al lui pi. n storei[l] se cunoate numrul x al mesajelor primite de pi de la pj. Cnd pi a terminat reluarea sa, trimite x lui pj. Cnd pj primete mesajul de la pi, ateapt pn cnd i calculeaz propria sa reluare. Atunci pj calculeaz starea canalului de la pj la pi pentru tietura consistent ca fiind sufixul, ncepnd cu al (x+1)-lea al secvenei de mesaje care este generat de reluare pe care el le-a trimis lui pi. Algoritmul de determinare a unui instantaneu distribuit: se modific a.. fiecare procesor pi nregistreaz irul de mesaje primite de la fiecare pj, de la momentul cnd pi i-a determinat rspunsul ansi pn n momentul n care pi primete un mesaj marker de la pj. Se obine astfel i informaie referitoare la mesajele n tranzit n configuraia care corespunde instantaneului distribuit. Problema sesiunii. Relaia captureaz dependenele din interiorul sistemului, dar nu surprinde interaciunea cu mediul nconjurtor. Problema sesiunii pe care o descriem n continuare poate fi uor rezolvat n sisteme sincrone, ns necesit extra-timp considerabil pentru sisteme asincrone, datorit necesitii comunicrii explicite. O sesiune este o perioad minim de timp n care fiecare procesor execut o aciune special cel puin o dat. Problema sesiunii cere ca pentru un s dat s se garanteze execuia a cel puin s sesiuni. Mai precis: -fiecare procesor pi are o variabil ntreag SAi. -n timpul execuiei fiecare procesor pi incrementeaz SAi la anumite evenimente de calcul (incrementarea lui SA reprezint aciunea special menionat mai sus). -orice execuie se partiioneaz n sesiuni disjuncte, unde o sesiune este un fragment de execuie n care orice procesor i incrementeaz variabila SA cel puin o dat. Problema cere s se construiasc un algoritm care pentru un s dat s garanteze c n orice execuie admisibil: -exist cel puin s sesiuni -nici un procesor nu-i incrementeaz variabila SA de o infinitate de ori (procesoarele se vor opri odat i odat n execuia aciunii speciale). Timpul de execuie este timpul pn la ultima incrementare a lui SA (folosind conveniile standard de la msurarea timpului n sisteme asincrone). Pentru sistemele sincrone algoritmul este banal: fiecare procesor este lsat s execute s aciuni speciale. n fiecare rund avem o sesiune i deci timpul este cel mult s. n sistemele asincrone timpul de rezolvare a problemei depinde de diametrul reelei de comunicaie. Teorem: Fie A un algoritm pentru problema s-sesiunii ntr-un sistem distribuit sincron de tip memorie partajat cu reeaua de comunicaie avnd diametrul D. Atunci CT a lui A este > (s-1)D. Dem.: Presupunem, prin reducere la absurd, c exista un algoritm A cu CT( s-1)D. Fie o execuie admisibil a lui A care este sincron ( const dintr-o serie de runde, fiecare rund coninnd un eveniment de livrare pentru fiecare mesaj n tranzit, urmat de un pas de calcul al fiecrui procesor). Fie planificarea lui unde se termin la sfritul rundei coninnd ultima aciune special. Deci nu are aciuni speciale (iar const din cel mult (s-1)D runde, din ipoteza asupra algoritmului A). Ideea demonstraiei: Vom nlocui cu un amestec cauzal al lui a.. s se realizeze mai puin de s sesiuni i totui procesorul s nu disting aceast situaie de cea original i deci ele vor opri execuia aciunilor speciale prematur. Intuitiv, aceasta se ntmpl ntruct nu-i timp suficient pentru ca informaia referitoare la ndeplinirea sesiunilor s circule prin toat reeaua. Lema 1: Fie un subir contiguu al lui constnd din cel mult x runde complete (x-ntreg pozitiv). Fie C configuraia ce precede imediat primul eveniment al lui n execuia .Considerm dou procesoare oarecare pi i pj. Dac dist(pi, pj)>x (n reeaua de comunicaie) atunci exist un ir de evenimente =12 numit split(, j, i) a..: -1 este pi-free (nu are evenimente referitoare la pi) -2 este pj-free -exec(C,) este un segment de execuie similar lui exec(C, ). Dem.: Fie i primul eveniment al lui pi n i j ultimul eveniment al lui pj n (Dac este pi-free 1= i 2 vid; Dac este pj-free atunci 2= i 1 vid). Artm c (ij) (nici un eveniment al lui pj n timpul lui nu depinde de vreun eveniment al lui pi n timpul lui ). Dac ar exista o astfel de dependen, ar exista un ir de mesaje de la i la j n . Numrul rundelor necesare pentru acest lan ar fi cel puin dist(pi, pj)+1, din construcia lui (ntr-o rund nu exist dou evenimente care s se influeneze cauzal). Dar acest numr de runde este cel puin x+1, contradicie cu alegerea lui . Fie R restricia relaiei la evenimentele din la care adugm perechea (j, i): j trebuie s apar naintea lui i. R este o relaie de ordine pe mulimea evenimentelor din . Fie o ordine total a evenimentelor din care este consistent cu R. Cum e consistent cu restricia ca i s apar dup j urmeaz c =12 unde 1 este pi-free i 2 este pj-free. ntruct este un amestec cauzal al lui rezulta ca exec(C, ) este un fragment de execuie similar lui exec(C, ). Partiionm =1s-1 , n care fiecare i const din cel mult D runde (dac n-ar fi posibil, atunci numrul de runde din ar fi mai mare de (s-1)D, n contradicie cu presupunerea asupra timpului de execuie al lui A). Alegem p0 i p1 a.. dist(p0, p1)=D. Considerm i=

split ( i ,1,0) daca i este impar 0 i s 1 . split ( i ,0,1) daca i este par

Lema 2. Fie C0 configuraia iniial a lui . Atunci exec(C0, 1s-1) este o execuie a lui A care e similar lui exec(C0,). Dem.: Se arat prin inducie dup i c exec(C0,1 i) este o execuie a lui A care este similar lui exec(C0, 1 i) 0is-1. n pasul inductiv se aplic lema precedent. Rezult c =exec(C0, 1 s-1 ) e o execuie admisibil a lui A. Artm c exist prea puine sesiuni n , contrazicnd ipoteza de corectitudine a lui A. Sesiunea 1 nu se poate termina naintea primei pri a lui 1 ntruct p0 nu face nici un pas n prima parte a lui 1. Sesiunea 2 nu se poate termina naintea prii a II-a a lui 2, cci p1 nu face nici un pas dup terminarea sesiunii 1 pn n a doua parte a lui 2. n acest fel obinem c sesiunea s-1 nu se poate termina pn la a doua jumtate a seciunii s-1. Dar ultima parte a lui s-1 nu conine o sesiune complet ntruct sau p0 sau p1 nu apare n ea! Cum n nu se execut nici o aciune special, toate sesiunile trebuie incluse n exec(C0, 1 s-1) i prin urmare conine cel mult s-1 sesiuni .

Sincronizarea ceasurilor.
Pentru studiul complexitii timp a sistemelor distribuite asincrone s-a introdus noiunea de t-executie (timed execution). Fiecare eveniment are asociat un timp de apariie (timpul real) care nu este accesibil procesoarelor. Modele mai puternice ale sistemelor distribuite presupun c procesoarele au acces la informaia referitoare la timp prin intermediul ceasurilor hard: acestea ofer aproximaii ale timpilor reali. Modelul formal al sistemelor distribuite cu ceasuri hard: ntr-o t-executie, se asociaz fiecrui procesor pi o funcie HCi:RR. Atunci cnd pi execut un pas de calcul la timpul real t, HCi(t) e disponibil ca intrare n funcia de tranziie a lui pi. Aceast funcie de tranziie nu poate modifica HCi. Vom considera c i HCi(t)=t+ci (ceasul hard al procesorului pi msoar fr abateri timpul trecut de la un eveniment la altul). Pentru fiecare t-executie se poate asocia starea iniial i irul de evenimente (de calcul i de livrare) asociate unui procesor: view(pi). Putem proceda i invers, din cele n view-uri s construim o execuie. Definiie: view(pi) ntr-un model cu ceasuri hard const dintr-o stare iniial a lui pi, un ir de evenimente (de calcul sau de livrare) ce apar n pi i cte o valoare a ceasului hard asociat fiecrui eveniment. irul valorilor ceasurilor hard este cresctor i dac irul de evenimente este infinit, atunci irul valorilor ceasurilor hard este nemrginit. Definiie: t-view(pi) ntr-un model cu ceasuri hard este un view(pi) mpreun cu o valoare real asociat fiecrui eveniment. Aceste valori trebuie s fie consistente cu ceasurile hard satisfcnd HCi(t)=t+ci. O mulime de n t-view-uri i i= 0, n 1 pot fi reunite ntr-o t-exec astfel: Configuraia iniial se obine considernd strile iniiale din i. Se consider apoi un ir de evenimente prin interleavingul evenimentelor din i, consistent cu timpii reali (dac exist mai multe evenimente la un moment t se respect ordinea impus de evenimentele de livrare, dac nu mai exist alt criteriu de ordonare se folosesc indicii procesoarelor). Aplicnd acest ir de evenimente strii iniiale se obine o t-execuie. Rezultatul este merge(0, , n-1). Aceasta este o execuie dac t-view-urile sunt consistente. Definiie: : Fie o t-exec cu ceasuri hard i fie x un vector real cu n componente. Definim shift(, timpul real asociat cu fiecare eveniment din i. Lema: Fie o t-exec cu ceasuri hard HCi 0 i n-1 i

x ) ca fiind merge(0, , n-1) unde i este t-view-ul obinut adugnd xi la

In shift(, x ):

x un vector real .

(a)HCi (ceasul hard asociat lui pi) este HCi-xi 0 i n-1. (b)mesaj de la pi la pj are ntrzierea -xi+xj unde este ntrzierea mesajului din i,j{0, , n-1}.

Problema sincronizrii ceasurilor.


Fiecare procesor are o component special de stare adji pe care o poate manipula. Ceasul ajustat al lui pi este funcie de HCi i variabila adji. n procesul de sincronizare a ceasurilor, pi modific valoarea lui adji i deci schimb valoarea ceasului ajustat.Dac ceasurile hard sunt fr abateri, atunci AC i(t)=HCi(t)+adji(t) unde adji(t) este valoarea lui adji n configuraia imediat dinaintea ultimului eveniment a crui apariie n timp este mai mare dect t. Dac ceasurile hard sunt fr abateri, odat atins sincronizarea nu mai este nevoie de nici o aciune ulterioar. Atingerea -sincronizrii ceasurilor: n t-exec admisibil tf timp real a.. algoritmul se termin la momentul t f i pi, pj t tf ACi(t)-ACj(t). se numete skew.(distorsiune, perturbaie) Vom presupune c d,u d u > 0 a.. n t-exec admisibil mesaj are ntrzierea n intervalul [d-u,d]. (pi trimite un mesaj m lui pj la momentul real t, atunci trebuie s apar un eveniment de livrare a lui m urmat de un pas de calcul al lui p j nu mai trziu de t+d i nu mai devreme de t+du). Vom presupune c reeaua de comunicare este complet (pentru simplificarea expunerii) Algoritm de sincronizare a ceasurilor pentru n procesoare (cod pentru pi , 0 i n-1) la primul pas de calcul: 1: trimite HC tuturor procesoarelor la primirea mesajului T de la pj : 2: diff[j]:=T +d -u/2-HC 3: if (s-au primit mesaje de la toate procesoarele) then 4: adj:= media aritmetic a componentelor vectorului diff Se poate demonstra Teorem: Algoritmul atinge u(1-1/n)-sincronizarea ceasurilor. Observaie: S-a dovedit c orice algoritm care atinge -sincronizarea satisface u(1-1/n), ceea ce arat c algoritmul dat este optimal.

Consens tolerant la defectri


1. Sisteme sincrone cu cderi Cel mai simplu scenariu de procesare distribuit tolerant la defectri: sisteme distribuite sincrone n care procesoarele "cad" , ncetnd s opereze. Vom considera numai sisteme distribuite sincrone cu topologia graf complet. Canalele vor fi considerate ca fiind fr defecte, deci toate mesajele trimise vor fi livrate. Sistemul se numete f-rezilient dac numrul maxim de procesoare care se pot defecta este f. Definiia unui execuii trebuie modificat pentru un sistem f-rezilent. n sistem exist o mulime F {p0, ..........pn-1} cu F f , necunoscut, a procesoarelor defecte.

Fiecare rund care conine exact un eveniment de calcul pentru fiecare procesor care nu-i din F i cel mult un eveniment de calcul pentru fiecare eveniment din F. n plus, dac un procesor din F nu are un eveniment de calcul ntr-o rund, atunci nu va mai avea n nici o rund care urmeaz. De asemenea se presupune c ntr-o rund n care un procesor cade, vor fi livrate doar o submulime arbitrar dintre mesajele pe care le trimite. Dac am avea o cdere curat - toate mesajele trimise sunt livrate sau nici un mesaj nu este livrat- atunci problemele create se rezolv mult mai simplu.

Problema consensului
Fiecare procesor pi are o component a strii sale xi (intrarea) i o component yi (ieirea sau decizia). Iniial xi are o valoare dintr-o mulime total ordonat iar y i este nedefinit. Orice asignare asupra lui yi este ireversibil. O soluie la problema consensului trebuie s garanteze: Terminarea: n execuie admisibil, yi va primi o valoare pentru fiecare procesor nedefect pi. Agreement: n executie dac yi i yj au fost asignate atunci yi = yj pentru procesoare nedefecte pi i pj. (procesoarele nedefecte nu decid pe valori conflictuale) Validitate: n execuie dac o valoare v a.. xi = v pt pi i dac yi este asignat pentru un procesor nedefect p i, atunci yi =v (dac toate procesoarele au aceeai intrare, atunci singura valoare pe care ele vor decide este intrarea comun).

Un algoritm simplu
Fiec procesor ii menine o mulime a valorilor pe care el le tie c n sistem. Iniial aceast mulime este format doar din intrarea sa. n fiecare din cele f+1 runde pe care le execut sistemul, fiecare procesor i actualiz mulimea sa cu mulimile primite de la acel procesor i difuzeaz orice nou modificare. n acest moment, procesoarele decid pe valorile minime din multimea fiecruia. Algoritm de consens (codul pentru pi) Iniial V= {x} runda k 1. 2. 3. 4. 1 k f+1 // V conine intratea lui pi

send {v; vV, v n-a fost deja trimis} tuturor procesoarelor receive Sj de la pj 0 j n-1 ji

V := V Sj
j =1

n 1

if k = f+1 then y:= min(V)

Terminarea este asigurat deorece algoritmul prevede exact f+1 runde, ultima asignnd o valoare a lui y. Validitatea este asigurat, deoarece aceast valoare este o intrare a unui procesor. Condiia de agreement este satisfcut aa cum rezult din urmtoarea lem. Lem: n orice execuie, la sfritul rundei f+1, Vi = Vj, dou procesoare nedefecte pi i pj. Demonstraie: Considerm dou proceasoare nedefecte oarecare pi i pj. Demonstrm c dac x Vi la sfritul rundei f+1 atunci x Vj la sfritul rundei f+1. Fie r prima rund la care x este adugat la un V k pentru un procesor nedefect p k (r =0 dac x era valoarea iniial a lui pk). Dac r f, n runda r+1 ( f+1), x va fi trimis lui pj care l adaug la Vj , dac nu era deja prezent. Presupunem, deci, c r= f+1 i c p k primete x pentru prima oar n runda f+1. Exist un ir de f+1 procesoare

pi , pi
1

f +1

a..

pi

trimite x lui

pi

n runda 1,

pi

lui

p i 3 n runda 2, ......... , p i f

lui

pi

f +1

n runda f i

pi

f +1

lui pk n runda f+1. Cum fiecare procesor trimite o valoare particular o singur dat, acestea sunt distincte.

Deci avem o mulime de f+1 procesoare care va conine sigur unul nedefect, care deci va aduga x la mulimea sa ntr-o rund f < r contrazicnd alegerea lui r. Teorem: Algoritmul precedent rezolv problema consensului n prezena a f cderi n f+1 runde.

O margine inferioar asupra numrului de runde


Fie o execuie admisibil a unui algoritm de consens i fie dec() decizia unui procesor oarecare nedefect ( care din condiia de agreement este unic definit). Ideea obinerii marginii inferioare: dac procesoarele decid prea devreme ele nu pot distinge o execuie admisibil n care ele iau decizii diferite. Vom presupune f n 2.

Definiie: Dou execuii 1 i 2 sunt similare n raport cu pi, notat dac 1 | pi = 2 | pi. Evident, dac valoare. Deci,

1 ~ p2

p1

1 ~ 2

pi

rezult c pi decide pe aceeasi valoare n ambele execuii. Din condiiile de agreement toate procesoarele nedefecte vor decide pe o aceeasi

1 ~ 2

pi

dec(1) = dec(2).

Considerm nchiderea tranzitiv a relaiei ~ notat : 1 2 1,..............., k+1 i pi1,..............,pik a.. 1 = 1

~ ~

pi

pi

,...,

pi

k+1 = 2.

Evident, 1 2 dec(1 ) dec (2 ). Vom presupune c procesor nedefect trimite mesaje la toate celelalte n fiecare rund (dac nu-i aa se pot trimite mesaje fictive). Considerm mai nti cazul parcticular cnd f=1. Lema. Dac n 3, nu exist algoritm care s rezolve problema consensului n mai puin de dou runde n prezena unei singure cderi. Demonstratie: Presupunem c un algoritm n care toate procesele nedefecte decid dup runda 1, pentru mulimea intrrilor {0,1}. Fie

execuia admisibil a algoritmului n care procesoarele p 0 pn la pi-1 au valorile iniiale 1 i celelalte 0 (0 i n) (n o procesoarele au toate intrrile 0 iar n au

toate intrrile 1). Dac artm c Considernd


i

i +1

0 i n 1 0 = dec ( 0 ) = dec ( n ) = 1 , contradicie.

ij

excuia n care procesoarele ncep cu aceeai valoare iniial ca i i, dar care n runda 1 se "defecteaz" netrimind mesaje la ultimele j procesoare:

p n 1 , p n j , 0 j n-1 (excluzndu-se eventual pe el nsui).


Evident
pk
i 0 = i . Pentru fiecare 0 j n-2, cum n > 3, un procesor nedefect p
k

diferit de procesorul care primete mesaj n

ij

dar nu n

ij +1 . Deci

ij ij +1
n
i n 1

pi nu trimite mesaje. Dac schimbm intrarea lui p i din 0 n 1 rezult o execuie admisibil

i . Pentru procesor p 0

pi

i i n 1 0

pk

pentru c am modificat

intrarea unui procesor care nu trimite mesaje. Pentru j =0, n 1 considerm

ij

execuia admisibil n care p0,....... pi ncep cu 1 restul cu 0 i n runda 1 p i trimite mesajele sale la primele j cele mai mici 0 j n-2, cum n 3, un procesor nedefect n pk altul dect procesorul ce primete mesajul lui p i

procesoare, excluzndu-se pe el nsui dac este cazul. Ca mai nainte j

ij +1 dar nu n ij , deci i i j j +1
Cazul general.

pk

. Evident

ni 1 = i +1 i deci am demonstrat c i i +1

Presupunem c exist un algoritm care rezolv problema consensului n cel mult f runde 1 f n-2. Un pattern al mesajelor specific pentru fiecare rund i fiecare procesor care din mesajele trimise de el vor fi livrate altui procesor n acea rund. Clar, patternul mesajelor descrie patternul cderilor. Un procesor este nedefect n runda r a unei execuii dac toate mesajele pe care el le-a trimis n runda r sunt livrate. O execuie admisibil este r - failurefree (r-ff) dac nici un procesor nu este defect ntr-o rund k. n particular, o execuie admisibil este failure-free dac este 1-ff. Fie o execuie admisibil r-ff cu configuraia iniial I i patternul cderilor M i presupunem c procesorul p i este nedefect n runda r. Notm cu crash (, pi, v) execuia admisibil cu configuraia iniial I i patternul mesajelor M' unde M' este egal cu M cu excepia faptului c p i nu va mai transmite nici un mesaj ncepnd cu runda r; dup runda r este posibil ca pi s se comporte diferit n cele 2 execuii. Lem. Pentru r, 1 r f, dac este r-ff cu cel mult o defeciune n fiecare rund i procesorul pi este nedefect n , atunci crash (, pi, r).

Demonstraie: Inducie dup f-r. r = f. Fie r-ff execuie i presupunem c pi e nedefect n . n runda f exist cel puin 3 procesoare nedefecte . (n fiecare rund se defecteaz cel mult un procesor, n runda f nu avem procesoare defecte deci avem cel mult f-1 procesoare defecte iar f n-2). Procedm ca n demonstraia precedent i construim un ir de execuii eliminnd cte un mesaj trimis de p i n runda f (execuia
i 0

pn la

n 1 ). Cum mcar dou 0

procesoare n afara lui pi sunt nedefecte n runda f i numai un procesor are view-urile diferite n fiecare pereche de execuii consecutive, cel puin un procesor nedefect are acelai view n fiecare pereche de execuii consecutive. Deci avem mesaj n runda f, deci crash (,pi , f) . n pasul inductiv, presupunem c lema are loc pentru runda r+1, 1 r f-1 i demonstrm c are loc pentru r. Fie o execuie r-ff cu cel mult o defeciune n fiecare rund i presupunem c pi este nedefect n runda r. Evident este i (r+1)-ff cu cel mult o defeciune n fiecare rund i deci aplicnd ipoteza inductiv lui pi obinem crash(,pi , v+1) . Fie 0 o execuie care este exact crash( ,pi , r+1) cu excepia faptului c p i cade la sfritul rundei r dup ce trimite toate cele n-1 mesaje, n loc s cad la nceputul rundei r+1.

pentru fiecare din execuiile consecutive. Ultima execuie din acest ir este o execuie n care p i nu trimite nici un

Dar 0

crash(,p , r+1) pentu procesor nedefect p . Se observ c


i j

pj

este (r+1)-ff. n plus 0 are cel mult o defeciune pe rund ntruct este r-ff i n runda r n 0

se adaug o defeciune prin construcie. Eliminm mesajele lui pi din runda r unul cte unul astfel: pentru j 1 j n-1, fie j execuia cu aceeasi configuraie iniial ca 0 i acelasi pattern al mesajelor ca 0, cu excepia faptului c pi nu trimite n runda r mesaje ultimelor j procesoare, cu excepia sa, dac este necesar (i desigur nu mai trimite mesaje n viitor). Fiecare j este (r+1)-ff i are cel mult o cdere pe rund. Dac demonstrm c j-1 j 1 j n-1 obinem n-1 i cum Fie ph procesorul care prin mesajul lui pi din runda r n j-1 dar nu n j n-1 = crash(,pi , v) lema este demonstrat. ( h = n-1-j dac ultimile j procesoare includ pi , altfel h = n-2-j).

Cazul 1. ph defect n . Cum este r-ff, ph cade ntr-o rund k< r i deci cade i n j-1 i n j . Clar j-1 Cazul 2. ph nu este defect n . Cum j-1 este (r+1)-ff i are cel mult o cdere pe rund, aplicand ipoteza inductiv, rezult crash( j-1 , ph , r+1) j-1 .

pentru un procesor nedefect p


j

pl

( pentru c r<f n-2 i

cel mult o cdere pe rund). (Nici un procesor nu poate spune dac pi trimite lui ph un mesaj n runda r, pentru c ph era deja mort).

Similar crash (j , ph , r+1 ) j . Cum singura diferen dintre crash(j-1 , ph , r+1) i crash (j , ph , r+1 ) este c mesajul lui p i ctre ph din runda r este prezent n prima i nu este prezent n a doua, iar ph nu va trimite mesaje mai departe, rezult c crash(j-1 , ph , r+1) crash (j , ph , r+1 ). Teorem: Nu exist algoritm care s rezolve problema consensului n mai puin de f+1 runde n prezena a f cderi dac n f+2. Demonstraie: Presupunem prin reducere la absurd c un algoritm care rezolv problema n mai puin de f+1 runde. Considerm o execuie admisibil fr cderi n care toate procesoarele au intrarea 0. Fie i (0 i n) execuia admisibil a algoritmului fr cderi n care procesoarele p 0 pn la pi -1 ncep cu 1 i celelalte ncep cu 0. Deci 0 are toate intrrile 0 iar n are toate intrrile 1. Demonstrm c: 0 1 ... n i cum dec(0) = 0 (datorit condiiei de validitate) obinem c dec(n) = 0 contrazicand condiia de validitate pentru n . i este fr cderi deci are cel mult o cdere pe rund. Deci i crash (i,pi , 1) i i+1 crash (i+1,pi , 1). Cum singura diferen dintre crash ( i,pi , 1) i crash (i+1,pi , 1) este intrarea lui pi i cum pi nu trimite mesaje crash (i,pi , 1) crash (i+1,pi , 1).

2. Sisteme sincrone cu cderi bizantine


Defeciunile sunt "rutcioase" fa de cele "curate" ale modelului precedent. Descrierea metaforic a problemei: Mai multe divizii ale armatei Bizantine sunt campate lng cetatea inamicului. Fiecare divizie este comandat de un general. Generalii comunic ntre ei doar prin mesageri (care ii ndeplinesc ireproabil sarcinile). Generalii trebuie s decid asupra unui plan comun de aciune, adic s decid dac s atace sau nu cetatea (agreement) i dac generalii sunt toi unanimi n opinia lor iniial atunci aceasta trebuie s fie decizia pe care o vor lua. Problema este c unii dintre generali pot fi trdtori (doar sunt n armata bizantin !!) i ei pot ncerca s-i mpiedice pe generalii loiali s fie de acord. Pentru aceasta ei trimit mesaje diferite la generali diferii, retransmit n mod eronat ce-au auzit de la alii sau chiar pot conspira i forma o coaliie. Modelul formal: Sistem distribuit sincron f - rezilient.

n orice execuie o submulime de cel mult f procesoare care se pot defecta (procesoarele defecte, trdtorii). ntr-un pas de calcul al unui procesor defect nu se impune nici o restricie asupra noii stri sau asupra mesajelor transmise (n particular se poate comporta ca n modelul precedent). Sistemul se comport ca i n lipsa cderilor: la fiecare rund fiecare procesor execut un pas de calcul i orice mesaj transmis n acea rund este livrat pentru urmtoarea rund. Problema consensului : exact acelai enun. Spre deosebire de modelul precedent, condiia de valabilitate nu este echivalent cu a cere ca decizia unui procesor oarecare nedefect s fie intrarea unui anumit procesor.

O margine superioar pentru numrul procesoarelor defecte


Lema: ntr-un sistem cu 3 procesoare n care unul poate fi bizantin nu exist un algoritm care s rezolve problema consensului. Demonstraie: Presupunem c exist un astfel de algoritm ntr-un sistem cu 3 procesoare p0, p1 , p2 conectate printr-un graf complet cu trei vrfuri. Notm cu A, B, C programele locale ale lui p0, p1 , p2 respectiv. Considerm un inel sincron cu 6 procesoare n care p0 i p3 au programul local A, p1 i p4 au programul local B i p2 i p5 au programul local C.

P3: A(0) P4: B(0) P2: C(1)

P1: B(1) P5: C(0) P0: A(1)

Desigur, mesajele dintr-un program local vor fi transmise procesorului vecin cu acelai program cu cel din triunghi. (p 0, nu trimite lui p2 ci lui p5 , p3, nu trimite lui p1 ci lui p4 etc. ). Considernd o execuie particular a acestui algoritm pe inel, n care p0, p1 , p2 au intrarea 1 iar p3, p4 , p5 au intrarea 0. Revenim la problema nostr. Consideram 1 execuia algoritmului n { p0, p1 , p2 } n care toate procesoarele pornesc cu 1 i procesorul p2 este defect. Mesajele pe care le trimite p2 le considerm ca fiind: p2 p0 mesajele trimise n de p5 lui p0 p2 p0 mesajele trimise n de p2 lui p1 Din condiia de validitate, p0 i p1 vor decide pe 1 n 1. Considerm 2 execuia algoritmului n { p0, p1 , p2 } n care toate procesoarele pornesc cu intrarea 0 i procesorul p0 este defect. p0 p1 mesajele trimise n de p3 lui p4 p0 p2 mesajele trimise n de p0 lui p5 Din condiia de validitate, p1 i p2 decid pe 0 n 2. Considerm 3 execuia algoritmului { p0, p1 , p2 } n care p0 pornete cu intrarea 0, p1 pornete cu intrarea 1, p2 pornete cu intrarea 0 i defect este p1. p1 p2 mesajele trimise n de p4 p5 p1 p0 mesajele trimise n de p1 p0 Observm c :

Mesajele pe care le trimite p0 le considerm ca fiind:

Mesajele pe care le trimite p1 le considerm ca fiind:

p0 are acelai view n 1 pe care l are i n p0 are acelai view n pe care l are i n 3

Deci (inductiv dup numrul de runde) 1 Similar 2


p2

p0

3 p0 decide 1 n 3.

3 p2 decide 0 n 3.

Dar acesta contravine condiiei de agreement. Contradicie.

Teorem. ntr-un sistem cu n procesoare dintre care f sunt bizantine nu exist un algoritm care s rezolve problema consensului dac n 3f. Demonstraie. Presupunem, prin reducere la absurd, c exist un astfel de algoritm. Partiionm mulimea procesoarelor n P0, P1, P2 fiecare coninnd cel mult

n procesoare. 3

Considerm un sistem cu trei procesoare {p0, p1, p2}. Pentru acest sistem descriem un algoritm de consens care poate tolera o cdere bizantin (contrazicnd teorema precedent). n algoritm, p0 simuleaz toate procesoarele din P0, p1 pe cele din P1 i p2 pe cele din P2. Dac unul din procesoare n sistemul {p0, p1, p2} este defect cum

n f 3

rezult c n sistemul simulat cu n procesoare avem cel mult f procesoare defecte. Algoritmul

simulat trebuie s pstreze validitatea i condiia de agreement din sistemul simulat i deci i n sistemul cu 3 procesoare. Un algoritm exponential Prezentm un algoritm care n f +1 runde rezolv problema consensului n ipoteza c n 3f+1. Totui, folosete mesaje de dimensiune exponenial Algoritmul are dou etape: - I se colecteaz informaia prin comunicare ntre procesoare - II pe baza informaiei colectate, fiecare procesor ia decizia sa. Este convenabil s descriem informaia meninut de fiecare procesor cu ajutorul unor arbori etichetai. Arborele fiecrui procesor are proprietatea c oricare drum de la rdcin la frunze are f+2 noduri (arborele are adncimea f+1). Fiecare nod este etichetat cu iruri de nume de procesoare astfel: rdcina are eticheta cuvntul vid nodul v cu eticheta i1 i2 ...ir (de pe nivelul r+1; aflat la adncimea r) are ca descendeni cte un nod etichetat i1 i2 ...ir i pentru oricare i {0, 1, ..., n-1} \ {i1 i2 ...ir} (etichetele au simboluri distincte). Vom spune c nodul i1 i2 ...ir-1 i de pe nivelul r corespunde procesorului i. Faza I-a n runda 1: fiecare procesor trimite valoarea sa tuturor procesoarelor (inclusiv lui nsui; aceasta se simuleaz) n runda 2: (fiecrui procesor i sunt livrate mesajele din runda precedent i procesoarele nedefecte memoreaz valoarea primit de la procesorul p j n nodul etichetat j de pe nivelul 1. Deci fiecare procesor nedefect are completat arborele:

1 x1 x2

n xn

fiecare procesor trimite un mesaj format din nivelul 2 din arborele su celorlalte procesoare. n runda 3: (fiecare procesor a luat mesajul primit de la pj i valoarea memorata de pj n nodul i, o memoreaz n nodul ij de pe nivelul 3.

1j

2j

nj

fiecare procesor trimite un mesaj format din nivelul 3 din arborele su celorlalte procesoare. n general n runda r fiecare procesor difuzeaz celorlalte nivelul r din arborele su. Cnd un procesor primete un mesaj de la pj cu valoarea din nodul arborelui lui pj etichetat i1 i2 ...ir-1 = x, el memoreaz valoarea x n nodul

i1 i2 ...ir j din arborele su. Intuitiv pi memoreaz n i1 ...ir j valoarea: "pj spune c pir spune c pir-1 spune c .... c

p i1

spune x".

Vom nota aceast valoare treei (i1, ..., iv, j) omiind indicile i cnd nu este pericol de confuzie. Faza I-a conine f+1 runde, cnd se umple fiecare arbore al procesoarelor. Urmeaz faza II-a. Procesorul pi i calculeaz decizia sa aplicnd fiecrui subarbore o funcie recursiv resolve. n arborele lui p i, dac avem un subarbore etichetat , valoarea determinat de funcie o notm resolvei (). (eventual omind indicele). Decizia luat de pi va fi resolvei ( )(aplicarea funciei rdacinii arborelui)

tree( ) dac nodul cu eticheta este frunz. ( are lg f + 1) resolve ( ) = majority( resolve ( ) ; descendent al lui )
Observaie:

1. 2.

dac n prima faz a algoritmului un nod primete o valoare nelegitim sau nu primete o valoare (procesorul care ar fi trebuit s i-o trimit este defect) nodul memoreaz n nodul corespunztor o valoare default v. dac majority nu exist funcia resolve ia valoarea v.

Fixm o execuie admisibil a algoritmului. S reamintim c dac un nod din arborele lui pi corespunde lui pj atunci valoarea memorat n tree() a fost primit ntr-un mesaj de la pj. Lema 1. Pentru orice nod de forma 'j unde pj este nedefect avem resolvei () = treej (') , pi nedefect. Demonstraie: Inductiv dup adncimea lui n arbore, pornind din frunze. frunz: prin definiie resolvei() = treei(), dar treei() memoreaz valoarea lui ' pe care pj o trimite lui i n ultima rund. Cum p j nu este defect acceast valoare este treej('). nod intern. Cum arborele are f +2 nivele rdcina are n descendeni i la fiecare nivel numrul descendenilor scade cu 1 are cel puin n - f descendeni. Cum n 3f+1 gradul lui este 2f +1. Majority aplicat descendenilor lui corespunde procesoarelor nedefecte. Fie k un descendent al lui (care corespunde procesorului nedefect pk). Din ipoteza inductiv, resolvei(k) = treek(), pj nedefect treek() = treej (') adic pj i spune corect lui pk valoarea pe care pj a memorat-o n '. Deci pi rezolv fiecare copil al lui corespunztor unui procesor nedefect ca fiind treej(') i deci resolvei() este egal cu valoarea majoritar treej('). Algoritmul satisface condiia de validitate. Presupunem c toate procesoarele nedefecte pornesc cu aceasi valoare v iniial. Decizia fiecrui procesor nedefect p i este resolvei(), care este valoarea majoritar din valorile rezolvate pentru descendenii rdcin. Pentru fiecare descendent j cu p j nedefect, lema precedent asigur c resolve i(j) = treej( ) =v (pj nu este defect). Cum valoarea majoritar corespunde procesoarelor nedefecte pi decide pe v. Pentru a demonstra condiia de agreement considerm urmtoarea definiie: Nodul este comun ntr-o execuie dac toate procesoarele nedefecte calculeaz aceeai valoare n nodul : resolvei() = resolvej(), pi, pj nedefecte. Un subarbore are frontier comun dac exist un nod comun pe oricare drum din rdcina subarborelui la frunzele sale. Lema 2. Fie un nod. Dac subarborele cu rdcina n are frontier comun e comun. Demonstraie: Inductiv dup nlimea lui . Dac este frunz, evident. n pasul inductiv, presupunem c lema are loc pentru orice nod cu nlimea k i fie cu nlimea k+1. Presupunem c nu este comun. Cum subarborele cu rdcina n are frontier comun orice subarbore cu rdcina n copiii lui are frontier comun, i din ipoteza inductiv fiecare copil al lui este comun. Deci toate procesoarele rezolv aceeai valoare pentru toi copii lui i prin urmare i pentru (pentru c se aplic majoritatea ). Rezult c este comun.

Nodurile de pe fiecare drum de la un copil al rdcinei la o frunz corespund la procesoare diferite (f+1), cel puin unul este nedefect i deci este comun conform lemei 1. Deci, lema 2 asigur faptul c rdcina este comun, adic are loc condiia agreement. Concluzie: Teorem. Dac n > 3f, exist un algoritm pentru n procesoare care rezolv problema consensului n prezena a f cderi bizantine n f+1 runde, folosind mesaje de dimensiune exponenial. Observaie: MC = n2 (f+1) (numrul mesajelor trimise). Mesajul cel mai lung trimis conine n(n-1)...(n-(f+1)) = (nf+2) valori.

Un alg polinomial
Dac n > 4f se poate construi un algoritm cu mesaje de dimensiune constant care rezolv problema n 2(f+1) runde Algoritmul are f+1 faze, fiecare faz cu 2 runde. Pentru fiecare faz, fiecare procesor are o decizie preferat (preferina sa), iniial, aceasta fiind valoarea sa. n prima rund a fiecrei faze toate procesoarele i trimit preferina lor tuturor celorlalte. Fie

v ik

valoarea majoritar n mulimea valorilor primite de un procesor pi la sfritul primei runde din faza k (dac nu exist majoritate se folosete o valoare default vT).
k vk

n a doua rund a fiecrei faze k, procesorul pk - numit regele fazei - trimite valoarea sa majoritar Dac un procesor pi primete >

celorlalte procesoare.

n +f 2

copii a lui
k vk

v ik

(n prima rund a fazei) atunci el consider preferina sa pentru faza urmtoare ca fiind

v ik . Altfel, alege drept

preferina sa pentru faza urmtoare ca fiind cea a regelui

(primit n runda 2-a a fazei).

Dup f+1 runde procesorul decide pe preferina sa

Algoritm polinomial de consens n prezena cderilor bizantine Codul pentru pi ( 0 Iniial pref [i] = x pref [j] = v

i n 1)
ji // prima rund a fazei k

Runda 2k-1 1: 2: 3:

1 k f +1

send < pref [i] > tuturor procesoarelor receive < vj > de la pj i asigneaz-l lui pref [j] 0 j n-1, ji fie maj valoarea majoritar din pref [0], ..., pref [n-1] (v dac nu exist) fie mult multiplicitatea lui maj // a doua rund a fazei k.

4:

Runda 2k, 1 k f+1 5: 6: 7: 8: 9: 10:

if i=k then send <maj> tuturor procesoarelor // regele fazei receive <king-maj> from pk (v dac nu exist) if mult >

n + f 2
then pref [i]: = maj else pref [i]: = king-maj

if k= f+1 then y : = pref [i]

// decide

Lema 1. Dac toate procesoarele nedefecte prefer v la nceputul fazei k, atunci toate prefer v la sfritul fazei k, k, 1 k f+1. Demonstraie: Cum toate prefer v la nceputul fazei k fiecare precesor primete cel puin n-f copii ale lui v (inclusiv pe a sa) n prima rund a fazei k. Cum n > 4f n-f > n/2 + f ; deci toate procesoarele prefer v la sfritul fazei k. Din acest lem rezult imediat proprietatea de validitate: dac toate procesoarele nedefecte ncep cu aceeai valoare de intrare v atunci ele vor prefera v n toate fazele; deci i n faza f+1 cnd vor decide pe v. Condiia de agreement este asigurat de intervenia regilor. Cum sunt f+1 faze, mcar o faz are un rege nedefect. Lema 2. Fie g o faz astfel nct regel pg nu este defect. Atunci toate procesoarele nedefecte sfresc faza g cu acceai preferin. Demonstraie: Presupunem c toate procesoarele nedefecte folosesc valoarea majoritar primit de la rege ca preferin. Cum regele nu este defect, trimite acest mesaj tuturor i deci ele vor avea aceeai preferin.

Presupunem c un procesor nedefect p i folosete valoarea majoritar proprie v ca preferin. Deci p i primete mai mult de

n + f 2

mesaje egale cu v n prima rund a

fazei g. n consecin orice procesor (inclusiv regele p g ) primete

>

n 2

mesaje egale cu v n prima rund a fazei g i ii va alege valoarea sa majoritar egal cu v. Deci n faza g+1

toate procesoarele vor avea acceai preferin i lema 1 ne asigur c vor decide pe acceai valoare la sfrit. Concluzie: Teorem: Dac n>4f, algoritmul precedent rezolv problema consensului n prezena a f defeciuni Bizantine n 2(f+1) runde folosind mesaje de dimensiune constant. Observaie. In cazul sistemelor distrbuite asincrone, nu se poate rezolva problema consensului, chiar n prezena unei singure defecuni.