Sunteți pe pagina 1din 16

SIMULARE DE SISTEME

Specificarea problemelor.
O problem se poate specifica la nivelul interfeei dintre algoritmul ce o rezolv i mediul extern.
O specificare de problem P este o mulime de evenimente de intrare in(P), o mulime de evenimente de ieire out(P) (cele dou mulimi constituind interfaa lui P) i o
mulime seq(P) de secvene admisibile de evenimente de intrare i evenimente de ieire (care precizeaz interleavingurile permise dintre intrri i ieiri).
Fiecare eveniment de intrare sau de ieire are un nume i poate avea asociate date ca parametri.
Exemplu. Problema excluderii mutuale pentru n procesoare:

evenimente de intrare: Ti, Ei, 0 i n-1, unde

Ti indic faptul c utilizatorul i dorete s ncerce s intre n seciunea critic.


Ei indic faptul c utilizatorul i dorete s ias din seciunea critic.

evenimentele de ieire: Ci, Ri 0 i n-1, unde

Ci indic faptul c utilizatorul i poate acum s intre n seciunea critic.


Ri indic faptul c utilizatorul i poate acum s intre n seciunea remainder.

o secven a acestor evenimente este admisibil dac pentru i:


1.
2.

|i cicleaz (Ti,Ci,Ei,Ri)
ori de cte ori Ci apare n , atunci j eveniment asociat lui j ce apare n naintea lui Ci nu este lj.

(Condiia 1 arat c utilizatorul i algoritmul interacionaz propriu; ea impune utilizatorului un mod corect de comportare. Condiia 2 afirm c nu doi utilizatori simultan n
seciunea critic).

Sisteme de comunicaie
n problemele de simulare vom fi interesai n implementarea unor anumite tipuri de sisteme de comunicaie ntre procesoare pe baza unor primitive.
Aceste sisteme de comunicaie vor fi descrise cu ajutorul unei specificaii de problem.
Exemple.
1. Transmiterea asincron de measej point-to-point
interfaa:

sendi (M): eveniment de intrare asociat procesorului pi care trimite o mulime M (eventual vid) de mesaje. Fiecare mesaj include o indicaie a trimitorului i a
destinatarului; exist cel mult un mesaj pentru fiecare destinatar i perechea transmitor-destinatar trebuie s fie compatibil cu topologia sistemului.

recvi(M): eveniment de ieire asociat procesorului pi n care o mulime M de mesaje este primit. Fiecare mesaj trebuie s-l aib pe p i ca destinatar.
mulimea secvenelor admisibile.
Fie o secven de evenimente de intrare i ieire.
Notm cu R mulimea tuturor mesajelor ce apar n toate evenimentele recv i(M) din i cu S mulimea tuturor mesajelor ce apar n toate evenimentele send i(M) din .
Exist o funcie K:RS care asociaz fiecrui mesaj din R un mesaj cu acelai coninut din S a..:

Integrity: K este bine definit. Orice mesaj primit a fost n prealabil trimis. Nu este permis corupia mesajelor.
No duplicates: K este injectiv. Nici un mesaj nu este primit mai mult de o dat.
Liveness: K este surjectiv. Orice mesaj trimis va fi primit.

Observaie. Aceste proprieti vor fi modificatecnd se vor considera i defeciunile n sistem.


Broadcast asincron

interfaa (la un sistem cu broadcast asincron de baz).

bc-sendi(m): eveniment de intrare n care procesorul pi, trimite un mesaj m


tuturor procesoarelor.

bc-recvi(m,j): eveniment de ieire n care procesorul p primete mesajul m, n prealabil difuzat de p .


i

mulimea secvenelor admisibile. Fie o secven de evenimente de intrare i de ieire.

bc-recvi(m,j) din un evniment precedent bc-sendj(m) a..


Integrity: K este bine definit (orice mesaj primit a fost n prealabil trimis).
No duplicates: Pentru ficare procesor pi 0 i n-1, restricia lui K la evenimentele bc-recvi este
injectiv (nici un mesaj nu este primit mai mult de o dat de un procesor).

Exist K o aplicaie care asociaz fiecrui

Liveness: Pentru ficare procesor pi 0 i n-1, restricia lui K la evenimentele bc-recvi este surjectiv
(orice mesaj trimis este primit de fiecare procesor).

Observaie: Din nou s-a presupus c nu exist defeciuni.


Procese
Pe fiecare procesor se vor executa buci de cod care implementeaz sistemul de comunicaie dorit. Deci nu va mai fi corect s identificm "algoritmul" cu procesorul,
pentru c avem procese multiple ce se execut pe acelai procesor. Vom folosi noiunea de nod iar sistemul de comunicaie va fi reprezentat ca o cutie neagr n care este implementat
o "stiv de protocoale".

mediul extern

Nivelul 1

Nivelul 2

Nivelul 3

sistemul de comunicaie

Un sistem este o colecie de noduri p0,...,pn-1, un sistem de comunicaie C i un mediu extern E.


C i E nu sunt explicit modelate ca procese. Ele vor fi date ca specificaii de probleme, care impun condiii asupra comportrii lor.
n fiecare nod exist o stiv de nivele cu acelai numr de nivele. Fiecare nivel interior comunic cu cele dou nivele adiacente. Nivelul de jos comunic cu sistemul de
comunicaie i nivelul de sus cu mediul extern.
Fiecare proces este modelat ca un automat cu o mulime (posibil infinit) de stri i o mulime de stri iniiale. Tranziiile dintre stri sunt declanate de apariia
evenimentelor procesului. Un proces are patru tipuri de evenimente:
1.
intrri din nivelul de deasupra (sau nivelul exterior dac este nivelul de sus).
2.
ieiri ctre nivelul de deasupra.
3.
intrri din nivelul de dedesubt (sau sistemul de comunicaii dac este nivelul de jos) .
4.
ieiri ctre nivelul de dedesubt.
Evenimentele de tipul 1 i 2: interfaa top a procesului
Evenimentele de tipul 3 i 4: interfaa bottom a procesului.
Un eveniment este activat ntr-o stare a procesului dac exist o tranziie din acea stare, etichetat cu acel eveniment.
Un eveniment de intrare poate fi activat n orice stare a procesului.
Evenimentele de ieire sunt activate de funcia de tranziie a procesului.
Intrrile din mediul extern i din sistemul de comunicaii sunt intrrile nodului.
Procesele de pe un singur nod interacioneaz a.. numai un numr finit de evenimente (diferit de intrrile nodului) sunt activate de o intrare n nod.
O configuraie a sistemului specific o stare pentru orice proces de pe orice nod (configuraia nu include starea sistemului de comunicaie). O configuraie iniial conine numai stri
iniiale ale proceselor.
O execuie a sistemului este un ir C0, 1, C1, 2,C2,.... alternativ de configuraii i evenimente, ncepnd cu o configuraie i, dac este finit, sfrind cu o configuraie a..:
1.
2.
3.

Configuraia C0 este o configuraie iniial.


i 1 evenimentul i este activat n configuraia Ci-1 i configuraia Ci este rezultatul lui i acionnd pe Ci-1. (Orice component de stare este aceeai n C i ca i n Ci1 cu excepia (cel mult dou) proceselor pantru care i este eveniment). Starile acestor procese se schimb conform funciei de tranziie a acestor procese.
i 1, dac i nu este o intrare pentru un nod, atunci i > 1 i este un eveniment pe acelai nod ca i i-1. (Primul eveniment trebuie s fie o intrare pe un nod).

i 1 dac i estte intrare pe un nod atunci n Ci-1 nu a fost avtivat nici un alt eveniment (diferit de un eveniment de intrare n nod).

4.

Observaie: Din 3. i 4. rezult c un nod este declanat de o intrare n nod (din exterior sau din sistemul de comunicaie) i aceast declanare cauzeaz un lan de evenimente pe acest
nod care apare atomic pn ce alet evenimente nu mai sunt declanate.
Planificarea unei execuii este irul evenimentelor din execuie.
Dac este o execuie atunci top() (respectivc bot()) este restricia planificrii lui la evenimentele din inerfaa top (respectiv bottom) a nivelului top (respectiv bottom).
O execuie este fair dac orice eveniment (diferit de o intrare ntr-un nod) care este activat va apare (odat i odat; execuia nu se oprete prematur, cnd mai exist pai de urmat).
O execuie are calitatea de a fi user-compliant pentru o specificaie de problem P, dac mediul extern satisface restriciile de intrare ale lui P: pentru orice prefix ' a lui unde
este o intrare din mediul extern, dac ' este prefix al unui element din seq(P), atunci aa este i '.
O execuie este corect pentru sistemul de comunicaie C dac bot() este un element al lui seq(C). (Sistemul de comunicaie este corect, n conformitate cu specificaiile de problem
a lui C).
O execuie este (P,C) admisibil dac estge fair, user compliant pentru specificaia de problem P i corect pentru sistemul de comunicaii C.
Atunci cnd P i C sunt clare din context execuia se va numi admisibil.

Simulare
Sistemul de comunicaii C, simuleaz (global) sistemul de comunicaii C2 dac exist o colecie de procese unul pentru fiecare nod numit Sim (procesul de simulare) care
satisface:
1.
2.
3.

Interfaa top a lui Sim este interfaa lui C2.


Interfaa bottom alui Sim este interfaa lui C1.
Pentru orice execuie (C2, C1) admisibil a lui Sim exist un ir n seq(C2) a.. =top().

(Executia simulrii n topul sistemului de comunicaie C1 produce aceleai apariii n mediul extern pe care le face sistemul de comunicaii C2).

C2 input

C2 input

C2 output

C2

C2 output

Sim
C1 input

C1 output

C1
O definiie mai slab a simulrii, este simularea local.
O execuie este local user compliant pentru o specificaie de problem P, dac ' un prefix al lui , unde este o intrare din mediul extern, dac 'seq(P) a.. '|i este
prefix al lui '|i pentru i , atunci seq(P) a.. '|i este un prefix al lui '|i pentru i (mediul extern satisface restriciile de intrare ale lui P pentru fiecare nod, dar nu neaprat
global).
O execuie este (P,C) local admisibil dac este fair, local user compliant i corect pentru sistemul de comunicaii C.
Definiia simulrii locale este aceeai cu a simulrii globale cu excepia condiiei 3 care devine acum:

3'.

Pentru orice execuie (C2, C1) local admisibil a lui Sim seq(C2) a.. |i=top()|i i 0 i n-1.

Convenii de pseudocod
Vom descrie un algoritm asincron de tip MP ca o list de evenimente de intrare i ieire.
Fiecare eveniment va avea un nume i se vor descrie schimbrile locale care vor fi cauzate de apariia acestui eveniment, ntr-un pseudocod secvenia uzual.
Pe lng schimbrile locale de stare, apariia unui eveniment poate cauza i activarea unor evenimante de ieire. Acestea vor fi indicate astfel: "enable input X". Dac
rezultatul unui eveniment de ieire este dezactivarea lui (nu se fac alte schimbri locale) nu va fi trecut n lista de evenimente.
Broadcast and multicast
Pentru a specifica calitatea unui serviciu de broadcast (proprieti ce vor fi descrise mai jos) interfaa descris mai anterior pentru un serviciu broadcast de baz se modific
astfel:

bc-sendi(m,qos): eveniment de intrare asociat procesorului p i, care trimite un mesaj m tuturor procesoarelor; qos este un parametru ce descrie calitatea serviciului
cerut.
bc-recvi(m,j,qos): eveniment de ieire n care procesorul pi primete mesajul m n prealabil difuzat de pj; qos este ca mai sus.

Observaie: Atunci cnd ne referim la un serviciu broadcast de baz vom considera qos=basic. Un mesaj difuzat este primit i de transmitor.
Operaiile bc send i bc recv nu sunt blocante: nu se ateapt ca un mesaj s fie primit de toate procesoarele iar operaia bc recv acioneaz n modul de lucru bazat pe ntreruperi.
Se pot discuta dou categorii de caliti prin adugarea de noi proprieti pentru secvenele admisibile (pe lng cele ale situaiei qos=basic: integrity, no duplicates, liveness).
Ordonare
Un sistem de broadcast single-source FIFO (qos=ssf) satisface proprietile lui basic i

Single-Source FIFO: m1, m2 i pi, pj dac pi trimite m1 nainte de al


trimite pe m2 , atunci pj nu-l primete pe m2 naintea lui m1.
Un sistem de broadcast total ordonat (qos=to) satisface proprietile lui basic i
Totally Ordered: m1, m2 i pi, pj dac m1 este primit n pi naintea lui m2 , atunci m2 nu este primit n pj naintea lui m1.
n cele dou condiii, primit este un bc recv cu qos pe una din cele dou valori iar trimis este un bc send cu qos corespunztor.
Pentru a defini al treilea model de broadcast cu ordonare este necesar s extindem relaia de apariie a unui eveniment naintea altuia, la mesaje.
Se presupune c toate comunicrile de la un nivel superior al aplicaiei se execut numai cu bc send i bc recv (nu exist mesaje "behind of the scenes").
Definiie: Dat o secven de evenimente bc send i bc recv spunem c mesajul m 1 se ntmpl naintea mesajului m2 dac
1.
evenimentul bc recv pentru m1 se ntmpl naintea
evenimentului bc send pentru m2 sau
2.
m1 i m2 sunt trimise de acelai procesor i m1 este trimis naintea lui m2.

Un sistem de broadcast ordonat cauzal, qos=co, satisface proprietile lui basic i


Causally Ordered: m1, m2 i pi dac m1 se ntmpl naintea lui m2 atunci m2 nu-i primit de pi naintea lui m1.
Exemple:
a

a ,b
cauzal ordonat
dar nu-i t.o.

b, a

b, a
t.o
dar nu-i cauzal ordonat

b, a

b, a
ssf dar nu-i t.o.
i nici cauzal ordonat

Sigurana n funcionare (Reliability)

a, b

Un sistem de broadcast este reliable (n prezena a f defecte) dac pentru orice secven de bc send i bc recv sunt satisfcute condiiile: Integrity, No duplicates iar Liveness se
modific astfel:
Nonfaulty Liveness: Dac se consider restrictia lui K la evenimentele asociate procesoarelor nedefecte atunci K este surjectiv (toate mesajele difuzate de un procesor nedefect sunt
primite odat i odat de procesoarele nedefecte).
Faulty Liveness: Dac un procesor nedefect are un eveniment bc recv cruia K i asociaz un eveniment bc send al unui procesor defect, atunci orice procesor nedefect are un
eveniment bc recv cruia K i asociaz acelai eveniment bc send (orice mesaj trimis de un procesor defect este sau primit de toate procesoarele nedefecte sau de niciunul).
Observaie: Condiiile nu depind de tipul de defeciune a procesoarelor; vom considera totui numai defeciuni de tip crash.
Anumite combinaii de proprietilor ale serviciilor de tip broadcast au nume specifice date de importana lor practic:
broadcast atomic = broadcast reliable cu t.o.
broadcast FIFO atomic = broadcast atomic cu ssf.
broadcast cauzal atomic = broadcast atomic cu c.o.
(ultimele dou sunt echivalente).

Implementarea serviciilor de broadcast


1. Basic
Se implementeaz simplu n topul unui sistem point-to-point MP fr defeciuni.
Cnd apare un bc send pentru un mesaj m la un procesor pi, pi folosete sistemul point-to-point MP pentru a trimite o copie a lui m la toate procesoarele.
Cnd un procesor primete mesajul de la pi pe sistemul point-to-point, execut evenimentul bc recv pentru m i i.
2. ssf
Se implementeaz n topul unui sistem basic. Fiecare procesor asigneaz un numr de ordine pentru fiecare mesaj pe care l difuzeaz; acesta este incrementat cu 1 ori de
cte ori un nou mesaj este difuzat. Primitorul unui mesaj de la p i cu numr de secven T ateapt pn se execut bc - recv i cu qos=ssf a tuturor mesajelor de la pi cu numrul de ordine
mai mic dect T.
3. t.o.
Un algoritm nesimetric
Se bazeaz din nou pe un sistem de broadcast basic. Pentru a difuza un mesaj m, procesorul p i l trimite utiliznd basic unui procesor central p c care asigneaz un numr de
ordine i l difuzeaz folosind basic.
Procesoarele execut receive pentru sitemul cu t.o. n ordinea specificat de numrul de ordine al mesajelor, ateptnd dac este necesar pn primesc toate mesajele cu
numr de ordine mai mic.
Clar, ordinea n care se execut receive pentru sistemul cu t.o. este aceeai la toate procesoarele i anume cea n care au fost trimise de procesorul central.
Rolul procesorului central poate fi preluat i de alte procesoare cu ajutorul unui token de identificare care s circule printre procesoare.
Un algoritm nesimetric
Ideea este de a asigna timestamp-uri mesajelor.
Algoritmul se bazeaz pe un sistem de broadcast cu caliti ssf.
Agoritm de broadcast t.o. (codul pentru pi, 0 i n-1)
Iniial ts[j]=0, 0 j n-1 i pending este vid.
1:
2:
3:
4:

atunci cnd apare bc sendi(m,to):


ts[i]:=ts[i] +1
adaug<m,ts[i],i> la pending
enable bc sendi(<m,ts[i]>,ssf)

atunci cnd apare bc recvi(<m,T>,j,ssf) ji :


// ignor mesajele ctre el nsui
6: ts[j]:=T
7: adaug<m,T,j> la pending
8: if T>ts[i] then
9:
ts[i]:=T
10:
enable bc sendi(<ts-up,T>,ssf)
//difuzeaz un mesaj de actualizare a timestamp-ului
5:

11:
12:

atunci cnd bc - recvi(<ts-up,T>,j,ssf) ji:


ts[j]:=T

13:
14:
15:
16:

enable bc recvi(m,j,to) atunci cnd


<m,T,j> este intrarea n pending cu cel mai mic (T,j) i
T ts[k] k
result: remove<m,T,j> din pending

Explicaii:

Fiecare procesor menine un contor cresctor: timestamp-ul su, folosit pentru a tampila mesajele pe care vrea s le difuzeze. n plus, fiecare procesor are un vector n care
estimeaz timestamp-urile celorlalte procesoare. Intrarea j din acest vector semnific faptul c p i nu va primi (nc o dat) un mesaj de la p j cu un timestamp mai mic sau egal cu acea
valoare.
Aceste componente ale vectorului sunt actualizate cu ajutorul timestampe-urilor asociate mesajelor sau folosind un mesaj special de actualizare trimis de p j.
Timestamp-ul propriu al fiecrui procesor va fi mai mare sau egal cu estimarea sa a timestamp-urilor celorlalte procesoare. Atunci cnd procesorul trbuie s-i mareasc
timestamp-ul pentru a asigura condiia precedent va trimite un mesaj de actualizare a timestamp-urilor tuturor celorlalte procesoare.
Fiecare procesor menine o mulime de mesaje ce ateapt s fie primite (pentru sistemul cu t.o.). Un mesaj cu timestamp-ul T este primit t.o., atunci cnd orice intrare n
vector este mai mare sau egal dect T. Fie o execuie fair a algoritmului care este corect pentru sistemul de comunicaii ssf.
Lema 1: Pentru procesor pi i bc sendi(m,to) din , pi asigneaz lui m un timestamp unic i aceste timestamp-uri sunt asignate n ordine cresctoare n raport cu apariiile lor n .
Lema 2: Timestamp-urile asignate mesajelor din , mpreun cu id-urile procesoarelor formeaz o ordine total (aceast ordine este numit ordinea timestamp).
Teorem: Algoritmul precedent este algoritm de broadcast t.o.
Demonstraie:
Trebuie demonstrat c au loc condiiile:
Integrity, No Duplicates, Liveness i Total Ordering.
Primele dou sunt satisfcute deoarece sistemul ssf pe care se bazeaz algoritmul le satisface.
Liveness: Presupunem c exist un procesor pi care are o intrare n pending care atept la nesfrit. Fie <m,T,j> intrarea blocat n pending cu cel mai mic (T,j).
ntruct procesoarele asigneaz timestamp-urile n ordine cresctoare odat i odat <m,T,j> va fi cea mai mic intrare n mulimea pending a lui p i. Pentru a fi blocat
trbuie s existe k a.. T>ts[k] n p i la nesfrit. Deci la un moment dat p i nu mai crete ts[k]. Fie T' cea mai mare valoare pe care p i o d lui ts[k]. Clar, ki. Deci de la un loc ncolo p i nu
mai primete mesaje de la p k (n sistemul ssf). Deci p k nu va mai trimite mesaje cu timestamp-ul mai mare dect T'. Dar aceasta nseamn c p k nu va primi mesajul <m,T,j> de la p j
contrazicnd corectitudinea sistemului ssf.
Total Ordering: Presupunem c pi execut bc recvi(m1,j1,to) i apoi
bc recvi(m2,j2,to). Trebuie s artm c (T1,j1)< (T2,j2) unde Ti este timestamp-ul lui mi, (i=1,2).
Cazul I: <m2,T2,j2> este n pendingi atunci cnd bc recv i(m1,j1,to) apare. Atunci, clar, (T1,j1)< (T2,j2) ntruct, altfel, m2 ar fi fost acceptat naintea lui m1.
Cazul II: <m2,T2,j2> nu este n pendingi atunci cnd bc recv i(m1,j1,to) apare.
Avem T1 tsi[j2]. Deci pi a primit un mesaj m de la

p j2

(pe sistemul ssf) naintea acestui moment cu timestamp-ul T T1. Din proprietatea ssf,

p j2

trimite m2 dup ce el trimite m

i deci timestamp-ul T2 al lui m2 este mai mare dect T. Deci T2 > T1.
Cauzalitate
S observm c timestamp-ul asignat unui mesaj m difuzat de pi este strict mai mare dect timestamp-ul oricrui mesaj primit de pi dup primirea mesajului m. Deci:
Teorem: Algoritmul precedent este un algoritm de broadcast c.o.
Observaie: Cauzalitatea se poate obine i fr t.o., pornind de la un sistem de broadcast basic i folosind timestamp-urile vectoriale. O raiune pentru aceasta, este aceea c se poate
obine calitatea c.o. chiar n prezen defeciunilor n timp ce t.o. nu poate fi asigurat n prezena defeciunilor.
Reliabilitate
Vom implementa un serviciu de broasdcast reliabil n topul unui sistem cu MP point-to-point n prezena a f cderi. Interfaa sistemului MP point-to-point este fomat din
evenimente de intrare sendi(M), recvj(M) unde M este o mulime de mesaje, ficare mesaj incluznd o indicaie a trimitorului i a primitorului. Secvenele admisibile se definesc
avnd urmtoarea proprietate (procesoarele sunt partiionate n defecte i nedefecte primele fiind n numr de cel mult f).
Integrity: Orice mesaj primit de un procesor pi i-a fost n prealabil trimis de
un procesor.
No duplicates: Nici un mesaj trimis nu este primit mai mult de o singur
dat.
Nonfaulty Liveness: Orice mesaj trimis de un procesor nedefect la un
procesor nedefect va fi odat i odat primit.
Algoritmul de broadcast reliabil (codul pentru pi, 0 i n-1)
la apariia lui bc sendi(m,reliable):
1: enable bc sendi(<m,i>,basic)
la apariia lui bc recvi(<m,k>,j,basic):
2: if m nu a fost deja primit then
3:
enable bc sendi(<m,k>,basic)
4:
enable bc recvi(m,k,basic)
Teorem: Algoritmul precedent este un algoritm de broadcast reliabil.
Observaii:
1: Calitatea de ssf se obine exact ca n cazul lipsei cderilor.
2: Broadcast-ul t.o. reliabil nu se poate obine atunci cnd sistemul pe care se bazeaz este asincron (altfel s-ar putea rezolva problema consensului n sisteme asincrone)
3: Broadcast-ul c.o. se obine utiliznd algoritmul dat pe un sistem de broadcast reliabil.
4: Toate problemele de implementare precedente pot fi extinse pentru a considera aa numitul multicast n care un mesaj trebuie trimis la un grup de procesoare i nu la toate.
Implementarile sunt simple atunci cnd grupurile sunt statice. Atunci cnd grupurile se pot modifica, n fiecare execuie apar probleme la ntreinerea dinamic a lor.

Memorie Partajat Distribuit

Memoria Partajat Distribuit (Distributed Shared Memory), DSM, este o simulare a unui sistem de comunicaie bazat pe memorie partajat cu ajutorul unui sistem de tip
transmitere mesaje (MP).

SIM

Memorie Partajat

Sistem MP

Programul de simulare va fi numit MCS (memory consistency system) care este alctuit din procese locale n fiecare procesor p i. Schematic:
Pentru simplitate, vom considera c obiectele din memoria partajat sunt regitri read/write.De asemenea, nu vom considera defeciuni ale procesoarelor.
Fiecare obiect partajat are o specificare secvenial care indic comportarea dorit a obiectului n absena concurenei.
O specificare secvenial const dintr-o mulime de operaii i o mulime de secvene de operaii (mulimea secvenelor legale de operaii).

rspuns
Invoc.

Invoc.
MCS
n
p0

send

rspuns

rspuns
Invoc.

MCS
n
p1

receive
send

MCS
n
p n-1

receive

send

receive

REEAUA
DSM
Exemplu: Un obiect read/write X suport operaiile read i write.
Invocarea unui read este readi (X) i rspunsul returni (X, v), unde i indic nodul i v valoarea returnat.
Invocarea unui write este writei (X, v) i rspunsul acki (X)
O secven de operaii este legat dac fiecare read returneaz valoarea celui mai recent write precedent (valoarea iniial dac aceast nu exist).
Sistem de comunicatie Linearizable Shared Memory ( LSM)
Intrri:

invocri ale obiectelor partajate.

Ieiri:

rspunsuri din obiectele partajate.

Secvenele admisibile:

O secven de intrri i ieiri este admisibil dac satisface:

Correct interaction: i I este un ir alternat de invocri i rspunsuri


pereche, ncepnd cu o invocare (fiecare procesor trebuie s
atepte un rspuns de la un obiect nainte de a invoca un alt
obiect; este interzis accesul tip pipeline)
Liveness: invocare are un rspuns pereche.
Linerizability: Exist o permutare a tuturor operaiilor din a..
1.

pentru orice obiect O, O este legal (adic aparine specificarii secveniale a lui O)

2.

dac rspunsul la operaia o1, apare n nainte de invocarea operaiei o2, atunci o1 apare naintea lui o2 n .

(Este posibil o reordonare a operaiilor din secvena a.. s respecte


semantica obiectelor exprimata de specificarile secventiale- si
ordonarea dup timpul real de apariie a evenimentelor, n toate nodurile.)

Exemplu: Fie x i y regitri, iniializai cu 0.


Atunci 1 = write0(x, 1) write1(y, 1) ack0(x) ack1(y) read0(y) read1(x) return0(y,1) return1(x, 1) este liniarizabil ntruct 1 = w0w1r1r0 este o permutare care satisface condiiile din
definiie.
ns, 2 = write0(x, 1) write1(y, 1) ack0(x) ack1(y) read0(y) read1(x) return0(y,0) return1 (x, 1) nu-i liniarizabil.
Pentru a respecta semantica lui y, r0 trebuie s precead w1. Dar aceasta nu respect ordonarea dup timpul real pentru c w1 precede r0 n 2.
Sistemul de comunicaie memorie partajat secvenial consistent
Aceleai intrri i ieiri iar secvenele admisibile satisfac Correct interaction, Liveness i
Sequentially consistent: Exist o permutare a operaiilor din a..
1.

pentru orice obiect O, |O este legal.

2.

dac rspunsul pentru operaia o1 n nodul pi (oarecare) apare n naintea invocrii operaiei o2 n nodul pi, atunci o1 apare naintea lui o2 n .

1.

Se cere deci ca s se pstreze ordinea operaiilor din acelai nod care nu se suprapun i nu pentru toate operaiile.

2.

n exemplul precedent 2 este secven consistent, permutarea dorit este w0r0w1r1. Deci condiia de liniarizare este mai tare dect condiia de consisten secvenial.

Observaii:

Exist secvene care nu sunt secvenial consistente:


3 = write0(x, 1) write1(y, 1) ack0(x) ack1(y) read0(y) read1(x) return0(y,0) return1(x,0).
Pentru a respecta semantica lui x i y trebuie ca r 0 s precead w1 i r1 s precead w0. Pentru a respecta ordinea evenimentelor din p 1 trebuie ca w1 s precead r1. Din tranzitivitate
rezult c r0 precede w0 care ncalc ordinea evenimentelor n p0.

Algoritmi
Vom presupune c sistemul MP de baz suport broadcast t.o. (am artat cum poate fi implementat). Pentru a evita confuzia vom folosi:

tbc sendi(m) pentru bc sendi(m,t.o.) i

tbc recvi(m) pentru bc recvi(m,t.o.)

Toi algoritmii folosesc replicarea complet: exist o copie local a oricrui obiect partajat n starea procesului MCS din fiecare nod. (Aa cum se face, de exemplu n ORCA;
gestionarea copiilor n alt stil este posibil dar aceasta este o alt problem).
Algoritm pentru simularea unui DSM liniarizabil
Atunci cnd procesul MCS dintr-un nod primete o cerere s citeasc sau s scrie un obiect partajat:

MCS trimite un mesaj broadcast coninnd cererea i ateapt s-i primeasc mesajul su.

Dup primirea mesajului, execut rspunsul pentru operaia ce ateapt (returnnd valoarea copiei obiectului pe care o deine el pentru un read i executnd ack
pentru write).

Ori de cte ori un proces MCS primete un mesaj difuzat pentru un write, actualizeaz copia obiectului, n mod corespunztor.

Teorem: Dac sistemul de broadcast este total ordonat atunci algoritmul precedent simuleaz un DSM liniarizabil.
Demonstraie: Fie o execuie admisibil a algoritmului (fair, user compliant pentru sistemul cu memorie partajata si corecta pentru sistemul broadcast de comunicaie). Trebuie s
demonstrm c top() este liniarizabil. Fie = top(). Ordonm operatiile din dup ordinea total a broadcast-urilor asociate lor din i obinem o permutare .

respect semantica obiectelor. Fie x un obiect read/write. |x sete secvena operatiilor ce acceseaz x. Cum broadcast-urile sunt t.o., orice proces MCS primete mesajele pentru
operaiile asupra lui x n aceeai ordine, care este ordinea lui , i gestioneaz x corect.

respect ordonarea dup timpul real de apariie a operaiilor n .


Presupunem c o1 se termin n nainte ca operaia o2 s nceap.

Atunci broadcast-ul corespunztor lui o 1, a fost primit de iniiatorul su nainte ca broadcast-ul lui o 2 s fie trimis de iniiatorul su. Evident, boadcastul lui o 2 este ordonat dup cel al
lui o1. Deci operaia o1 apare n naintea lui o2.
Observaie: Cum un serviciu broadcast t.o. se poate implementa n topul unui sistem MP point-to-point, rezult c un DSM liniarizabil se poate implementa n topul unui sistem MP.
Nu este evident de ce trebuie difuzat un mesaj pentru operaia read, atta timp ct nu se modific nici o copie a obiectului ca rezultat al primirii mesajului de citire.
Considerm algoritmul n care read-ul returneaz imediat valoarea din copia procesului MCS respectiv i renun la broadcast.

Fie o execuie n care valoarea iniial a lui x este 0. Procesorul p i invoc o scriere a lui 1 n x i execut un tbc send pentru write. Mesajul difuzat ajunge la procesorul p j
care-i actualizeaz copia sa local a lui x pe 1, dup care, sa spunem, execut un read pe x ce returneaz valoarea nou 1. Considerm un al treilea procesor p k care nu a primit mesajul
de broadcast al lui pi i are nc valoarea copiei lui x pe 0. Presupunem c pk citete x (dup ce pj execut read, dar nainte de a primi broadcastul lui pi); clar va obine valoarea 0.
Nici o permutare a acestor trei operaii nu poate fi i conform cu specificaia lui read/write i s pstreze ordonarea dup timpul real de apariie a operaiilor n .
Totui acest algoritm ndeplinete condiia de consisten secvenial.
Algoritm de consisten secvenial cu read local
(codul pentru procesorul pi)
Iniial, copy[x] pstreaz valoarea iniial a obiectului partajat x pentru orice x.
1:

atunci cnd apare readi(x):

2:
3:

enable returni(x, copy[x])


atunci cnd apare writei(x,v):

4:
5:

enable tbc sendi(x,v)


atunci cnd apare tbc recvi(x,v) din pj :

6:

copy[x]:=v

7:

if j=i then enable acki(x)

Fie o execuie admisibil a algoritmului.


Lema 1:

Pentru orice procesor pi copiile locale ale lui pi sunt actualizate de operaiile write n aceeai ordine n fiecare procesor i aceast ordine psteraz ordinea operaiilor write

asociate fiecrui procesor.


Aceast ordine va fi numit ordine tbcast.
Lema 2:

Pentru orice procesor pi i orice obiecte partajate x i y dac un read r al obiectului y urmeaz dup un write w asupra obiectului x n top()|i atunci readul r al copiei locale

a lui pi a lui y urmeaz dup write-ul w al lui pi asupra copiei locale a lui x.
Din cele dou leme rezult.
Teorem: Algoritmul precedent implementeaz un DMS secvenial consistent cu read local.
Demonstraie: Trebuie demonstrat c top() satisface condiia de consisten secvenial.
Construcia lui .
Ordonm write-urile din conform ordinii tbcast. Trebuie s mai inserm read-urile. Pentru fiecare read din parcurs de la stnga la dreapta: Read-ul r executat de pi asupra lui x este
plasat imediat dup ultima apariie din asociat (1) apariiei precedente din asupra lui pi (read sau write asupra oricrui obiect) i (2) write-ului care a cauzat ultima actualizare a
copiei locale a lui x deinut de pi, care precede punctul n care returul lui r a fost activat.
n caz de egalitate se folosete id-ul procesoarelor pentru stabilirea ordinii (de exemplu dac orice procesor citete un obiect inainte ca orice procesor s scrie un obiect atunci ncepe
cu read-ul lui p0, urmat de read-ul lui p1 .a.m.d).
Trebuie demonstrat c top()|i=|i. Din construce, pentru un procesor p i fixat ordinea relativa a dou read sau a dou write este aceeai n top( )|i ca i n |i. Ceea ce trebuie artat
este c r i w sunt n aceast ordine i aceasta rezult din codul algoritmului. n plus trebuie artat c este legal.
Se poate inversa rolul celor dou operaii:
Facem write-ul local i read-ul ncet (datorit tbc send-urilor)
Algoritmul de consisten secvenial cu write local
(codul pentru procesorul pi 0 i n-1)
Iniial, copy[x] pstreaz valoarea iniial a obiectului partajat x pentru x i num=0.
1:
2:
3:

Atunci cnd apare readi(x):


if num=0 then enable returni(x,copy[x])
atunci cnd apare writei(x,v):

4:

num:=num+1

5:

enable tbc sendi(x,v)

6:

enable acki(x)

7:
8:

atunci cnd apare tbc recvi(x,v) din pj:


copy[x]:=v;

9:

if j=i then

10:

num:=num-1

11:

if num=0 and (exist un read care ateapt pe x) then

12:

enable returni(x,copy[x])

Ideea algoritmului: Cnd apare un write(x) n p i se trimite un mesaj de broadcast ca i n algoritmul precedent; totui el este confirmat imediat. Cnd apare un read(x) n p i, dac pi nu
are actualizri care ateapt (pe obiect nu numai pe x) atunci returneaz valoarea curent a copiei sale a lui x. Altfel, ateapt pn primete mesajul de broadcast pentru toate writeurile pe care el le-a iniiat i abia atunci returneaz. Aceasta se realizeaz meninnd un contor al tuturor write broadcasturilor iniiate de el i ateapt pn acesta este zero.
n esen, algoritmul implementeaz un pipeline pentru actualizarea write-urilor generate de acelai procesor.
Teorem: Algoritmul precedent implementeaz un DMS secvenial consistent cu write local.
Observaie: Acest algoritm, ca i precedentul nu asigur linearitatea.

Margini inferioare
Vom presupune c DSM a fost implementat n topul unui sistem de tip MP, point-to-point.
Adaptm definiia unei execuii cu timpi (timed execution) pentru sistemul simulat, considernd c numai evenimentelor de intrare ntr-un nod li s-au asignat timpi,
celelalte evenimente din nod motenind timpii evenimentelor de intrare n nod, care le-au declanat.
n plus vom considera c:

orice mesaj are o ntrziere ntr-un interval [d-u,d], unde 0 < u d.

Pentru un MCS fixat i o operaie op vom nota cu t op timpul, n cazul cel mai nefavorabil, peste toate execuiile admisibile, necesitat de operatia op (diferena dintre timpul real de
apariie a rspunsului i timpul real de apariie al invocarii).
Teorema 1: Pentru orice MCS secvenial consistent care asigur dou obiecte partajate read/write, t read + twrite d.
Demonstraie: Fie un MCS secvenial consistent i dou obiecte partajate x i y, iniial 0 amndou.
Exist o execuie admisibila 0 a lui MCS a..
top(0) = write0(x, 1) ack0(x) read0(y) return0(y,0)
i write ncepe la timpul 0 iar read rspunde inaintea timpului d.
Presupunem, n plus, c orice mesaj trimis in 0 are intirzierea d. Rezulta ca nici un mesaj n-a fost primit de nici un nod la momentul de timp cnd read primete rspunsul.
Similar, exist o execuie admisibil 1 a lui MCS a..
top(1) = write1(y, 1) ack1(y) read1(x) read1(x) return1(x,0)
write apare la timpul 0, rspunsul la read apare naintea timpului d. Deci nici un mesaj n-a fost primit n nici un nod la momentul de timp cnd read primete rspunsul.
Vom construi o nou execuie care combin comportarea lui p0 n 0 (n care p0 scrie x i citete y) cu comportamentul lui p 1 n 1 (scrie y i citete x). Cum amndoua
operaiile pe fiecare procesor se termin nainte de momentul d, p 0 nu tie despre opearaiile lui p1 i invers. Deci procesoarele returneaz aceeai valoare n pe care ele le fac n 0
(1). Dup timpul d n , se permite ca orice mesaj ce ateapt s fie livrat, dar este deja prea trziu pentru a mai afecta valorile returnate anterior. Clar, aceste valori sunt inconsistente
cu condiia de consisten secvenial.
Formal, fie i|i (i=0,1) i i prefixul cel mai lung al lui i|i ce se termin naintea timpului d, i '=merge(0, 1). ' este prefixul unei execuii admisibile . Dar top() este
exact secvena 3 din observaia de dup definiia condiiei de secvenial consisten, care s-a vzut c nu-i secvenial consistent.
Observaie: Marginea inferioar obinut este valabil n particular i pentru MCS liniarizabil. n acest caz se poate spune chiar mai mult.
Teorema 2: Pentru orice MCS liniarizabil care asigur un obiect partajat read/write scris de dou procesoare i citit de un al treilea

write

u
2

Demonstraie: Fie un MCS liniarizabil i un obiect partajat x iniial 0 care este citit de p0 i scris de p1 i p2. Presupunem prin reducere la absurd ca
Exist o execuie admisibil a lui MCS a..

top() = write1(x, 1) ack1(x) write2(x, 2) ack2(x) read0(x) return0(x,2).

write1(x,1) apare la timpul 0, write2(x,2) apare la timpul u/2 i read0(x) apare la timpul u.

ntrzierile mesajelor n sunt: d din p1 la p2; d-u din p2 la p1 i d-u/2 pentru orice alt pereche ordonat de procesoare.

Fie =shift(,<0,u/2,-u/2>) adic l dm pe p1 nainte cu u/2 i pe p2 napoi cu u/2.

write

u.
2

este nc admisibil, ntruct ntrzierea mesajelor din p1 sau n p2 devine d-u, ntrzierea mesajelor din p2 sau n p1 devine d i toate celelalte ntrzieri rmn neschimbate.
Dar top()=write2(x, 2) ack2(x) write1(x, 1) ack1(x) read0(x) return0(x,2). Dar aceasta ncalc liniarizabilitatea deoarece read-ul lui p0 ar trebui s returneze 1 i nu 2.

u/2

r(x,2)

p0
w(x,1)

p1
:
p2

w(x,2)

u/2

p0

r(x,2)

w(x,1)

: p1
w(x,2)

p2

Teorema 3: Pentru orice MCS care asigur un obiect partajat x citit de dou procesoare i scris de un al treilea

write

u
4

Demonstraie: Fie un MCS liniarizabil i x un obiect partajat, iniial 0 care este scris de p0 i citit de p1 i p2. Presupunem prin reducere la absurd c

write

u
4

Ideea demonstraiei este aceeai ca n teorema precedent, numai c este ceva mai elaborat.
Fie

K twrite/n

. Considerm o execuie admisibil a lui MCS n care toate ntrzierile mesajelor sunt d-u/2 cominnd urmatoarele evenimente:

La momentul u/4, p0 face un write0(x,1)

La un moment intre

La momentul

La un moment ntre

La momentul

La un moment ntre

2i

2i

u
4

4k 1 n , p face ack (x). ( 4k 1 n n twrite i deci write-ul lui p se termin n acest interval).
0

n
, p1 face read1(x) 0 i 2k.
4
2i

n
4

4i 1 n , p face return (x,V ) 0 i 2k.


4

2i

n
, p2 face read2(x) 0 i 2k.
4

2i 1 n i 2i 2 n , p face return (x,V


4

2i+1

) 0 i 2k.

Deci n top(), read-ul lui p1 al lui V0 precede write-ul lui p 0, read-ul lui p2 al lui V4k+1 urmeaz dup write-ul lui p0, nu avem read-uri suprapuse i ordinea citirilor valorilor din x este
V0, V1, V2,...,V4k+1.
Din liniarizabilitatea v0=0 i V4k+1=1. j 0 j 4k a.. Vj=0 i Vj+1=1. Presupunem c j este par deci Vj este rezultatul unui read al lui p1.
Definim =shift(,<0,0,-n/4>) adic l dm napoi pe p 2 cu n/4. este admisibil, ntruct ntrzierea mesajelor n p2 devine d-n, ntrzierea mesajelor din p 2 devine d i
celelalte ntrzieri rmn neschimbate.

Rezultatul shift-rii este c s-a schimbat ordinea operaiilor read n raport cu


v1, v0, v3, v2,...,vj+1, vj,..... Deci n top() avem vj+1=1 citit naintea lui vj=0, care violeaz liniarizabilitatea.

u/4
2u/4
r(x,v1)

0
p2
r(x,v0)

: p1

4ku/4
r(x,v3)

(4k+1)u/
4r(x,V4k+1)

r(x,V4k)

r(x,v2)

p0
w(x,1)
p2
: p1

r(x,v1)

r(x,v3)
r(x,v0)

r(x,V4k+1)
r(x,v2)

r(x,V4k)

w(x,1)

p0

Simulri tolerante la defeciuni ale obiectelor read-write


Simularea unui obiect de nivel nalt cu unul de nivel jos este util pentru proiectarea algoritmilor folosind primele obiecte dei execuia se face ntr-un sistem realist ce
dispune doar de ultimele.
Vom prezenta simulri de sisteme cu memorie partajat n topul altor tipuri de obiecte cu memorie partajat sau n topul unui sistem asincron de tip transmisie de mesaje, n
prezena defeciunilor de tip crash.
Considerarea cderilor se poate face n dou moduri echivalente: definim un sistem de memorie partajat care s permit defeciuni sau modificm definiia simulrii
pstrnd definiia sistemelor de memorie partajat libere de defeciuni.

Sistem cu memorie partajat f-rezilient


Intrrile sunt invocri ale obiectelor partajate i ieirile sunt rspunsuri de la obiectele partajate. Se presupune o partiie a procesoarelor cu dou clase, procesoare defecte i nedefecte,
numrul celor defecte este mai mic sau egal cu f. O secven de i|o este admisibil dac urmtoarele proprieti au loc:
Correct Interaction: Pentru fiecare procesor pi, |i este ir alternat de invocri i rspunsuri pereche, ncepind cu o invocare.
Nonfaulty Liveness: Orice invocare a unui procesor nedefect are un rspuns pereche.
Extended Liniarizability: Exist o permutare a tuturor operaiilor complete din (cele care au rspuns) i a unei submulimi a operaiilor incomplete a..:
1.
|o este legal pentru orice obiect o.
2.
Dac n , rspunsul la operaia o1 apare naintea invocrii lui o2 , atunci o1 apare naintea lui o2 n .
Vom studia dac sistemul de comunicaie C1 poate simula sistemul de comunicaie C2 , unde C2 este un sistem cu memorie partajat cu un anumit tip de obiecte care
admite f cderi de procesoare, iar C1 este un sistem de comunicaie (sau cu memorie partajat sau de tip MP) care admite f cderi de procesoare.
De fapt vom discuta cazul f=n-1, numit wait-free datorit definiiei urmtoare echivalente.
O simulare a unui sistem de tip memorie partajat (fr defeciuni) de ctre alt sistem de tip memorie partajat (tot fr defeciuni) se numete wait-free dac:
Pentru orice execuie admisibil a programului de simulare, daca ' este un prefix n care un procesor p i are o operaie incomplet (exist n ' o invocare din
mediul extern n pi fr un rspuns pereche) =', atunci |pi conine rspunsul la aceast operaie.
(Orice operaie trebuie s fie capabil s se termine n orice punct fr asistena altor procesoare, f=n-1; operaiile pe procesoarele nedefecte se desfoar normal).
Observaie: Condiia de liniarizabilitate corespunde intuiiei c operaiile (de nivel nalt) apar ca fiind executate atomic ntr-un anumit moment n timpul execuiei lor. Acest
moment se afl undeva ntre invocarea i rspunsul la operaie i se numete punct de liniarizabilitate. Un mod de a demonstra c o secven este liniarizabil este acela de a
asigna explicit fiecrei operaii un punct de liniarizabilitate. Acesta va asigura ordinea temporal a operaiilor ce nu se suprapun. Dac se arat n plus c fiecare nod
returneaz valoarea operatorului write cu punctul de liniarizabilitate cel mai recent ce precede operatorul read, am demonstrat c execuia este liniarizabil.
Vom prezenta n continuare urmtorul lan de simulri wait-free ale registrelor de tip read-write.

single writer
single reader
binary

single writer
single reader
multi-valued

single writer
multi reader
multi valued

multi-writer
multi reader
multi-valued

1.

Binar Multivaluat

Un registru este single reader (s r) dac exist un singur procesor (cititorul) ce poate citi din el i single writer dac exist un singur procesor (scriitorul) ce
poate scrie n el, (s w).
Simularea unui registru cu K valori, de tip s r, s w cu ajutorul unor registre s r, s w cu valori binare.
Pentru simplitate vom considera un singur registru R cu K valori i dou procesoare bine definite scriiorul i cititorul. Pentru simularea lui R, vom considera un tablou de K
regitri binari B[0..K-1]. Valoarea i va fi reprezentat de un 1 n componenta B[i] i 0 n celelalte. Deci, valorile posibile ale lui R sunt {0,1,...,K-1}.
O operaie read(R) va fi simulat prin scanarea vectorului B ncepnd cu indicele 0 i returnnd prima component egal cu 1 (dac exist). O operaie
write(R,v) va fi simulat punnd 1 n B[v] i i tergnd componenta egal cu 1 ce corespunde valorii precedente a lui R.
Acest scenariu simplu funcioneaz n cazul operaiilor R i W care nu se suprapun.
Dac operaiile cititorului sunt n ordine read(R,2) read(R,1)iar ale scriitorului write(R,1) write(R,2) atunci, o liniarizare a acestor operaii va trebui s se
pstreze ordinea operaiilor fiecrui procesor. Pentru a fi ndeplinit semantica registrului R va trebui ca write(R ,1) s apar nainte de read(R,2) pe cnd write(R,1) trebuie
s apar nainte de read(R,1) i dup read(R,2). Deci, sau ordinea operaiilor read sau ordinea operaiilor write trebuie schimbat. Algoritmul urmtor rezolv aceast
problem a inversiunilor "nou vechi" ale valorilor.
Algoritmul de liniarizare registru multi-valuat cu registre binare
Iniial regitrii partajati B[0].....B[K-1] sunt 0 cu excepia lui B[i]=1, unde i este valoarea iniial a lui R
1:
2:
3:
4:
5:
6:
1:
2:
3:

cnd apare read(R):


//cititorul citete din registrul R
i:=0
while B[i]=0 do i:=i+1
up,v:=i
for i:=up-1 downto 0 do
if B[i]=1 then v:=i
return(R,v)
cnd apare write(R,v): //scriitorul scrie valoarea v n registrul R
B[v]:=1
for i:=v-1 downto 0 do B[i]:=0
ack(R)

Evident , algoritmul este wait-free; fiecare write execut cel mult K operaii write de nivel jos iar fiecare read execut cel mult 2K-1 operaii read de nivel jos.
Pentru a demonstra c algoritmul este corect trebuie s artm c orice execuie edmisibil este liniarizabil, admite o permutare a operaiilor de nivel nalt a.. s se
pstreze ordinea operaiilor care nu se suprapun i n care orice read returneaz valoarea ultimului write precedent.
Fixm o execuie admisibil a algoritmului. Cum este corect pentru sistemul de comunicaie cu registre binare, operaiile cu registre binare sunt liniarizabile. Deci
fiecare operaie de nivel jos admite un punct de liniarizabilitate.
Asociem fiecrei configuraii a execuiei o "valoare actual" a registrului multivaluat R: valoarea actual a lui R este

k min i | i 0,1, , K 1 , B i 1, B 0 B i 1 0

n aceast definiie valoarea lui B(i) este n raport cu punctele de liniarizabilitate ale operaiilor de nivel jos.
Construim o liniarizare a lui . Punctele de liniarizabilitate al operaiei write(R,k) este imediat dup prima configuraie din intervalul ei n care b[k]=1 i B[0]=...=B[k-1]=0. La
terminare alui write(R,k) (atunci cnd apare ack(R)) aceasta este situaia, dar punctul de liniarizabilitate poate fi mai nainte (dac, de exemplu valoarea precedent a lui R a fost mai
mare dect k, el este imediat dup execuia operaiei de nivel jos B[k]:=1).
Punctul de liniarizabilitate a lui read(R) care se termin cu return(R,k) este imediat dup prima configuraie din intervalul ei, n care k este asignat variabilei locale v, (linia 3 sau 5).
Lema 1: Valoarea actual a lui R rmne fix ntre dou puncte de liniarizabilitate ale operaiei write consecutive de nivel nalt.
Lema 2: Pentru fiecare operaie read r (de nivel nalt) din 2, r returneaz valoarea scris n R de operaia write (de nivel nalt) cu ultimul punct de liniarizabilitate naintea ultimului
punct de liniarizabilitate al lui r.
Din cele dou leme rezult urmtoarea
Teorem. Algoritmul precedent reprezint o simulare wait-free a unui registru K-valuat folosind K regitri binari s-r, s-w, n care fiecare operaie necesit O(K) operaii de nivel jos.
2.

Single reader Multi reader

Mai multe procesoare (n) citesc din acelai registru. Vom permite existena unui singur scriitor pentru fiecare registru. Registrului R i se va asocia o colecie de n registre s
w, s r Val[i] i=1,n , unul pentru fiecare cititor.
Un scenariu simplu de simulare:

write(R,v) va obliga cititorul s parcurg toate cele n registre Val[i] i s memoreze v n ele.

read(R) : cititorul i returneaz valoarea din Val[i].


Din pcate aceast simulare este incorect, exist execuii care nu sunt liniarizabile.
Exemplu:
Valoarea iniial a registrului este 0. Scriitorul pw dorete s scrie 1 n registru. Considerm urmtoarea secven de operaii:

pw starteaza operaia de write(R,1), scriind 1 n Val[1]


p1 citete din R i returneaz 1 din Val[1]
p2 citete din R i returneaz 0 din Val[2]

pw primete ack dup scrierea lui 1 n Val[1], scrie 1 n Val[2] i confirm (ack) scrierea sa (de nivel superior).
Citirea lui p1 trebuie ordonat dup scrierea lui p w i citirea lui p 2 naintea scrierii lui p w. Deci citirea lui p1 trebuie ordonat dup citirea lui p 2.Totusi, citirea lui p1 apare naintea citirii
lui p2.
Are loc urmtoarea teorem:
Teorem:
n orice simulare wait-free a unui registru s w, m r cu orice numr de registre s r, s w, cel puin un cititor trebuie s scrie.

Soluia pentru simulare va necesita ca cititorii s-i scrie unii altora creind o ordine ntre ei. nainte de a returna valoarea din read-ul su, un cititor i va anuna pe ceilali
aceasta valoare. Un cititor va citi valoarea scris de scriitor pentru el, dar i valorile anunate de ceilali cititori. Va alege cea mai recent valoare pe care el a citit-o. Vom presupune c
registrele pot lua un numr nemrginit de valori. n aceast ipotez, scriitorul poate asocia un numr ntreg drept timestamp (a cta oar a scris) pentru fiecare valoare scris. n
continuare vom referi o valoare ca fiind perechea ce conine o valoare real i numrul su de ordine.
Se vor folosi tablourile de registre s r :
Val[i]: valoarea scris de pw pentru cititorul pi 1 i n
Report[i,j]: Val returnat de cea mai recent operaie read
executat de pi; scris de pi i citit de pj 1 i,j n
Algoritm de simulare a unui registru m r R cu regitri s r
Iniial, Report[i,j]=Val[i]=(v0,0) 1 i,j n (unde v0 este valoarea iniial a
lui R)
cnd apare readr(R) :
1:
2:
3:
4:
5:
6:
7:

//cititorul r citete din registrul R

(v[0],s[0]):=Val(v) // cea
for i:=1 to n do

mai recent valoare raportat lui pr , de scriitor.

(v[i],s[i]):=Report[i,r] // cea mai


fie j a. . s[j]=max(s[0],s[1],...,s[n])
for i:=1 to n do
Report[r,i]:= (v[j],s[j]) // pr
returnr(R,r[j])

recent valoare raportat lui pr , de pi

raporteaz fiecarui cititor pi

cnd apare write(R,v) : //scriitorul scrie n registrul R


seq:=seq+1
8:
for i:= to n do
9:
Val[i]:=(v,seq)
10:
ack(R)
11:
Algoritmul este waitfree : fiecare operaie simulat execut un numr fix de oparaii de nivel jos (n pentru write i 2n+1 pentru read).
Liniarizabilitatea se demonstreaza considerind o execuie admisibil oarecare si construind explicit permutarea .
3.

Single writer Multi writer

Ideea algoritmului de simulare. Fiecare scriitor anun valoarea pe care intenioneaz s o scrie, tuturor cititorilor (scriindu-le-o n registrul fiecruia, registru de tip s w, m
r). Fiecare cititor citete toate valorile scrise de scriitori i o alege pe cea mai recent dintre ele. Depistarea valorii cea mai recent se face cu ajutorul unui timestamp asociat fiecrei
valori. Spre deosebire de algoritmul precedent, timestamp-ul nu este generat de un singur procesor (unicul writer) ci de mai multe procesoare (toi scriitorii posibili).
Scriitorii sunt p0,...,pm-1 iar cititorii sunt toate procesoarele p0,p1,...,pn-1. Se vor folosi tablourile de registri s w, m r :
TS[i] timestamp-ul vectorial al scriitorului pi 0 i m-1. Este scris de pi i citit de toi scriitorii.
Val[i] Ultima valoare scris de scriitorul pi 0 i m-1, mpreun cu timestamp-ul vectorial asociat cu acea valoare. Scris de pi i citit de toi cititorii.
Algoritm de simulare a unui registru m w R cu regitri s w
Iniial, TS[i]=<0,...,0> i
Val[i] este valoarea iniial a lui R 0 i m-1
cnd apare readr(R):
// cititorul pr citete din registrul R, 0 r n
1: for i:=0 to m-1 do (v[i],t[i]):=Val[i]
//v,t sunt locale
2: fie j a.. t[j]=max{t[0],...,t[m-1]}
// maximul lexicografic
3: returnr(R,v[j])
cnd apare writew(R,v): //scriitorul pw scrie v n R, 0 w m-1
4: ts:=NewCTS()
//ts este local
5: val[w]:=(v,ts)
6: ackw(R)
procedure NewCTSw() //scriitorul pw obine un nou timestamp vectorial
1: for i:=1 to m do lts[i]:=TS[i].[i]
2: lts[w]:=lts[w]+1
3: TS[w]:=lts
4: return lts
Simularea regitrilor partajai n sisteme de tip MP
n cazul existenei defeciunilor, metoda descris pentru simularea memoriei partajate n topul unui sistem broadcast t.o., bazat pe ateptarea confirmrii din sistemul MP,
nu mai funcionaz. Atunci cnd exist defeciuni, un procesor nu poate fi sigur c va primi un mesaj trimis ctre el. Mai mult, nu poate atepta o confirmare de la destinatar, pentru c
acesta poate pica.Vom folosi toate procesoarele ca extra memorie pentru a implementa fiecare registru partajat (nu numai scriitorii i cititorii acelui registru). Desigur, valorile sunt
acompaniate de numare de ordine. Metoda pe care o vom descrie funcioneaz n ipoteza c numrul procesoarelor defecte f satisface f < n/2 (se poate demonstra c nu este posibil o
simulare a unui registru read/write n topul unui sistem asincron MP dac n2f).
Considerm un registru particular ce va fi simulat. Cnd scriitorul dorete s scrie o valoare n acest nou registru, incrementeaz un numr de ordine i trimite un mesaj
<newval> coninnd noua valoare i numrul de ordine, tuturor procesoarelor.
Fiecare primitor actualizeaz o variabil local cu aceast informaie, dac numrul de ordine asociat este mai mare dect valoarea curent a numrului de ordine din
variabila local; n orice eveniment receptorul trimite un mesaj de <ack>.

Odat ce scriitorul primete <ack> de la cel puin

n
n
2 1 procesoare el termin de scris. Cum n>2f 2 1 n f

i deci avem garania c va termina de

scris.Cnd cititorul dorete s citeasc un registru, el trimite un mesaj de tip <request> tuturor procesoarelor. Fiecare procesor trimite napoi un mesaj de tip <value> coninnd
informaia curent pe care o deine. Odat ce cititorul primete <value> de la cel puin
primite.
Comunicarea cu

n
2 1 procesoare, el returneaz valoarea cu cel mai mare numr de secven dintre cele

n
2 1 procesoare garanteaz un quorum pentru fiecare operaie read sau write. Cum n aceste quorum-uri avem majoritatea procesoarelor, va exista

un procesor n intersecia oricrui quorum al unui read cu orice quorum al unui write. Acesta garanteaz faptul c ultima valoare scris va fi obinut.
Pentru a evita problemele poteniale legate de asincronie, i scriitorul i cititorul menin o variabil local status [0..n-1] pentru a guverna comunicarea; status[j] conine una
din valorile:

not-sent: mesajul pentru cea mai recent operaie n-a fost nc trimis lui pj (pentru c pj n-a confirmat un mesaj anterior)

not-acked: mesajul pentru cea mai recent operaie a fost trimis lui pj dar n-a fost confirmat de pj

acked: mesajul pentru cea mai recent operaie a fost confirmat de pj

n plus, fiecare procesor are un numrtor num-acks cu care-i numr rspunsurile primite n timpul operaiei curente.
Algoritm pentru simularea unui registru read/write cu MP
(codul pentru unicul scriitor)
Iniial status[j]=acked pentru j, seq=0 i pendinng=false
Cnd apare writew(v): // procesorul pw scrie n registru
pendinng:=true
1:
seq:=seq+1
2:
num-acks:=0
3:
for j do
4:
if status[j]=ackd then //are rspuns dat pentru operaia precedent
5:
enable sendw<newval, (v,seq)> to pj
6:
status[j]:=not-acked
7:
else status:=not-sent
8:
Cnd apare <ack> de la pj:
if not pending then status[j]:=acked //nici o operaie n execuie
9:
else if status[j]=not-sent then
//rspuns la un mesaj precedent
10:
enable sendw(<newval>, (v,seq)> to pj
11:
status[j]:=not-acked
12:
else
//rspuns la operaia curent
13:
status[j]:=acked
14:
num-acks:= num-acks+1
15:
16:

17:
18:

if

n
1 then
2

num - acks
pending:=false
enable ackw

//confirmare de la majoritatea

Algoritm pentru simularea unui registru read/write cu MP


(Codul pentru unicul cititor pi)
Iniial status[j]=acked pentru j, seq=0 i pendinng=false
Cnd apare readi():
pendinng:=true
1:
num-acks:=0
2:
for j do
3:
if status[j]=acked then //are rspuns dat pentru operaia precedent
4:
enable sendi<request> to pj
5:
status[j]:=not-acked
6:
else status:=not-sent
7:
Cnd apare receive<value, (v,s)>
if not pending then status[j]:=acked //nici o operaie n execuie
8:
else if status[j]=not-sent then
//rspuns la un mesaj precedent
9:
enable sendi<request> to pj
10:
status[j]:=not-acked
11:
else
//rspuns la operaia curent
12:
if s>seq then {val:=v; seq:=s}
13:
status[j]:=acked
14:
num-acks:= num-acks+1
15:
16:

if

n
1 then
2

num - acks

pending:=false
enable returni(val)
Algoritm pentru simularea unui registru read/write cu MP
17:
18:

(codul pentru orice procesor pi 0 i n-1, inclusiv pw i pi)


Iniial last=(v0,0) unde v0 este valoarea iniial a registrului simulat
Cnd apare receivew<newval,(v,s)> :
last:=(v,s)
1:
enable sendi(ack) to pw
2:
Cnd apare receive i(request):
3.enable sendi(value, last) to pi

//v este mai recent dect valoarea curent