UniTO/anno2/Sem1/mie/Mcad/relazione_mcad.md

Impossibilita` di accordo in presenza di fallimenti

Ogni utente ha a disposizione un'interfaccia di output initi e un'interfaccia di output decidei. Ogni utente i esegue al massimo un'azione initi.

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 decidei 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)