Somma di un array di N numeri in MPI

Transcript

1 Facoltà di Ingegneria Corso di Studi in Ingegneria Informatica Esercitazione di Calcolo Parallelo Somma di un array di N numeri in MPI Anno Accademico 2010/2011 Prof.ssa Alessandra D'alessio Candidati Mario Buonomo Lorenzo Carullo Luigi De Simone

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

3 Elenco delle figure 2.1 Disegno II Strategia Situazione d errore Grafico Tempi Grafico Speed Up Grafico Efficienza Esempio d uso ii

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

5 Capitolo 1 Descrizione del problema Sviluppare un algoritmo per il calcolo della somma di N numeri in ambiente di calcolo parallelo su architettura MIMD a memoria distribuita, che utilizzi la libreria MPI. Per la comunicazione dei risultati finali, tale algoritmo utilizzerà la 2 a strategia, la quale prevede che, al termine della computazione, il risultato finale sia presente in un unico processore prestabilito. 1

6 Capitolo 2 Descrizione Algoritmo 2.1 Descrizione La nostra implementazione dell algoritmo è basata sulla seconda strategia. In essa ogni processore calcola la sua somma parziale si e poi a coppie distinte i processori comunicano tra di loro le somme calcolate, cioè un processore invia all altro la sua somma parziale. Il risultato finale ovviamente è nel processo Master (cioè p0). Ad esempio, supponendo di avere a disposizione p = 4 processori, l applicazione della seconda strategia può essere schematizzata nel modo seguente: 2

7 Figura 2.1: Disegno II Strategia Come si può notare, nel primo passo i processori P1 e P3 inviano le loro somme parziali rispettivamente a P0 e a P2. Nel secondo passo invece, sarà soltanto il processore P0 che avrà il risultato finale. Rispetto alla prima strategia, questo algoritmo ha sicuramente il vantaggio di dimezzare i passi temporali per giungere al risultato e di fare in modo che, in ciascun passo, coppie distinte di processori operino concorrentemente. Tuttavia, l indubbio svantaggio è quello di avere uno sbilanciamento nel carico di lavoro dei processori, poiché risulta che ad ogni passo parte dei processori rimane inattiva, e alla fine è attivo soltanto il processore che contiene il risultato. Rispetto alla terza strategia invece, le differenze sono praticamente nulle, tranne per il fatto che, alla fine, nella terza strategia il risultato si trova in tutti i processori. La nostra implementazione funziona così: Calcoliamo la dimensione dei chunk dell array da inviare, cioè il numero di elementi da distribuire a ciascun processore; 3

8 Tramite la funzione MPI_Scatter inviamo dal Master a tutti gli altri processori questi pezzi dell array ( e il master detiene i primi chunk elementi dell array); Dopo aver ricevuto gli elementi, calcoliamo le somme parziali (in ciascun processore) tramite la funzione update; Infine, ad ogni passo e per ogni coppia di processori, inviamo la somma parziale al processore precedente, il quale la unisce questa somma ricevuta a quella già in suo possesso, e poi si ripete il tutto ciclicamente, dimezzando ad ogni passo i processori e fin quando non rimarrà so il processore p0 il quale conterrà la somma finale. Ovviamente nella fase di calcolo, tutti i processori del comunicatore vengono sincronizzati con una chiamata a MPI_Barrier. 2.2 Input, output, errori e subroutine L input dell algoritmo è un array di interi di dimensione pari a un multiplo del numero di cpu, le quali devono essere multiplo di 2 n (altrimenti non potremmo dimezzare le cpu ad ogni passo). Queste due condizioni sono garantite da due if iniziali nel codice. In output a video, il programma mostrearà tre cose: il calcolo della somma effettuato in maniera sequenziale; lo stesso calcolo effettuato in parallelo per confrontare la bontà del risultato; 4

9 Il tempo d esecuzione dell algoritmo in parallelo. Una possibile situazione d errore si verifica quando lanciamo il programma su un numero di CPU che non è un multiplo di 2 n : Figura 2.2: Situazione d errore Nella nostra implementazione usiamo due procedure di appoggio: update, int update(int *data,int chunk, int myid) che mi calcola la somma parziale; prende come input l array, il numero di elementi dell array, e l identificativo del processore; log2, double log2(double n) che mi calcola il logaritmo (necessario per individuare lo step e a chi processore inviare la somma parziale); 5

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

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

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

13 Grafico Figura 3.1: Grafico Tempi Come si può vedere dal grafico, per un determinato numero di processori si risulta un peggioramento dei tempi d esecuzione, semplicemente perchè aumenta il numero di processori che resta inattivo, quindi non migliora sempre la situazione all aumentare del numero di processori, al contrario di quanto intuitivamente ci si aspetta. 9

14 3.2.2 Speed Up Tabella Speed-Up N = 1024 N = 5120 N = N = Tabella 3.2: Tabella Speed Up Grafico Figura 3.2: Grafico Speed Up 10

15 3.2.3 Efficienza Tabella Efficienza N = 1024 N = 5120 N = N = Tabella 3.3: Tabella Efficienza Grafico Figura 3.3: Grafico Efficienza 11

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

17 Murli: ed ecco il codice in C, implementando l algoritmo presente nel testo di / ========================================================================= Name : esercitazione 6 di calcolo parallelo Author : Mario Buonomo, Lorenzo Carullo, Luigi De Simone Copyright : Your copyright notice Description : Calculate sum of an array of n elements, using p processors (2nd strategy ) ========================================================================= / #include "mpi. h" #include <s t d i o. h> #include <s t d l i b. h> #include <time. h> #include <math. h> #define ARRAYSIZE #define MASTER 0 int main ( int argc, char argv [ ] ) { int numtasks, t a s k i d, i, q, k, chunksize, tag =0,mysum=0,sum=0, s t e p ; int update ( int data, int chunk, int myid ) ; double l o g 2 ( double n ) ; int data, r_data ; double check, t0, t f i n e, te, tmax ; MPI_Status s t a t u s ; / I n i z i a l i z z a z i o n e / MPI_Init(& argc, &argv ) ; / Numero Tasks / MPI_Comm_size(MPI_COMM_WORLD, &numtasks ) ; / Individuazione ranks / 13

18 MPI_Comm_rank(MPI_COMM_WORLD,& t a s k i d ) ; / Controlli / check = pow ( 2, ( double ) ( numtasks ) ) ; i f ( ( int ) check % numtasks!=0) { p r i n t f ( "ERROR: The number of CPU must be multiple of 2^n" ) ; MPI_Abort(MPI_COMM_WORLD, 1) ; else i f (ARRAYSIZE%numtasks!=0) { p r i n t f ( "ERROR: s ize array must be a multiple of the number of CPU" ) ; MPI_Abort(MPI_COMM_WORLD, 1) ; else { / Creazione chunks / c h u n k s i z e = (ARRAYSIZE / numtasks ) ; data = ( int ) malloc ( s i z e o f ( int ) ARRAYSIZE) ; r_data = ( int ) malloc ( s i z e o f ( int ) c h u n k s i z e ) ; / Master / i f ( t a s k i d == MASTER) { / Creazione array e calcolo somma i n i z i a l e / srand ( time (NULL) ) ; // printf ("\narray GENERATED\n") ; for ( i =0; i <ARRAYSIZE; i ++) { data [ i ]=( int ) ( rand ( ) %1000) ; // printf("%d ", data [ i ] ) ; sum = sum + data [ i ] ; p r i n t f ( "\n \nsequential array sum = %d \n",sum) ; // printf ("\n Sent %d elements to every tasks \n", chunksize ) ; sum=0; / Invio e Ricezione chunk dal master / 14

19 MPI_Scatter ( data, chunksize, MPI_INT, r_data, chunksize, MPI_INT,MASTER,MPI_COMM_WORLD) ; / I n i z i a l i z z a z i o n e Tempi / t0 = MPI_Wtime ( ) ; / Calcolo Somma parziale / sum = update ( r_data, chunksize, t a s k i d ) ; // printf ("\ncpu: %d somma parziale : %d\n", taskid,sum) ; / Calcolo a quale step stiamo / s t e p = ( int ) l o g 2 ( numtasks ) ; / Invio e ricezione delle somme p a r z i a l i ai r i s p e t t i v i vettori / for ( k=1; k<=s t e p ; k++){ q = ( int ) pow ( 2. 0, ( double ) k 1) ; for ( i=q ; i<=numtasks q ; i=i +(int )pow ( ( double ) 2, ( double ) k ) ) { i f ( t a s k i d == i ) { MPI_Send(&sum, 1, MPI_INT, ( i q ), tag, MPI_COMM_WORLD) ; // printf ("\n CPU: %d > CPU: %d\n", i, i q) ; MPI_Barrier (MPI_COMM_WORLD) ; for ( i =0; i <numtasks q ; i = i + ( int ) pow ( 2. 0, ( double ) k ) ) { i f ( t a s k i d == i ) { MPI_Recv(&mysum, 1, MPI_INT, ( i+q ), tag,mpi_comm_world,& s t a t u s ) ; // printf ("\n CPU: %d < CPU: %d\n", i, i+q) ; sum = sum + mysum ; // printf ("\ncpu : %d sum= %d mysum= %d\n", i,sum, mysum) ; / Fine Tempi / 15

20 t f i n e = 1. 6 e (MPI_Wtime ( ) t0 ) ; f r e e ( data ) ; f r e e ( r_data ) ; MPI_Reduce(& t f i n e,&tmax, 1,MPI_DOUBLE,MPI_MAX, 0,MPI_COMM_WORLD) ; i f ( t a s k i d ==0){ p r i n t f ( "\ nparallel array sum = %d\n",sum) ; p r i n t f ( "\ntempo d esecuzione : %f usecondi\n\n", tmax ) ; MPI_Finalize ( ) ; / end of main / / Funzione calcolo somma / int update ( int data, int chunk, int myid ) { int i, mysum ; mysum = 0 ; for ( i =0; i < chunk ; i ++) { mysum = mysum + data [ i ] ; // printf ("\n Task %d mysum = %d \n",myid,mysum) ; return (mysum) ; / Funzione calcolo logaritmo / double l o g 2 ( double n ) { double r = ( l o g ( n ) / l o g ( 2. 0 ) ) ; return r ; implementazione dell algoritmo in C 16

21 Bibliografia Gnuplot. Gnuplot. URL: Almerico Murli. Lezioni di Calcolo Parallelo. Liguori Editore. 17