Elezione di un leader in una rete ad anello

Elezione di un leader in una rete ad anello
Corso di Algoritmi Distribuiti
Prof. Roberto De Prisco
Lezione n° 3
a cura di Rosanna Cassino e Sergio Di Martino
Introduzione
In questa lezione viene presentato il primo problema da risolvere usando il modello delle reti
sincrone: il problema dell’elezione di un unico leader.
Descrizione del problema.
Assumiamo di avere una rete ad anello G costituita da n nodi, numerati da 1 a n in senso orario
(Figura 1). Nel caso generale gli indici dei processi associati ai nodi di G non sono noti.
n
n-1
1
2
n-2
3
4
5
Figura 1: Una rete ad anello.
Ad ogni processo è associata una variabile di stato che può assumere due valori: leader o non
leader. La richiesta del problema è che alla fine della computazione esattamente un processo deve
dire se è il leader o non lo è valorizzando la propria variabile di stato a leader.
Ci sono diverse versioni del problema:
1. La richiesta del problema è che alla fine della computazione ogni processo non leader deve
dire che non è il leader ponendo a non leader la propria variabile di stato.
2. La rete ad anello può essere unidirezionale o bidirezionale. Se è unidirezionale, i messaggi
possono essere inviati solo in senso orario.
3. Il numero di nodi n nella rete può essere noto o non noto ai processi. Se è noto, i processi
possono usare il valore n nei loro programmi. Se non è noto, i processi non possono usare
l’informazione sulla taglia della rete.
4. I processi possono essere identici o possono essere distinti attraverso un unico identificatore
(UID) ∈ Ν+. Si assume che l’UID di ogni processo è diverso da ogni altro nella rete, ma che
non c’è nessun vincolo sull’ordine di apparizione sulla rete (per esempio, gli interi non
1
devono essere necessariamente consecutivi). In tale situazione si possono verificare due
casi:
a. i processi non conoscono l’UID dei vicini;
b. i processi conoscono l’UID dei vicini.
TEOREMA 1. Sia A un sistema di n processi, n > 1, disposti in una rete
bidirezionale sincrona. Se tutti i processi in A sono identici, allora in A il
problema dell’elezione di un unico leader è irrisolvibile.
DIMOSTRAZIONE.
Supponiamo che esiste un sistema A che risolve il problema dell’elezione del leader. Con il
discorso che segue, vogliamo ottenere una contraddizione. Senza perdere di generalità
possiamo assumere che ogni processo di A ha esattamente una stato iniziale. Consideriamo
la seguente invariante (proprietà del sistema sempre vera).
INVARIANTE. All’inizio di ogni round tutti i processi si trovano nello stesso
stato.
Se dimostriamo l’invariante asseriamo che i processi sono tutti nello stesso stato, quindi nessuno di
essi è leader.
DIMOSTRAZIONE DELL’INVARIANTE.
Per induzione sul numero di round.
Base. Numero di round = 0. Banale dall’ipotesi del teorema: “se tutti i processi in A sono
identici”.
Passo induttivo. Supponiamo che l’invariante è vera all’inizio del round r. Proviamo che
risulta vera al round r+1. Per dimostrare ciò dobbiamo assumere che i processi conoscano il
proprio nome. Il seguente algoritmo ci aiuta a dimostrare il passo induttivo.
Algoritmo LCR.
L’algoritmo usa solo comunicazione unidirezionale e non dipende dalla conoscenza della taglia
della rete. Solo il leader rilascia l’output. L’algoritmo usa solo operazioni di confronto sugli UID.
Descrizione informale dell’algoritmo.
1
UID1
2
6
UID6
UID2
UID5
UID3
3
5
UID4
4
Ogni processo invia il proprio identificatore lungo la rete. Quando un processo riceve un
identificatore inviato, lo confronta con il proprio. Se l’identificatore inviato è più grande del
2
proprio, trasmette l’identificatore; se è più piccolo non fa niente; se è uguale, il processo si
dichiara leader. In questo modo sulla rete transita sempre l’identificatore più grande.
Descrizione formale dell’algoritmo.
Sia M = { UID } l’insieme degli id.
Per ogni i la variabile di stato statoi è costituita dalle seguenti componenti:
u : UID , inizialmente UID = i;
send : messaggio da spedire, un UID o null, inizialmente UID è i;
stato : con valori in { unknown, leader }, inizialmente unknown.
Per ogni i la funzione di generazione del messaggio msgsi è definita come:
spedisce il corrente valore di send al processo i +1
Per ogni i la funzione di transizione transi è definita dal seguente pseudocodice:
send := null
if il messaggio
case
v > u
v = u
v < u
che ricevo è v, un UID, then
: send := v
: status := leader
: niente
Eseguendo l’algoritmo, ad un certo punto il leader dirà che è leader e gli altri processi non
diranno nulla.
Prova di correttezza dell’algoritmo LCR
Per dimostrare la correttezza dell’algoritmo LCR, utilizziamo due lemmi. Il primo afferma che solo
il processo imax dichiarerà di essere leader dopo n round, mentre il secondo afferma che nessun
processo diverso da imax dichiarerà di essere leader. Questi due risultati dimostrano quindi la
correttezza dell’algoritmo LCR.
Lemma 1: Il processo imax dichiara di essere leader dopo n round.
La dimostrazione del lemma 1 richiede due inviarianti:
Invariante 1: Per 0 ≤ r ≤ n-1, dopo r rounds, si ha che sendi max +r = umax
Informalmente, questa invariante afferma che il valore massimo appare nella variabile send
nella posizione a distanza r da imax, cioè che al round 1, umax sarà a distanza 1 da imax, ed in
generale al round r-mo, tutti i processori tra imax ed imax+r manderanno il messaggio umax,
come in figura 2.
3
imax+r
imax+r+1
imax
Figura 2
Prova per induzione su r
Base:
Per r=0, l’inizializzazione ci assicura che sendi max = umax
Passo induttivo:
Assunto vero per r, dimostriamo che vale per r+1.
All’inizio del round r+1, l’algoritmo fa sì che il processo imax+r spedisca umax. Il processo
imax+r+1 riceverà quindi il messaggio umax, eseguendo quindi il primo case dell’algoritmo. Il
risultato di tale istruzione sarà sendi max +r = umax, provando quindi l’invariante 1
Invariante 2: Dopo n rounds, si ha che statusi max = leader
Dall’invariante 1, usata con r=n-1, si ha che sendi max -1 = umax.
Al round n, imax riceverà il messaggio umax (per definizione della funzione generatrice).
Essendo nel case 2 dell’algoritmo, quindi, status imax sarà posto a leader ed il nodo non
spedirà più alcun messaggio.
L’invariante 2 prova quindi il lemma 1.
Lemma 2: Un qualsiasi processo i≠ imax non dichiarerà mai di
essere leader.
Anche la dimostrazione del lemma 2 richiede l’utilizzo di un’inviariante:
Invariante 3: ∀round r e qualsiasi i,j si ha che dopo r rounds se i≠j e j ∈[imax, i), allora
sendj ≠ ui
DIMOSTRAZIONE:
Prova per induzione sul numero del round r
Base:
Per r=0, fissati i,j tali che i≠j (per hip), si ha che sendj = uj ≠ ui
Passo induttivo:
Assunto vero per r-1, dimostriamo che vale per r.
Dobbiamo considerare due casi:
• ∀ j’ ∈ [imax, j-1), per ipotesi induttiva risulta che sendj’ = uj.
4
•
Se invece j’ = imax-1, allora la dimostrazione si ottiene semplicemente applicando la
funzione generatrice.
imax≤j<i
i
UIDi
imax
UIDmax
Figura 3
Teorema 2: L’algoritmo LCR risolve il problema dell’elezione di un unico
leader in una rete ad anello sincrono.
DIMOSTRAZIONE:
La dimostrazione deriva dei lemma 1 e 2.
Complessità dell’algoritmo LCR.
Complessità di tempo:
Banalmente, l’algoritmo LCR richiede n round per essere eleggere il leader, risultando quindi
lineare sul numero di processi.
Complessità di messaggi
Informalmente, ogni messaggio è inviato sulla rete al più di n volte. Avendo n messaggi, la
complessità risultante sarà O(n2).
Formalmente, analizziamo il caso pessimo che si ottiene quando gli UID sono ordinati in ordine
decrescente. In questo caso, il messaggio del leader deve attraversare tutti i nodi, quello con UID
immediatamente inferiore al leader, tutti i nodi meno 1, e così via.
La complessità risultante sarà quindi data dalla sommatoria:
n
Σ
i =
O (n2)
i =1
5