Documente Academic
Documente Profesional
Documente Cultură
02.cauzalitate Si Timp
02.cauzalitate Si 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
( 1 2) ( 2 1).
Din lemele 1 i 2 rezult c dac 1
) n , dac
fiecare procesor pi pstreaz un tablou n-dimensional VCi (ceasul vectorial), cu componente ntregi, iniial 0.
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 p i 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 store i 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=
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 un vector real .
In shift(, x ):
(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}.
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 x i (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.. x i = 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 k f+1
1.
2.
receive Sj de la pj 0 j n-1
ji
n 1
3.
V : V S j
4.
j 1
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 Vk pentru un procesor nedefect pk (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
lui
p i 3 n runda 2, ......... , p i f
lui
pi
f 1
n runda f i
pi
f 1
pi , pi
1
f 1
a..
pi
trimite x lui
pi
n runda 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.
Vom presupune f n 2.
Definiie: Dou execuii 1 i 2 sunt similare n raport cu pi, notat
p1
1 ~ p2
dac 1 | pi = 2 | pi.
Evident, dac
pi
1 ~ 2
rezult c pi decide pe aceeasi valoare n ambele execuii. Din condiiile de agreement toate procesoarele nedefecte vor decide pe o aceeasi
valoare.
Deci,
pi
1 ~ 2
dec(1) = dec(2).
1 = 1
pi
~ ~
,...,
pi
k+1 = 2.
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
ij
i 1
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:
ij
dar nu n
ij 1 . Deci
pk
ij ij 1
n
ni 1
pi nu trimite mesaje. Dac schimbm intrarea lui p i din 0 n 1 rezult o execuie admisibil
0i . Pentru procesor p
pi
pk
ni 1 0i
pentru c am modificat
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
ij 1
dar nu n
pk
ij , deci i i
j
j 1
. Evident
0 j n-2, cum n 3, un procesor nedefect n pk altul dect procesorul ce primete mesajul lui p i
ni 1 i 1 i deci am demonstrat c i i 1
Cazul general.
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).
0i
pn la
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
pentru fiecare din execuiile consecutive. Ultima execuie din acest ir este o execuie n care p i nu trimite nici un
Dar 0
crash(,pi , r+1) pentu procesor nedefect pj . Se observ c 0 este (r+1)-ff. n plus 0 are cel mult o defeciune pe rund ntruct este r-ff i n runda r n 0
pl
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
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).
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 .
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).
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.
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.
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.
p2
p0
3 p0 decide 1 n 3.
3 p2 decide 0 n 3.
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
3
procesoare.
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:
-
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).
2
x1
xn
x2
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
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)
resolve
Observaie:
1.
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.
2.
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 resolve i() = 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 p k). 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 resolve i() 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() = resolve j(), 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 v T).
n a doua rund a fiecrei faze k, procesorul pk - numit regele fazei - trimite valoarea sa majoritar
Dac un procesor pi primete >
n
f
2
copii a lui
v kk
v ik
v kk
celorlalte procesoare.
(n prima rund a fazei) atunci el consider preferina sa pentru faza urmtoare ca fiind
pref i = x pref j = v
i n 1)
ji
1 k f 1
Runda 2k-1
1:
2:
3:
fie maj valoarea majoritar din pref 0, ..., pref n-1 (v dac nu
exist)
4:
5:
6:
7:
if mult >
8:
9:
10:
n
f
2
then pref [i]: = maj
else pref [i]: = king-maj
// 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
2
n
f
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.