Dal modello a memoria condivisa al modello a rete, impossibilità del consenso in sistemi asincroni

DAL MODELLO A MEMORIA
CONDIVISA AL MODELLO A RETE,
IMPOSSIBILITÀ DEL CONSENSO
IN RETI ASINCRONE
Lopardo Bruno, Marignati Luca, Nasso Alessandro

Obiettivi (1)
1. Dimostrare come viene ereditato il teorema di
impossibilità del consenso dal sistema a memoria
condivisa al sistema a rete;
2. Fornire una soluzione di tipo probabilistica al problema
del consenso nei sistemi asincroni: Algoritmo di BenOr;
3. Dimostrarne la correttezza.

Riprendiamo il teorema 12.8
Impossibilità del consenso in reti asincrone
con memoria condivisa
Dati n processi (>= 2), non esiste un algoritmo deterministico
nel modello a memoria condivisa che risolva il problema del
consenso e garantisca la 1-failure termination.

Dimostriamo, ora, come è possibile ereditare il
teorema di impossibilità 12.8 per:
A) sistemi a rete send/receive.
B) sistemi a rete broadcast.

Problema generale
■ Dato un sistema asincrono a rete (A).
■ Costruire un sistema asincrono a memoria condivisa (B).
■ B sia una SIMULAZIONE DI A.

■Mostrare com’è possibile SIMULARE il
modello a rete send/receive tramite il
modello a memoria condivisa.
■SimpleSRSim Algorithm.
Problema generale

SimpleSRSim Algorithm (1/3)
1. Per ogni arco(i,j) del grafo del sistema
A, il sistema B ha un variabile condivisa
x(i,j) (scrivibile dal processo i e leggibile
dal proccesso j).
2. Ogni variabile condivisa x(i, j) contiene
una coda di messaggi inizialmente
vuota.

3. Lo stato di un processo i di B è caratterizzato
da 3 code:
– una coda FIFO out-msgs(j)
(per ogni Pi vicino in uscita nel sistema A);
– Una coda FIFO in-msgs(j)
(per ogni Pi vicino in ingresso nel sistema
A);
– Una coda FIFO processed-msgs(j)
(per ogni Pi vicino in ingesso nel sistema A).

Azioni possibili
1. Per simulare un’azione SEND(m)i,j di un
Pi di A, Pi di B inserisce il messaggio m
alla fine della coda nella variabile x(i,j).
2. Per simulare un’azione RECEIVE(m)i,j di
un Pi di A, Pi di B controlla (check) tutte
le sue variabili x(i,j) in entrata per
determinare se ci sono nuovi messaggi.

Teorema 17.7
Se A è un sistema send/receive
asincrono con FIFO affidabili, allora
l’algoritmo SimpleSRSim è una
simulazione di A.

Sistemi a rete broadcast
■ Variabili single-writer/multi-reader
■ Broadcast(m)i
P0
P1
P2
Pn
…
m
m
m

■Mostrare com’è possibile SIMULARE il
modello a rete broadcast tramite il
modello a memoria condivisa.
■SimpleBcastSim Algorithm.
Problema generale

SimpleBcastSim algorithm (1/2)
1. Per ogni processo i del sistema A, il sistema B
include una variabile condivisa x(i), scrivibile da i e
leggibile da tutti gli altri processi (incluso i).
2. Ogni variabile condivisa x(i) contiene una coda
messaggi inizialmente vuota.

SimpleBcastSim algorithm (2/2)
Azioni possibili
■ Per simulare un’azione BROADCAST(m)i di un Pi di A, Pi
di B aggiunge il messaggio m alla fine della coda nella
variabile x(i).
■ Per simulare un’azione RECEIVE(m)i,j di uncontrolla
(check) tutte le variabili x(j), Pi di A, Pi di B inclusa x(i),
per determinare se ci sono nuovi messaggi.

Teorema 17.8
Se A è un sistema broadcast
asincrono con un canale affidabile,
allora l’algoritmo SimpleBcastSim è
una simulazione di A.

Teorema 17.9
Possiamo, dunque, affermare che:
■ non esiste un algoritmo deterministico nei
sistemi asincroni a rete send/receive con canali
affidabili che risolva il problema del consenso
garantendo una 1-failure termination.
■ non esiste un algoritmo deterministico nel
modello broadcast asincrono con un canale
affidabile che risolva il problema del consenso
garantendo una 1-failure termination.

Dimostrazione (1/3)
■ Inizialmente si ha un modello a rete broadcast;
■ PER ASSURDO supponiamo che esista un algoritmo
A che risolva il problema del consenso;

Dimostrazione (2/3)
■ SimpleBcastSim: Modello broadcast → modello a
memoria condivisa (teorema 17.8)
■ Possiamo dire che tutti i problemi risolvibili nel sistema
a rete broadcast si riescono a risolvere anche nel
modello a memoria condivisa
■ Per l’ipotesi iniziale l’algoritmo B, nel modello a
memoria condivisa, è una soluzione al problema del
consenso e garantisce la risoluzione di 1-failure
termination

Dimostrazione (3/3)
■ Contraddizione con il teorema 12.8 → ASSURDO.
■ Conclusione: non esiste un algoritmo deterministico
per il modello broadcast asincrono con canali sicuri,
che risolve il problema del consenso e garantisce la
terminazione 1-failure.

Obiettivi (2)

Problema del consenso (1/4)
■ Ogni processo Pi parte con un suo valore iniziale e
decide un suo valore finale.
■ Tutti i processi si devono concordare sullo stesso valore
finale.
■ Si utilizzano due primitive:
a) azione di INPUT: init(v)i
b) azione di OUTPUT: decide(v)

■ Ogni processo ha un valore iniziale v che propone per il
consenso attraverso una proposta propose(v).
■ Tutti i processi corretti inizialmente propongono un valore.
■ Tutti i processi corretti devono decidere lo stesso valore
attraverso un’indicazione di decisione decide(v) che porta al
valore v.

■ Well-formed: si ha una sequenza di azioni init e decide. Ogni
azione di init è seguita da al più una decide.
■ Agreement:
∀ i,j
IF Pi decide(v) AND Pj decide(v’)
THEN allora v = v’
■ Validity: se viene effettuata una init con lo stesso valore v su
ogni processo allora v sarà l’unico valore possibile per
l’operazione decide.

■ Failure-free: in ogni esecuzione fair e failure-free ogni
processo effettua una decide.
■ F-failure (0 ≤ f ≤ n): in ogni esecuzione fair in cui gli eventi di
init avvengono su tutte le porte, se ci sono al massimo f
eventi di stop, gli eventi decide avvengono per tutti i
processi sani.
■ Wait-free: f-failure termination con f = n.

Soluzione
Utilizzo di un algoritmo randomizzato
■ il problema del consenso è così fondamentale per il calcolo
distribuito che è importante trovare modi per aggirare la
limitazione.
■ per ottenere un algoritmo valido si può pensare di
indebolire i requisiti di correttezza del problema.
■ Terminazione probabilistica
■ Algoritmo di BenOr

Ben-Or Algorithm (1/3)
■ Si richiede che : n > 3f e V = {0,1}
■ Funzionamento
– Ogni processo Pi ha due variabili locali x e y inizialmente nulle.
– L’evento di input init(v)i fa sì che il processo Pi inizializzi la
propria variabile x = v.
– Ogni processo Pi esegue un certo numero di round, ciascuno
costituito da 2 fasi.
– Ogni processo esegue un numero infinito di round anche dopo
aver effettuato la decide del valore.

■ FASE 1: REPORT (R)
■ Pi invia a tutti (in broadcast) il messaggio formato dalla tripla (R, k, x)
dove R = fase di report, k = intero che indica quante volte è stato
eseguito il ciclo (round) e x = valore della variabile locale del processo.
■ il processo aspetta di ricevere n – f messaggi (ovvero i messaggi inviati
da processi non guasti) della forma (R, k, *).
■ Se la maggioranza dei messaggi ricevuti (> n/2) hanno lo stesso valore v
(0 o 1) → invia a tutti (in broadcast) il messaggio (P, k, v).
■ Altrimenti il processo non sa cosa proporre e invia il messaggio (P, k, ?).

■ FASE 2: PROPOSE (P).
■ Il processo aspetta di ricevere n – f messaggi della forma (P, k, *).
■ Vi sono 3 casi:
– Caso 1: se il processo ha ricevuto almeno n – f messaggi contenenti lo
stesso valore v (con v ≠ ?) → allora fa decide(v).
– Caso 2: se non tutti, ma almeno n – 2f degli n – f messaggi ricevuti
riportano lo stesso valore v ≠ ? allora il processo Pi pone x = v ma non
decide.
– Caso 3: se non si verificano i casi precedenti, il processo Pi esegue
una scelta casuale impostando x = 0 oppure x = 1 (scelta
probabilistica).

Stato iniziale
6 processi
x = valore
iniziale
y = valore finale

Round k = 0
init(v) su tutte
le porte

Fase R (report)
Round 1
Ogni processo
invia m(R, 1, *)
P6 → crash

1. Attesa degli n – f
messaggi
2. Gli n – f messaggi
hanno valori y diversi
3. tutti i processi
inviano m (P, 1, ?)

Fase P (propose)
Round 1
1) attesa degli n – f
messaggi
2) caso 3: y = ?
Scelta casuale (0 o 1)
P1 = 1, P2 = 1, P3= 1,
P4 = 1, P5 = 1
k = k + 1 = 2

Fase R (report)
Round 2
Ogni processo
invia m(R, 1, *)

1. Attesa degli n – f
messaggi
2. Gli n – f
messaggi hanno
valori y uguali
3. tutti i processi
inviano m (P, 2, 1)

Fase P (propose)
Round 2
1) attesa degli n – f
messaggi
2) caso 1: i valori di y
sono tutti uguali
Tutti i processi fanno
decide(y)
CONSENSO!

Obiettivi (3)

Dimostrazione di correttezza
■ Due proprietà:
– Safety: l’algoritmo Ben-Or garantisce sempre la
well-formed, l’agreement e la validity.
– Liveness: l’algoritmo Ben-Or garantisce la
terminazione con probabilità 1.

Lemma 21.3
L’algoritmo Ben-Or garantisce la
well-formed, l’agreement e la
validity.

Lemma 21.3: dimostrazione (1/3)
Validità (validità)
Proprietà
Se ogni init contiene lo stesso valore v, allora v è l’unica decisione possibile.
Dimostrazione
■ Supponiamo che tutte le azioni di init dei processi siano state inizializzate
con lo stesso valore v.
■ Dunque nella fase R tutti i processi invieranno il messaggio (P, 1, v) con v
avente lo stesso valore per tutti i processi.
■ È, dunque, ovvio che qualsiasi processo che completa la fase P esegua
l’azione decide(v), soddisfacendo quindi la condizione di validità.

Ben formata (well-formed)
Proprietà
Ogni init è una sequenza seguita da al più una decide.
Dimostrazione
■ Ogni processo inizia con un’azione di init(v).
■ Quando eseguirà l’azione di decide non la ripeterà più in seguito.

Accordo (agreement)
Proprietà
∀ i,j IF Pi decide(v) AND Pj decide(v’) THEN allora v = v’
Dimostrazione
■ Supponiamo che il processo Pi sia il primo a decidere un valore v nel Round s.
■ Pi ha, quindi, ricevuto almeno n – f messaggi con lo stesso valore (R, round, v)
■ Questo implica che qualsiasi altro processo Pj che completa il Round s, riceve almeno
n – 2f messaggi del tipo (P, round, v) poiché riceve da tutti gli n – f processi che
hanno inviato Pi meno, al più f messaggi, nel caso che tutti gli f processi guasti
falliscano dopo aver inviato il messaggio a Pi, quindi (n – f) – f = n – 2f.
■ In effetti, qualsiasi processo Pj può solo:
– eseguire decide(v).
– impostare x = v e compiere l’azione decide(v) al round successivo (s+1).

Lemma 21.4: complessità (1/2)
■ d è un limite superiore del tempo di consegna per il
messaggio più vecchio in transito;
■ l è un limite superiore del tempo per ciascuna
attività di processo.
■ Ogni processo non difettoso completa ogni fase s in
O(s (d + l)) tempo dopo l'ultimo evento init.

Lemma 21.4: complessità (2/2)
■ Nell’algoritmo, un processo può scegliere allo step s un
valore di x casuale (0 o 1).
■ Se tutti i processi estraggono lo stesso valore allo step s,
allora la decisione e la terminazione avviene allo step s + 1.
■ Si può immaginare l’esistenza di una moneta globale che
tutti i processi lanciano allo stesso istante nel momento in
cui uno o più processi devono assegnare un valore casuale
alla variabile locale x.
■ Questa assunzione di moneta globale riduce drasticamente
il tempo di esecuzione dell’algoritmo.

Lemma 21.5
Terminazione con probabilità 1
Pe ogni s >=0, tutti i processi corretti
decideranno entro lo step s + 1 con
probabilità
≥ 1 − 1 −
1
2 𝑛
𝑠

Lemma 21.5 (1/6)
■ caso base:
s = 0 (stato iniziale) → ovvia
𝑝(𝑡) ≥ 1 − 1 −
1
2 𝑛
0
= 1 − 1 = 0 → 𝑝(𝑡) ≥ 0

Lemma 21.5 (2/6)
Passo induttivo. s ≥ 1
■ La prova si ottiene provando che la probabilità
che tutti i processi corretti scelgano, alla fine
del round s, lo stesso valore v è >=
1
2 𝑛.
■ Infatti, se questo è vero, nel round successivo
s + 1, tutti i processi corretti eseguiranno la
decide(v).

Lemma 21.5 (3/6)
■ α = esecuzione finita più corta in cui Pi ha
ricevuto n - f messaggi del tipo (R, s, *).
■ Se almeno f + 1 di questi messaggi contengono lo
stesso valore v, allora il valore v e detto valore
“buono” per α.

Lemma 21.5 (4/6)
Ci possono essere 1 o 2 valori buoni:
■ 1 valore “buono”:
– Ogni messaggio inviato nella fase due (P, s, *) conterrà lo stesso
valore v o ?.
– I processi che non impostano x = v dovranno scegliere il valore
casualmente.
– La probabilità che i restanti processi scelgano lo stesso valore è
≥
1
2n
■ 2 valori “buoni”:
– I processi sani avranno ricevuto sia il valore 0 che il valore 1 ed
invieranno nella seconda fase il messaggio: (P, s, ?).
– Di nuovo, la probabilità che tutti i processi scelgano in fase 2 lo
stesso valore e ≥
1
2n

Lemma 21.5 (5/6)
■ Dunque, alla fine del round s, tutti i processi corretti
scelgano lo stesso valore v con probabilità ≥
1
2 𝑛.
■ Quindi, la probabilità che non venga compiuta alcuna scelta
è ≤ 1 −
1
2 𝑛 .
■ Ogni fase s dipende dalle scelte casuali in essa.
P(nessuna scelta unica nelle prime s step) ≤ 1 −
1
2 𝑛
𝑠
■ Ne deriva che la probabilità che tutti i processi non guasti
decidono lo stesso valore v entro lo step s + 1 è
P(unico valore deciso prima dello step s + 1) ≥ 1 − 1 −
1
2 𝑛
𝑠

Lemma 21.5 (6/6)
■ Quindi la probabilità che tutti i processi sani
compiano un’azione di decide(v) prima dello step s +
1 è:
𝑝(𝑡) ≥ 1 − 1 −
1
2 𝑛
𝑠
■ Per infiniti step s → ∞ : p = 1
■ Dunque, l’algoritmo garantisce la terminazione con
probabilità p(t) = 1.

Probabilità 1 ≠ Certezza
■ Se un evento ha probabilità 1 di verificarsi possiamo affermare che
avverà quasi sicuramente ma non ne abbiamo la certezza
matematica.
■ Esempio: LANCIO DELLA MONETA
■ Supponiamo di lanciare infinite volte una moneta.
– La probabilità che esca solo croce è:
1
2∞ = 0
– La probabilità che esca solo testa è:
1
2∞ = 0
– La probabilità che esca almeno una volta testa è: 1 −
1
2∞ = 1
■ Esiste comunque la possibilità di ottenere una sequenza composta da
sole croci.

Dal modello a memoria condivisa al modello a rete, impossibilità del consenso in sistemi asincroni

Recommended

Recommended

More Related Content

What's hot

What's hot (10)

Similar to Dal modello a memoria condivisa al modello a rete, impossibilità del consenso in sistemi asincroni

Similar to Dal modello a memoria condivisa al modello a rete, impossibilità del consenso in sistemi asincroni (16)

More from Luca Marignati

More from Luca Marignati (6)

Dal modello a memoria condivisa al modello a rete, impossibilità del consenso in sistemi asincroni