Diapositiva 1

TEOREMA DI BRENT
Lezione n°4
Algoritmi Avanzati
Prof.ssa Rossella Petreschi
Sequenze pulite
Una sequenza binaria si dice pulita se è composta interamente da 0 o da 1.
Se S è bitonica almeno una delle due sottosequenze bitoniche m(S) e M(S) è pulita
(diretta conseguenza del fatto che la cardinalità di {0,1} è due).
In figura è presentato un circuito di ordinamento, di profondità logaritmica, per
sequenze 0/1 bitoniche (ad ogni passo rendiamo pulita metà della sequenza).
0
0
1
1
1
0
0
0
0
0
0
0
1
0
1
1
0
0
0
0
1
0
1
1
0
0
0
0
0
1
1
1
Circuito di fusione
Il circuito di fusione fonde due sequenze ordinate costruite sullo stesso alfabeto
sfruttando il fatto che, date due sequenze ordinate entrambe crescenti (o decrescenti) x
e y, la sequenza che si ottiene concatenando x con z=“y rovesciata” è bitonica
(l’inversione della stringa y si realizza semplicemente variando le connessioni).
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
1
0
0
0
0
1
1
1
1
1
1
1
1
1
La profondità del circuito è logaritmica e il numero di comparatori ad ogni passo è n/2.
Circuito di ordinamento
In figura è riportato un circuito di ordinamento che realizza l’ordinamento connettendo
iterativamente diversi circuiti di fusione (la base di questa costruzione sta nel fatto che
ogni sequenza di due elementi è bitonica).
1
0
0
0
0
1
1
0
0
1
0
0
0
1
0
1
0
0
1
0
0
0
1
1
0
0
0
1
0
0
1
1
0
0
0
0
1
0
1
1
0
0
0
0
1
0
1
1
0
0
0
0
0
1
1
1
Poiché concateniamo un numero logaritmico di circuiti di fusione, otteniamo una
profondità del circuito O(log2 n).
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.
Teorema di Brent/Circuiti di ordinamento
Il circuito di ordinamento, O, è un circuito combinatorico di
profondità d = O(log2 n), di dimensione pari al numero di
comparatori c = O(nlog2n), fan in e fan out limitati. Per il
Teorema di Brent, l’algoritmo di ordinamento che lavora su O
può essere simulato da una algoritmo che lavora su una PRAM
EREW con p processori in tempo O(c / p + d),
ovvero O((n log2 n) / p + log2 n).
Quando p = O(n) si ha che la complessità temporale
dell'ordinamento su una PRAM EREW è
O(log2 n) e il costo O(n log2 n).
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).
Numero di processori limitato (1)
Vogliamo sommare n numeri, con la tecnica della prima metà, avendo a disposizione un
numero fissato a priori di p processori (p < n).
Ricordiamo come si lavora con n processori
Begin
for i = 1 to log n do
for j = 0 to n/2i -1 pardo
Pj: A[ j ] = A[ j ] + A[ j+n/2i ]
return A[ 0 ]
end
P1 P 2 P3 P4
4 2 7 4 1 6 3 8
5 8 10 12
15 20
35
Numero di processori limitato (2)
p = 2 P1 P2
Vediamo cosa cambia con p <n processori
Begin
for i = 1 to log n do
for s = 0 to (n/2i) / p -1 do
for j = 0 to min(n/2i, p) -1 pardo
if (j+s*p < n/2i) then
Pj: A[ j+s*p ] = A[ j+s*p ] + A[ j+s*p +n/2i ]
return A[ 0 ]
end
i=1
4 2 7 4 1 6 3 8
s=0
5 8 7 4 1 6 3 8
s=1
i=2 5 8 10 12
s=0
i=3 15 20
s=0
35