mcad seminario

anno2/mie/Mcad/ScalettaMCAD.txt

@@ -0,0 +1,11 @@
+Introduzione al problema con esempi
+Equivalenza fra modelli con cenni di dimostrazione
+Definizione agreement
+Well-formedness, validity, failure free-termination
+Definizione formale problema
+Teorema 21.2 con dimostrazione
+Algoritmo randomizzato definizione
+Algoritmo di BenOr
+Ottimizzazioni per BenOr
+Failure detector
+Modellazione failure detector

anno2/mie/Mcad/relazione_mcad.md

@@ -0,0 +1,72 @@
+# 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.
+
+
+Aggiunte:
+Aguilera: 
+- Nel paper si mostra (in maniera intuitiva) perche` la probabilita` di terminazione e` 1.
+- 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)