Algoritmi Paralleli e Distribuiti

Somme prefisse su reti
Ricerca in vettori ordinati
Lezione n°7
Algoritmi Avanzati
a.a.2011/2012
Prof.ssa Rossella Petreschi
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 = 0 to R-1 pardo
for j = 0 to C-2 pardo
Pi,j:
xi,j = xi,j + sui,j
end
Tempo parallelo R+C
AA 2011-2012
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
P
i
i+1
for j = 2 to 2 -1 pardo
P j:
xj = x2j + x2j+1
P X +…+x
X1+…+x8
1
1
2
P4 X1+x2
P1: sp1 = 0
for i = 0 to log n -1 do
for j = 2i to 2i+1-1 pardo
P j:
sp2j = spj
sp2j+1 = spj + x2j
for i = n to 2n-1 pardo
P i:
xi = xi + spi
end
P8 x1
X5+…+x8 P
3
4
X5+x6 P
6
P5 X3+x4
x2
x2
x3
x5
x6
X7+x8 P
7
x7
x8
P15
sp = 0
X1+…+x8
sp = X1+…+x4
sp = 0
X1+…+x4
X1+x2
AA 2011-2012
X3+x4
X5+x6
X7+x8
sp = X1+…+x7
x1
sp = 0
x1
sp = X1+…+x6
X1+x2
sp = 0
Tempo parallelo logaritmico
X5+…+x8
x2
x3
x4
x5
x6
x7
x8
Ricerca di un elemento
in un vettore ordinato
Variabili:
• N: numero dei processori
• y: elemento da cercare
• X = (x1, x2, …, xn), tale che x1  x2 …  xn: vettore in cui cercare y
• l ed r (inizializzati a 0 ed n rispettivamente): estremi del vettore su cui si lavora;
• q0,…qN+1 (relative a ciascun processore + 2 aggiuntive): indice degli elementi da
analizzare;
• c0,…cN+1 (inizializzate a 0, cN+1 inizializzata ad 1): identificatori del sottovettore su
cui iterare.
Input: X, y
Output: i t.c. xi  y  xi+1
• Passo 1: dividi iterativamente il vettore in sottovettori più o meno bilanciati finché
il numero di elementi nel sottovettore identificato non è  N e controlla se X[qi]=y;
• Passo 2: controlla se nel sottovettore di dimensione  N è presente l’elemento
cercato.
AA 2011-2012
Algoritmo Ricerca Binaria
P1:
c0 = 0; cN+1 = 1
while (r-l) > N do
Pj:
for j = 1 to N pardo
if j = 1 then q0 = l; qN+1 = r
qj = l +  j (r-l) / (N+1) 
if y = X[ qj ] then return qj
else if y > X[ qj ] then cj = 0 else cj = 1
if cj < cj+1 then l = qj; r = qj+1
if j = 1 and c0 < c1 then r = q1
Pj:
for j = 1 to N pardo
if y = X[ l+j ] then return l+j
else if y > X[ l+j ] then cj = 0 else cj = 1
if cj < cj+1 then return l+j
if j = 1 and c0 < c1 then return l
AA 2011-2012
Passo 1
Passo 2
Esempio
l
0
r
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n = 14
N=2
y = 37
x - -22 -3 4 10 12 15 27 32 35 42 55 56 61 70 
q0
q1
q2
0
c
l
4
1
6
7
8
9
10
3
0 0 1 1
r
5
2
q3
11
Passo 2
l
x 10 12 15 27 32 35 42 55
q0 q1
0
c
q2
1
2
q3
7
r
8
9
10
11
x 27 32 35 42 55
0
3
c
0 0 0 1
AA 2011-2012
1
2
3
0 0 1 1
return 9
Complessità dell’algoritmo
Ciascuna iterazione del Passo 1 richiede tempo O(1). Analizziamo
il numero di iterazioni esplicitando la dimensione si del sottovettore
nell’iterazione i-esima:
s0 = n+2
si+1 = si / (N+1) = s0 / (N+1)i
Quindi il numero totale di iterazioni è:
logN+1(n+2) = log2(n+2) / log2(N+1)
Il Passo 2 richiede tempo costante, quindi il tempo complessivo
richiesto dall’algoritmo è O(log2(n+2) / log2(N+1)). Il modello di
PRAM è CREW perché tutti gli N processori accedono
contemporaneamente alle variabili y, l, r e c.
Si noti che, quando N = O(1), il costo complessivo dell’algoritmo è
O(log n): pari all’ottimo nel sequenziale. Quando N = O(n) il
tempo diventa costante.
AA 2011-2012