UNIVERSITA DEGLI STUDI DI NAPOLI FEDERICO II

Transcript

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

2 1. OBIETTIVI E AMBIENTE DI CALCOLO Si vuole distribuire un algoritmo di somma di componenti di un vettore 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 un vettore e si vuole ottenere il valore somma. 3. CODICE DELL ALGORITMO Di seguito è riportato il codice dell algoritmo per il calcolo parallelo #include <stdio.h> #include "mpi.h" #include "malloc.h" double LeggiTempo(char *nomefile); void ScriviTempi(int nproc, 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 nproc,iarraydim,myid, root; int i; int temp; int sumtot; int sumdim,sumcorr; int sumtemp1, sumtemp2; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&nproc); MPI_Comm_rank(MPI_COMM_WORLD,&myid); //GESTIONE DATI DI INPUT iarraydim = ; //valore di default; if(argc==2) iarraydim = atoi(argv[1]); //dimensione array passato da utente else if(argc>2) { //errore printf("errore parametri (n.%d)\n", argc); printf("> SOMMA [n_elementi]\n"); printf("\n"); printf("[n_elementi] numero di elementi dell'array (default=100000)\n"); MPI_Finalize(); return 1; sumdim = iarraydim/nproc; //numero di elementi per ogni processore 2

3 printf("n. di processori: %d\n",nproc); printf("dimensione array: %d\n",iarraydim); //allocazione dinamica dell'array di input int* sum = (int*)malloc(sizeof(int)*sumdim); int* inputarray = (int*)malloc(sizeof(int)*iarraydim); sumtot=0; root =0; // id (rank) del processore P0 temp =0; //inizializzazione dell'array di input. for(i=0; i<iarraydim; i++){ inputarray[i] = i; //sincronizzazione e distribuzione dell'array di input a tutti i processori MPI_Scatter(inputarray,sumdim,MPI_INT,sum,sumdim,MPI_INT,root,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); t0 = MPI_Wtime(); //inizio conteggio tempo //SOMMA DEGLI ELEMENTI (PARALLELO) for(i=0; i<sumdim; i++){ temp = temp + sum[i]; //somma degli elementi //il risultato di somma di ogni processore viene mandato al //root che somma il risultati parziali MPI_Reduce(&temp,&sumtot,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(nproc==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/nproc; //scrive numero di processore, tempo, speedup ed efficienza in un file ScriviTempi(nproc, time, speedup, eff); //verifica del valore somma. Se è corretto il checksum è pari a 0. sumtemp1 =(iarraydim-1)*(iarraydim); sumtemp2 = sumtemp1/2; int checksum = sumtot-sumtemp2; printf("checksum=%d\n", checksum); //deallocazione array dinamico free(inputarray); free(sum); MPI_Finalize(); return 0; L algoritmo è stato concepito per funzionare in maniera completamente dinamica. L unico parametro di configurazione è la dimensione dell array di input e tutti i valori verranno calcolati in base al PBS caricato in fase 3

4 di esecuzione, leggendo il numero dei processori allocati per il task. Se si vogliono eseguire test su array di dimensioni diverse allora sarà sufficiente passare alla chiamata del programma un nuovo valore di dimensione (default ) e il software provvederà a modificare la variabile interna iarraydim. Si è scelto di distribuire l array da sommare a tutti i processori attivi (con unico vincolo che il numero di elementi dell array di input iarraydim sia multiplo del numero di processori nproc). Per fare ciò si usa la primitiva MPI_Scatter(). Una volta che tutti i processori avranno ottenuto la loro porzione di array, ognuno di essi procederà con la somma degli elementi e memorizzeranno tale valore nella variabile temp. Successivamente viene effettuata una operazione di collezione di tali valori temporanei da parte del processore radice mediante l utilizzo della primitiva MPI_Reduce() che darà origina ad un unico valore sumtot che è la somma dei valori parziali. 4. ANALISI DEL SOFTWARE In questo paragrafo sono riportati i grafici e tabelle relativi al calcolo del tempo T(p), dello speedup e dell efficienza. 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. Si nota subito un andamento quasi regolare di riduzione del tempo di esecuzione fino ad un valore asintodico (dovuto alla porzione sequenziale dell algoritmo). La drastica riduzione è, ovviamente, più marcata applicando l algoritmo ad un array di grandissime dimensioni ( di elementi). 4

5 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 e della relativa efficienza. 2 0,4 2 20,00% 4 0, ,84% 8 0, ,23% 10 0, ,21% 20 0, ,59% 40 0, ,13% 50 0, ,15% 2 1, ,50% 4 1, ,38% 8 0, ,79% 10 0, ,57% 20 0, ,03% 40 0, ,72% 50 0, ,53% Tabella1: Parametri di valutativi per n=1000 Tabella2: Parametri di valutativi per n= , ,72% 4 2, ,36% 8 4, ,52% 10 3, ,54% 16 3, ,96% 20 2, ,03% 32 3, ,89% 40 1, ,39% 50 2, ,37% 2 1, ,57% 4 3, ,05% 8 7, ,17% 10 8, ,77% 16 8, ,49% 20 9, ,61% 32 13, ,47% 40 14, ,71% 50 14, ,81% 64 19, ,46% Tabella3: Parametri di valutativi per n= Tabella4: Parametri di valutativi per n= 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 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, quindi le prestazioni tendono a degradare. Se, invece, manteniamo fisso il numero dei 5

6 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. 5. 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 un array di elementi. L output del programma mostra informazioni sul numero dei processori istanziati (in questo caso 10), la dimensione dell array (in questo caso ), 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: 6. APPENDICE 6.1. CHECKSUM Il CheckSum è calcolato basandosi sulla condizione che l array di ingresso è precaricato con il valore della posizione della cella stessa nell array, quindi quindi 6

7 La somma può anche essere calcolata usando il principio di induzione ed è noto che la somma dei primi è: numeri 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 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"); 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. 7