Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi ELEZIONE DEL LEADER Lezione n°8

La tecnica del Accelerated Cascading Dato un problema P di dimensione n, siano A 1 e A 2 due algoritmi per risolvere il problema P che operano rispettivamente in tempo T 1 e T 2 (T 1 > T 2 ), si costruisce un nuovo algoritmo A nel seguente modo: 1.si applica a P l’algoritmo A 1 (A 1 lavora per fasi) fintanto che l’output delle fasi non produca una istanza P’ di P di dimensione minore di una soglia prefissata; 2.si applica a P’ l’algoritmo A 2 E’ da notare che invece di un solo algoritmo di riduzione A 1 si potrebbe avere una catena di algoritmi di questo tipo. In tal caso si considera la catena di algoritmi di riduzione ordinata dall’algoritmo più lento al più veloce e si costruisce il nuovo algoritmo sostituendo il passo1 con l’applicazione a P della catena così ordinata.

Somma con la tecnica dell’accelerated cascading L’algoritmo di somma parallelo con la tecnica della prima metà non è ottimo perché costa O(n log n) (ovvero n processori per log n tempo),mentre il miglior algoritmo sequenziale richiede tempo O(n). La tecnica dell’accelerated cascading ci permette di ridurre il costo dell’algoritmo parallelo a O(n) e quindi a raggiungere valore dell’efficienza uguale ad 1. La tecnica consiste nel dividere l’algoritmo in due fasi: 1° fase: si applica l’algoritmo sequenziale su k sotto-istanze del problema di piccola dimensione h in modo da ridurre la dimensione totale dello intero problema. Tempo parallelo O(h). 2° fase: si applica l’algoritmo parallelo con p processori sui k risultati del passo precedente. Tempo parallelo O(log k) Costo = O(p (h + log k))

Algoritmo per la somma con la tecnica dell’Accelerated Cascading Si adoperano p processori SommaAC(A, n) begin k = p h = n/k for i = 0 to k-1 pardo P i : b i = i * h for j = 1 to h -1 do if b i + j < n then A[ b i ] = A[ b i ] + A[ b i + j ] B[ i ] = A[ b i ] Somma(B, k)// algoritmo di somma parallela standard end Tempo parallelo O(h + log k)

Esempio di somma con la tecnica dell’Accelerated Cascading n = 12 P = 4 size = P0P0 P1P1 P2P2 P3P ° fase sequenziale 2° fase parallela

Analisi dell’algoritmo SommaAC Per ottenere costo C p =O(n) e quindi Eff=1, dobbiamo scegliere O(n/log n) processori, assegnando a ciascuno O(log n) elementi da sommare sequenzialmente. La 1° fase pertanto richiede tempo paralello O(log n) per generare O(n/log n) elementi. Con O(n/log n) processori si opera con l’algoritmo di somma parallelo su gli O(n/log n) elementi, impiegando un tempo parallelo pari a: log (n/log n) = log n – log log n = O(log n) Costo totale = O(n/log n (log n + log n)) = O(n)

Somme prefisse con Accellerated Cascading Si adoperano k processori Per semplicità assumiamo n multiplo di k: n = h·k begin for i = 0 to k-1 pardo P i : b i = i * h // inizio blocco i-esimo for j = 1 to h -1 do A[ b i + j ] = A[ b i + j ] + A[ b i + j-1 ] B[ i ] = A[ b i + h-1 ] // l’ultimo del blocco PrefixSum(B, k) for i = 1 to k-1 pardo P i :for j = 0 to h -1 do A[ b i + j ] = A[ b i + j ] + B[ i-1 ] end Tempo parallelo O(h + log k)

Elezione del Leader su una rete ad anello Algorithm LEA (Leader Election su un anello) begin Pinit=i:stato = ignoto stato finale =F send i al succ repeat P i :receive inf if inf = halt and stato = ignoto then send halt al succ if inf = halt and stato = leader then stato finale =T if inf > i then send inf al succ if inf = i then stato = leader send halt al succ until inf = halt and stato finale =T end O(n 2 ) messaggi in n passi Si noti che l’intero algoritmo termina quando il segnale di halt torna al leader.

Esempio di funzionamento di LEA Passo 1 Passo 4Passo 3Passo 2 inizializzazione LEADER

Correttezza e complessità dell’algoritmo LEA Teorema: L’algoritmo LEA risolve il problema dell’elezione del leader su un sistema distribuito sincrono ad anello. Esso richiede complessità temporale n e complessità dei messaggi O(n 2 ). Dimostrazione: La correttezza si basa sui seguenti due fatti: Fatto 1: Nessun processore, eccetto quello di indice massimo, raggiunge lo stato di leader. Fatto 2: Dopo n passi lo stato del processore di indice massimo è quello di leader. Dal Fatto 2 si deduce la complessità temporale che implica anche quella dei messaggi.

Un solo iniziatore Algorithm LEA (Leader Election su un anello con un solo inizializzatore init) begin P i :stato = ignoto P init : send init al succ repeat P i : receive inf if inf = halt and stato = ignoto then send halt al succ if inf = i then stato = leader send halt al succ if inf < i then inf = i send inf al succ until inf = halt and stato =leader end O(n) messaggi in O(n) passi

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

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 2 k - 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

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 p i che è risultato Leader temporaneo alla fase l-1 manda il valore del proprio identificativo i al suo 2 l -vicinato. Solo i vicini con identificativo minore di i, mandano a p i una risposta. Se p i riceve risposta da tutto il suo vicinato, p i diviene Leader alla fase l e attivo alla fase l+1

Cosa ricevo e cosa invio P j invia: (test,j,l,d): dove test esprime che il messaggio è per verificare se P j 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 2 l, 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 P j vuole comunicare che si dichiara perdente e, per quanto lo riguarda, P k può essere leader nella fase l, e quindi attivo nella fase l+1. P k riceve: (test,j,l,d): P j e P k si confrontano. P k si attiva solo se P k < P j. Se la sua distanza d da P j è minore di 2 l deve far da tramite per passare l’informazione test al processore suo vicino a distanza d+1 da P j, altrimenti deve chiedere al suo vicino a distanza d-1 da P j di far da tramite per far sapere a P j che, per quanto lo riguarda, può essere leader nella fase l. (risp,j,l): P k deve distinguere se lui stesso è P j o no. Se non è P j deve solamente far passare l’informazione al suo vicino nel cammino fra lui e P j. Se invece è P j, 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.

Algoritmo per l’elezione del Leader con l’ausilio del k-vicinato Algorithmo LEAK (Leader Election su un anello con k-vicinato) begin P init=i :stato = ignoto; send (test,i,0,1) al vicino sx e al vicino dx; repeat P i :if receive (test,j,l,d) from sx (dx) if j = id then stato = leader; send halt to sx if j > i and d ≧ 2 l then send (risp,j,l) to dx(sx) if j > i and d < 2 l 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.

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(M d ) = numero di fasi (ovvero T d ) moltiplicato per numero di messaggi trasmessi in ogni singola fase: Numero di fasi: al termine della generica fase l, il massimo numero di processori Leader temporanei(Lt) è dato da n/(2 l +1) dato che, se un processore p i risulta Lt, tutti i processori nel suo 2 l - vicinato debbono avere identificativo minore di i. Ne consegue che fra due Lt, p i e p j, ci debbono essere almeno 2 l 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 2 l messaggi di test, uno ad ogni processore del suo vicinato. Analogamente può ricevere al più 2x 2 l messaggi di risp, uno da ogni processore del suo vicinato, quindi n/(2 l +1) x 2 x 2 l <=4n Pertanto il numero totale di messaggi trasmessi sarà dato da O(nlogn)