UNIVERSITA DEGLI STUDI DI NAPOLI FEDERICO II

Transcript

1 UNIVERSITA DEGLI STUDI DI NAPOLI FEDERICO II PROGETTO DI CALCOLO PARALLELO PRODOTTO MATRICE VETTORE STUDENTE Gabriele Piantadosi (885/000282)

2 1. OBIETTIVI E AMBIENTE DI CALCOLO Si vuole distribuire un algoritmo di calcolo del prodotto di una matrice di dimensioni per un vettore di elementi sfruttando un architettura parallela a 64 CPU (16 x Intel Xeon E5410 quad-core@2.33ghz 64 bit) offerta dall Università degli Studi di Napoli Federico II attraverso l infrastruttura S.Co.P.E. [ Il software è stato scritto il linguaggio C mediante l uso delle libreria Message Passing Interface (MPI). 2. DEFINIZIONE DEL PROBLEMA Di seguito viene descritto formalmente il problema. Si ha una matrice e la si vuole moltiplicare per il vettore per poi ottenere il vettore prodotto Per lo scopo sono stati utilizzati tre approcci diversi alla parallelizzazione dell algoritmo che differiscono tra di loro per quanto riguarda la procedura distribuzione della matrice e del vettore ai vari processori coinvolti nel calcolo: Strategia 1: Distribuzione per righe Strategia 2: Distribuzione per colonne Strategia 3: Distribuzione per blocchi E per ogni strategia si è mostrato l algoritmo distribuito utilizzato e, tramite parametri standard, si è analizzato in termini di tempi di esecuzione e di efficienza. 3. STRATEGIA I: DISTRIBUZIONE PER RIGHE Questa strategia prevede che la matrice venga distribuita ai processori in blocchi di righe. Ossia, consierando la matrice iniziale M: E supposto il numero dei processori utilizzati tale che sia un multiplo finito di, ogni processore avrà una porzione precisa di righe di M. Ad esempio, supposto quindi la matrice M sarà: 2

3 e considerato (quindi due processori che lavorano in parallelo) il processore avrà la seguente porzione di matrice: Mentre il processore avrà la restante porzione di matrice: Per quanto riguarda la distribuzione del vettore, invece, questo viene inviato in broadcast (ossia senza segmentarlo) a tutti i processori. In generale ogniuno dei processori, quindi il processore, avrà a disposizione: una matrice con elementi (con ) un vettore di elementi L algoritmo locale dovrà, quindi, effettuare il prodotto seguendo l algoritmo matematico già descritto nel paragrafo 2 ed ottenendo un numero di valori pari al numero di righe che compongono la propria matrice, ossia. A questo punto sarà necessario unire i array contenenti le somme locali in un unico array. I processori, infatti, devono provvedere ad inviare il loro contribbuto al processore root che si occuperà di unire e visualizzare il risultato. 3.1 DESCRIZIONE DELL ALGORITMO Di seguito è riportato il codice dell algoritmo per il calcolo parallelo #include "mpi.h" #include <stdio.h> double LeggiTempo(char *nomefile); void ScriviTempi(int numprocs, double time, double speedup, double eff); void ScriviTempo(double time); int main( int argc, char *argv[] ){ // variabili per il calcolo del tempo e delle prestazioni double t0, t1, time, time_1, speedup, eff; // variabili dell'algoritmo int myid, numprocs, rows, n, nelem, i, j; int root =0; // id (rank) del processore P0 MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); //GESTIONE DATI DI INPUT n = 64; //valore di default; if(argc==2) n = atoi(argv[1]); //colonne matrice passato da utente else if(argc>2) { //errore printf("errore parametri (n.%d)\n", argc); printf("> MATVET1 [n]\n"); printf("\n"); printf("[n] cardinalitࠤella matrice (default=64)\n"); 3

4 MPI_Finalize(); return 1; rows = n/numprocs; //numero di righe per ogni processore printf("numero di processori: %d\n", numprocs); printf("dimensioni matrice: %dx%d\n", n, n); printf("dimensioni array: %d\n", n); int M[n][n], a[n], sum[n]; int C[rows][n]; int b[rows]; //inizializzazione di b (vettore delle somme locali) for(i=0; i<rows; i++){ b[i] = 0; //generazione dell'array di n elementi a[i] = i+1; //printf("a[%d]= %d\n", i,i+1); //inizializzazione della matrice di input. for(j=0; j<n; j++){ M[i][j]=j+1; //printf("m[%d][%d]= %d\n", i,j,j+1); //BROADCAST DEL VETTORE MPI_Bcast(a,n,MPI_INT,root,MPI_COMM_WORLD); //DISTRIBUZIONE MATRICE PER RIGHE MPI_Scatter(M,rows*n,MPI_INT,C,rows*n,MPI_INT,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); if(myid==0) t0 = MPI_Wtime(); //inizio conteggio tempo //CALCOLO DEL PRODOTTO (PARALLELO) [+DBG] int tmp=0; char*msg = "<PROC %d> b[%d] = b[%d] + C[%d][%d]*a[%d] = %d + (%d*%d) = %d\n"; for(i=0; i<rows; i++){ for(j=0; j<n; j++){ tmp = b[i]; b[i] = b[i] + C[i][j]*a[j]; //DBG //printf(msg, myid,i,i,i,j,j,tmp,c[i][j],a[j],b[i]); //RACCOLTA DEI RISULTATI PARZIALI MPI_Gather(&b,rows,MPI_INT,sum,rows,MPI_INT,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); //stop al tempo //calcolo e stampa del tempo trascorso time = 1.e6 * (t1-t0); printf("tempo: %f\n", time); //se è monoprocessore allora scrive il tempo su un file if(numprocs==1) ScriviTempo(time); //legge il valore del tempo per un processore time_1 = LeggiTempo("tempi_1.txt"); //calcolo speedup ed efficienza speedup = time/time_1; eff = speedup/numprocs; 4

5 //scrive numero di processore, tempo, speedup ed efficienza in un file ScriviTempi(numprocs, time, speedup, eff); //scampa il risultato printf("risultato: [ %d, %d,... %d, %d ]\n", sum[0], sum[1], sum[n-2], sum[n-1]); //verifica del valore risultato. Se è corretto checksum è pari a 0. int sumtemp1, sumtemp2, checksum; sumtemp1 =(2*n+1)*(n+1)*(n); sumtemp2 = sumtemp1/6; checksum = 0; checksum = checksum + (sum[i]-sumtemp2); printf("checksum=%d\n", checksum); MPI_Finalize(); return 0; L algoritmo è stato concepito per funzionare in maniera completamente dinamica. L unico parametro di configurazione è la dimensione della matrice di input e tutti i valori verranno calcolati in base al PBS caricato in fase di esecuzione, leggendo il numero dei processori allocati per il task. Se si vogliono eseguire test su una matrice di dimensioni diverse allora sarà sufficiente passare alla chiamata del programma un nuovo valore di dimensione (default 64) e il software provvederà a modificare la variabile interna n. Una volta assegnato il valore di, viene assegnato alla variabile rows il valore: che rappresenta il numero di righe della matrice che possiederà ogni processore (con unico vincolo che il numero di righe della matrice di input sia multiplo del numero di processori nproc). Avremo quindi: M (matrice di input) di dimensioni {inizializzato con per ogni sua riga a (vettore di input) di dimensioni {inizializzato con sum (vettore del risultato) di dimensioni Ogni processore avrà a disposizione le seguenti variabili con valenza locale: C (porzione della matrice di input) di dimensioni a (porzione del vettore di input) di dimensioni b (vettore delli risultati locali) di dimensioni La comunicazione avviene sfruttando le seguenti primitive MPI MPI_Bcast() per la distribuzione in broadcast della variabile a (vettore di input) a tutti i processori MPI_Scatter() per la distribuzione e scomposizione della matrice M ad ogni processore. MPI_Gather() per raccogliere i dati prodotti da tutti i processori al processore root sum. 5 nella variabile La sincronizzazione avviene tramite la funzione: MPI_Barrier() mette in attesa tutti i processi di un canale di comunicazione fin quando tutti non raggiongono la stessa funzione; si usa solitamente dopo una richiesta di distribuzione di dati per fare in modo che tutti i processi si sincronizzino dopo aver ricevuto i dati da un processo padre.

6 3.2 ANALISI DEL SOFTWARE In questo paragrafo sono riportati i grafici e tabelle relativi al calcolo del tempo T(p), dello speedup S(p) e dell efficienza E(p). Figura 1: Analisi del tempo di esecuzione Nella Figura 1 riportiamo sull asse delle ordinate il tempo di esecuzione in microsecondi, mentre sulle ascisse sono presenti i valori del numero processori utilizzati. Dal grafico si evince che il parallelismo riduce i tempi di calcolo fino ad un limite di 8 processori. Unica osservazione davvero importante è che le curve sono pressoché regolari fino ad un numero pari a 16 processori e dopo iniziano a subire delle pertubazioni probabilmente dovute all infrastuttura ed al carico temporale. S.Co.P.E. mette, infatti, a disposizione 16 processori quadcore (su 8 nodi con mainboard dual processor); si creano, quindi, almeno due differenti livelli di parallelismo uno maggiormente influenzato rispetto all altro dalla concorrenza di altri utenti, dalle esigenze del sistema operativo e dallo stato puntuale della rete. Nelle tabelle seguente sono riportati i valori calcolati dello speed-up con affiancato il valore dello speed-up ideale e della relativa efficienza. 6

7 #CPU T(p) S(p) E(p) , ,788 1, ,51% 4 292,807 3, ,49% 8 203,016 4, ,37% ,431 4, ,12% ,556 4, ,22% ,308 4, ,15% Tabella1: Parametri di valutativi per M=320x320 #CPU T(p) S(p) E(p) , ,568 1, ,76% 4 673,361 3, ,27% 8 384,853 6, ,60% ,741 6, ,12% ,203 6, ,28% ,138 6, ,72% Tabella2: Parametri di valutativi per M=512x512 #CPU T(p) S(p) E(p) , ,719 1, ,80% 4 999,533 3, ,77% 8 641,126 5, ,10% ,949 7, ,55% ,796 7, ,99% ,613 6, ,92% Tabella3: Parametri di valutativi per M=640x640 #CPU T(p) S(p) E(p) , ,041 1, ,66% ,884 3, ,62% 8 784,378 6, ,66% ,695 7, ,33% ,675 8, ,03% ,707 8, ,09% Tabella4: Parametri di valutativi per M=832x832 Si evince facilmente che la configurazione che sfrutta meglio il parallelismo è quella a due processori, dove il valore dello speedup è il più vicino a quello ideale e l efficienza è la maggiore (escludendo il caso monoprocessore). I risultati di speedup ed efficienza sono in linea con la legge di Amdhal. Infatti, se manteniamo fissa la dimensione del problema e aumentiamo il numero dei processori, allora otteniamo valore di speedup sempre più lontani da quello ideale, quindi le prestazioni tendono a degradare. Se, invece, manteniamo fisso il numero dei processori e aumentiamo man mano la dimensione del problema abbiamo che sia l efficienza che lo speedup tendono a crescere e quindi si hanno prestazioni decisamente migliori. 3.3 ESEMPI D USO In questo paragrafo verrà mostrato un esempio dell output che viene generato una volta terminata l esecuzione del programma. L immagine che segue mostra l esecuzione del programma con una matrice 64x64. 7

8 L output del programma mostra informazioni sul numero dei processori istanziati (in questo caso 4), la dimensione della matrice (in questo caso 64 come da parametro di default), il tempo (che non è affidabile dato che è stato eseguito in ambiente simulato) ed un valore di CheckSum. E prevista una gestione dei parametri errati come si mostra di seguito: 8

9 4. STRATEGIA II: DISTRIBUZIONE PER COLONNE Questa strategia prevede che la matrice venga distribuita ai processori in blocchi di colonne e che il vettore venga anch esso suddiviso in parti uguali al numero di processori. Ossia, consierando la matrice iniziale M: E supposto il numero dei processori utilizzati tale che sia un multiplo finito di, ogni processore avrà una porzione precisa di colonne di M. Ad esempio, supposto quindi la matrice M e il vettore a saranno: e considerato (quindi due processori che lavorano in parallelo) il processore avrà la seguente porzione di matrice e di vettore: Mentre il processore avrà la restante porzione di matrice: In generale ogniuno dei processori, quindi il processore, avrà a disposizione: una matrice con elementi (con ) un vettore di elementi L algoritmo locale dovrà, quindi, effettuare il prodotto seguendo l algoritmo matematico già descritto nel paragrafo 2 ed ottenendo un numero di valori pari al numero di righe che compongono la propria matrice, ossia ; questa volta il risultato è ancora un risultato parziale che va sommato al valore posseduto dagli altri processori nella stessa posizione dell array. I processori, infatti, devono provvedere ad inviare il loro contribbuto al processore root che si occuperà di sommare, unire e visualizzare il risultato. 4.1 DESCRIZIONE DELL ALGORITMO Di seguito è riportato il codice dell algoritmo per il calcolo parallelo 9

10 #include "mpi.h" #include <stdio.h> double LeggiTempo(char *nomefile); void ScriviTempi(int numprocs, double time, double speedup, double eff); void ScriviTempo(double time); int main( int argc, char *argv[] ){ // variabili per il calcolo del tempo e delle prestazioni double t0, t1, time, time_1, speedup, eff; // variabili dell'algoritmo int myid, numprocs, n, cols, nelem, i, j; int root =0; // id (rank) del processore P0 MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); //GESTIONE DATI DI INPUT n = 64; //valore di default; if(argc==2) n = atoi(argv[1]); //righe matrice passato da utente else if(argc>2) { //errore printf("errore parametri (n.%d)\n", argc); printf("> MATVET2 [n]\n"); printf("\n"); printf("cardinalità della matrice (default=64)\n"); MPI_Finalize(); return 1; cols = n/numprocs; //numero di colonne per ogni processore printf("numero di processori: %d\n", numprocs); printf("dimensioni matrice: %dx%d\n", n, n); printf("dimensioni array: %d\n", n); int M[n][n], a[n], sum[n]; int C[n][cols]; int b[n]; int c[cols]; //inizializzazione di b (vettore delle somme locali) b[i] = 0; //generazione dell'array di n elementi a[i] = i+1; //printf("a[%d]= %d\n", i,i+1); //inizializzazione della matrice di input. for(j=0; j<n; j++){ M[i][j]=j+1; //printf("m[%d][%d]= %d\n", i,j,j+1); //DISTRIBUZIONE DEL VETTORE MPI_Scatter(a,cols,MPI_INT,c,cols,MPI_INT,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); //DISTRIBUZIONE MATRICE PER COLONNE (passando per la trasposta) int MT[n][n], D[cols][n]; //trasposta di M for(j=0; j<n; j++){ MT[i][j] = M[j][i]; 10

11 MPI_Scatter(MT,n*cols,MPI_INT,D,n*cols,MPI_INT,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); //trasposta di D salvata in C for(j=0; j<cols; j++){ C[i][j] = D[j][i]; if(myid==0) t0 = MPI_Wtime(); //CALCOLO DEL PRODOTTO (PARALLELO) [+DBG] int tmp=0; char*msg = "<PROC %d> b[%d] = b[%d] + C[%d][%d]*c[%d] = %d + (%d*%d) = %d\n"; for(j=0; j<cols; j++){ tmp = b[i]; b[i] = b[i] + C[i][j]*c[j]; //DBG //printf(msg, myid,i,i,i,j,j,tmp,c[i][j],c[j],b[i]); //RACCOLTA DEI RISULTATI PARZIALI MPI_Reduce(&b[i],&sum[i],1,MPI_INT,MPI_SUM,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); //stop al tempo //calcolo e stampa del tempo trascorso time = 1.e6 * (t1-t0); printf("tempo: %f\n", time); //se è monoprocessore allora scrive il tempo su un file if(numprocs==1) ScriviTempo(time); //legge il valore del tempo per un processore time_1 = LeggiTempo("tempi_1.txt"); //calcolo speedup ed efficienza speedup = time_1/time; eff = speedup/numprocs; //scrive numero di processore, tempo, speedup ed efficienza in un file ScriviTempi(numprocs, time, speedup, eff); //scampa il risultato printf("risultato: [ %d, %d,... %d, %d ]\n", sum[0], sum[1], sum[n-2], sum[n-1]); //verifica del valore risultato. Se è corretto checksum è pari a 0. int sumtemp1, sumtemp2, checksum; sumtemp1 =(2*n+1)*(n+1)*(n); sumtemp2 = sumtemp1/6; checksum = 0; checksum = checksum + (sum[i]-sumtemp2); printf("checksum=%d\n", checksum); MPI_Finalize(); return 0; L algoritmo è stato concepito per funzionare in maniera completamente dinamica. L unico parametro di configurazione è la dimensione della matrice di input e tutti i valori verranno calcolati in base al PBS caricato in fase di esecuzione, leggendo il numero dei processori allocati per il task. Se si vogliono eseguire test su una matrice 11

12 di dimensioni diverse allora sarà sufficiente passare alla chiamata del programma un nuovo valore di dimensione (default 64) e il software provvederà a modificare la variabile interna n. Una volta assegnato il valore di, viene assegnato alla variabile cols il valore: che rappresenta il numero di colonne della matrice che possiederà ogni processore (con unico vincolo che il numero di colonne della matrice di input sia multiplo del numero di processori nproc). Avremo quindi: M (matrice di input) di dimensioni {inizializzato con per ogni sua riga a (vettore di input) di dimensioni {inizializzato con sum (vettore del risultato) di dimensioni Ogni processore avrà a disposizione le seguenti variabili con valenza locale: C (porzione della matrice di input) di dimensioni c (porzione del vettore di input) di dimensioni b (vettore delli risultati locali) di dimensioni La comunicazione avviene sfruttando le seguenti primitive MPI: MPI_Scatter() per la distribuzione e scomposizione della matrice M ad ogni processore (si sfrutta la funzionalità di questa funzione di distribuire gli array bidimensionali effettuando una trasposizione della matrice M in MT e poi ricalcolando la trasposata della copia locale) MPI_Scatter() per la distribuzione e scomposizione del vettore di ingresso a a tutti i processori. MPI_Reduce() per raccogliere i dati prodotti da tutti i processori al processore root nella variabile sum come ci suggerisce il nome, la funzione effettua una riduzione di più elementi (residenti nella memoria dei vari processori) in una variabile del processore root sfruttando una funzione di riduzione, che nel nostro caso è MPI_SUM che, ovviamente, effettua la somma dei termini. La sincronizzazione avviene tramite la funzione: MPI_Barrier() mette in attesa tutti i processi di un canale di comunicazione fin quando tutti non raggiongono la stessa funzione; si usa solitamente dopo una richiesta di distribuzione di dati per fare in modo che tutti i processi si sincronizzino dopo aver ricevuto i dati da un processo padre. 4.2 ANALISI DEL SOFTWARE In questo paragrafo sono riportati i grafici e tabelle relativi al calcolo del tempo T(p), dello speedup S(p) e dell efficienza E(p). 12

13 Figura 2: Analisi del tempo di esecuzione Nella Figura 2 riportiamo sull asse delle ordinate il tempo di esecuzione in microsecondi, mentre sulle ascisse sono presenti i valori del numero processori utilizzati. Si evince subito che questa strategia non migliora mai i tempi di esecuzione a causa della prevalenza dei tempi di comunicazione e dei tempi di attesa. Riportimo comunque, per completezza, i grafici dei valori calcolati dello speed-up con affiancato il valore dello speed-up ideale e della relativa efficienza. #CPU T(p) S(p) E(p) 1 901, ,362 0, ,82% ,316 0, ,49% ,436 0, ,99% ,292 0, ,34% ,027 0, ,58% ,956 0, ,28% Tabella1: Parametri di valutativi per M=320x320 #CPU T(p) S(p) E(p) , ,508 0, ,30% ,389 0, ,33% ,838 0, ,19% ,742 0, ,98% ,458 0, ,37% ,390 0, ,65% Tabella3: Parametri di valutativi per M=640x640 #CPU T(p) S(p) E(p) , ,944 0, ,60% ,751 0, ,34% ,786 0, ,86% ,251 0, ,47% ,744 0, ,20% ,267 0, ,46% Tabella2: Parametri di valutativi per M=512x512 #CPU T(p) S(p) E(p) , ,340 0, ,18% ,765 0, ,40% ,775 0, ,70% ,485 0, ,10% ,389 0, ,52% ,265 0, ,72% Tabella4: Parametri di valutativi per M=832x832 13

14 Dalle tabelle si ricava che la configurazione che sfrutta meglio il parallelismo è quella a due processori, dove il valore dello speedup è il più vicino a quello ideale. Tuttavia in generale questa strategia non è molto performante in quanto lo speedup diminuisce sempre di più. I valori ottenuti sono in linea con la legge di Amdhal, infatti si ha un degrado delle prestazioni mantenendo fissa la dimensione e aumentando il numero dei processori. Mentre aumentando la dimensione mantenendo fisse le CPU abbiamo un incremento dello speedup. 4.3 ESEMPI D USO In questo paragrafo verrà mostrato un esempio dell output che viene generato una volta terminata l esecuzione del programma. L immagine che segue mostra l esecuzione del programma con una matrice 64x64. L output del programma mostra informazioni sul numero dei processori istanziati (in questo caso 4), la dimensione della matrice (in questo caso 64 come da parametro di default), il tempo (che non è affidabile dato che è stato eseguito in ambiente simulato) ed un valore di CheckSum. E prevista una gestione dei parametri errati come si mostra di seguito: 14

15 5. STRATEGIA III: DISTRIBUZIONE PER BLOCCHI Questa strategia prevede che la matrice venga distribuita ai processori per blocchi (sottomatrici). Ossia, consierando la matrice iniziale M: Ad esempio, supposto quindi la matrice M e il vettore a saranno: E supposto il numero dei processori utilizzati tale che sia un multiplo finito di ed un quadrato perfetto, ogni processore avrà una porzione precisa di M di dimensioni ed una parte del vettore di ingresso contenente elementi. Ad esempio, supposto quindi la matrice M e il vettore a saranno: e considerato (quindi quattro processori che lavorano in parallelo) il processore avrà la seguente porzione di matrice e di vettore: Mentre il processore avrà la restante porzione di matrice e di vettore: Di conseguenza il resto dei processori, ossia e avranno i seguenti elementi: In generale ogniuno dei processori, quindi il processore, avrà a disposizione: una matrice con elementi (con ) un vettore di elementi L algoritmo locale dovrà, quindi, effettuare il prodotto seguendo l algoritmo matematico già descritto nel paragrafo 2 ed ottenendo un numero di valori pari al numero di righe che compongono la propria matrice, ossia ; questa volta il risultato è ancora un risultato parziale che va sommato al valore posseduto dagli altri processori nella stessa posizione dell array. I processori, infatti, devono provvedere ad inviare il loro contribbuto al processore root che si occuperà di sommare, unire e visualizzare il risultato. 15

16 5.1 DESCRIZIONE DELL ALGORITMO Di seguito è riportato il codice dell algoritmo per il calcolo parallelo #include "mpi.h" #include <stdio.h> #include <math.h> double LeggiTempo(char *nomefile); void ScriviTempi(int numprocs, double time, double speedup, double eff); void ScriviTempo(double time); int main( int argc, char *argv[] ) { // variabili per il calcolo del tempo e delle prestazioni double t0, t1, time, time_1, speedup, eff; // variabili dell'algoritmo int myid, numprocs; int n, rowscols,i,j,k; int period[2], ndim[2], free_coords[2]; int root =0; // id (rank) del processore P0 //ambienti di comunicazione MPI_Comm MPI_COMM_GRID, MPI_COMM_ROWS, MPI_COMM_COLS; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); //GESTIONE DATI DI INPUT n = 64; //valore di default; if(argc==2) n = atoi(argv[1]); //righe matrice passato da utente else if(argc>2) { //errore printf("errore parametri (n.%d)\n", argc); printf("> MATVET3 [n]\n"); printf("\n"); printf("cardinalità della matrice (default=64)\n"); MPI_Finalize(); return 1; rowscols = n/sqrt((double)numprocs); //dimensione del blocco printf("dimensioni matrice: %dx%d\n", n, n); printf("dimensioni array: %d\n", n); printf("numero di processori: %d (griglia: %dx%d di blocchi %dx%d)\n", numprocs,n/rowscols,n/rowscols,rowscols,rowscols); int M[n][n], M1[rowscols][n], M1_T[n][rowscols], M2_T[rowscols][rowscols], M2[rowscols][rowscols]; int a[n], b[rowscols], c[rowscols],d[rowscols], sum[n]; //inizializzazione di b (vettore delle somme locali) b[i] = 0; //generazione dell'array di n elementi a[i] = i+1; //printf("a[%d]= %d\n", i,i+1); //inizializzazione della matrice di input. for(j=0; j<n; j++){ M[i][j]=j+1; //printf("m[%d][%d]= %d\n", i,j,j+1); 16

17 //CREAZIONE DELLA GRIGLIA 2D //dimensioni ndim[0] = n/rowscols; ndim[1] = n/rowscols; //parametri di peridicitࠤella griglia (non è periodica) period[0] = 0; period[1] = 0; MPI_Cart_create(MPI_COMM_WORLD,2,ndim,period,0,&MPI_COMM_GRID); //creazione della griglia 2D //definizione della dimensione lungo la quale verrࠤreata la sottogriglia free_coords[0] = 0; free_coords[1] = 1; MPI_Cart_sub(MPI_COMM_GRID,free_coords,&MPI_COMM_ROWS); //creazione della sottogriglia delle righe //definizione della dimensione lungo la quale verrࠤreata la sottogriglia free_coords[0] = 1; free_coords[1] = 0; MPI_Cart_sub(MPI_COMM_GRID,free_coords,&MPI_COMM_COLS); //creazione della sottogriglia delle colonne //DISTRIBUZIONE DEL VETTORE //1) broadcast di al gruppo della prima colonna MPI_Bcast(a,n,MPI_INT,0,MPI_COMM_COLS); MPI_Barrier(MPI_COMM_COLS); //2) distribuzione dell'array ai gruppi di riga MPI_Scatter(a,rowscols,MPI_INT,c,rowscols,MPI_INT,root,MPI_COMM_ROWS); MPI_Barrier(MPI_COMM_ROWS); //DISTRIBUZIONE MATRICE PER COLONNE (passando per la trasposta) //1) per righe alla prima colonna della griglia 2D MPI_Scatter(M,n*rowscols,MPI_INT,M1,n*rowscols,MPI_INT,root,MPI_COMM_COLS); MPI_Barrier(MPI_COMM_COLS); //- trasposta della matrice M1 ricevuta dagli elementi della prima colonna for(j=0; j<rowscols; j++){ M1_T[i][j] = M1[j][i]; //2) per colonne ai processori delle sottogriglie di righe MPI_Scatter(M1_T,rowscols*rowscols,MPI_INT,M2,rowscols*rowscols,MPI_INT,root,MPI_COMM_ROWS); MPI_Barrier(MPI_COMM_ROWS); //- trasposta della matrice appena ricevuta for(i=0; i<rowscols; i++){ for(j=0; j<rowscols; j++){ M2_T[i][j] = M2[j][i]; if(myid==0) t0 = MPI_Wtime(); //start al tempo //CALCOLO DEL PRODOTTO (PARALLELO) [+DBG] int tmp=0; char*msg = "<PROC %d> b[%d] = b[%d] + M2_T[%d][%d]*c[%d] = %d + (%d*%d) = %d\n"; for(i=0; i<rowscols; i++){ for(j=0; j<rowscols; j++){ tmp = b[i]; b[i] = b[i] + M2_T[i][j]*c[j]; //DBG //printf(msg, myid,i,i,i,j,j,tmp,m2_t[i][j],c[j],b[i]); //somma dei risultati parziali per righe for(i=0; i<rowscols; i++) MPI_Reduce(&b[i],&d[i],1,MPI_INT,MPI_SUM,root,MPI_COMM_ROWS); //raccolta dei risultati a P0 a formare il vettore risultato 17

18 MPI_Gather(d,rowscols,MPI_INT,sum,rowscols,MPI_INT,root,MPI_COMM_COLS); t1 = MPI_Wtime(); //stop al tempo //calcolo e stampa del tempo trascorso time = 1.e6 * (t1-t0); printf("tempo: %f\n", time); //se è monoprocessore allora scrive il tempo su un file if(numprocs==1) ScriviTempo(time); //legge il valore del tempo per un processore time_1 = LeggiTempo("tempi_1.txt"); //calcolo speedup ed efficienza speedup = time/time_1; eff = speedup/numprocs; //scrive numero di processore, tempo, speedup ed efficienza in un file ScriviTempi(numprocs, time, speedup, eff); //scampa il risultato printf("risultato: [ %d, %d,... %d, %d ]\n", sum[0], sum[1], sum[n-2], sum[n-1]); //verifica del valore risultato. Se è corretto checksum è pari a 0. int sumtemp1, sumtemp2, checksum; sumtemp1 =(2*n+1)*(n+1)*(n); sumtemp2 = sumtemp1/6; checksum = 0; checksum = checksum + (sum[i]-sumtemp2); printf("checksum=%d\n", checksum); MPI_Finalize(); return 0; L algoritmo è stato concepito per funzionare in maniera completamente dinamica. L unico parametro di configurazione è la dimensione della matrice di input e tutti i valori verranno calcolati in base al PBS caricato in fase di esecuzione, leggendo il numero dei processori allocati per il task. Se si vogliono eseguire test su una matrice di dimensioni diverse allora sarà sufficiente passare alla chiamata del programma un nuovo valore di dimensione (default 64) e il software provvederà a modificare la variabile interna n. Una volta assegnato il valore di, viene assegnato alla variabile rowcols il valore: che rappresenta il numero di righe e colonne della matrice che possiederà ogni processore (con unico vincolo che il numero di colonne della matrice di input sia un multiplo del numero di processori nproc ed in più, che p sia un quadrato proprio). Avremo quindi: M (matrice di input) di dimensioni {inizializzato con per ogni sua riga a (vettore di input) di dimensioni {inizializzato con sum (vettore del risultato) di dimensioni Ogni processore avrà a disposizione le seguenti variabili con valenza locale: 18

19 C (porzione della matrice di input) di dimensioni c (porzione del vettore di input) di dimensioni b (vettore delli risultati locali) di dimensioni La comunicazione avviene sfruttando le seguenti primitive MPI MPI_Scatter() per la distribuzione (in due fasi: prima sulla prima colonna e poi a tutte le righe) e scomposizione della matrice M ad ogni processore (si sfrutta la funzionalità di questa funzione di distribuire gli array bidimensionali effettuando una trasposizione della matrice M in MT e poi ricalcolando la trasposata della copia locale) MPI_Bcast() per inviare la porzione di matrice già suddivisa nella prima riga a tutte le restanti righe della matrice di processori. MPI_Scatter()per la distribuzione (in due fasi: prima sulla prima colonna e poi a tutte le righe) e scomposizione del vettore di ingresso a a tutti i processori. MPI_Bcast() per inviare la porzione di array già suddivisa nella prima riga a tutte le restanti righe della matrice di processori. MPI_Reduce() per raccogliere i dati prodotti da tutti i processori al processore root nella variabile d (di ogni riga); come ci suggerisce il nome, la funzione effettua una riduzione di più elementi (residenti nella memoria dei vari processori) in una variabile del processore root sfruttando una funzione di riduzione, che nel nostro caso è MPI_SUM che, ovviamente, effettua la somma dei termini. MPI_Gather() per raccogliere i dati prodotti da tutti i processori al processore root sum. La sincronizzazione avviene tramite la funzione MPI: nella variabile MPI_Barrier() mette in attesa tutti i processi di un canale di comunicazione fin quando tutti non raggiongono la stessa funzione; si usa solitamente dopo una richiesta di distribuzione di dati per fare in modo che tutti i processi si sincronizzino dopo aver ricevuto i dati da un processo padre. Per questo esercizio è necessario creare nuovi contesti di comunicazione per poter sfruttare un architettura a griglia; per fare questo si sono usate le seguenti primitive MPI: MPI_Cart_create() crea una griglia di comunicazione cartesiana (nel nostro caso di 2 dimensioni) MPI_Cart_sub()crea una sottogriglia di comunicazione in una struttura cartesiana già definita (ad esempio come nel nostro caso di sole righe o sole colonne) MPI_Comm_rank() restituisce il rank in una griglia di comunicazione (già usato per lo spazio di comuncazione di default MPI_COMM_WORLD ed ora usato per ridefinire il sottospazio ed i suoi indici) 5.2 ANALISI DEL SOFTWARE In questo paragrafo sono riportati i grafici e tabelle relativi al calcolo del tempo T(p), dello speedup S(p) e dell efficienza E(p). 19

20 Figura 3: Analisi del tempo di esecuzione Nella Figura 3 riportiamo sull asse delle ordinate il tempo di esecuzione in microsecondi, mentre sulle ascisse sono presenti i valori del numero processori utilizzati. Si evince subito che questa strategia non migliora mai i tempi di esecuzione a causa della prevalenza dei tempi di comunicazione e dei tempi di attesa. Riportimo comunque, per completezza, i grafici dei valori calcolati dello speed-up con affiancato il valore dello speed-up ideale e della relativa efficienza. #CPU T(p) S(p) E(p) 1 981, ,656 0, ,06% ,993 0, ,41% ,293 0, ,07% Tabella1: Parametri di valutativi per M=320x320 #CPU T(p) S(p) E(p) , ,774 0, ,28% ,509 0, ,26% ,255 0, ,10% Tabella2: Parametri di valutativi per M=512x512 #CPU T(p) S(p) E(p) , ,494 1, ,93% ,892 0, ,70% ,194 0, ,16% Tabella3: Parametri di valutativi per M=640x640 #CPU T(p) S(p) E(p) , ,813 1, ,05% ,993 0, ,22% ,854 0, ,21% Tabella4: Parametri di valutativi per M=832x832 Dalla tabella si ricava che la configurazione che sfrutta meglio il parallelismo è quella a quattro processori, dove il valore dello speedup è il più vicino a quello ideale. Tuttavia in generale questa strategia non è molto performante in quanto lo speedup diminuisce sempre di più. I valori ottenuti sono in linea con la legge di Amdhal, infatti si ha un degrado delle prestazioni mantenendo fissa la dimensione e aumentando il numero dei processori. Mentre aumentando la dimensione mantenendo fisse le CPU abbiamo un incremento dello speedup. 20

21 5.3 ESEMPI D USO In questo paragrafo verrà mostrato un esempio dell output che viene generato una volta terminata l esecuzione del programma. L immagine che segue mostra l esecuzione del programma con una matrice 64x64. L output del programma mostra informazioni sul numero dei processori istanziati (in questo caso 4), la dimensione della matrice (in questo caso 64 come da parametro di default), il tempo (che non è affidabile dato che è stato eseguito in ambiente simulato) ed un valore di CheckSum. E prevista una gestione dei parametri errati come si mostra di seguito: 21

22 6. APPENDICE 6.1 CHECKSUM Il CheckSum è calcolato basandosi sulla condizione che i parametri di ingresso sono precaricati con i valori della posizione orizzontale della cella stessa della matrice, quindi: quindi quindi Il prodotto matrice per vettore si riduce quindi ad un array di elementi tutti uguali pari alla somma dei quadrati perfetti che può anche essere calcolata usando il principio di induzione; è noto che la somma dei primi quadrati perfetti è: Il CheckSum viene quindi calcolato confrontando il valore restituito dall algoritmo parallelo ed il valore atteso calcolato con la formula su citata. Se questo valore è 0 allora vuol dire che i processori hanno calcolato il valore corretto. 6.2 FUNZIONI AUSILIARIE Per quanto riguarda i sotto programmi sono state definite soltanto tre funzioni che vengono richiamate con lo scopo di scrivere e leggere i tempi rilevato durante l esecuzione. Di seguito vengono riportate le interfacce e l implementazione. double LeggiTempo(char* nomefile); void ScriviTempi(int nproc,double time,double speedup,doubleeff); void ScriviTempo(double time); double LeggiTempo(char *nomefile){ FILE *ingresso; double tempo; ingresso = fopen(nomefile, "r"); fscanf(ingresso,"%lg",&tempo); fclose(ingresso); return tempo; void ScriviTempo(double time){ FILE *pf1; char *nomefile1 = "tempi_1.txt"; pf1 = fopen(nomefile1, "a"); if(pf1){ fprintf(pf1, "%f\n", time); fclose(pf1); else printf("errore"); void ScriviTempi(int numprocs, double time, double speedup, double eff){ FILE *pf; char *nomefile = "tempi.txt"; pf = fopen(nomefile, "a"); 22

23 if(pf){ fprintf(pf, "%d %f %f %f\n", numprocs, time, speedup, eff); fclose(pf); else printf("errore"); La funzione LeggiTempo() ha il compito di aprire il file dove è stato memorizzato il tempo relativo all esecuzione su una sola CPU, per poi memorizzarlo nella variabile time_1. ScriviTempi() scrive all interno di un file di testo i tempi rilevati man mano che aumenta il numero di processori, associando ad essi i relativi valori di speedup (calcolato mediante l uso del valore precedentemente memorizzato in time_1) ed efficienza. 23