AA-Lezione3-30-09-2015

Lezione n°3
Algoritmi Avanzati
a.a.2015/2016
Prof.ssa Rossella Petreschi
Somme prefisse su albero binario
Le n foglie hanno già il valore da sommare nella variabile xi
•begin
• for i = log n -1 downto 0 do
•
for j = 2i to 2i+1-1 pardo
•Pj:
xj = x2j + x2j+1
•P1:sp1 = 0
• for i = 0 to log n -1 do
•
for j = 2i to 2i+1-1 pardo
•Pj:
sp2j = spj
•
sp2j+1 = spj + x2j
• for i = n to 2n-1 pardo
•Pi:
xi = xi + spi
•end
P2
P8
x1
X5+…+x8
X1+…+x4
P4 X1+x2
x2
P3
X5+x6 P
6
P5 X3+x4
x2
x3
x5
x6
X7+x8 P
7
x7
x8
P15
sp = 0
X1+…+x8
sp = X1+…+x4
sp = 0
X1+…+x4
X5+…+x8
sp = X1+…+x6
X1+x2
sp = 0
X1+x2
X5+x6
X3+x4
X7+x8
x1
sp = 0
Tempo parallelo logaritmico
X1+…+x8
P1
x1
x2
sp = X1+…+x7
x3
x4
x5
x6
x7
x8
Somme prefisse su mesh
Ogni processore ha il valore da sommare in xi,j
begin
for i = 0 to R-1 pardo
for j = 1 to C-1 do
•Pi,j:
xi,j = xi,j + xi,j-1
•P0,C-1: su0,C-1 = 0
for i = 1 to R-1 do
•Pi,C-1:
sui,C-1 = xi-1,C-1 + sui-1,C-1
for i = 1 to R-1 pardo
for j = C-2 downto 0 do
•Pi,j:
sui,j = sui,j+1
for i = 1 to R-1 pardo
for j = 0 to C-1 pardo
•Pi,j:
xi,j = xi,j + sui,j
end
Tempo parallelo R+C
Concorrenza in lettura e scrittura
Memoria
PRAM
P0
–
–
–
–
P1
P2
EREW: Exclusive Read, Exclusive Write;
CREW: Concurrent Read, Exclusive Write;
ERCW: Exclusive Read, Concurrent Write;
CRCW: Concurrent Read, Concurrent Write;
Pn-1
Scrittura Concorrente
Nei modelli a scrittura concorrente, quando più processori
richiedono di scrivere in una stessa locazione di memoria
condivisa, viene consentita la scrittura ad un solo processore in
accordo con uno dei seguenti criteri di scelta:
– stabilita una scala di priorità tra i processori, si permette la scrittura solo al
processore nella prima posizione della scala
(CRCW prioritaria);
– supposto che tutti i processori vogliano scrivere lo stesso valore,
consentire la scrittura ad uno qualunque dei processori
(CRCW arbitraria).
Esistono in letteratura altri criteri, anche se meno usati, che permettono ad un
fissato processore di scrivere nella cella di memoria il valore di una funzione di
tutti i dati (ad esempio il massimo, lo xor, la somma).
Broadcast su P-RAM EREW
Si adoperano n processori
Broadcast(x)
begin
P0: A[ 0 ] = x
for i = 0 to log n -1 do
for j = 2i to 2i+1-1 pardo
Pj:
A[ j ] = A[ j-2i ]
end
x
x x
x x x x
x x x x x x x x
Tempo parallelo logaritmico
Un semplice esempio di algoritmo
su P-RAM di tipo CR-W
Si adoperano n processori
Cerca(A, n, x)
begin
indice = -1
for i = 0 to n-1 pardo
Pi:
if A[ i ] = x then indice = i
return indice
end
Il modello adoperato richiede solo la lettura concorrente di x se si assume che gli A[ i ]
siano tutti distinti. Se invece si accetta che il vettore A possa contenere elementi
ripetuti allora più processori possono scrivere concorrentemente la variabile indice e il
modello necessario in tal caso è la P-RAM CRCW (con scrittura concorrente basata su
priorità dei processori).
In entrambi i casi il tempo parallelo è costante
Con il broadcast su P-RAM ER-W
Si adoperano n processori
Cerca(A, n, x)
begin
Broadcast(x)
indice = -1
for i = 0 to n-1 pardo
Pi:
if A[ i ] = x [ i ] then indice = i
return indice
end
Tempo parallelo logaritmico
Se gli A[ i ] sono tutti distinti il modello è P-RAM EREW altrimenti è ERCW
per la scrittura dell’indice (scrittura concorrente basata su priorità dei
processori)
Trasportabilità degli algoritmi
Dati due differenti modelli di computazione M e M’, si dice che
un algoritmo A progettato per la computazione C sul modello M è
trasportabile sul modello M’ se l’algoritmo A’ che computa C sul
modello M’ è ottenibile da A tramite l’applicazione di un insieme
finito di regole fisse.
Il broadcast su PRAM è un primo esempio di trasportabilità di un
algoritmo:
se su una PRAM CR tutti i processori vogliono leggere la stessa
informazione, pagando un tempo O(logn) per il broadcast si può
trasportare l’algoritmo su una PRAM ER.
Vediamo come affrontare la trasportabilità della scrittura
concorrente da PRAM CW a PRAM EW.
Simulazione della lettura concorrente
(caso generale)
Problema: n processori P1, P2, …, Pn vogliono leggere il contenuto di k celle di memoria (in
generale k<n e non tutti i processori vogliono leggere dalla stessa locazione di memoria) su una PRAM di tipo EREW.
Algoritmo:
Passo 1: si costruisca M, vettore di coppie del tipo (Pi, Lj), ciascuna indicante che il processore iesimo vuole leggere la j-esima locazione di memoria (i=0…n-1, j=1…k). Questo vettore viene
ordinato in modo stabile, rispetto ai valori Lj (la stabilità garantisce l’ordinamento delle coppie).
Passo 2: si raggruppino i processori rispetto alla comune locazione di memoria a cui vogliono
accedere, si individuino gli inizializzatori di ogni blocco e si caratterizzino gli elementi in ogni
blocco.
Passo 3: il primo processore di ogni blocco legge la locazione corrispondente e poi attiva
un’operazione di broadcast sul blocco.
Passo 4: tutti i processori in parallelo leggono l’informazione richiesta.
AA 2011-2012
10
PASSI 1 e 2
Passo 1:
for i = 0 to -1 pardo
Pi:
M[ i ] = (i, Lj) // coppie (proc, loc)
sort(M, loc);
Passo 2:
P0: iniz[ 0 ] = true; B[ 0 ] = 1
for i = 1 to n-1 pardo
Pi:
if M[ i ].loc  M[ i-1 ].loc then
iniz[ i ] = true; B[ i ] = 1
else
iniz[ i ] = false; B[ i ] = 0
PrefixSum(B, n)
Proc
0
1
2
3
4
5
Loc
8
3
3
9
8
3
Proc
1
2
5
0
4
3
Loc
3
3
3
8
8
9
iniz
T
F
F
T
F
T
B
1
0
0
1
0
1
B
1
1
1
2
2
3
Il vettore B è utilizzato per identificare il blocco di appartenenza di ogni processore
PASSO 3
Invece di eseguire k broadcast differenti (uno per blocco) si esegue un unico broadcast
multiplo che tiene conto della separazione in blocchi
iniz T
Passo 3: // Broadcast multiplo
for i = 0 to n-1 pardo
Pi:
if iniz[ i ] then
D[ i ] = contenuto di M[ i ].loc
for j = 0 to log n -1 do
for i = 0 to n-1 pardo
Pi:
if iniz[ i ] and i+2j<n and B[ i ] = B[ i+2j ] then
D[ i+2j ] = D[ i ]
iniz[ i+2j ] = true
F
F
D x
T
F
y
B 1
1
D x
x
D x
x
D x
x
1
T
z
2
2
3
y
y
z
x
y
y
z
x
y
y
z
PASSO 4
Passo 4:
for i = 0 to n-1 pardo
P i:
// chi aveva richiesto l’i-esimo dato
R[ M[ i ].proc ] = D[ i ]
// nel registro del proc i-esimo
// si carica il dato voluto
Ri = R[ i ]
Proc
1
2
5
0
4
3
Loc
3
3
3
8
8
9
D
x
x
x
y
y
z
R
y
x
x
z
y
x
Al termine ogni processore i avrà nel suo registro R il dato contenuto alla locazione Lj
inizialmente specificata.
Tempo Parallelo:
Passo 1: Tsort
Passo 2: Tprefixsum
Passo 3: logaritmico
Passo 4: costante