Algoritmo per il calcolo della somma di N numeri In ambiente di calcolo parallelo su architettura MIMD a memoria distribuita

Transcript

1 Algoritmo per il calcolo della somma di N numeri In ambiente di calcolo parallelo su architettura MIMD a memoria distribuita Carlo Maurizio Santoro Attività di laboratorio Università Parthenope - Corso di Calcolo Parallelo Aprile 2007 Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 1

2

3 Primo approccio Accentrare il carico di management dei risultati parziali su un solo processore Il carico di lavoro è distribuito, ma il carico di gestione è centralizzato Analisi del problema L algoritmo parallelo da sviluppare vrà ricevere in input N dati da sommare e restituire in output la somma degli N valori. Per applicare questa strategia sarà necessario distribuire sui vari processori in maniera paritaria l intera mole di lavoro, san inizialmente gli N dati di partenza ed in fine raccogliere i risultati. Descrizione generale dell algoritmo Ogni processore, po aver ricevuto i dati da sommare che potrebbero essere forniti tramite varie modalità, effettua la suddetta operazione matematica tramite un ciclo iterativo enumerativo ed accumula il risultato in una variabile locale al processo. L ultimo passaggio che deve compiere ogni computing process è inviare il proprio risultato parziale al processore scelto come no di gestione. Altresì, il processore di coordinazione, oltre ad eseguire le istruzioni basilari prima descritte deve effettuare un numero di procedure di ricezione degli altri risultati parziali, pari al numero di processori restanti. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 2

4 Grafici dei Tempi, dello speed-up e dell efficienza Consideran i seguenti dati di benchmark ricavati in mo induttivo - sperimentale tramite la combinazione dello script bash con lo script gnu plot e consideran una mole di dati in input pari a 10 3 : P T(p) T(ideale) SpeedUp(p) Efficienza Il primo grafico presentato è ottenuto misuran i tempi dell algoritmo nel caso peggiore, che nella prima strategia è sempre associato al processore che svolge l operazione di aggregazione dei risultati. L asse Y è stata adattata ad una scala logaritmica per consentire la visualizzazione normalizzata delle due curve che altrimenti sarebbero state graficate come dissimili, in particolare quella con ordine di grandezza superiore sarebbe risultata molto pendente verso il basso, altresì la curva che rappresenta la dimensione computazionale minore sarebbe stata assimilabile ad una retta. 10 Grafico dei tempi - Prima strategia 10 4 Dati Ideale 10 3 Dati Ideale Tempo (sec) in log Numero di Processori Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 3

5 Entrambe le curve risultano minare i valori ideali, calcolati a partire da p=2 ed attendensi un riduzione della complessità di tempo in base al numero di processori; è da osservare che la flessione delle due traiettorie ideali è da imputarsi esclusivamente alla scala logaritmica senza la quale i valori ideali sarebbero risultati giacenti su una linea retta, come osservabile tramite i valori della tabella prima scritta. Verrà soffermata l attenzione sull algoritmo avviato con 10 3 dati, rappresentato dalla curva in blu nel grafico dei tempi. Si può direttamente constatare l anomalia del tempo dell algoritmo eseguito su 6 processori, tale tempo risulta fuori traiettoria ideale della curva, con molta probabilità è imputabile ad un sovraccarico temporaneo della struttura di calcolatori a disposizione. Risulta palese osservare come tale anomalia influisca sulle curve dello speed up e dell efficienza e sia verificata esclusivamente in corrispondenza di 6 processori, ciò è da addurre alle formule di calcolo che dipenno strettamente da T p da che, nel caso sia falsato si ripercuote su tali dati Dati Ideale Dati Ideale Lo speed up ideale, rappresentato dalla retta bisettrice dal colore chiaro, segue ed è approssimato fedelmente dalla curva dello speed up reale, discostansi tal volta per difetto o per eccesso, facen esclusione del caso numero 6. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 4

6 Secon approccio Decentrare il carico di management dei risultati parziali su più processori Il carico di lavoro è distribuito, il carico di gestione è parzialmente distribuito Descrizione generale dell algoritmo Per aggregare i risultati parziali vrà essere generato un albero binario in cui la base è rappresentata dalle somme parziali che ogni no ha calcolato, ogni no dell albero corrisponde ad un invio e ricezione tra i due genitori, dei quali esclusivamente uno calcolerà la somma parziale e continuerà le elaborazioni nella fase successiva. Per applicare questa strategia sarà necessario disporre di un numero di processori pari ad una potenza di 2, tale limitazione vrà essere prevista nell algoritmo. Il carico di gestione risulta parzialmente distribuito perché non tutti i processori proseguono le elaborazioni ad ogni passo temporale, difatti al termine dell algoritmo esclusivamente il no accentratore sarà possessore del risultato. Per identificare i processori addetti alle comunicazioni ci si baserà sul identificativo del processore nel comunicatore, calcolan il resto della moltiplicazione con la potenza di 2 relativa al passo temporale. E importante notare che ad ogni passo temporale, all interno delle coppie formate per la comunicazione, solo un processore effettuerà la somma ed andrà avanti nel prossimo passaggio iterativo. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 5

7 Grafici dei Tempi, dello speed-up e dell efficienza Si osserva che, i tempi misurati risultano essere esatti nelle prime due cifre ed hanno una buona approssimazione anche sulla terza cifra decimale, ciò è direttamente riscontrabile anche dal grafico, ve entrambe le curve risultano sovrapposte alle traiettorie ideali. Algoritmo eseguito su 10 3 dati P T(p) T(ideale) SpeedUp(p) Efficienza Lo speed up e l efficienza nel primo test minano sempre i valori ideali, anche se lo scarto è di un ordine di grandezza di piccole dimensioni, tali da non essere scindibili nel grafico ve le curve risultano sovrapposte. Algoritmo eseguito su 10 4 dati P T(p) T(ideale) SpeedUp(p) Efficienza Grafico dei tempi - Seconda strategia 10 4 Dati Ideale 10 3 Dati Ideale Tempo (sec) in log Numero di Processori Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 6

8 Grafico dello Speed Up - Seconda Strategia Dati Ideale Numero di Processori Si nota chiaramente che la retta dell efficienza mina di poco quella ideale, tale scarto è tale da provocare una lieve tangenza. 1.4 Grafico Efficienza - Seconda strategia 10 3 Dati Ideale Numero di Processori Si potrebbe esprimere un giudizio sull algoritmo complessivamente positivo. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 7

9 Terzo approccio Distribuire il carico di management dei risultati parziali su tutti i processori Il carico di lavoro ed il carico di gestione sono distribuiti Descrizione generale dell algoritmo Questa strategia si differenzia dalle precedenti perché tutti i processori eseguono somme ad ogni passo temporale, al termine dell algoritmo ogni processore possederà la somma totale. Per implementare questo algoritmo è necessario individuare le coppie che vranno scambiarsi i risultati parziali ed effettuare le somme, si procederà come nella seconda strategia basansi sulle potenze di 2 relative al passo temporale i-simo. Grafici dei Tempi, dello speed-up e dell efficienza Algoritmo eseguito su 10 3 dati P T(p) T(ideale) SpeedUp(p) Efficienza Algoritmo eseguito su 10 4 dati P T(p) T(ideale) SpeedUp(p) Efficienza Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 8

10 Tempo (sec) in log 10 1 Grafico dei tempi - Terza strategia 10 4 Dati Ideale 10 3 Dati Ideale Si osserva la precisione di tutti i tempi misurati ed in particolare con un carico di lavoro di 10 3 dati su 4 processori, ve risulta avvicinarsi alla cifra ideale per addirittura 6 cifre Numero di Processori 1.4 Grafico Efficienza - Terza strategia 10 3 Dati Ideale 9 8 Grafico dello Speed Up - Terza Strategia 10 3 Dati Ideale Numero di Processori Nanosleep Numero di Processori Tutti i grafici presentati sono stati ottenuti forzan ogni somma con la funzione nanosleep, provocan un overhead ad ogni somma, che anche se minimo aiuta a far prescindere la valutazione dell algoritmo dal carico attuale del cluster. La funzione è stata studiata in maniera da accumulare nanosecondi ogni somma, pari a 1 millisecon che equivale a 10-3 secondi, in pratica ogni mille somme viene accumulato un secon di overhead. Non attan questa strategia si sarebbero ottenuti grafici strettamente dipendenti dal momento in cui si sia lanciato l algoritmo, ottenen risultati come il seguente Tempo (sec) in log Grafico dei tempi - Seconda strategia Numero di Processori 10 4 Dati Ideale 10 3 Dati Ideale Si nota come all aumentare del numero di processori, cresca anche il tempo di esecuzione, ciò è imputabile sia al carico del cluster sia alla complessità di tempo delle procedure MPI che mina la complessità dell algoritmo. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 9

11 Analisi del software sviluppato Il software protto è stato articolato in un programma in linguaggio C che utilizza le librerie mpi, uno script unix bash ed uno script gnu plot. Programma C Il sorgente è stato articolato in 5 funzioni principali che sono richiamate in mo sequenziale all interno della funzione main. Il programma può essere eseguito con varie modalità agen sui parametri, la prima riguarda la strategia da attare che è variabile tramite il parametro -str, sono disponibili le 3 precedentemente descritte; per verificare l attendibilità di tutte le modalità è stata implementata una quarta strategia che ha il compito di calcolare i risultati delle somme totali seguen tutte le vie a disposizione e confrontare i risultati ottenuti. I Grafici relativi alla dimensione computazionale di 10 3 sono stati ottenuti eseguen il programma in modalità benchmark con l opzione -b 3. void init_environment( int argc, char *argv[]) E la prima funzione richiamata, essa effettua un controllo sui parametri di input ed inizializza l ambiente MPI restituen l' identificativo di ogni processore nell ambiente del comunicatore principale. void step1() Questa procedura si occupa di generare e distribuire su tutti i processori una mole di dati in input ranm pari ad una potenza di 10 specificata come parametro di -b oppure di acquisire dati dallo standard input se eseguito con l opzione -b 0. int step1() Consiste nel cuore dell algoritmo, viene eseguita indipendentemente dalla strategia attata, effettua le vere e proprie somme locali ad ogni processore, ritornan come variabile di uscita la somma calcolata. int str_n_step3(int PartialSum ) Sono state sviluppate 3 funzioni con N = 1,2, 3 che applicano le strategie prima descritte, la funzione prende in input il risultato parziale di ogni processore e restituisce la somma totale. Nella prima e seconda strategia il risultato è contenuto solo nel processore root che potrà effettuare la stampa del valore ritornato da tale funzione. Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 10

12 /Users/alanturing2/Desktop/somma_parallela.c //================================================= file=somma_parallela.c ===== //= Titolo : //= Three stategy approaches for parallel sum 1.0 build=52 //============================================================================== //= Note: = //= 1) Questo programma e' stato compilato su Cluster Linux usan MPIch = //= 2) E' stato sviluppato uno script bash che automatizza i test = //= per eseguirlo e' necessario GNUplot = //= = //= Parametri : = //= Benchmark = //= -b 0 Attiva un input manuale dallo STD_INPUT = //= -b <k> Attiva un input ranm = //= generan una dimensione computazionale pari a 10^k = //= e visualizzan sullo STD_OUTPUT il tempo impiegato = //= = //= Strategia = //= -str <k> Attiva la strategia k con k = 1,2,3 = //= = //= Controllo di consistenza = //= -str 4 Attiva il programma eseguen tutte le strategie = //= computan gli stessi dati in input = //= e controllan l'uguaglianza dei 3 risultati = //= = //= Esempio di esecuzione = //= = //= mpirun -np 8 -machinefile lista somma_parallela -b 3 -str 4 = //= esegue su 8 processori usan : un input Ranm = //= visualizzan il tempo = //= usa la terza strategia = //= = //= Compilazione: mpicc somma_parallela.c -o somma_parallela = //= = //= Fine alla prova di medio corso di Calcolo Parallelo e Distribuito = //= Prof. A. Murli = //= = //= Autore: Carlo Maurizio Santoro = //= Universita' Parthenope, Informatica Generale, Napoli = //= WWW: = //= alanturing2@hotmail.com = //= Perio di sviluppo: 13 Aprile - Maggio 2007 = //= Ultima revisione : 3 Maggio :00 = //= = Printed: 07/05/07 20:29 Page 1

13 /Users/alanturing2/Desktop/somma_parallela.c #include <stdio.h> #include <mpi.h> #include <math.h> #include <stdlib.h> #include <time.h> // Useful bitwise function int log_2(int n); int is_pow_2(int n); // start - end environment void erroreinput(char **argv); void init_environment( int argc, char *argv[]); void end_environment(void); void step1(void); int step2(void); int str_1_step3( int PartialSum ); int str_2_step3( int PartialSum ); int str_3_step3( int PartialSum ); //Global var int myrank; int clustersize; int n; int nloc; // My Processor ID from MPI_Comm_Rank() // Size of cluster from MPI_Comm_Size() // number of elements to add // Size of sub_array int * VettLoc; int * RecvSumVett; //Input Var int Benchmark = 0 ; int Strategy = 0 ; // Dinamic Sub-Array containing the elements to add // Dinamic Array contain the recived sum // Define if Benchmark is on // Computing strategy Printed: 07/05/07 20:29 Page 2

14 /Users/alanturing2/Desktop/somma_parallela.c int main ( int argc, char *argv[]) // Benchmark variable uble starttime; uble endtime; int PartialSum ; int FinalSum ; // initialize the computational size and input parameter init_environment(argc,argv); // Barrier for wtime MPI_Barrier(MPI_COMM_WORLD); //Wtime start if (myrank == 0 && Benchmark == 1) starttime = MPI_Wtime(); // Ranm number, creation and distribution step1(); // SubTotal sum and aggregation PartialSum = step2(); // Final total sum and output if (Strategy == 1) FinalSum = str_1_step3(partialsum); else if (Strategy == 2) FinalSum = str_2_step3(partialsum); else if (Strategy == 3) FinalSum = str_3_step3(partialsum); else if (Strategy == 4) int return1; int return2; int return3; Printed: 07/05/07 20:29 Page 3

15 /Users/alanturing2/Desktop/somma_parallela.c return1 = str_1_step3(partialsum); return2 = str_2_step3(partialsum); return3 = str_3_step3(partialsum); if (myrank==0) printf ("strategy 1 = %d\n", return1 ); printf ("strategy 2 = %d\n", return2 ); printf ("strategy 3 = %d\n", return3 ); else // Strategy is not 1,2,3 or 4 fprintf(stderr,"error : Strategy must be : \n"); MPI_Abort( MPI_COMM_WORLD, 1 ); // Barrier for wtime MPI_Barrier(MPI_COMM_WORLD); // Output result if ( myrank == 0 ) if (Benchmark == 1) endtime = MPI_Wtime(); // Output formatting for TAB if ( (endtime-starttime) >= 10 ) printf("%d\t%8.6f\n",clustersize,endtime-starttime); else printf("%d\t%8.7f\n",clustersize,endtime-starttime); else if (Benchmark == 0) printf("final Sum = %d\n",finalsum); end_environment(); Printed: 07/05/07 20:29 Page 4

16 /Users/alanturing2/Desktop/somma_parallela.c //Visualizza il messaggio di errore se si passano parametri errati void erroreinput(char **argv) printf("errore : Sintassi errata\n"); printf("uso: %s [-b] [dimensione computazionale in potenza di 10] [-st] [Numero di strategia]\n",argv[0]); printf("usare l'opzione -b per attivare i benchmark generan un input automatico ranm\n"); printf("generan una dimensione computazionale pari a 10 elevato alla potenza inserita"); printf("non usan opzioni si attiver! un input manuale\n"); printf("%s -b 5 -str 2 #genera un input rann con dimensione computazionale 10^5 applican la seconda strategia\n"); printf("%s #avvia il programma con input manuale\n"); return; // produces logarithm in base 2 of n using bitwise operation int log_2(int n) int i=0; int result; int mask=1; result =n; if( (mask & result) == 1 ) return i; i++; result = result >> 1; while(i<=31); // Gli int sono al massimo 32 bit // finds if n is -> n = 2^x with 0 < x < 31 int is_pow_2(int n) int mask = 1; if( mask == n) return 1; mask = mask << 1; while(mask<= n); //Se non! stata trovata nessuna maschera valida return 0 ; Printed: 07/05/07 20:29 Page 5

17 /Users/alanturing2/Desktop/somma_parallela.c void init_environment( int argc, char *argv[]) int i; // For Variable int potenza; // input exp // Init. the MPI env. MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &myrank); MPI_Comm_size (MPI_COMM_WORLD, &clustersize); // starts MPI env. // get current process id // get number of processor // Check INPUT //Numero Parametri if ( (argc!= 5) && (argc!= 1) ) fprintf(stderr,"error : Incorrect Parameters \n"); erroreinput(argv); MPI_Abort( MPI_COMM_WORLD, 1 ); // Set the correct input variable if (argc == 5) // -b setting if (strcmp(argv[1],"-b")==0) Benchmark = 1; else Benchmark = 0 ; potenza = atoi(argv[2]); // -str setting if ( strcmp(argv[3],"-str") == 0 ) Strategy = atoi(argv[4]) ; else Strategy = atoi(argv[4]) ; if ( (Strategy <= 0) (Strategy >= 5) ) fprintf(stderr,"error : Strategy must be \n"); MPI_Abort( MPI_COMM_WORLD, 1 ); Printed: 07/05/07 20:29 Page 6

18 /Users/alanturing2/Desktop/somma_parallela.c //Init. the seed value srand((unsigned int)time(0)); //input if (myrank==0) if (Benchmark == 0) // Manual Input printf("insert Number of element : "); scanf("%d",&n); else // Ranm input n = pow(10,potenza); // Computational size must be bigger then Cluster Size if (n < clustersize) fprintf(stderr,"error : computational size () must be bigger then Cluster Size () \n",n,clustersize); MPI_Abort( MPI_COMM_WORLD, 1 ); // In the Second and third strategy, // the computational process must be in logaritmic_2 scale if ( (Strategy == 2) (Strategy == 3) ) if ( is_pow_2(clustersize) == 0) fprintf(stderr,"error, Cluster Size must be in logaritmic_2 scale \n"); MPI_Abort( MPI_COMM_WORLD, 1 ); // Broadcast of n MPI_Bcast(&n,1,MPI_INT,0,MPI_COMM_WORLD); // How many number i must sum nloc = n / clustersize; Printed: 07/05/07 20:29 Page 7

19 /Users/alanturing2/Desktop/somma_parallela.c void end_environment(void) MPI_Finalize(); void step1() MPI_Status STAT; int k; int i; int rest; // Stat for MPI_Recv() // For Variable // For Variable // Rest used if n is not pair // Distribute the rest, if n is not pair rest = n % clustersize; if (myrank<rest) nloc++; // Sub-Array allocation if (!(VettLoc = (int *) calloc(nloc,sizeof(int) ) ) ) fprintf(stderr,"error : Calloc error\n"); MPI_Abort( MPI_COMM_WORLD, 1 ); if (myrank==0) // Rank 0 es not know the nloc of other Computing Proc. int RealLoc ; // Delivery loop for (i=1;i<clustersize;i++) // determines the real nloc, because rank 0 // can not look to nloc of other process RealLoc = nloc-1; if (i<rest) RealLoc++; // fills up and send the sub-array for (k=0;k<realloc;k++) if (Benchmark == 0) Printed: 07/05/07 20:29 Page 8

20 /Users/alanturing2/Desktop/somma_parallela.c printf("insert element %d for rank %d : ",k,i); scanf("%d",&vettloc[k]); else //Generate ranm number in range 1-20 VettLoc[k] = (int) (rand()) ; MPI_Send(VettLoc,RealLoc,MPI_INT,i,10,MPI_COMM_WORLD); // fills up the sub-array of rank 0 for (k=0;k<nloc;k++) if (Benchmark == 0) printf("insert element %d for rank 0 : ",k); scanf("%d",&vettloc[k]); else //Generate ranm number in range 1-20 VettLoc[k] = (int) (rand()) ; // Recived Sum Array allocation RecvSumVett = (int *) calloc(clustersize,sizeof(int)); else // My Rank is not 0 // Recive the Sub-array MPI_Recv(VettLoc,nloc,MPI_INT,0,10,MPI_COMM_WORLD,&STAT); Printed: 07/05/07 20:29 Page 9

21 /Users/alanturing2/Desktop/somma_parallela.c int step2(void) int sum =0; int i; struct timespec tv; // Temp sum // For Variable // Construct the timespec from the number of whole seconds... tv.tv_sec = 0; // nanosec = 1 millisec = 10^-3 sec // Ogni mille somme viene accumulato un secon tv.tv_nsec = ; if (Benchmark == 1) // Sum the elements of Sub-Array for (i=0;i<=nloc-1;i++) nanosleep (&tv, NULL); // And sum sum = sum + VettLoc[i]; else // Sum the elements of Sub-Array for (i=0;i<=nloc-1;i++) // And sum sum = sum + VettLoc[i]; return sum ; Printed: 07/05/07 20:29 Page 10

22 // SubTotal Aggregation int str_1_step3( int PartialSum ) /Users/alanturing2/Desktop/somma_parallela.c int i; // For Variable int FinalSum; // Final Sum developed by rank 0 MPI_Status STAT; // Stat for MPI_Recv() // SubTotal Aggregation if (myrank==0) for (i=1;i<=clustersize-1;i++) MPI_Recv( &RecvSumVett[i], 1, MPI_INT, i, i, MPI_COMM_WORLD, &STAT); // Store the Sub-Sum of rank 0 RecvSumVett[0]=PartialSum; else MPI_Send(&PartialSum, 1, MPI_INT, 0, myrank, MPI_COMM_WORLD ); // Rank 0 make the final aggregation of sub-sum to final sum if (myrank==0) FinalSum=0; for (i=0;i<=clustersize-1;i++) FinalSum = FinalSum + RecvSumVett[i]; return FinalSum ; Printed: 07/05/07 20:29 Page 11

23 /Users/alanturing2/Desktop/somma_parallela.c int str_2_step3( int PartialSum ) // Power 2 array int power_2[31]; int mask = 1; int i=0; int RecvSum = 1; int RecvSumTmp = 0; MPI_Status STAT; // Stat for MPI_Recv() power_2[i] = mask; mask = mask << 1; i++; while(i <= 29); //int = 32 bit (-3) RecvSum = PartialSum ; for ( i=1 ; i <= log_2( clustersize ) ; i++) if ( (myrank % power_2[i]) == 0 ) MPI_Recv(&RecvSumTmp,1,MPI_INT, (myrank + power_2[i-1]),i,mpi_comm_world,&stat); RecvSum = RecvSum + RecvSumTmp ; else if ( (myrank % power_2[i-1]) == 0 ) MPI_Send(&RecvSum, 1, MPI_INT, (myrank - power_2[i-1]), i, MPI_COMM_WORLD ); else // Stop the for, is not a computing proc. break ; // End for return RecvSum ; Printed: 07/05/07 20:29 Page 12

24 /Users/alanturing2/Desktop/somma_parallela.c int str_3_step3(int PartialSum ) // Power 2 array int power_2[31]; int mask = 1; int i=0; int MySum = 0; int RecvSum = 0; MPI_Status STAT; // Stat for MPI_Recv() power_2[i] = mask; mask = mask << 1; i++; while(i <= 29); //int = 32 bit MySum = PartialSum ; for ( i=1 ; i <= log_2( clustersize ) ; i++) if ( (myrank % power_2[i]) < (power_2[i-1]) ) MPI_Recv( &RecvSum, 1, MPI_INT, (myrank + power_2[i-1]), i, MPI_COMM_WORLD, &STAT); MPI_Send( &MySum, 1, MPI_INT, (myrank + power_2[i-1]), i, MPI_COMM_WORLD ); MySum = MySum + RecvSum ; else MPI_Send( &MySum, 1, MPI_INT, (myrank - power_2[i-1]), i, MPI_COMM_WORLD ); MPI_Recv( &RecvSum, 1, MPI_INT, (myrank - power_2[i-1]), i, MPI_COMM_WORLD, &STAT); MySum = MySum + RecvSum ; // End for return MySum; Printed: 07/05/07 20:29 Page 13

25 Script Bash Il seguente script implementato ha il compito di automatizzare i test di esecuzione richiaman il sorgente e lo script gnuplot produce in output File : Tempi.dat contenente tutti i tempi dei vari test con le descrizioni sotto forma di tabella con speed up ed efficienza. Directory : Grafici/ contiene tutti i grafici in formato post script, il nome di ogni file si riferisce alla strategia attata e alla dimensione computazionale. Lo script è articolato secon le seguenti fasi : 1. Cancella i file delle precedenti esecuzioni che potrebbero danneggiare l attuale test 2. Compila il sorgente 3. Esegue il sorgente con le 3 strategie, con i processori disponibili e con le varie dimensioni computazionali tramite 3 cicli for innestati che richiamano mpirun. 4. Tramite awk crea le tabelle che affiancano i test eseguiti precendentemente, in particolare calcola : Tempi ideai, Speed-up ed efficienza 5. Dopo aver ottenuto un file con i tempi per ogni caso, richiama lo script gnuplot 6. Raccoglie tutti i tempi generati in un solo file : Tempi.dat 7. Elimina tutti i file non necessari temporanei ed esce Script GNU Plot Tale script si basa sui file temporanei con i tempi creati dallo script bash, po aver impostato l ambiente di esecuzione e di output, in particolare il formato post script, richiama il coman plot sui file dat. Le curve dei tempi sono state ottenute con delle spline interpolanti su tutti i punti, mentre le traiettorie ideali dello speed up e dell efficienza sono state visualizzate come funzioni. I grafici relativi ai tempi, sono stati disegnati impostan sull asse y la scala logaritmica per migliorare la visione delle due diverse dimensioni computazionali, mentre tale scala è stata eliminata degli ultimi due tipo di grafici che considerano una sola curva dei valori e la sua traiettoria ideale Carlo Maurizio Santoro Attività di laboratorio - Somma N numeri! 11

26 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script.sh #!/bin/bash echo " SCRIPT START " # Cleaning old file # Because, they interfere with normal programm running echo "Cleaning DAT FILE : str$i_n$j.dat... " rm -f *.dat echo "Cleaning executable..." rm -f somma_parallela; echo "Compiling source..." mpicc somma_parallela.c -o somma_parallela # Executable launch for each study case for j in # Strategy variable for k in 3 4 # Computational size 10 ^3-10 ^ 4 if [ "$j" -eq "1" ] then # Running Strategy 1 echo " " for (( i = 2 ; i <= 8; i++ )) # for each available proc. echo "Running $j Strategy for $i computing proc on 10^$k " mpirun -np $i -machinefile lista somma_parallela -b $k \ -str $j >> str$j_n$k.dat ne else # Running Strategy 2 or 3 echo " " for i in # Must be in logarithmic scale echo "Running $j Strategy for $i computing proc on 10^$k " mpirun -np $i -machinefile lista somma_parallela -b $k \ -str $j >> str$j_n$k.dat ne fi ne ne Printed: 07/05/07 21:36 Page 1

27 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script.sh # Ideal time comparsion for k in for j in 3 4 rm -f ideale?.dat; if [ "$k" -eq "1" ] then for (( i=2 ; i <= 8 ; i++ )) cat str1_n$j.dat awk ' if ($1 == 2) print $2 ' \ tail -n 1 >> ideale1.dat ne cat ideale1.dat awk ' print $1/NR ' >> ideale2.dat cat ideale2.dat awk ' print NR+1, $0 ' >> ideale3.dat else for i in cat str$k_n$j.dat awk ' if ($1 == 2) print $2 ' \ tail -n 1 >> ideale1.dat ne cat ideale1.dat awk ' if (NR == 1) print 2, $1 \ if (NR == 2) print 4, $1 if (NR == 3) print 8, $1 ' \ >> ideale2.dat cat ideale2.dat awk ' if (NR == 1) print $1, $2 if (NR == 2) \ \ print $1, $2/2 if (NR == 3) print $1, $2/4 ' >> ideale3.dat fi rm -f Ideale_str$k_n$j.dat; mv ideale3.dat Ideale_str$k_n$j.dat rm -f ideale?.dat; ne ne Printed: 07/05/07 21:36 Page 2

28 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script.sh echo " " # SPEED UP TEST # Executable launch for each study case for j in # Strategy variable for k in 3 4 # Computational size 10 ^3-10 ^ 4 #cleaning rm -f speed.dat rm -f speed?.dat echo "Speed Up : Running $j Strategy for 1 computing proc on 10^$k" mpirun -np 1 -machinefile lista somma_parallela -b $k -str $j >> \ speed.dat if [ "$j" -eq "1" ] then # Running Strategy 1 for (( i=2 ; i <= 8 ; i++ )) cat speed.dat awk ' print $2 ' >> speed1.dat ne else # Running Strategy 2 or 3 for i in cat speed.dat awk ' print $2 ' >> speed1.dat ne fi paste str$j_n$k.dat speed1.dat >> speed2.dat cat speed2.dat awk ' print $3/$2 ' >> speed3.dat cat speed3.dat awk 'if ($1 >= 10 ) printf("%8.6f\n",$1) \ if ($1 < 10 ) printf("%8.7f\n",$1 ) ' >> speed4.dat cat Ideale_str$j_n$k.dat awk 'if ($2 >= 10 ) printf("%8.6f\n",$2)\ if ($2 < 10 ) printf("%8.7f\n",$2 ) ' >> speed5.dat paste str$j_n$k.dat speed5.dat speed4.dat >> speed6.dat cat speed6.dat awk ' print $4/$1 ' >> speed7.dat ; echo -e "# P\tT(p)\t\tT(ideale)\tSpeedUp(p)\tEfficienza" \ >> Strategia$j_n$k.dat paste speed6.dat speed7.dat >> Strategia$j_n$k.dat ne ne Printed: 07/05/07 21:36 Page 3

29 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script.sh echo " " # Cleaning and plotting rm -f speed.dat rm -f speed?.dat rm -r -f Grafici mkdir Grafici echo "Cleaning GRAPHIC :... " rm -f *.ps; echo "Plotting... " gnuplot script_plot.gp mv *.ps Grafici/ echo " " #Cleaning rm -f Ideale* rm -f str* # File dat aggregation in one big file and cleaning echo "Cleaning Tempi.dat..." rm -f Tempi.dat; echo "Test effettuati il : " >>Tempi.tmp; date >> Tempi.tmp; echo "" >> Tempi.tmp echo "" >> Tempi.tmp more *.dat >> Tempi.tmp rm -f *.dat; mv Tempi.tmp Tempi.dat echo "Cleaning executable..." rm -f somma_parallela; echo "Cleaning executable.o..." rm -f somma_parallela.o; echo " SCRIPT -- END " Printed: 07/05/07 21:36 Page 4

30 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script_plot.gp set term postscript eps enhanced color solid set autoscale # scale axes automatically unset log # remove any log-scaling unset label # remove any previous labels set xtic auto # set xtics automatically set ytic auto # set ytics automatically set xlabel "Numero di Processori" font "Times-Roman,25" set ylabel "Tempo (sec) in log " font "Times-Roman,30" set xr [1:9] set logscale y set yr [0.2:20] set output "GraficoTempi_str1.ps" set title "Grafico dei tempi - Prima strategia" font "Times-Roman,40" plot "str1_n4.dat" smooth csplines title '10^4 Dati' with lines lw 4 lt 1,\ "str1_n4.dat" notitle with points lw 5 lt 1,\ "Ideale_str1_n4.dat" smooth csplines title 'Ideale' with lines lw 2 lt 2,\ "str1_n3.dat" smooth csplines title '10^3 Dati' with lines lw 4 lt 3,\ "str1_n3.dat" notitle with points lw 5 lt 3,\ "Ideale_str1_n3.dat" smooth csplines title 'Ideale' with lines lw 2 lt 4 set output "GraficoTempi_str2.ps" set title "Grafico dei tempi - Seconda strategia" font "Times-Roman,40" plot "str2_n4.dat" smooth csplines title '10^4 Dati' with lines lw 4 lt 1,\ "str2_n4.dat" notitle with points lw 5 lt 1,\ "Ideale_str2_n4.dat" smooth csplines title 'Ideale' with lines lw 2 lt 2,\ "str2_n3.dat" smooth csplines title '10^3 Dati ' with lines lw 4 lt 3,\ "str2_n3.dat" notitle with points lw 5 lt 3,\ "Ideale_str2_n3.dat" smooth csplines title 'Ideale' with lines lw 2 lt 4 set output "GraficoTempi_str3.ps" set title "Grafico dei tempi - Terza strategia" font "Times-Roman,40" plot "str3_n4.dat" smooth csplines title '10^4 Dati' with lines lw 4 lt 1,\ "str3_n4.dat" notitle with points lw 5 lt 1,\ "Ideale_str3_n4.dat" smooth csplines title 'Ideale' with lines lw 2 lt 2,\ "str3_n3.dat" smooth csplines title '10^3 Dati ' with lines lw 4 lt 3,\ "str3_n3.dat" notitle with points lw 5 lt 3,\ "Ideale_str3_n3.dat" smooth csplines title 'Ideale' with lines lw 2 lt 4 unset log # remove any log-scaling Printed: 07/05/07 21:43 Page 1

31 /Volumes/EsternoMac/Universita/Calcolo Parallelo/Esercizi/Somma/Codice/script_plot.gp set yr [1:9] set ylabel "Tempo (sec) " font "Times-Roman,30" set output "GraficoSpeedUp_str1.ps" set title "Grafico dello Speed Up - Prima strategia" font "Times-Roman,40" plot "Strategia1_n3.dat" using 1:4 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia1_n3.dat" using 1:4 notitle with points lw 5 lt 1,\ "Strategia1_n3.dat" using 1:1 smooth csplines title 'Ideale' with lines lw 2 lt 3 set output "GraficoSpeedUp_str2.ps" set title "Grafico dello Speed Up - Seconda Strategia" font "Times-Roman,40" plot "Strategia2_n3.dat" using 1:4 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia2_n3.dat" using 1:4 notitle with points lw 5 lt 1,\ "Strategia2_n3.dat" using 1:1 smooth csplines title 'Ideale' with lines lw 2 lt 3 set output "GraficoSpeedUp_str3.ps" set title "Grafico dello Speed Up - Terza Strategia" font "Times-Roman,40" plot "Strategia3_n3.dat" using 1:4 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia3_n3.dat" using 1:4 notitle with points lw 5 lt 1,\ "Strategia3_n3.dat" using 1:1 smooth csplines title 'Ideale' with lines lw 2 lt 3 set yr [0.5:1.5] set output "GraficoEfficienza_str1.ps" set title "Grafico Efficienza - Prima strategia" font "Times-Roman,40" plot "Strategia1_n3.dat" using 1:5 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia1_n3.dat" using 1:5 notitle with points lw 5 lt 1,\ 1 title 'Ideale' with lines lw 2 lt 3 set output "GraficoEfficienza_str2.ps" set title "Grafico Efficienza - Seconda strategia" font "Times-Roman,40" plot "Strategia2_n3.dat" using 1:5 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia2_n3.dat" using 1:5 notitle with points lw 5 lt 1,\ 1 title 'Ideale' with lines lw 2 lt 3 set output "GraficoEfficienza_str3.ps" set title "Grafico Efficienza - Terza strategia" font "Times-Roman,40" plot "Strategia3_n3.dat" using 1:5 smooth csplines title '10^3 Dati' with lines lw 8 lt 1,\ "Strategia3_n3.dat" using 1:5 notitle with points lw 5 lt 1,\ 1 title 'Ideale' with lines lw 2 lt 3 Printed: 07/05/07 21:43 Page 2