Lezione del 13/03/2009

Algoritmi Paralleli e Distribuiti
a.a. 2008/09
Lezione del 13/03/2009
Prof.ssa ROSSELLA PETRESCHI
a cura del Dott. SAVERIO CAMINITI
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 |
receive messaggio da un vicino
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
2
Esempio broadcast con eco 1
Processore non raggiunto dal Broadcast
Processore raggiunto dal Broadcast (all’interno
sono riportati i valori di conti e di |Ni|)
Messaggio di Broadcast
Peco
Processore che ha ricevuto conferma da
tutti i vicini (incluso l’eco)
0/4
Messaggio di eco
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.
Passo 1: Inizializzazione
Pa
1/4
0/2
Pc
0/4
Pd
Passo 2
2/2
Pb
1/2
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.
Algoritmi Paralleli e Distribuiti a.a. 2008/09
3
Esempio broadcast con eco 2
2/2
2/2
2/2
1/4
4/4
0/2
1/1
1/4
2/2
2/4
2/2
Passo 3
Passo 4
2/2
4/4
Passo 5
Passo 6
Algoritmi Paralleli e Distribuiti a.a. 2008/09
4
Sistemi sincroni e asincroni
Sistema sincrono
Sistema asincrono
Un messaggio spedito da un
La trasmissione dei messaggi ha
nodo ad un suo vicino arriva
durata variabile
sempre in tempo costante
L'assenza
di
informazione
segnale
è L'assenza di segnale
fornisce informazione
non
La computazione locale ha costo zero
Algoritmi Paralleli e Distribuiti a.a. 2008/09
5
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
6
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
7
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 speedup 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
8
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
9
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)
end
// algoritmo di somma parallela standard
Tempo parallelo O(h + log k)
Algoritmi Paralleli e Distribuiti a.a. 2008/09
10
Esempio di somma con la tecnica
dell’Accelerated Cascading
n = 12
P=4
P0
P1
24
1° fase
sequenziale
2° fase
parallela
32
10
11
7
size = 3
P2
16
9
45
P3
2
19
31
24
11
9
19
56
18
54
50
66
34
56
55
122
89
5
211
Algoritmi Paralleli e Distribuiti a.a. 2008/09
11
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
12