Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi

Presentazione sul tema: "Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi"— Transcript della presentazione:

1 Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Simulazione di lettura e scrittura concorrente Lezione n°4 Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi 1

2 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 P-RAM di tipo EREW. Algoritmo: Passo 1: si costruisca M, vettore di coppie del tipo (Pi, Lj), ciascuna indicante che il processore i-esimo 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 conti il numero di 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 2

3 PASSI 1 e 2 Passo 1: for i = 0 to n-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) Il vettore B è utilizzato per identificare il blocco di appartenenza di ogni processore 1 2 3 4 5 Proc 8 9 Loc T F iniz B AA 3

4 PASSO 3 Invece di eseguire K broadcast differenti (uno per blocco) si esegue un unico broadcast multiplo che tiene conto della separazione in blocchi 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 Pi: if iniz[ i ] and i+2j<n and B[ i ] = B[ i+2j ] then D[ i+2j ] = D[ i ] iniz[ i+2j ] = true T F iniz x y z D 1 2 3 B AA 4

5 PASSO 4 Passo 4: for i = 0 to n-1 pardo
Proc 1 2 5 4 3 Passo 4: for i = 0 to n-1 pardo // chi aveva richiesto l’i-esimo dato Pi: R[ M[ i ].proc ] = D[ i ] // nel registro del proc i-esimo // si carica il dato voluto Ri = R[ i ] 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 Loc 3 3 3 8 8 9 D x x x y y z R y x x z y x AA 5

6 Simulazione della scrittura concorrente (caso generale)
Problema: N processori P1, P2, …, Pn vogliono scrivere i valori a1, a2, …, an rispettivamente, in K diverse celle di memoria di una P-RAM di tipo EREW. In generale K<N e si vuole 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 i-esimo 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. AA 6

7 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 1 2 3 4 5 Proc 8 9 Loc x y z a b c D T F iniz y Memoria x a 1 2 3 4 5 6 7 8 9 z b c D P3 P0 P5 AA 7

8 Somme prefisse Sequenziale PrefixSum(A, n) begin for i = 1 to n-1 do
A[ i ] = A[ i ] + A[ i-1 ] end Tempo O(n) 2 5 1 3 6 7 8 11 13 19 20 AA 8

9 Somme prefisse su P-RAM
P-RAM EREW con n processori PrefixSum(A, n) begin for i = 0 to log n -1 do for j = 0 to n-1 -2i pardo Pj: A[ j+2i ] = A[ j ] + A[ j+2i ] end Tempo Parallelo O(log n) 2 5 1 3 6 7 4 8 11 12 9 13 19 20 AA 9

10 Somme prefisse su albero binario
Le n foglie hanno già il valore da sommare nella variabile xi begin for i = log n -1 to 0 do for j = 2i to 2i+1-1 pardo Pj: xj = x2j + x2j+1 P1: sp1 = 0 for i = 0 to log n -1 do Pj: sp2j = spj sp2j+1 = spj + x2j for i = n to 2n-1 pardo Pi: xi = xi + spi end Tempo parallelo logaritmico X1+…+x4 X1+x2 X3+x4 X5+…+x8 X5+x6 X7+x8 X1+…+x8 x1 x2 x3 x5 x6 x7 x8 P2 P1 P4 P8 P5 P6 P7 P3 P15 sp = 0 X1+…+x8 sp = 0 sp = X1+…+x4 X1+…+x4 X5+…+x8 sp = 0 X1+x2 sp = X1+…+x6 X1+x2 X3+x4 X5+x6 X7+x8 sp = 0 x1 sp = X1+…+x7 x1 x2 x3 x4 x5 x6 x7 x8 AA 10 10

11 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 j = C-2 to 0 do Pi,j: sui,j = sui,j+1 for j = 0 to C-1 pardo Pi,j: xi,j = xi,j + sui,j end Tempo parallelo R+C AA 11 11