La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Parallel sparse Matrix-Vector and Matrix-Transpose-Vector multiplication using compressed sparse blocks Presentazione a cura di: Marco Cherubini, Andrea.

Presentazioni simili


Presentazione sul tema: "Parallel sparse Matrix-Vector and Matrix-Transpose-Vector multiplication using compressed sparse blocks Presentazione a cura di: Marco Cherubini, Andrea."— Transcript della presentazione:

1 Parallel sparse Matrix-Vector and Matrix-Transpose-Vector multiplication using compressed sparse blocks Presentazione a cura di: Marco Cherubini, Andrea De Pirro, David Santucci, Andrea Tersigni, Luca Tracuzzi A. Buluc, J. T. Fineman, M. Frigo, J. R. Gilbert, C. E. Leiserson Calcolo Parallelo e Distribuito Anno Accademico 2009/2010

2 Sommario Formati di memorizzazione convenzionali Il nuovo formato CSB Moltiplicazione Matrice-Vettore con CSB Analisi della complessità Sperimentazione

3 Formati convenzionali: CSR Analizziamo alcuni formati di memorizzazione convenzionali Consideriamo matrici sparse n×n con nnz elementi non nulli CSR - Compressed Sparse Rows o Memorizzazione per righe o Efficiente: memorizza n+nnz indici o puntatori per matrici sparse n×n con nnz elementi non nulli o Adatto per y Ax o Non adatto per y A T x

4 Formati convenzionali: CSR

5 Ax parallelo con CSR CSR_S P MV (A, x, y) 1 n A.rows 2 for i 0 to n1 in parallel 3 do y[i] 0 4 for k A.row_ptr[i] to A.row_ptr[i+1]1 5 do y[i] y[i]+A.val[k]·x[A.col_ind[k]] val[nnz] : array dei valori non nulli della matrice (ordinati per righe) col_ind[nnz] : indici di colonna degli elementi nell'array val row_ptr[n] : puntatori al'inizio della riga n nell'array val Nota: A T x con CSC è analogo

6 Formati convenzionali: CSC CSC - Compressed Sparse Columns o Memorizzazione per colonne o Efficiente: memorizza n + nnz indici o puntatori o Adatto per y A T x risoluzione di problemi di programmazione lineare o Non adatto per y Ax

7 Formati convenzionali: CSC

8 Il nuovo formato CSB Consideriamo matrici sparse n×n con nnz elementi non nulli β = block-size parameter o valore ideale = circa n o per semplicità si assume β potenza di 2 CSB - Compressed Sparse Blocks o Partizionamento della matrice in blocchi quadrati di dimensione β × β o Numero di blocchi n 2 / β 2 o Ordinamento Z-Morton interno ai blocchi o Sostiene y Ax e y A T x

9 Il nuovo formato CSB

10

11

12

13

14 Prod. Matrice-Vettore con CSB CSB_S P MV (A, x, y) 1 for i 0 to n/β1 in parallel // riga di blocco 2 do Initialize a dynamic array R i 3 R i [0] 0 // Array di indici per // gli ultimi blocchi dei chunk 4 count 0 // Contatore nnz in un chunk 5 for j 0 to n/β2 6 do count count+nnz(A i,j ) 7 if count+nnz(A i,j+1 ) > O(β) 8 then // Fine chunk 9 append j to R i // Ultimo blocco del chunk 10 count 0 11 append n/β1 to R i 12 CSB_B LOCKROW V (A, i, R i, x, y[(iβ),…,((i+1)β)1])

15 Prod. Matrice-Vettore con CSB Divisione in chunk

16 Prod. Matrice-Vettore con CSB Divisione in chunk

17 Prod. Matrice-Vettore con CSB Divisione in chunk

18 Prod. Matrice-Vettore con CSB Divisione in chunk

19 CSB_B LOCKROW V (A, i, R, x, y) 11 if R.length = 2 // Singolo chunk 12 then R[0]+1 // Blocco più a sinistra nel chunk 13 r R[1] // Blocco più a destra nel chunk 14 if = r 15 then // Il chunk contiene un singolo blocco denso 16 start A.blk_ptr[ f(i,)] 17 end A.blk_ptr[ f(i,)+1]1 18 CSB_B LOCK V (A, start, end, β, x, y) 19 else // Il chunk è sparso 20 multiply y (A i, A i,+1 … A i,r )x serially 21 return // Se la riga di blocchi contiene più chunk 22 mid R.length/2 1 // Divide i chunk in due sottoinsiemi // Calcola il punto di split per il vettore x 23 xmid β·(R[mid]R[0]) 24 Alloca un vettore z di cardinalità β, inizializzati a 0 25 in parallel 26 do CSB_BLOCKROWV(A, i, R[0…mid], x[0…xmid1], y) 27 do CSB_BLOCKROWV(A, i, R[mid…R.length1], x[xmid…x.length1], z) 28 for k 0 to β1 29 do y[k] y[k]+z[k]

20 CSB_B LOCKROW V (A, i, R, x, y) 11 if R.length = 2 // Singolo chunk 12 then R[0]+1 // Blocco più a sinistra nel chunk 13 r R[1] // Blocco più a destra nel chunk 14 if = r 15 then // Il chunk contiene un singolo blocco denso 16 start A.blk_ptr[ f(i,)] 17 end A.blk_ptr[ f(i,)+1]1 18 CSB_BLOCKV (A, start, end, β, x, y) 19 else // Il chunk è sparso 20 multiply y (A i, A i,+1… A i,r )x serially 21 return // Se la riga di blocchi contiene più chunk 22 mid R.length/2 1 // Divide i chunk in due sottoinsiemi // Calcola il punto di split per il vettore x 23 xmid β·(R[mid]R[0]) 24 Alloca un vettore z di cardinalità β, inizializzati a 0 25 in parallel 26 do CSB_B LOCKROW V(A, i, R[0…mid], x[0…xmid1], y) 27 do CSB_B LOCKROW V(A, i, R[mid…R.length1], x[xmid…x.length1], z) 28 for k 0 to β1 29 do y[k] y[k]+z[k]

21 Prod. Matrice-Vettore con CSB Split ricorsivo dei chunk y[β..2β-1]

22 Prod. Matrice-Vettore con CSB Split ricorsivo dei chunk y[β..2β-1]

23 CSB_B LOCK V (A, start, end, dim, x, y) 28 if endstart O(dim) 29 then // Calcola la computazione seriale yy+Mx 30 for k start to end // A.val[start…end] è un blocco dim×dim 31 do y[A.row_ind[k]] y[A.row_ind[k]] + A.val[k]·x[A.col_ind[k]] 32 return 33 // Ricorsione: divide il blocco M in 4 quadranti 34 binary search start, start+1,…,end per il più piccolo s 2 tale che (A.row_ind[s 2 ] & dim/2) 0 35 binary search start, start+1,…,s 2 1 per il più piccolo s 1 tale che (A.col_ind[s 1 ] & dim/2) 0 36 binary search s 2, s 2 +1,…,end per il più piccolo s 3 tale che (A.col_ind[s 3 ] & dim/2) 0 37 in parallel 38 do CSB_B LOCK V (A, start, s 1 1, dim/2, x, y) // M do CSB_B LOCK V (A, s 3, end, dim/2, x, y) // M in parallel 41 do CSB_B LOCK V (A, s 1, s 2 1, dim/2, x, y) // M do CSB_B LOCK V (A, s 2, s 3 1, dim/2, x, y) // M 10

24 Prod. Matrice-Vettore con CSB Decomposizione Z-Morton in 4 quadranti

25 Prod. Matrice-Vettore con CSB Decomposizione Z-Morton in 4 quadranti

26 Prod. Matrice-Vettore con CSB Decomposizione Z-Morton in 4 quadranti

27 Prod. Matrice-Vettore con CSB Decomposizione Z-Morton in 4 quadranti

28 Analisi di complessità Al fine di valutare la complessità dell'algoritmo definiamo: o work: denotato con T 1, rappresenta il tempo di esecuzione in una macchina monoprocessore monothread o span: denotato con T, rappresenta il tempo di esecuzione con un infinito numero di processi o thread Viene definito grado di parallelismo il rapporto T 1 /T

29 Lemma 1 Lemma 1: il formato CSR usa nlog(nnz) + nnzlog(n) bit di indici di supporto per una matrice n×n con nnz elementi non nulli. Dimostrazione: per indicizzare x elementi sono necessari log(x) bit. Dal prodotto righe-colonne risultano nlog(nnz) bit per il row_ptr e nnzlog(n) bit per col_ind.

30 Lemma 1 (continua)

31 Lemma 2 Lemma 2: Il formato CSB usa (n 2 /β 2 )log(nnz)+2nnzlog(β) bit di indici di supporto per una matrice n×n con nnz elementi non nulli. Dimostrazione: per ogni elemento in val, usiamo log(β) bit per rappresentare l'indice di riga e log(β) bit per rappresentare l'indice di colonna e richiede quindi nnzlog(β) bit per ciascuno degli indici. Aggiungiamo lo spazio dato dall'array blk_ptr, ossia (n 2 /β 2 ) log(nnz) bit.

32 Lemma 2 (continua)

33

34 Corollario 3 Corollario 3: il formato CSB usa (n)log(nnz)+nnzlog(n) bit di indici di supporto per una matrice n×n con nnz elementi non nulli, con β=n.

35 Lemma 4 Lemma 4: Su un blocco di dimensioni β×β, contenente r elementi non nulli, CSB_BlockV viene eseguito con work O(r) e span O(β). Dimostrazione (span): o lo span relativo alla moltiplicazione di una matrice dim × dim può essere descritto da S(dim)=2S(dim/2)+O(log(dim))=O(dim). 2 S(dim/2): viene invocata 2 volte in parallelo la ricorsione su un singolo blocco di dim/2 O(log(dim)): costo della ricerca binaria dei tre indici di split caso base = O(dim): il caso base è seriale su O(dim) elementi ed è dominante sui casi ricorsivi

36 Lemma 4 (continua) Dimostrazione (work): o Consideriamo l'albero di grado 4 generato dalle chiamate ricorsive della funzione CSB_BlockV; ogni nodo corrisponde alla computazione di un sottoblocco dim × dim, con dim=2 h, e 0

37 CSB_B LOCK V (A, start, end, dim, x, y) 28 if endstart O(dim) 29 then // Calcola la computazione seriale yy+Mx 30 for k start to end // A.val[start…end] è un blocco dim×dim 31 do y[A.row_ind[k]] y[A.row_ind[k]] + A.val[k]·x[A.col_ind[k]] 32 return 33 // Ricorsione: divide il blocco M in 4 quadranti 34 binary search start, start+1,…,end per il più piccolo s 2 tale che (A.row_ind[s 2 ] & dim/2) 0 35 binary search start, start+1,…,s 2 1 per il più piccolo s 1 tale che (A.col_ind[s 1 ] & dim/2) 0 36 binary search s 2, s 2 +1,…,end per il più piccolo s 3 tale che (A.col_ind[s 3 ] & dim/2) 0 37 in parallel 38 do CSB_B LOCK V (A, start, s 1 1, dim/2, x, y) // M do CSB_B LOCK V (A, s 3, end, dim/2, x, y) // M in parallel 41 do CSB_B LOCK V (A, s 1, s 2 1, dim/2, x, y) // M do CSB_B LOCK V (A, s 2, s 3 1, dim/2, x, y) // M 10

38 Lemma 4 (continua)

39

40

41 [...] Se un nodo è interno, allora ha almeno O(dim) elementi non nulli. Il costo computazionale del nodo, senza considerare nodi figli, è pari a O(log(dim))=O(log(2 h ))=O(h), dovuto alla ricerca binaria. I nodi generici di livello h sono al più O(r/dim), e quindi concorrono ad un lavoro complessivo per ogni livello pari a O(hr/dim). sommando, per ogni h, nodi interni su tali livelli e nodi foglia, otteniamo O(r):

42 Lemma 5 Questo lemma analizza la moltiplicazione fra una riga di blocchi e un vettore Lemma 5: Su una riga di blocchi contenente n/β blocchi e r elementi non nulli, CSB_BlockrowV viene eseguito con work O(r) e span O(βlog(n/β)).

43 Lemma 5 (continua) Dimostrazione (work): o consideriamo la chiamata su una riga di blocco partizionata in C chunk e definiamo W(C) il lavoro (work) eseguito. La funzione inizializza un vettore z di O(β) elementi e richiama ricorsivamente se stessa due volte, sulla metà dell'input o Il lavoro è descritto dalla disequazione W(C) 2W( C/2 )+O(β) da cui deriva W(C)=O(Cβ+r), poiché si hanno C attivazioni di complessità O(β), più i casi base di complessità O(r), ossia la computazione seriale del prodotto. Il numero C di chunk è, al più, pari a O(r/β) nel caso in cui r=O(β)

44 Lemma 5 (continua) Dimostrazione (span): o Lo span può essere descritto da S(C)=S( C/2 )+O(β)=O(βlog(C))+S(1) o Abbiamo che il caso base ha uno span pari O(β) sia nel caso della moltiplicazione seriale che in quella nella chiamata CSB_BlockV o Il caso base viene eseguito log(C) volte, con C n/β o Lo span complessivo è quindi O(βlog(n/β))

45 Teorema 6 Teorema 6: In una matrice n×n contenente r elementi non nulli, CSB_SpMV viene eseguito con un work O(r+n 2 /β 2 ) e uno span di O(β lg(n/β))+n/β). Dimostrazione: o CSB_SpMV ricostruisce i chunk e avvia la funzione CSB_BlockrowV. Il costo computazionale, per work e span deriva dal lemma precedente con l'aggiunta del costo necessario alla costruzione dei chunk. o [...]

46 Teorema 6 (continua) Dimostrazione: o [...] o nel caso del work si aggiunge un costo pari a O(n 2 /β 2 ) dovuto all'analisi di una singola riga di blocchi di costo O(n/β) per un costo totale di O(r+n 2 /β 2 ) o nel caso dello span si aggiunge un costo pari a O(n/β) dato che è possibile parallelizzare l'operazione per ogni singola riga di blocchi, ottenendo un costo totale di O(βlg(n/β))+n/β)

47 Corollario 7 e 8 Corollario 7: in una matrice n×n, contenente nnz n valori non nulli, scegliendo β=O(n), CSB_SpMV lavora con un work di O(nnz) e uno span di O(n)log(n)) raggiungendo un parallelismo di almeno O( nnz / (nlog(n)) ) Corollario 8: in una matrice n×n, contenente nnz n valori non nulli, scegliendo β=O(n), CSB_SpMV_T lavora con un work di O(nnz) e uno span di O(nlog(n)) raggiungendo un parallelismo di almeno O( nnz / (nlog(n)) )

48 Lemma 9 Lemma 9: In una matrice n×n, scegliendo β = O(n), la serializzazione di CSB_SpMV richiede uno spazio di O(nlog(n)) non contando lo spazio occupato dalla matrice stessa Dimostrazione: o lo spazio complessivo utilizzato è dato da due overhead il primo, R, è l'array dei chunk, che, per ogni riga, utilizza uno spazio O(n/β). Dato che β=n, si ha che lo spazio complessivo utilizzato è O(n). il secondo, z, è il vettore temporaneo di dimensione pari a β. A causa della profondità della ricorsione, lo spazio utilizzato è O(βlog(n))=O(nlog(n)) la complessità finale è quindi O(nlog(n))+O(n)=O(nlog(n))

49 Corollario 10 Corollario 10: supponiamo un'esecuzione di CSB_SpMV per una matrice n×n con la scelta β=n in un work-stealing scheduler (preemptive round robin) con la proprietà busy-leaves. Allora l'esecuzione richiede uno spazio di O(Pnlog(n)), con P pari al numero di processi utilizzati

50 Sperimentazione Scelta valore di β Performance media di Ax e A T x Risultati reali sulla scalabilità degli algoritmi o matrici di medie dimensioni o matrici di grandi dimensioni

51 Scelta del valore di β Si dimostra sperimentalmente che il valore ottimale di β deve rispettare la disequazione log(n) log(β) 3+ log(n) L'utilizzo di β=n per semplicità di calcolo rispetta tale vincolo

52 Performance media di Ax e A T x Sia CSB_SpMV che CSB_SpMV_T offrono ottime prestazioni all'aumentare del numero di processori o fino a 4 processori lo speedup cresce linearmente o da 4 a 8 è meno che lineare, ma comunque crescente o con più di 8, le prestazioni decadono a causa dei limiti della memoria di sistema

53 Risultati sperimentali (dim media) I risultati sono stati condotti con matrici relative a problemi reali (e.g. elettroforesi DNA, meccanica strutturale,...)

54 Risultati sperimentali (dim grande) Per matrici grandi CSB scala in modo ottimale

55 CSR vs CSB Analizziamo il rapporto tra le performance di CSR e CSB nel caso di esecuzione parallela Per il confronto è stato usato lalgoritmo Star-P che usa CSR

56 Grazie per l'attenzione


Scaricare ppt "Parallel sparse Matrix-Vector and Matrix-Transpose-Vector multiplication using compressed sparse blocks Presentazione a cura di: Marco Cherubini, Andrea."

Presentazioni simili


Annunci Google