90 lines
4.8 KiB
Markdown
90 lines
4.8 KiB
Markdown
# Impossibilita` di accordo in presenza di fallimenti
|
|
|
|
Ogni utente ha a disposizione un'interfaccia di output init[i](v) e un'interfaccia di output decide[i](w).
|
|
Ogni utente i esegue al massimo un'azione init[i](v).
|
|
|
|
Agreement: In ogni esecuzione, i valori di decision sono identici.
|
|
Validita`: In ogni esecuzione, se le azioni init[i] contengono lo stesso valore v allora v e` l'unico valore di decisione possibile.
|
|
Failure free termination: In ogni esecuzione fair senza fallimenti in cui gli eventi init[i] avvengono su tutte le porte, allora gli eventi decide[i] avvengono su tutte le porte.
|
|
Well formedness???
|
|
|
|
# BEN OR
|
|
|
|
Riduciamo il costraint sulla terminazione:
|
|
un programma non faulty eseguiranno decide[i](v) ad un tempo t con probabilita` p(t) dove p e` una funzione monotona, non decrescente e unbounded.
|
|
Questo implica terminazione con probabilita` 1.
|
|
|
|
Ogni processo ha due variabili locali: a = null, b = null. Il valore di decisione e` {0, 1} e ci sono n > 3f processi.
|
|
|
|
L'algoritmo esegue una serie di step ognuno dei quali consiste di due stage.
|
|
|
|
```
|
|
Fase 1:
|
|
Send(x, r) dove r e` il timestap.
|
|
for i = 0 to n - f: wait(S[i], r).
|
|
se ogni s appartenente ad S e` identico, allora y = s.
|
|
|
|
Fase 2:
|
|
Send(y, r)
|
|
for i = 0 to n - f: wait(S[i], r).
|
|
- se ogni s appartenente ad S e` identico, allora x = s; decide(s).
|
|
- altrimenti se esistono n - 2f valori s identici, allora x = s.
|
|
- altrimenti x = scegli uniformemente (0, 1)
|
|
|
|
```
|
|
|
|
Lemma 1:
|
|
* well-formedness, agreement e validita` sono garantiti.
|
|
|
|
* Well formedness (se ho ben capito cosa significa): una volta fatto un decide il valore non viene mai cambiato.
|
|
* validity: ogni processo scegliera` allo step 1: in fase 1 tutti i processi ricevono il valore v, e decidono in fase 2 dato che l'unico valore mandato e ricevuto e` v.
|
|
* Agreement:
|
|
Supponiamo che il processo Pi decide per primo allo step st. Questo significa che ha ricevuto n - f messagi con valori identici v.
|
|
Questo implica che che tutti gli altri processi hanno ricevuto almeno n - 2f contenente il valore v.
|
|
Quindi i processi Pj possono esclusivamente:
|
|
- decidere per il valore v;
|
|
- avere x = v e successivamente decidere per v allo step st+1;
|
|
|
|
Ora consideriamo la terminazione.
|
|
In ogni esecuzione fair in cui gli eventi di init avvengono su tutte le porte ogni processo che non fallisce esegue infiniti stepp.
|
|
__d__ e` l'upper bound per il delivery time del broadcast del messaggio piu` vecchio e __l__ l'upper bound del tempo necessario per ilcompletamento del task di ogni processo (?).
|
|
Si puo` dire he ogni processo completa ogni volta uno step s in O(s(d+l)) dall'ultimo evento di init.
|
|
|
|
(Ovvero che per il costo di uno step e` dato dalla somma dei tempi l e d moltiplicato per il numero di step a cui ci si trova).
|
|
|
|
L'algoritmo non garantisce che alla fine un processo esegua decide[i]. Questo e` garantito solo probabilisticamente.
|
|
|
|
|
|
Mostriamo ora un'esecuzione senza decisioni:
|
|
Abbiamo un numero di processi m: f < m <= 2f, n = 3f+1
|
|
Gli m processi hanno x = 0 e i restanti x = 1.
|
|
|
|
Dopo il round 1 tutti i processi hanno y = null e al round 2 tutti i processi scelgono il loro valore di x casualmente.
|
|
Se pensiamo che questa decisione casuale ci porta ad una situazione in cui esiste un numero m' di processi: f < m' <= 2f dove x = 0 ed i restanti hanno x=1.
|
|
Torniamo alla situazione iniziale che si puo` ripetere all'infinito senza portare ad una decisione.
|
|
|
|
|
|
# Adversary, Lemma 21.5
|
|
|
|
Consideriamo l'iterazione s.
|
|
Un processo non fallimentare mantiene un valore v "buono" se almeno f+1 messaggi del tipo ("first", s, *) contengono lo stesso valore v.
|
|
Ci possono essere al piu` due valori buoni.
|
|
(Se c'e` un solo valore buono v allora in ogni messaggio del tipo ("second", s, *) contiene il valore null o il valore v.)
|
|
(Se se ci sono due valore buoni allora in ogni messaggio del tipo ("second", s, *) contiene il valore null e x viene scelto a caso.)
|
|
|
|
Nel caso in cui vi sia un solo valore buono, allora con probabilita` 1/2^n tutti i processi sceglieranno un valore x identico al valore buono.
|
|
Allo stesso modo, nel caso ci fossero due valori buoni, con probabilita` 1/2^n tutti i processi sceglieranno lo stesso valore x.
|
|
(In entrambi i casi i processi avranno lo stesso valore x con probabilita` 1/2^n.)
|
|
Dato che le probabilita` ad ogni iterazione sono indipendenti, possiamo combinarle per ottenere che:
|
|
1 - (probabilita` che almeno un processo non sia d'accordo su ogni iterazione) = 1 - (1 - 1/2^n)^s, ovvero la probabilita` che i processi decidano allo stage s+1.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Aggiunte:
|
|
Aguilera:
|
|
- C'e` una variante dove alla fine della fase 2 viene lanciato un "global coin", ovvero il numero casuale e` lo stesso per tutti i processi che lo richiedono.
|
|
Questo accorcia di molto il tempo di esecuzione del programma a costo di avere n/3 < f < n/2 .
|
|
- Lo scopo del paper e` di dimostrare che BenOr funzion con n >= 2f (piuttosto che 3f per la Lynch)
|