Lezione n°3
Algoritmi Avanzati
a.a.2014/2015
Prof.ssa Rossella Petreschi
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
5
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
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).
Simulazione della scrittura concorrente:
stessa informazione
Sia dato un algoritmo per PRAM CW con scrittura concorrente di valori identici. L’operazione compiuta da tutti
i processori di scrivere nella stessa locazione R viene simulata su PRAM EW dal solo processore P0, dopo aver
controllato che tutti i valori ai scritti dai rispettivi Pi siano uguali*. Questo controllo si effettua usando un vettore
A con tutti i valori da scrivere e un vettore di booleani utilizzato per riportare le eventuali diversità nei valori di
A:
for j = 0 to n-1 pardo
Pj:
A[ j ] = aj; B[ j ] = true
for i = 1 to log n do
for j = 0 to (n/2i -1) pardo
Pj:
if A[ j ] A[ j+ n/2i ] or not B[ j ] or not B[ j+ n/2i ] then
B[ j ] = false
P0: if B[ 0 ] then R = A[ 0 ]
Il tempo parallelo richiesto è O(log n)
* Questo controllo su PRAM CW si suppone effettuato a livello hardware
Simulazione della scrittura concorrente:
funzione dei valori
La simulazione di PRAM CW con scrittura del massimo valore (o della
somma o di qualsiasi altra funzione commutativa f dei valori) viene eseguita su
PRAM EW semplicemente utilizzando la tecnica della metà per il computo di f
su un vettore A:
for j = 0 to n-1 pardo
Pj:
A[ j ] = aj
for i = 1 to log n do
for j = 0 to (n/2i -1) pardo
Pj:
A[ j ] = f ( A[ j ], A[ j+ n/2i ] )
P0: R = A[ 0 ]
Con lo stesso schema si può simulare anche la scrittura concorrente basata su
priorità (ad esempio in funzione dell’indice del processore che vuole scrivere).
In entrambi i casi la simulazione richiede tempo parallelo logaritmico.
