Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi

Presentazione sul tema: "Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi"— Transcript della presentazione:

1 Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi
Lezione n°11 Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi 1

2 K-vicinato DEFINIZIONE:
Il k-vicinato di un processore p in un anello è dato dall’insieme dei processori che sono a distanza k da p nell’anello (sia da sinistra che da destra). Il k-vicinato chiuso di un processore include esattamente 2k+1processori 2

3 Algoritmo per l’elezione del Leader con l’ausilio del k-vicinato
ALGORITMO (Si procede per fasi) In ogni fase k un processore cerca di diventare leader temporaneo del suo 2k-vicinato. Solo i processori che riescono ad essere leader temporanei nella fase k diventano poi attivi nella fase k+1. Si dimostra che le fasi sono al più O(logn) Notare che l’anello ora è considerato bidirezionale 3

4 Leader temporaneo Nella fase 0 tutti i processori mandano il loro identificativo al proprio vicino di dx e al proprio vicino di sx. Diventano Leader temporanei nella fase 0 (e quindi processori attivi nella fase 1) tutti quei processori il cui identificativo è maggiore sia dell’identificativo del vicino dx che dell’identificativo del vicino sx. Alla generica fase l, ogni processore pi che è risultato Leader temporaneo alla fase l-1 manda il valore del proprio identificativo i al suo 2l-vicinato. Solo i vicini con identificativo minore di i, mandano a pi una risposta. Se pi riceve risposta da tutto il suo vicinato, pi diviene Leader alla fase l e attivo alla fase l+1 4

5 Cosa ricevo e cosa invio
Pj invia: (test,j,l,d): dove test esprime che il messaggio è per verificare se Pj può diventare leader temporaneo alla fase l dopo essersi confrontato con tutti i suoi vicini, da quelli a distanza 1 fino a quelli a distanza 2l , sia a destra che a sinistra. d inizialmente è pari ad 1 ed indica in ogni istante temporale a che distanza da j sono i vicini con cui ci si sta confrontando. (risp,k,l): quando Pj vuole comunicare che si dichiara perdente e, per quanto lo riguarda, Pk può essere leader nella fase l, e quindi attivo nella fase l+1. Pk riceve: (test,j,l,d): Pj e Pk si confrontano. Pk si attiva solo se Pk< Pj. Se la sua distanza d da Pj è minore di 2l deve far da tramite per passare l’informazione test al processore suo vicino a distanza d+1 da Pj , altrimenti deve chiedere al suo vicino a distanza d-1 da Pj di far da tramite per far sapere a Pj che, per quanto lo riguarda, può essere leader nella fase l. (risp,j,l): Pk deve distinguere se lui stesso è Pj o no. Se non è Pj deve solamente far passare l’informazione al suo vicino nel cammino fra lui e Pj. Se invece è Pj, allora deve aspettare la risposta dal vicinato nell’altra direzione. Se questa risposta arriva, si dichiara leader temporaneo alla fase l, altrimenti si deve dichiarare perdente. 5

6 Algoritmo per l’elezione del Leader con l’ausilio del k-vicinato
Algorithmo LEAK (Leader Election su un anello con k-vicinato) begin Pinit=i: stato = ignoto; send (test,i,0,1) al vicino sx e al vicino dx; repeat Pi: if receive (test,j,l,d) from sx (dx) if j = id then stato = leader; send halt to sx if j > i and d ≧ 2l then send (risp,j,l) to dx(sx) if j > i and d < 2l then send (test,j,l,d+1) to sx(dx) if receive (risp,j,l) from sx (dx) if j ≠ i then send (risp,j,l) to dx(sx) if hai già ricevuto (risp,j,l) from dx(sx) then send (test,j,l+1,1) to dx and sx if receive (halt) and stato = ignoto then send (halt) to sx until inf = halt e and stato = leader end Nota: per non appesantire la scrittura dell’algoritmo sono state dettagliate solo alcune parti dell’algoritmo. 6

7 Correttezza e complessità dell’algoritmo LEAK
Anche in questo caso la correttezza dell’algoritmo si basa sul fatto che nessun processore, eccetto quello di indice massimo, raggiunge lo stato di Leader globale. Complessità dei messaggi(Md) = numero di fasi (ovvero Td) moltiplicato per numero di messaggi trasmessi in ogni singola fase: Numero di fasi: al termine della generica fase l, se un processore pi risulta Lt, tutti i processori nel suo 2l-vicinato debbono avere identificativo minore di i. Ne consegue che fra due Lt, pi e pj , ci debbono essere almeno 2l processori (il vicinato sx dell’uno e quello dx dell’altro). Da queste considerazioni ne consegue che il numero delle fasi sarà al più dell’ordine di logn. Messaggi trasmessi in ogni singola fase: ogni processore attivo al più trasmette 2x 2l messaggi di test , uno ad ogni processore del suo vicinato. Analogamente può ricevere al più 2x 2l messaggi di risp , uno da ogni processore del suo vicinato, quindi n/2l x 4 x 2l <=4n Pertanto il numero totale di messaggi trasmessi sarà dato da O(nlogn) 7

8 Broadcast in un sistema distribuito ad anello
P0 ha l’informazione da distribuire nella variabile inf begin P0: send inf al successore repeat Pi: receive inf da predecessore send inf al successore until P0 riceve messaggio dal predecessore end In una rete ad anello ad n nodi, vengono inviati n messaggi in n passi P0 P2 Pn-1 P1 P3 8

9 Broadcast in una qualsiasi rete a connessione fissa
Assumiamo connessioni unidirezionali e rete aciclica begin Pinit: Ninit = { q : q è un vicino di Pinit } send messaggio ad ogni q in Ninit repeat Pi: receive messaggio da un vicino p Ni = { q : q è un vicino di Pi } send messaggio ad ogni q in Ni until … end Si ricorda che Pi invia lo stesso messaggio a tutti i suoi vicini contemporaneamente però sia i processori sia i canali di comunicazione sono eterogenei, quindi il tutto è asincrono. In una rete di n nodi, vengono inviati O(m) messaggi in O(d) passi m = numero archi d = diametro della rete Manca il segnale di terminazione globale Pinit 9

10 Broadcast con eco in una qualsiasi rete a connessione fissa
Per risolvere il problema della terminazione si usa l’eco e servono connessioni bidirezionali begin Peco: Neco= { q : q è un vicino di Peco } send messaggio ad ogni q in Neco conteco = 0 while conteco < | Neco | receive messaggio da un vicino incrementa conteco termina Pi≠ eco: receive messaggio da un vicino p che chiamo padre Ni = { q  p : q è un vicino di Pi } send messaggio ad ogni q in Ni conti = 0 while conti < | Ni | incrementa conti send messaggio al padre p end 10

11 Complessità del broadcast con eco
Durante una esecuzione dell’algoritmo di Broadcast con eco vengono inviati in totale Md = 2m messaggi (2 per ogni arco) e l’algoritmo richiede Td = O(d) passi di comunicazione (dove d è il diametro della rete). 11

12 Esempio broadcast con eco 1
0/4 Processore non raggiunto dal Broadcast Processore raggiunto dal Broadcast (all’interno sono riportati i valori di conti e di |Ni|) Messaggio di Broadcast Processore che ha ricevuto conferma da tutti i vicini (incluso l’eco) Messaggio di eco Peco Passo 1: Inizializzazione Ogni processore manda solo due messaggi: uno di broadcast ai suoi vicini dopo averlo ricevuto dal padre (prime istruzioni del processore Pi) e uno di eco dopo aver ricevuto messaggi da tutti i suoi vicini (al termine del ciclo while). La distinzione tra messaggi di broadcast e di eco è soltanto logica, di fatto i messaggi sono identici. Nell’esempio, al passo 2, abbiamo due tipi di processori che ricevono messaggi: quelli ancora in attesa del padre e quelli che già sono nel ciclo while. In particolare il processore Pc riceve un messaggio sia da Pa che da Pb. Supponiamo che Pa sia il padre, in quanto il messaggio da lui inviato è finito in testa alla coda. Pc invierà subito un messaggio a Pb, che incrementa il suo contatore, mentre invierà un messaggio a Pa soltanto dopo aver ricevuto Nc messaggi dai suoi vicini (incluso quello inviato da Pb). Il contatore di Pd ha già raggiunto il suo valore massimo e quindi Pd è pronto per mandare un eco al padre. 0/2 0/4 1/2 2/2 1/4 Pa Pc Pd Pb Passo 2 12

13 Esempio broadcast con eco 2
0/2 1/4 2/2 1/1 2/2 2/4 4/4 Passo 3 Passo 4 4/4 Passo 5 Passo 6 13