Somma di un array di N numeri in MPI

Транскрипт

1 Facoltà di Ingegneria Corso di Studi in Ingegneria Informatica Elaborato di Calcolo Parallelo Somma di un array di N numeri in MPI Anno Accademico 2011/2012 Professoressa Alessandra D Alessio Studenti

2 Definizione del Problema Il punto di partenza del nostro elaborato è il calcolo della somma di N numeri eseguito su di un architettura parallela MIMD multi computer, in particolare ci avvarremo di quella a 64 CPU (16 x Intel Xeon E5410 [email protected] 64 bit) offerta dall Università degli Studi di Napoli Federico II attraverso l infrastruttura S.Co.P.E.. L obiettivo è la valutazione dell efficienza dell algoritmo da noi implementato, valutazione a cui giungeremo raccogliendo i risultati dei diversi test eseguiti (che si differenziano per il numero di elementi da sommare e/o per il numero di processori coinvolti ) in tre parametri fondamentali: tempo impiegato dall algoritmo parallelo con p processori T(p), speed-up S(p) ed efficienza E(p). 2

3 Descrizione dell algoritmo Nome capitolo Esistono tre differenti algoritmi paralleli per il calcolo della somma di N numeri, tutti applicabili non appena ciascun processore disponga della somma locale di una parte degli elementi totali, somma che sarà di sua esclusiva competenza. L eterogeneità tra i vari approcci si giustifica notando come ciascuno di essi rappresenti una diversa proposta di gestione degli scambi delle somma parziali, locali ad ogni processore. La strategia implementata dal nostro algoritmo è la seconda, anche se potenzialmente potrebbe degenerare nella prima, come sarà chiarito in seguito. Le somme parziali sono calcolate e accumulate nelle memorie dei processori coinvolti secondo la mappa descritta da un albero binario, la cui base avrà un numero di nodi pari al numero di processori (Figura 1). I nodi disposti nei livelli successivi costituiscono, quindi, ancora delle somme parziali ma del cui calcolo si fà carico uno solo dei due processori figli; ovviamente solo dopo aver ricevuto il risultato parziale dall altro. Per applicare questa strategia sarà necessario disporre di un numero di processori pari ad una potenza del 2. A differenza della prima, in cui il carico di lavoro è tutto sbilanciato su un solo processore che somma i risultati parziali ottenuti dalle altre macchine della rete, la seconda strategia prevede un numero di passi dimezzato e la possibilità, ad ogni passo, di lavorare in parallelo per coppie distinte di processori. Tuttavia il carico di gestione risulta parzialmente distribuito perché non tutti i processori proseguono le elaborazioni ad ogni passo temporale; di fatto al termine dell algoritmo esclusivamente il nodo accentratore 3

4 sarà possessore del risultato. Figura 1 Esempio II strategia con 4 processori Passiamo alla descrizione dell algoritmo sviluppato. Dopo aver definito le variabili, inizializziamo l ambiente di esecuzione MPI tramite la funzione di libreria MPI_Init, ad ogni processore assegniamo nella variabile numproc il numero di processori coinvolti sfruttando la funzione di libreria MPI_Comm_size; mentre con la MPI_Comm_rank il processore chiamante potrà memorizzare nella variabile id il proprio identificativo. La variabile in cui andremo a memorizzare la somma totale ( sommatotale ) è stata definita come un unsigned int per evitare la possibilità di determinare un overflow. Seguono dei controlli sugli input per verificare la correttezza del numero e del tipo di input passati. In particolare l esito del controllo sul numero dei processori determina la strategia che sarà utilizzata, in quanto nel caso in cui numproc non fosse una potenza del 2 si ricadrebbe nella I strategia. In seguito sono allocati dinamicamente ed inizializzati solo dal processore 0 i vettori SendCount e Displs, entrambi sono, però, definiti da ciascun processore pena il non funzionamento della MPI_Scatterv utilizzata in seguito. I due vettori considerati 4

5 sono atti a contenere rispettivamente il numero di elementi che ogni singolo processore dovrà sommare localmente nello step immediatamente precedente l applicazione della strategia e l offset che garantirà alla funzione MPI_Scatterv il posizionamento corretto, nel vettore contenente gli elementi da sommare, del punto a partire dal quale inviare gli elementi ad ogni singolo processore. L impiego della funzione calloc per l allocazione garantisce, al contrario della malloc, anche l inizializzazione degli stessi a zero; inoltre l allocazione è dinamica perché i parametri di input del main saranno noti a tempo di esecuzione, passati dal file PBS. Nelle memorie di tutti i processori sarà allocato dinamicamente un altro vettore ( somma ) la cui lunghezza è pari al numero di elementi che ogni processore riceverà in prima battuta. Nel codice successivo facciamo allocare dinamicamente al processore 0 il vettore degli elementi da sommare, in particolare si è scelto di porli tutti pari ad 1 per evitare overflow nel caso della somma di un numero elevato di elementi. Infine sfruttando la funzioni MPI_Scatterv il processore 0 può distribuire a ciascun processore del MPI_COMM_WORLD gli elementi da sommare localmente anche nel caso in cui il numero totale degli stessi non sia un multiplo del numero dei processori (in questo caso la differenza del numero di elementi da sommare per ogni singolo processore può essere al più pari ad 1 ). La funzione MPI_Barrier garantisce che il calcolo dei tempi ( ricavato dal processore 0 come differenza degli intervalli temporali tin e tfin restituiti dalla funzione di libreria MPI_Wtime ) avvenga solo dopo che tutti i processori abbiano ricevuto gli elementi di cui calcolare la somma. La seconda strategia è implementata nel caso in cui il numero di processori sia una potenza del due mediante la funzione MPI_Reduce, eseguita da ciascun processore dopo il calcolo della somma degli elementi ricevuti attraverso la MPI_Scatterv. Prima della MPI_Finalize abbiamo deallocato tutti i puntatori utilizzati con la funzione free. 5

6 Input, Output e situazioni d errore Descriviamo, ora, il modo di funzionamento dell algoritmo da noi implementato, andando a specificare gli input forniti, gli output ottenuti e le possibili situazioni d errore in cui è possibile incorrere. Parametri di Input I parametri forniti in ingresso al programma da noi sviluppato sono due: - n: lunghezza del vettore che contiene gli elementi di cui effettuare la somma. E un intero positivo. Se omesso è settato al valore di default, n=20. - p: numero di processori a cui sarà sottomessa l esecuzione dell algoritmo. Il sistema su cui andiamo a lavorare è dotato di 64 core, quindi p dovrà essere necessariamente inferiore a tale numero. Si noti che il vettore degli elementi è stato riempito, all interno del codice, da un valore numerico costante (1), in quanto lo scopo principale di questo lavoro è quello di mostrare l efficienza dell algoritmo di somma parallela. Parametri di Output Il programma da noi implementato fornisce come output, mostrati a video al termine 6

7 dell esecuzione, due parametri: - Il tempo impiegato per effettuare i calcoli, in maniera tale da poter fare delle valutazioni riguardanti l efficienza dell algoritmo. - La somma degli n elementi, calcolata in parallelo sul numero di processori indicati in input. I parametri di input vengono forniti al sistema mediante il file somma.pbs e, all interno dello stesso file, viene stabilito che il sistema genererà il file di output somma.out al termine dell esecuzione. Il file stabilisce anche la generazione di un file somma.err che conterrà gli eventuali errori restituiti dal sistema. Il formato PBS (Portable Batch System) permette di comandare l esecuzione di un insieme di jobs su un architettura parallela. Abbiamo scritto il file somma.pbs in maniera tale che esso fornisca in ingresso i parametri, evitando di dover modificare il file somma.c per ogni esecuzione. Riportiamo qui di seguito il contenuto del file somma.pbs : #!/bin/bash ########################## # # # The PBS directives # # # ########################## #PBS -q studenti #PBS -l nodes=2 #PBS -N somma #PBS -o somma.out 7

8 #PBS -e somma.err ########################################## # # # Output some useful job information. # # # ########################################## NCPU=`wc -l < $PBS_NODEFILE` echo echo ' This job is allocated on '${NCPU' cpu(s)' echo 'Job is running on node(s): ' cat $PBS_NODEFILE PBS_O_WORKDIR=$PBS_O_HOME/somma echo echo PBS: qsub is running on $PBS_O_HOST echo PBS: originating queue is $PBS_O_QUEUE echo PBS: executing queue is $PBS_QUEUE echo PBS: working directory is $PBS_O_WORKDIR echo PBS: execution mode is $PBS_ENVIRONMENT echo PBS: job identifier is $PBS_JOBID echo PBS: job name is $PBS_JOBNAME echo PBS: node file is $PBS_NODEFILE echo PBS: current home directory is $PBS_O_HOME echo PBS: PATH = $PBS_O_PATH echo echo "Eseguo: /usr/lib64/openmpi/1.4-gcc/bin/mpicc -o $PBS_O_WORKDIR/somma $PBS_O_WORKDIR/somma.c" 8

9 /usr/lib64/openmpi/1.4-gcc/bin/mpicc -o $PBS_O_WORKDIR/somma $PBS_O_WORKDIR/somma.c echo "Eseguo: /usr/lib64/openmpi/1.4-gcc/bin/mpiexec -machinefile $PBS_NODEFILE -np $NCPU $PBS_O_WORKDIR/somma" /usr/lib64/openmpi/1.4-gcc/bin/mpiexec -machinefile $PBS_NODEFILE -np $NCPU $PBS_O_WORKDIR/somma Il numero di processori viene fornito mediante la direttiva #PBS -l nodes=x, mentre il numero n di elementi del vettore viene sottomesso aggiungendolo in coda alla direttiva di esecuzione mpiexec. Situazioni d errore e avvertenze Elenchiamo qui di seguito le situazioni d errore che vengono restituite dal programma nel caso di un errato utilizzo dello stesso. Elencheremo, inoltre, le avvertenze che saranno mostrate a video nel caso di situazioni particolari; tali avvertenze non comportano una terminazione del programma. Per quanto riguarda le situazioni d errore: 1) Errore dovuto all inserimento di un numero più di un argomento. L unico, eventuale, argomento da fornire in input è n, il numero di elementi dell array di cui effettuare la somma. ERRORE! Sono stati inseriti troppi argomenti! Sintassi corretta: Somma n_processori [dim_array] Il parametro [dim_array] e' opzionale ed e' settato a 20 di default. 9

10 2) Errore dovuto all inserimento di un valore negativo come dimensione dell array ERRORE! La dimensione dell'array non può essere negativa! Il programma terminerà. 3) Errore dovuto all inserimento di un valore non intero come dimensione dell array ERRORE! La dimensione dell'array deve essere un intero! Il programma terminerà. 4) Errore dovuto alla richiesta di esecuzione su un numero di core superiore a 64, ovvero il numero di core di cui dispone il sistema su cui il programma è stato testato. ERRORE! Il sistema dispone di 64 core. Non è possibile richiederne un numero superiore. Il programma terminerà. Per quanto riguarda le avvertenze: - La funzione scelta per la soluzione del problema della somma parallela è la funzione MPI_Reduce(). Tale funzione, a seconda del numero di processori sulla quale è richiamata, andrà ad implementare una strategia piuttosto che un altra. In particolare, se il numero di processori è una potenza del due, la funzione svolgerà al suo interno i passi necessari alla realizzazione della II strategia. Se invece il numero di processori non rispetta questa condizione, essa implementerà la I strategia. Essendo il programma nato per il testing del funzionamento della II strategia, abbiamo ritenuto opportuno segnalare all utente tale situazione. Ad ogni modo, dato che il programma funziona ugualmente e restituisce un risultato corretto, non abbiamo ritenuto necessaria la terminazione dello stesso. Per questo motivo abbiamo deciso di ricorrere alla stampa a video del seguente messaggio: 10

11 WARNING! Il numero di processori non e' una potenza del due! Verrà utilizzata la strategia I! 11

12 Analisi del software Adesso concentreremo l attenzione sulle tabelle e i grafici relativi al calcolo del tempo di esecuzione T(p), dello speed-up S(p) e dell efficienza E(p). Tempo di esecuzione T(p) Nella tabella che segue sono riportati i valori del tempo di esecuzione registrato al variare del numero di processori P e del numero di elementi da sommare N. Quindi muovendoci lungo la colonna possiamo capire se c è un vantaggio o meno legato all aumento del numero di processori coinvolti. Tutti i valori del T(p) sono espressi in microsecondi, mentre ciascuno dei valori in tabella è stato ottenuto eseguendo la media sui campioni ottenuti eseguendo una decina di prove; un analogo discorso si estende anche ai valori posizionati nelle tabella del S(p) e dell E(p). N p 1 9, , , , , , , , , , , , , , , , , , , , , , , , ,41579 Tabella 1 Tempo di esecuzione T(p) 12

13 Figura 2 T(p) al variare del numero di processori e del numero di elementi da sommare Guardando la Figura 2 e la Tabella 1 possiamo notare che per N fissato non è sempre conveniente l utilizzo di un architettura parallela. In particolare per N=1.000 i tempi di esecuzione quasi raddoppiano passando da un incremento all altro del numero di processori, il caso più drastico, ma ciò accomuna tutti gli N è quello di p=16. Per quanto concerne N=10000 è quasi indifferente l impiego di più processori, mentre iniziamo a scoprirne i vantaggi a partire da N= e ad avere dei tempi particolarmente soddisfacenti per N= Negli ultimi tre casi citati minori tempi si registrano con p=8. Invertendo il punto di vista e quindi ponendoci con la prospettiva del N variabile con p fissato, i tempi, com è ragionevole che sia, aumentano ma nel caso p=16 si attestano su valori insolitamente vicini considerate le differenze tra gli ordini di grandezza degli N considerati. 13

14 Speed-up S(p) Nella tabella che segue sono riportati i valori dello speed-up, ricordiamo che esso misura la riduzione del tempo di esecuzione rispetto all algoritmo su 1 processore. Il valore è stato ottenuto a partire dal T(p) medio calcolato a partire da una decina di campioni. N p 2 0,4794 1,2625 1,892 1,7215 1, ,3297 1,1526 3,2407 3,3914 3, ,2038 0,8385 4,0776 6,3765 6, , , ,0087 0,0921 0,7369 Tabella 2 Valori dello Speed-up S(p) al variare di N e di P Figura 3 Speed up S(p) al variare di N e di p 14

15 Il punto di riferimento per giudicare lo speed-up delle nostre esecuzioni è la linea tratteggiata, che rappresenta il valore ideale. Per N=1.000 e N= siamo ancora lontani dall approssimarci al miglior caso possibile, come accade invece per gli altri tre valori della N. Anche con questo grafico abbiamo la conferma che p=16 non porti nessun miglioramento, mentre valori nei dintorni di quelli ideali sono stati registrati per p=2 con N= e N= , per p=4 con N= ; con p=8 a partire da N= traiamo dei benefici dall impiego dell architettura parallela, ma non al punto da essere ottimi come nei due casi su menzionati. Efficienza E(p) Nella tabella che segue sono riportati i valori dell efficienza, indicativa di quanto l algoritmo sfrutti il parallelismo del calcolatore. N p 2 0,2397 0, ,946 0, , , , , , , , , ,5097 0, , ,18E-05 5,74E-05 0, , , Tabella 3 Valori dell Efficienza E(p) al variare di N e p Il valore di riferimento di E(p) è rappresentato nella Figura 4, in rapporto allo stesso scopriamo che i nostri test forniscono un risultato interessante per N= e N= con p=2 e con p=4, mentre sugli stessi processori per N= si ottengono valori quasi ideali. In tutti gli altri casi all aumentare di p l efficienza degrada, raggiungendo il suo minimo nel caso p=16; ciò in piena aderenza con le osservazioni suggeriteci dai grafici di T(p) ed S(p). 15

16 Figura 4 Efficienza E(p) al variare di N e di p 16

17 Esempi d uso e codice In questo capitolo verranno illustrati degli esempi d uso dell algoritmo. Mostreremo in che modo verrà richiamato il programma e come esso verrà mostrato a video. Inoltre, mostreremo qui il codice del programma da noi sviluppato, il quale sarà correlato da una documentazione interna che ne spiegherà il funzionamento. Esempi d uso Mostriamo un esempio del risultato che si ottiene a video andando a eseguire il programma fornendo come input un numero di elementi n= 20 e richiedendo che l algoritmo venga eseguito su p=4 processori. Come illustrato nel capitolo dedicato a Input, Output e Situazioni d Errore, tali input saranno forniti al sistema mediante il file somma.pbs. 17

18 Figura 5 Esempio esecuzione con N=20 Si nota che vengono mostrate a video le informazioni sugli input forniti, n e p, il tempo totale impiegato per il calcolo della somma e, infine, il risultato dell elaborazione. Il risultato visibile, somma=20, è corretto in quanto è stato scelto di riempire il vettore con una costante unitaria; tale scelta è stata operata in quanto il nostro obiettivo era quello di ottenere informazioni significative riguardo i tempi di esecuzione, essendo già stata provata la correttezza dell algoritmo sviluppato. Codice del programma Riportiamo qui di seguito il codice da noi scritto per la realizzazione di questo programma. Abbiamo utilizzato il linguaggio di programmazione C. Il codice è stato corredato di una documentazione interna che spiega le varie istruzioni utilizzate. 18

19 /*Algoritmo per il calcolo della somma di n numeri. Autori: Giuffrida Serena M63/239 Lampognana Francesca M63/144 Mele Gianluca M63/145 */ #include <stdio.h> #include <mpi.h> #include "malloc.h" #define ROOT 0 int main(int argc, char **argv) { /***Definizione delle variabili***/ int id, numproc; int dim,dimarray=20; // questo è il valore di default del numero di elementi da sommare unsigned int sommatotale; // unsigned in quanto la somma è un valore positivo in quanto sommiamo tra di loro valori positivi; così facendo sarà possibile sommare un numero maggiore di elementi prima di andare in overflow unsigned int temp=0; int i; double tin,tfin,tempotot; float warning; int* SendCount=0; // Tali puntatori vengono utilizzati ed allocate solo dal int* Displs=0; // processore 0 ma devono essere visti da tutti per le varie int* Vettore=0; // funzioni offerte da MPI /****Inizializzazione***/ MPI_Init(&argc, &argv); /***Numero processori***/ MPI_Comm_size(MPI_COMM_WORLD, &numproc); /***Individuazione ranks***/ MPI_Comm_rank(MPI_COMM_WORLD, &id); // Controlli sugli input if(argc==2) //nel caso in cui sia stato specificato nel file pbs il numero di elementi da sommare dimarray=atoi(argv[1]); else if(argc>2){ //controllo su eventuale inserimento di un numero eccessivo di argomenti if(!id){ printf("errore! Sono stati inseriti troppi argomenti!\n"); printf("\nsintassi corretta:\n"); printf("somma n_processori [dim_array]\n\n"); printf("il parametro [dim_array] e' opzionale ed e' settato a 20 di default.\n"); MPI_Finalize(); return -1; 19

20 //Avvertenza riguardante il numero di processori warning=log(numproc)/log(2); //se il numero di processi specificati non è una potenza del 2 sarà calcolata warning=warning-(int)warning; //la somma con la prima strategia if(warning!=0) if(!id) printf("warning! Il numero di processori non e' una potenza del due!\nverra' utilizzata la strategia I!\n"); //Controllo sull'eventuale inserimento di una dimensione negativa dell'array if(dimarray<0){ if(!id){ printf("errore! La dimensione dell'array non può essere negativa!\n"); printf("il programma terminerà.\n"); MPI_Finalize(); return -1; //Controllo sull'eventuale richiesta di esecuzione su un numero eccessivo di processori if(numproc>64){ if(!id){ printf("errore! Il sistema dispone di 64 core. Non è possibile richiederne un numero superiore.\n"); printf("il programma terminerà.\n"); MPI_Finalize(); return -1; //Controllo su inserimento di una dimensione dell'array non intera if((dimarray-(int)dimarray)!=0){ if(!id){ printf("errore! La dimensione dell'array deve essere un intero!\n"); printf("il programma terminerà.\n"); MPI_Finalize(); return -1; //Fine controlli sugli input if(!id){ //Istanzio dinamicamente i vettori necessari alla ScatterV SendCount=(int*)calloc(numproc,sizeof(int)); Displs=(int*)calloc(numproc,sizeof(int)); //Il processore 0 inizializza il vettore SendCount for(i=0;i<numproc;i++) SendCount[i]=(int)(dimarray/numproc); if(dimarray%numproc>0) //nel caso in cui il numero di elementi da sommare non è multiplo for(i=0;i<dimarray%numproc;i++) //o sottomultiplo del numero di processori SendCount[i]=SendCount[i]+1; //Il processore 0 inizializza il vettore Displs Displs[0]=0; for(i=1;i<numproc;i++) Displs[i]=Displs[i-1]+SendCount[i-1]; dim=(int)(dimarray/numproc); if(id<(dimarray%numproc)) //nel caso in cui il numero di elementi da sommare non è dim=dim+1; //multiplo o sottomultiplo del numero di processori 20

21 //Istanzio il vettore in cui l'id-esimo processore riceve i numeri che andrà a sommare int* somma=(int*)calloc(dim,sizeof(int)); //Il processore ROOT inizializza i valori del Vettore if(!id){ printf("numero di processori: %d.\n",numproc); printf("dimensione array: %d.\n",dimarray); //Istanzio il vettore che contiene gli elementi da sommare Vettore=(int*)calloc(dimarray,sizeof(int)); for(i=0;i<dimarray;i++) Vettore[i]=1; //Il vettore sarà riempito da una costante unitaria //CALCOLO SU PIU PROCESSORI //Mediante la funzione ScatterV, ad ogni processore vengono distribuiti gli elementi da sommare //Avendo usato tale funzione, il numero di elementi può variare da processore a processore MPI_Scatterv(Vettore,SendCount,Displs,MPI_INT,somma,dim,MPI_INT,ROOT,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); //aspettiamo che tutti abbiano ricevuto gli elementi da sommare //Inizio valutazione dei tempi if(!id) tin=mpi_wtime(); //restituisce in tin il tempo a partire dall'istante immediantemente precedente //l'inizio del calcolo della somma //Ogni processore effettua il calcolo for(i=0;i<dim;i++) temp=temp+somma[i]; //La funzione Reduce effettua la riunione dei risultati calcolati da ogni processore, calcolando la somma totale. //Per farlo utilizzerà la strategia I o la II a seconda di quanti siano i processori richiesti. //Il risultato complessivo verrà passato al processore ROOT nella variabile sommatotale MPI_Reduce(&temp,&sommatotale,1,MPI_INT,MPI_SUM,ROOT,MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); //attendiamo che tutti i processori abbiano inviato le somme parziali if(!id){ tfin=mpi_wtime(); //restituisce in tfin il tempo a partire dall'istante immediantemente successivo // alla fine del calcolo della somma tempotot=1.e6*(tfin-tin); //il tempo impiegato viene calcolato come differenza di intervalli printf("tempo totale impiegato: %f.\n",tempotot); printf("algoritmo PARALLELO\n"); printf("somma su %d processori: %d.\n",numproc,sommatotale); //Deallocazione delle variabili dinamiche istanziate all'interno del programma. free(vettore); free(somma); free(sendcount); free(displs); MPI_Finalize(); return 0; 21