AA-Lezione9-11-11-2014

Lezione n°9
Algoritmi Avanzati
a.a.2014/2015
Prof.ssa Rossella Petreschi
La tecnica del
Accelerated Cascading
Dato un problema P di dimensione n, siano A1 e A2 due algoritmi per
risolvere il problema P che operano rispettivamente in tempo T1e T2 (T1>
T2), si costruisce un nuovo algoritmo A nel seguente modo:
1.
si applica a P l’algoritmo A1(A1lavora 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 A2
E’ da notare che invece di un solo algoritmo di riduzione A1 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
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)
Esempio di somma con la tecnica
dell’Accelerated Cascading
n = 12
P0
P=4
P1
size = 3
P2
P3
24 32 10 11 7 16 9 45 2 19 31 5
1° fase
sequenziale
2° fase
parallela
24
11
9
19
56
18
54
50
66
34
56
55
122
89
211
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)
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
Pi:
bi = i * h
// inizio blocco i-esimo
for j = 1 to h -1 do
A[ bi + j ] = A[ bi + j ] + A[ bi + j-1 ]
B[ i ] = A[ bi + h-1 ]
// l’ultimo del blocco
PrefixSum(B, k)
for i = 1 to k-1 pardo
Pi:
for j = 0 to h -1 do
A[ bi + j ] = A[ bi + j ] + B[ i-1 ]
end
Tempo parallelo O(h + log k)
Ear Decomposition
Dato un grafo non orientato G e P0 ciclo semplice in G, una Ear
Decomposition è una partizione ordinata dell’insieme degli archi
E = P0P1P2…Pk tale che 1ik Pi è un cammino semplice in cui
entrambi gli estremi (e solo gli estremi) appartengono a P0…Pi-1.
Non è unica:
P3
P2
P0
P0
P1
P1
P2
P0
Se 1ik Pi non è un ciclo (gli estremi sono distinti) allora la
decomposizione si dice aperta (vedi secondo esempio).
P3
Quali grafi ammetto una Ear Decomposition?
G è privo di ponti   EAR Decomposition
P0
P1
NO
SI
G è biconnesso   EAR Decomposition aperta
P2
P1
P3
P0
Ear e Spanning Tree
Dato G si consideri un suo spanning tree T. Esistono m-n+1 archi di G
non in T, ciascuno dei quali induce un ciclo se viene aggiunto a T.
3
e1
2
3
e7
e8
1
e2
4
e9
5
e3
6
e6
e4
8
e10
9
7
e5
2
4
1
5
8
6
9
7
Questa è una copertura del grafo tramite cicli, non una Ear
Decomposition: infatti due cicli possono condividere degli archi.
È necessario “rompere” i cicli per ottenere una Ear Decomposition.
Etichettare gli archi
Etichettiamo ogni arco e=(u,v) in G-T nel seguente modo:
label(e) = <level(lca(u,v)),e>
Livello e lca sono da intendersi in T, aggiungiamo l’indice dell’arco per
disambiguare ed avere tutte etichette distinte.
Poi etichettiamo gli archi in T assegnando a ciascun arco e=(u,v) in T la
minima etichetta associata ad una arco e' non in T che induce un ciclo
eT
label(e)
contente e.
eT
(2,1)
(1,8)
(3,5)
(7,8)
(7,6)
lca
3
4
3
8
4
label(e)
<0,e8>
<1,e9>
<0,e2>
<2,e10>
<1,e4>
(3,2)
(3,4)
(4,1)
(4,8)
(4,5)
(8,9)
(9,7)
(5,6)
<0,e8>
<0,e2>
<0,e8>
<1,e4>
<0,e2>
<1,e4>
<1,e4>
<1,e4>
Risultato
Ordinando gli archi rispetto a label(e) si ottiene la Ear
Decomposition come sequenza ordinata di cammini disgiunti.
e
(4,5)
(3,5)
(3,4)
(4,1)
(3,2)
(2,1)
(8,9)
(5,6)
(9,7)
(7,6)
(4,8)
(1,8)
(7,8)
label(e)
<0,e2>
<0,e2>
<0,e2>
<0,e8>
<0,e8>
<0,e8>
<1,e4>
<1,e4>
<1,e4>
<1,e4>
<1,e4>
<1,e9>
<2,e10>
3
Pe2
Pe8
Pe8
Pe2
2
4
1
Pe9
5
8
6
Pe4
Pe9
Pe10
Pe10
9
Pe4
7
Calcolo di label(e)  eT
•Dopo aver calcolato label(e)  e  T si definisca:
•f(v) = min{label(v,u) : (v,u)  T}
 vT
•È possibile verificare che per ogni arco e=(v, p(v))T il valore label(e) sarà il
minimo valore f(u) tra i nodi u appartenenti al sottoalbero Tv radicato in v.
•Il calcolo del minimo nel sottoalbero si può realizzare, tramite la tecnica del
salto del puntatore, in tempo O(log n) su una PRAM CRCW (con scrittura del
valore minimo) con n processori. L’assegnamento di f(v) v richiede O(1) e m
processori sullo stesso modello.
•Il costo è quindi O((n+m) log n) su PRAM CRCW o, simulando la scrittura
concorrente, O((n+m) log2 n) su PRAM CREW.
Algoritmo Ear Decomposition
Input: G privo di ponti rappresentato come sequenza di archi
begin
T = spanning tree di G
calcola TDE; radica T in qualunque nodo; calcola level(v) vT
for each  e=(u,v)  T pardo
Pe:
calcola lca(u,v)
label(e) = <level(lca(u,v)), e>
for each  e  T pardo
Pe:
label(e) = min{ label(e') : e'T  e  ciclo indotto da e' in T }
ordina gli archi rispetto a label(e)
end