AA-Lezione3

Broadcast
Lezione n°3
Algoritmi Avanzati
a.a.2013/2014
Prof.ssa Rossella Petreschi
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
Uso di Broadcast su P-RAM
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)
Broadcast su rete a Vettore
Si adoperano N processori
Input su P0
Broadcast(x)
begin
P0:
a0 = x
for i = 1 to N-1 do
Pi:
ai = ai-1
end
Tempo parallelo N
x
0
x
1
2
N-1
Caricare n valori distinti in un vettore
ovvero pipeline su rete a vettore
Si adoperano N processori
begin
for h = 0 to N-1 do
for i = 0 to h pardo
Pi:
if (i = 0) then
a0 = read(); b0 = a0
else
ai = ai-1; bi = ai
end
c
b
All’istante i, tutti i processori dallo 0-esimo all’h-esimo lavorano in
parallelo caricando nella propria memoria locale il valore contenuto nella
memoria locale del processore che lo precede
Poiché bisogna caricare N elementi il tempo parallelo totale rimane N
a
Pipelining
Una CPU con pipeline è un modello semplice di macchina parallela
composta da cinque stadi specializzati, capaci di eseguire, ciascuno in maniera
sequenziale, una delle operazione elementari caratterizzanti l’elaborazione di una
istruzione da parte di una normale CPU (lettura dell’istruzione dalla memoria,
decodifica istruzione, lettura degli operandi dai registri,esecuzione
dell’istruzione, scrittura del risultato nel registro opportuno).
Ad ogni ciclo di clock dall'ultimo stadio esce un'istruzione completata.
A regime, in uno stesso istante, ogni stadio esegue l’istruzione che lo specializza
su successive diverse istruzioni. Di conseguenza si guadagna una maggior
velocità di esecuzione a prezzo di una maggior complessità circuitale del
microprocessore.
L'implementazione di una pipeline non sempre moltiplica il “throughput” finale,
in quanto questo dipende da quante istruzioni possono essere eseguite in
parallelo senza creare conflitti o errori di esecuzione. Istruzioni che possono
richiedere l'elaborazione di dati non ancora disponibili o la presenza di salti
condizionati sono due esempi tipici di istruzioni non parallelizzabili.
.
Broadcast su mesh
Si adoperano RxC processori
Input su P0,0
Broadcast(x)
begin
P0,0: a0,0 = x
for j = 1 to C-1 do
P0,j:
a0,j = a0,jfor i = 1 to R-1 do
for j = 0 to C-1 pardo
Pi,j:
ai,j = ai-1,j
end
Tempo parallelo C+R
x
x
0
0 x
1
x
x
1 x
2
x
x
2
x
x
C-1
Caricare RxC valori distinti
in
una
mesh
Si adoperano RxC processori
begin
for k = 1 to R do
for h = 0 to C-1 do
for j = 0 to h pardo
P0,j:
if (j = 0) then
a0,0 = read(); b0,0 = a0,0
else
a0,j = a0,j-1; b0,j = a0,j
if (k < R) then
for i = k downto 1 pardo
for j = 0 to C-1 pardo
Pi,j:
ai,j = ai-1,j; bi,j = ai,j
end
Poiché bisogna caricare RC elementi il
tempo è pari a RC
c
b
a
f
e
d
i
h
g
l
k
j
g
f
e
d
a
a
Broadcast su albero binario
Con n foglie e 2n-1 processori
Input alla radice
Broadcast(x)
begin
P1: a1 = x
for i = 0 to log n -1 do
for j = 2i to 2i+1-1 pardo
Pj:
a2j = aj
a2j+1 = aj
end
Tempo parallelo logaritmico
a1
a2
a4
a3
a5
a6
a7
Broadcast su ipercubo
Si adoperano n=2d processori
Input su P0
110
Broadcast(x)
begin
P0:
a0 = x
for i = 0 to d-1 do
for j = 0 to 2i-1 pardo
Pj:
aj+2i = aj
end
010
111
011
100
101
000
x
001
x
x
x
x
x
x
Tempo parallelo d = log n
x
x
x
x
x
x
x
x
Rete combinatoria
Una rete combinatoria C può essere vista come un grafo diretto aciclico GC
avente un nodo per ciascun elemento combinatorio c e un arco diretto (c',c") se
l’output di c' è input di c".
La dimensione di una rete combinatoria è il numero di nodi del grafo e la
profondità è il diametro del grafo.
Il fan-in di un elemento c è il grado entrante del nodo c in GC e corrisponde al
numero di input dell’elemento.
Il fan-out di un elemento c è il grado uscente del nodo c in GC.
È da notare che non necessariamente il numero di output di un elemento
combinatorio è uguale al suo fan-out, infatti un elemento combinatorio con un
solo filo di output può “servire” un numero qualunque di altri elementi.
Elemento combinatorio
Def: Un elemento combinatorio è un qualunque elemento di
circuito che abbia un numero costante di input e output e che
esegua una funzione ben precisa.
Esempi:
– Porte logiche
– Comparatore
– ecc…
not
x
y
and
comp
or
min{x, y}
max{x, y}
Più elementi combinatori possono essere collegati tra di loro
formando una rete combinatoria dove l'output di un elemento
può essere l'input di uno o più altri elementi.
Circuiti di ordinamento
Utilizziamo il comparatore, ossia un circuito di confronto con due ingressi e due
uscite il cui valore è la coppia di valori in input ordinati in modo ascendente.
x
min(x,y)
y
max(x,y)
I circuiti formati da comparatori, se opportunamente combinati, costituiscono
un'architettura in grado di ordinare n valori di input.
9
5
2
2
5
9
7
5
5
2
2
5
7
7
7
7
9
9
Insertion Sort
Due architetture per implementare l'insertion sort (tra 8 valori in input):
Questa macchina utilizza una
versione seriale dell'algoritmo di
complessità O(n2) (indicata dalla
profondità del circuito, ossia il
numero di porte che vengono
attraversate in tempi differenti).
È
possibile
ottenere
una
complessità O(n) ottimizzando lo
scheduling dei comparatori e
parallelizzando l'algoritmo.
Sulla monotonicità
Se un circuito di ordinamento trasforma la sequenza di input a = (a1, a2,
…, an) nella sequenza di output b = (b1, b2, …, bn), allora per ogni
funzione monotona crescente f, il circuito trasforma la sequenza di input
f(a) = (f(a1), f(a2), …, f(an)) nella sequenza di output f(b)=(f(b1), f(b2), …,
f(bn)).
Tale proprietà è facilmente verificata da un singolo comparatore e per
induzione la si può provare per un intero circuito di ordinamento.
x
min(x,y)
f(x)
min(f(x), f(y))) = f(min(x,y))
y
max(x,y)
f(y)
max(f(x), f(y))) = f(max(x,y))
Principio 0/1
Teorema (principio 0/1): se un circuito combinatorio di ordinamento lavora
correttamente per qualunque input costruito sull'alfabeto {0,1} allora lavora
correttamente per qualunque input costruito su di un qualsiasi alfabeto finito A.
Dim: supponiamo per assurdo che il circuito ordini tutte le sequenze costruite
sull'alfabeto {0,1} correttamente, ma che esista una sequenza di input di
numeri arbitrari a = (a1, a2, …, an) contenente elementi ai e aj tali che ai < aj
mentre il circuito pone aj prima di ai nella sequenza di output. Definiamo una
funzione f monotona crescente come:
•f(x) = 0 se x <= ai
•f(x) = 1 se x > ai
dal lemma precedente segue che il circuito sistema f(aj) prima di f(ai) nella
sequenza di output quando f(a) è l'input. Ma poiché f(aj) = 1 mentre f(ai) = 0,
neghiamo l'ipotesi giungendo ad un assurdo.
Sequenze bitoniche
Una Sequenza Bitonica è una sequenza che può essere divisa in due sottosequenze
monotone, una crescente e l'altra decrescente o viceversa.
Sono bitoniche le due sequenze:
•m(S) = (min{s1,sn+1}, min{s2,sn+2}, …, min{sn,s2n})
•M(S) = (max{s1,sn+1}, max{s2,sn+2}, …, max{sn,s2n})
ottenute dalla sequenza bitonica S = s1, s2, …, s2n
Sfruttando la definizione di m(S) ed M(S) e le relative proprietà si può ottenere una
definizione ricorsiva per le sequenze bitoniche che ci permette di realizzare un primo
algoritmo di ordinamento che opera ricorsivamente secondo lo schema:
S=13896554
S1 = m(S) = 1 3 5 4
S2 = M(S) = 6 5 8 9
S3 = m(S1) = 1 3 S4 = M(S1) = 5 4
S5 = m(S2) = 6 5 S6 = M(S2) = 8 9
13
45
56
89
Complessità O(log(n)).