AA-Lezione4-16-10-2014

Lezione n°4
Algoritmi Avanzati
a.a.2014/2015
Prof.ssa Rossella Petreschi
Simulazione della scrittura concorrente
(caso generale)
Problema: N processori P1, P2, …, Pn vogliono scrivere i valori d1, d2, …, dn in K diverse celle di
memoria di una P-RAM di tipo EREW, in generale K<N . I valori d1, d2, …, dn sono contenuti in
un vettore D dato in input.
Sivuole simulare la concorrenza con priorità (scrive il processore di indice minore).
Algoritmo:
Idea analoga a quello visto per il caso generale di lettura concorrente
Passo 1: si costruisca M, vettore di coppie del tipo (Pi, Lj), ciascuna indicante che il processore iesimo vuole scrivere nella j-esima locazione di memoria (i=0…N-1, j=1…K) il dato memorizzato
nel vettore D (i-esima locazione). Questo vettore viene ordinato in modo stabile, rispetto ai valori
di Lj.
Passo 2: si raggruppino i processori rispetto alla comune locazione di memoria a cui vogliono
accedere e si individuino gli inizializzatori di ogni blocco.
Passo 3: in ogni blocco, il processore di indice minore (il primo del blocco) scrive la sua
informazione nella locazione di memoria caratterizzante il blocco.
Esempio di scrittura concorrente
Passo 1:
analogo
Passo 2:
P0: iniz[ 0 ] = true
for i = 1 to n-1 pardo
Pi:
if M[ i ].loc  M[ i-1 ].loc then iniz[ i ] = true
else iniz[ i ] = false
Passo 3:
for i = 0 to n-1 pardo
Pi:
if iniz[ i ] then
scrivi D[ M[ i ].proc ] in M[ i ].loc
D
x
y
z
P0
Memoria
a
b
1
2
3
5
1
2
3
4
5
Loc
8
3
3
9
8
3
D
x
x
z
a
b
c
Proc
1
2
5
0
4
3
Loc
3
3
3
8
8
9
iniz
T
F
F
T
F
T
P5
P3
x
4
0
c
y
0
Proc
6
7
8
a
9
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
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
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
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 = bi-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.
.
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 = b0,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
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.
Teorema di Brent
Teorema (CREW): ogni algoritmo che lavora su una
rete combinatoria di profondità d e dimensione n che
sia a fan-in limitato, può essere simulato da un
algoritmo che lavora su una PRAM CREW con p
processori in O(n/p+d) tempo.
Teorema (EREW): ogni algoritmo che lavora su una
rete combinatoria di profondità d e dimensione n che
sia a fan-in e fan-out limitato, può essere simulato da
un algoritmo che lavora su una PRAM EREW con p
processori in O(n/p+d) tempo.
Teorema di Brent - Esempio
Profondità: d = 5
Dimensione: n = 22
Processori: p = 3
Dimostrazione del teorema di Brent
•Modelli di calcolo:
- PRAM-EW con p processori p0, p1, …, pp-1.
- Rete combinatoria C di profondità d e dimensione n = ∑ni , i=1..d, con ni
numero di elementi al livello i.
L’input del circuito combinatorio si considera disponibile nella memoria
condivisa. Il fan-in limitato evita che la memoria condivisa non sia sufficiente a
memorizzare i risultati intermedi del calcolo.
•Idea della dimostrazione: Ogni processore simula un componente del primo
livello della rete e fornisce l’output che può essere immagazzinato nella memoria
condivisa. Si ripete l’operazione per un numero di volte pari alla profondità del
circuito utilizzando l’output di ogni livello come input del livello successivo. Nel
caso in cui p sia minore del massimo numero di elementi combinatori presenti in
uno stesso livello, si dovrà effettuare un numero di passi seriali proporzionale al
rapporto tra il numero di elementi del livello i e p.
Modelli CREW ed EREW nel Teorema di Brent
• La complessità tiene conto della profondità del circuito e dei passi seriali necessari a
simulare un livello.
• Tp = ∑ ⎡ni /p⎤ ≤ ∑ (ni /p +1) = n / p + d
con i=1..d
• Abbiamo detto che il processore che simula l’elemento combinatorio fornisce l’output
che può essere immagazzinato nella memoria condivisa. Se più processori richiedono
in input quello stesso valore si deve accettare che la P-RAM sia a lettura concorrente.
Se si accetta l’ipotesi che anche il il fan-out sia limitato, si può considerare che in
tempo costante l’output del circuito combinatorio sia direttamente copiato nell’input
dei circuiti che lo richiedono. Questa limitazione permetterebbe la simulazione su una
P-RAM a lettura esclusiva.
Trasportabilità fra P-RAM con diverso numero
di processori
Teorema (p' < p): ogni algoritmo A che lavora in tempo parallelo O(t) su
una PRAM con p processori può essere simulato da un algoritmo A' che
lavora su una PRAM con p' processori (p' < p) in tempo O(t p / p').
Dimostrazione: durante ognuno dei t passi dell’esecuzione di A, i p
processori lavorano parallelamente in tempo O(1). Durante ogni passo
della esecuzione di A', ciascuno dei p'<p processori eseguirà un blocco
seriale di p/p' operazioni in tempo O(p/p'). Pertanto il tempo parallelo
relativo alla esecuzione di A' sarà O(tp/p').
Il costo dei due algoritmi A e A' rimane pari a O(tp).