Algoritmi Paralleli e Distribuiti a.a. 2008/09

Presentazione sul tema: "Algoritmi Paralleli e Distribuiti a.a. 2008/09"— Transcript della presentazione:

1 Algoritmi Paralleli e Distribuiti a.a. 2008/09
Lezione del 13/03/2009 Prof.ssa ROSSELLA PETRESCHI a cura del Dott. SAVERIO CAMINITI Anno Accademico 2007/2008

2 Broadcast con eco in una qualsiasi rete a connessione fissa
Per risolvere il problema della terminazione si usa l’eco 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 In una rete di n nodi, vengono inviati O(m) messaggi in O(d) passi Algoritmi Paralleli e Distribuiti a.a. 2008/09

3 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 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. Passo 1: Inizializzazione 0/2 0/4 1/2 2/2 1/4 Pa Pc Pd Pb Passo 2 Algoritmi Paralleli e Distribuiti a.a. 2008/09

4 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 Algoritmi Paralleli e Distribuiti a.a. 2008/09

5 Sistemi sincroni e asincroni
Sistema sincrono Sistema asincrono Un messaggio spedito da un nodo ad un suo vicino arriva sempre in tempo costante La trasmissione dei messaggi ha durata variabile L'assenza di segnale è informazione L'assenza di segnale non fornisce informazione La computazione locale ha costo zero Algoritmi Paralleli e Distribuiti a.a. 2008/09

6 Complessità distribuita
complessità dei messaggi (Md): è il numero totale di messaggi spediti tra nodi vicini durante la computazione; complessità temporale (Td): tempo speso per la comunicazione durante la computazione del caso peggiore fino a quando l’output richiesto è stato raggiunto (o il sistema va in halt) Ad esempio durante una esecuzione dell’algoritmo di Broadcast con eco vengono inviati in totale Md = 2m messaggi (2 per ogni arco). L’algoritmo però richiede soltanto Td = O(d) passi di comunicazione (dove d è il diametro della rete). Per quanto riguarda la complessità temporale, nel modello sincrono il suo calcolo si riduce essenzialmente a contare il numero delle pulsazioni che trascorrono durante la computazione, mentre nel modello asincrono consiste nel calcolare il numero di messaggi nella più lunga catena casuale della forma “ricevi un messaggio e spedisci un messaggio come conseguenza”, calcolata su tutte le possibili esecuzioni dell’algoritmo e su tutte le possibili strutture del grafo G. Come sempre, queste misure sono considerate nel caso peggiore e in forma asintotica in funzione di n e m, nodi e archi di G. Algoritmi Paralleli e Distribuiti a.a. 2008/09

7 Complessità parallela
Tempo di esecuzione (Tp): si calcola come differenza tra il tempo in cui tutti i processori hanno terminato il loro lavoro e il tempo di inizio del primo processo. Numero di processori (Np): viene considerato il massimo numero di processori utilizzati. Costo (Cp): di un algoritmo è dato dal prodotto del tempo di esecuzione per il numero di processori. Speed-up (Su): è una misura utile a determinare quanto un algoritmo parallelo sia veloce rispetto al migliore algoritmo seriale conosciuto per lo stesso problema. Si calcola come rapporto tra il tempo impiegato nel caso pessimo dal miglior algoritmo seriale e il tempo del nostro algoritmo parallelo. Su = Ts / Tp. Efficienza (Eff): è il rapporto tra la complessità nel caso pessimo dell'algoritmo seriale ottimo e il costo dell'algoritmo parallelo. Eff = Ts / Cp . Algoritmi Paralleli e Distribuiti a.a. 2008/09

8 Algoritmi Paralleli e Distribuiti a.a. 2008/09
Speed-up / efficienza Lo speed-up è una misura utile a determinare quanto un algoritmo parallelo sia veloce rispetto al migliore algoritmo seriale conosciuto per lo stesso problema. Se si considera lo speed-up a partire da un algoritmo seriale ottimo, lo speed-up ideale è uguale al numero di processori, poiché un algoritmo che lavora su Np processori può essere al più Np volte più veloce del corrispondente algoritmo seriale. Quando si raggiunge lo speed-up ottimo si ottiene l'algoritmo parallelo ottimo (se lo era il seriale). Nel caso in cui lo speed-up sia maggiore di Np, l'algoritmo seriale utilizzato non è ottimo e se ne può trovare uno migliore eseguendo serialmente i passi dell'algoritmo parallelo utilizzato. L'efficienza deve risultare minore o uguale a 1. Se risultasse maggiore di 1 allora l'algoritmo seriale non sarebbe ottimo e sarebbe possibile trovarne uno migliore simulando l'algoritmo parallelo con l'esecuzione seriale degli stessi calcoli dell'algoritmo parallelo su di un unico processore. Bisogna ricordare che il numero Np di processori risulta vincolato da considerazioni di carattere tecnologico ed economico (costo iniziale e di manutenzione); in pratica si cerca di rendere Np indipendente dalla dimensione n del problema e comunque abbastanza piccolo. Volendo esprimere il rapporto esistente tra Np ed n, possiamo utilizzare un'equazione del tipo: Np = f(n) = n1-x con 0 ≤ x ≤ 1 Algoritmi Paralleli e Distribuiti a.a. 2008/09

9 Accelerated Cascading
Abbiamo visto come l’algoritmo di somma parallelo non sia 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). 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 sui k risultati del passo precedente. Tempo parallelo O(log k) Costo = O(P (h + log k)) Algoritmi Paralleli e Distribuiti a.a. 2008/09

10 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 Pi: bi = i * h for j = 1 to h -1 do if bi + j < n then A[ bi ] = A[ bi ] + A[ bi + j ] B[ i ] = A[ bi ] Somma(B, k) // algoritmo di somma parallela standard end Tempo parallelo O(h + log k) Algoritmi Paralleli e Distribuiti a.a. 2008/09

11 Esempio di somma con la tecnica dell’Accelerated Cascading
n = P = size = 3 24 32 10 11 7 16 9 45 2 19 31 5 P0 P1 P2 P3 56 18 54 50 66 34 55 122 89 211 1° fase sequenziale 2° fase parallela Algoritmi Paralleli e Distribuiti a.a. 2008/09

12 Analisi dell’algoritmo SommaAC
Per ottenere costo Cp=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) Algoritmi Paralleli e Distribuiti a.a. 2008/09