Prodotto Matrice - Vettore in MPI - III Strategia

Transcript

1 Facoltà di Ingegneria Corso di Studi in Ingegneria Informatica Esercitazione di Calcolo Parallelo Prodotto Matrice - Vettore in MPI - III Strategia Anno Accademico 2010/2011 Prof.ssa Alessandra D'alessio Candidati Mario Buonomo Lorenzo Carullo Luigi De Simone

2 Indice 1 Descrizione del problema 1 2 Descrizione Algoritmo Descrizione Input, output, errori e subroutine Analisi del software Analisi Tabelle Tempi Speed Up Efficienza Esempi d uso e Codice 13 Bibliografia 23 i

3 Elenco delle figure 2.1 Blocchi della matrice Suddivisione matrice Suddivisione finale della matrice Invio vettore Calcolo Prodotti parziali Situazione d errore Grafico Tempi Grafico Speed Up Grafico Efficienza Esempio d uso ii

4 Elenco delle tabelle 3.1 Tabella Tempi Tabella Speed Up Tabella Efficienza iii

5 Capitolo 1 Descrizione del problema Si vuole effettuare il calcolo del prodotto matrice vettore: Ax=y, A R nxn, x,y R n su un calcolatore MIMD a memoria distribuita con p processori, con A matrice quadrata di ordine n multiplo del numero di processori. 1

6 Capitolo 2 Descrizione Algoritmo 2.1 Descrizione L algoritmo sequenziale prevede, ovviamente, il calcolo del vettore y componente per componente: y i = n j=1 a i,j x j, con i=1,...,n Siccome il calcolo di ciascun prodotto delle righe della matrice A per il vettore x può essere fatto indipendentemente dagli altri prodotti, l algoritmo parallelo prevede di distribuire il calcolo delle componenti y ai processori utilizzati. La matrice A, di dimensione N, può essere distribuita ai processori secondo varie strategie, quella utilizzata in quest algoritmo, definita come la terza, è la distribuzione per blocchi di dimensione (N/sqrt(p), N/sqrt(p)) utilizzando una griglia bidimensionale. La strategia adottata per distribuire la matrice è stata quella di linearizzare la matrice stessa, e successivamente, di inviare quest ultima dal processore di rank 0 della griglia bidimensionale tramite una scatter ai processori che 2

7 Prodotto Matrice Vettore in MPI appartengono alla prima colonna. Ogni processore della prima colonna avrà un blocco della matrice di dimensione (N/sqrt(p), N/sqrt(p)). Sempre il processo di rank 0 della griglia bidimensionale invia tramite scatter il vettore X questa volta però alla prima riga della griglia bidimensionale in questo modo ogni processore della prima riga avrà un blocco di dimensione N/sqrt(p). Ogni processore della prima riga invia il proprio blocco di X in broadcast lungo la sua colonna d appartenza. Adesso ogni processore avrà il suo blocco della matrice originaria e il vettore x e può effettuare il calcolo riga (appartenente al suo blocco di righe locale) per colonna; ogni processore avrà nella sua memoria locale i risultati parziali e questi andranno poi raccolti e concatenati dal processore root della propria riga tramite un operazione di Reduce il quale scriverà il tutto nel vettore risultato. In figura è mostrato un esempio di suddivisione della matrice A in blocchi a 4 processori: Figura 2.1: Blocchi della matrice 3

8 Prodotto Matrice Vettore in MPI Di seguito è riportata la suddivisione della matrice A suddivisa per strisce orizzontali inviata alla prima colonna della griglia: Figura 2.2: Suddivisione matrice Nella seguente figura è mostrato l invio in blocchi delle strisce verticali della matrice originaria contenute nei processori della prima colonna lungo le altre colonne: Figura 2.3: Suddivisione finale della matrice Di seguito riportiamo i passi successivi per l implementazione dell algoritmo quali l invio in blocchi del vettore X e dei calcoli delle somme parziali: 4

9 Prodotto Matrice Vettore in MPI Figura 2.4: Invio vettore Figura 2.5: Calcolo Prodotti parziali 2.2 Input, output, errori e subroutine L input dell algoritmo è una matrice quadrata A di dimensioni NxN, dove N deve essere multiplo del numero di processori utilizzato; la dimensione della matrice è memorizzata in una costante nel programma C. L output generato dall algoritmo è composto dalla matrice A di ingresso (generata in maniera casuale), il vettore x (generato in maniera casuale), il vettore y contenente il prodotto Ax, il vettore contenente il prodotto Ax 5

10 Prodotto Matrice Vettore in MPI calcolato in maniera sequenziale (dal solo processore root) e infine da una stampa con un codice ok che ci da conferma del fatto che il risultato parallelo è corretto (lo si confronta con quello sequenziale). Un possibile errore del programma si verifica quando, la dimensione della matrice in considerazione non è un multiplo del numero di processori su cui facciamo girare il programma oppure quando il numero di processori su cui facciamo girare il programma non è un quadrato perfetto. Proprio per questo abbiamo inserito un controllo apposito nel codice. Un esempio della situazione d errore è la seguente (N della matrice = 16): Figura 2.6: Situazione d errore 6

11 Capitolo 3 Analisi del software 3.1 Analisi Osserviamo ora il nostro algoritmo analizzando in dettaglio alcune caratteristiche atte a valutare le prestazioni di un software parallelo. Esse consentiranno all utente di capire in quale situazione è più opportuno utilizzare l algoritmo e quando invece il suo utilizzo non reca alcun palese vantaggio. Tali caratteristiche sono: Tempo di esecuzione utilizzando un numero p>1 di processori. Generalmente indicheremo tale parametro con il simbolo T(p) ; Speed up riduzione del tempo di esecuzione rispetto all utilizzo di un solo processore, utilizzando invece p processori. In simboli, avremo S(p) = T(1) / T(p). Il valore dello speed up ideale dovrebbe essere pari al numero p dei processori, perciò l algoritmo parallelo risulta migliore quanto più S(p) è prossimo a p. 7

12 Prodotto Matrice Vettore in MPI Efficienza, Calcolare solo lo speed-up spesso non basta per effettuare una valutazione corretta, poiché occorre rapportare lo speed-up al numero di processori, e questo può essere effettuato valutando l efficienza. Siano dunque p il numero di processori ed S(p) lo speed - up ad esso relativi. Si definisce efficienza il parametro E(p) = S(p) / p, essa fornisce un indicazione di quanto sia stato usato il parallelismo nel calcolatore. Idealmente, dovremmo avere che E(p) = 1 e quindi l algoritmo parallelo risulta migliore quanto più E(p) è vicina ad 1. 8

13 Prodotto Matrice Vettore in MPI 3.2 Tabelle Le tabelle che seguono mostrano i dati raccolti analizzando ciascuna delle caratteristiche sopraelencate. I tempi sono stati raccolti presso su un cluster di nodi di calcolo presso il Data Center SCoPE. La prima riga di ogni tabella contiene il valore dei dati forniti in input, mentre la prima colonna elenca il numero di processori impiegati nella computazione. Accanto a ciascuna tabella viene mostrato il relativo grafico (ottenuti attraverso il software Gnuplot [1986])che evidenzia l andamento dei valori esaminati Tempi Tabella dei tempi (in microsecondi) N = 144 N = 1440 N = Tabella 3.1: Tabella Tempi 9

14 Prodotto Matrice Vettore in MPI Grafico Figura 3.1: Grafico Tempi Come si può vedere dal grafico, per una dimensione della matrice piccola, il tempo d esecuzione con 1, 4, 9 e 16 cpu è pressocchè costante. Quando invece aumentiamo ancora la dimensione della matrice, nel passaggio da 1 a 2 processori c è un notevole miglioramento del tempo d esecuzione, mentre aumentando ancora il numero di processori il tempo di esecuzione aumenta notevolmente rispetto a quello iniziale. 10

15 Prodotto Matrice Vettore in MPI Speed Up Tabella Speed-Up N = 144 N = 1440 N = Tabella 3.2: Tabella Speed Up Grafico Figura 3.2: Grafico Speed Up 11

16 Somma N numeri in MPI Efficienza Tabella Efficienza N = 144 N = 1440 N = Tabella 3.3: Tabella Efficienza Grafico Figura 3.3: Grafico Efficienza 12

17 Capitolo 4 Esempi d uso e Codice Per compilare il codice, aperta una shell linux digitiamo: mpicc eser13.c e nella directory di lavoro comparirà un nuovo file, quello d esecuzione. Eseguendolo con: mpiexec -n 4 a.out avremo l output a video: Figura 4.1: Esempio d uso 13

18 Somma N numeri in MPI Murli: ed ecco il codice in C, implementando l algoritmo presente nel testo di / ========================================================== ================== Name : esercitazione 13 di calcolo parallelo Author : Mario Buonomo Lorenzo Carullo Luigi De Simone Version : Copyright : Your copyright notice Description : Prodotto Matrice vettore I I I strategia ========================================================== ================== / #include <s t d i o. h> #include <s t d l i b. h> #include <math. h> #include <time. h> #include "mpi. h" / A(n, n) matrice da distribuire p numero di processori e quadrato perfetto di q ( righe o colonne della grigla ) che indica la dimensione della g r i g l i a elementi per blocco n/sqrt (p) / #define N 16 //deve essere un multiplo del numero di processori #define dim 2 // g r i g l i a 2D #define MASTER 0 // CPU MASTER int main ( int argc, char argv [ ] ) { int col, row, r e o r d e r, i, j, ndim [ 2 ], p e r i o d [ 2 ], b e l o n g s [ 2 ], rows [ 2 ], c o o r d i n a t e [ 2 ], coo_row [ 2 ] ; 14

19 Somma N numeri in MPI double t0, t1, te, t _ f i n ; int menum, nproc, menum2d, merow, k, p, q, a, b ; MPI_Comm comm2d, commcol, commrow; MPI_Init(& argc, &argv ) ; MPI_Comm_rank(MPI_COMM_WORLD, &menum) ; MPI_Comm_size(MPI_COMM_WORLD, &nproc ) ; / Controllo dimensione array / i f (N % nproc!= 0) { f p r i n t f ( s t d e r r, "\nquitting. Size of Matrix must be multiple of Number of Process \n" ) ; MPI_Abort(MPI_COMM_WORLD, 0) ; // i n i z i a l i z z o alcune v a r i a b i l i p = nproc ; row = s q r t ( ( double ) p ) ; / Controllo quadrato perfetto / i f ( ( int ) (pow ( ( double ) ( row ), 2 ) )!= p ) { f p r i n t f ( s t d e r r, "\nquitting. Number of process Must Be a perfect square \n" ) ; MPI_Abort(MPI_COMM_WORLD, 0) ; c o l = row ; //parametri della g r i g l i a bidimensionale ndim [ 0 ] = row ; ndim [ 1 ] = c o l ; p e r i o d [ 0 ] = p e r i o d [ 1 ] = 0 ; r e o r d e r = 0 ; a = N / s q r t ( ( double ) p ) ; b = s q r t ( ( double ) p ) ; 15

20 Somma N numeri in MPI int temp11 = ( int ) malloc ( s i z e o f ( int ) N) ; int temp22 = ( int ) malloc ( s i z e o f ( int ) a ) ; int b l o c c o = ( int ) malloc ( s i z e o f ( int ) a a ) ; int A_ricc = ( int ) malloc ( s i z e o f ( int ) N a ) ; int x_ric = ( int ) malloc ( s i z e o f ( int ) a ) ; int somma_parz = ( int ) malloc ( s i z e o f ( int ) a ) ; int somma_tot = ( int ) malloc ( s i z e o f ( int ) a ) ; int x = ( int ) malloc ( s i z e o f ( int ) N) ; int A_lin = ( int ) malloc ( s i z e o f ( int ) N N) ; int somma_par = ( int ) malloc ( s i z e o f ( int ) N) ; //Alloco variabile per risultato sequenziale int r e s u l t _ s e q = ( int ) malloc ( s i z e o f ( int ) N) ; // costruisco la matrice da inviare a blocchi i f (menum == MASTER) { / Alloco matrice da inviare e vettore in cui linearizzo la matrice / int A = ( int ) malloc ( s i z e o f ( int ) N) ; for ( k = 0 ; k < N; k++) { A[ k ] = ( int ) malloc ( s i z e o f ( int ) N) ; // printf ("\ nmatrice da inviare a blocchi \n") ; / Riempio la matrice con numeri casuali da zero a trenta / srand ( time (NULL) ) ; for ( i = 0 ; i < N; i ++) { for ( j = 0 ; j < N; j++) { A[ i ] [ j ] = ( int ) ( rand ( ) % 30) ; // printf("%d ", A[ i ] [ j ] ) ; //genero vettore x random x [ i ] = ( int ) ( rand ( ) %30) ; 16

21 Somma N numeri in MPI // printf ("\n") ; // printf ("\nvettore x : ") ; //for ( i = 0; i < N; i++) { // printf("%d ", x [ i ] ) ; // // printf ("\n") ; for ( i = 0 ; i < N; i ++){ r e s u l t _ s e q [ i ]=0; // i n i z i a l i z z o ogni elemento del vettore for ( j = 0 ; j < N; j++) r e s u l t _ s e q [ i ]= r e s u l t _ s e q [ i ]+A[ i ] [ j ] x [ j ] ; p r i n t f ( "\n\nrisultato FINALE sequenziale\n" ) ; for ( i =0; i <N; i ++) p r i n t f ( "%d ", r e s u l t _ s e q [ i ] ) ; p r i n t f ( "\n" ) ; // linearizzo la matrice i =0; for ( k = 0 ; k < N; k++) { for ( j = 0 ; j < N; j++) { A_lin [ i ] = A[ k ] [ j ] ; i ++; / Dealloco la matrice i n i z i a l e / for ( i =0; i <N; i ++) f r e e (A[ i ] ) ; f r e e (A) ; // free ( result_seq ) ; // fine MASTER 17

22 Somma N numeri in MPI MPI_Barrier (MPI_COMM_WORLD) ; / I n i z i a l i z z a z i o n e Tempi / t0 = MPI_Wtime ( ) ; //creo una g r i g l i a 2D MPI_Cart_create (MPI_COMM_WORLD, dim, ndim, period, r e o r d e r, &comm2d) ; //prendo i l rank del processo in esecuzione MPI_Comm_rank(comm2D, &menum2d) ; //prendo le coordinate del processo in esecuzione MPI_Cart_coords (comm2d, menum2d, dim, c o o r d i n a t e ) ; // s o t t o g r i g l i a di colonne b e l o n g s [ 0 ] = 1 ; b e l o n g s [ 1 ] = 0 ; MPI_Cart_sub (comm2d, belongs, &commcol) ; // s o t t o g r i g l i a di righe rows [ 0 ] = 0 ; rows [ 1 ] = 1 ; MPI_Cart_sub (comm2d, rows, &commrow) ; //prendo i l rank del processo in esecuzione MPI_Comm_rank(commRow, &merow) ; //prendo le coordinate del processo in esecuzione MPI_Cart_coords (commrow, merow, dim, coo_row ) ; // invio la matrice linearizzata per blocchi di righe a l l a prima colonna della g r i g l i a MPI_Scatter ( A_lin, N a, MPI_INT, A_ricc, N a, MPI_INT, 0, commcol) ; // invio i l vettore x in blocchi a l l a prima riga MPI_Scatter ( x, a, MPI_INT, x_ric, a, MPI_INT, 0, commrow) ; // invio in broadcast lungo le colonne i l blocco x presente nella prima riga MPI_Bcast ( x_ric, a, MPI_INT, 0, commcol) ; MPI_Barrier (MPI_COMM_WORLD) ; 18

23 Somma N numeri in MPI k = 0 ; //una scatter per riga ricevuta dai processori della prima colonna for ( i = 0 ; i < a ; i ++) { //solo g l i P0 della prima colonna della g r i g l i a crea i l vettore per la scatter i f (merow == 0) { // costruisco i l vettore temporaneo da inviare for ( q = N i ; q < N ( i + 1) ; q++) { temp11 [ q N i ] = ( int ) A_ricc [ q ] ; MPI_Scatter ( temp11, a, MPI_INT, temp22, a, MPI_INT, 0, commrow) ; for ( j = k ; j < k+a ; j++) b l o c c o [ j ] = temp22 [ j k ] ; k = k + a ; MPI_Barrier (MPI_COMM_WORLD) ; // i n i z i a l i z z o somma_parz for ( i = 0 ; i < a ; i ++) { somma_parz [ i ] = 0 ; //ogni cpu deve eseguire la propria somma parziale k=0; for ( i = 0 ; i < a ; i ++) { p = 0 ; for ( j = k ; p < a ; j++) { somma_parz [ i ] = somma_parz [ i ] + b l o c c o [ j ] x_ric [ j k ] ; p++; 19

24 Somma N numeri in MPI k = k + a ; MPI_Barrier (MPI_COMM_WORLD) ; MPI_Reduce( somma_parz, somma_tot, a, MPI_INT, MPI_SUM, MASTER, commrow) ; / Fine Tempi / t1 = MPI_Wtime ( ) ; MPI_Gather ( somma_tot, a, MPI_INT, somma_par, a, MPI_INT, MASTER, commcol) ; / i f (merow == 0) { //stampo i valori ricevuti printf ("Sono %d con coordinate (%d, %d) ho la parte di y:\n", menum2d, coordinate [ 0 ], coordinate [ 1 ] ) ; for ( i = 0; i < a ; i++) { printf("%d ", somma_tot[ i ] ) ; printf ("\n") ; / t e = 1. e6 ( t1 t0 ) ; MPI_Reduce(& te,& t_ fin, 1,MPI_DOUBLE,MPI_MAX, 0,MPI_COMM_WORLD) ; i f (menum == MASTER) { p r i n t f ( "\n\nrisultato FINALE parallelo \n" ) ; for ( i =0; i <N; i ++) p r i n t f ( "%d ", somma_par [ i ] ) ; 20

25 Somma N numeri in MPI p r i n t f ( "\n" ) ; / Check di controllo per la prodotto / int f l a g = 0 ; for ( i =0; i <N; i ++){ i f ( r e s u l t _ s e q [ i ]!= somma_par [ i ] ) { p r i n t f ( "\nerrore nel prodotto parallelo " ) ; f l a g =1; i=n; i f ( f l a g == 0) p r i n t f ( "\nverifica OK" ) ; p r i n t f ( "\n\ntempo d esecuzione : %f usecondi\n\n", t _ f i n ) ; //Dealloco f r e e ( x_ric ) ; f r e e ( somma_parz ) ; f r e e ( somma_tot ) ; f r e e ( temp11 ) ; f r e e ( temp22 ) ; f r e e ( b l o c c o ) ; f r e e ( A_ricc ) ; f r e e ( x ) ; f r e e ( A_lin ) ; f r e e ( r e s u l t _ s e q ) ; MPI_Finalize ( ) ; return 0 ; implementazione dell algoritmo in C 21

26 Bibliografia Gnuplot. Gnuplot. URL: Almerico Murli. Lezioni di Calcolo Parallelo. Liguori Editore. 22