Algoritmi paralleli per la moltiplicazione di matrici

Transcript

1 UNIVERSITA CA FOSCARI VENEZIA Facoltà di Scienze Matematiche, Fisiche e Naturali Corso di Laurea in Informatica Progetto di Calcolo Parallelo Prof. S. Orlando Algoritmi paralleli per la moltiplicazione di matrici Anno Accademico Franzin Alberto Mat Savian Dario Mat Marchetto Giovanni Mat

2 INTRODUZIONE... 4 IMPLEMENTAZIONE... 5 MATRIX-MATRIX MULTIPLICATION... 5 Funzionamento... 5 [master] Lettura e partizionamento matrici A e B... 6 [master] Spedizione sottoblocchi ai processi... 7 [master e slave] Ricezione dei sottoblocchi... 8 [master e slave] Scambio blocchi mancanti tra processi... 9 [master e slave] Moltiplicazione sottoblocchi (calcolo sottoblocco della matrice C)... 1 [master e slave] Spedizione blocco calcolato al master [master] Raccolta di tutti i blocchi e creazione della matrice C CANNON ALGORITHM Funzionamento [master] Lettura e partizionamento matrici A e B [master] Allineamento delle matrici A e B [master] Spedizione sottoblocchi ai processi [master e slave] Ricezione dei sottoblocchi... 2 [master e slave] Rotazione sottoblocchi e calcolo blocco della matrice C... 2 [master e slave] Spedizione blocco calcolato al master [master] Raccolta di tutti i blocchi e creazione della matrice C ALGORITMI SEQUENZIALI PER LA MOLTIPLICAZIONE DELLE MATRICI ALGORITMO NORMALMENTE UTILIZZATO Algoritmo di Strassen TEST PROGETTO PRINCIPALI GRAFICI REALIZZATI CON RELATIVI COMMENTI COMMENTO GRAFICI NUMERO PROCESSI VS. TEMPO Matrice Matrice COMMENTO GRAFICI RITARDO VS. TEMPO Numero processi Numero processi GRAFICI DIMENSIONE MATRICE TEMPO Funzione di rallentamento disattivata Funzione di rallentamento attivata GRAFICI DIMENSIONE NUMERO PROCESSORI SPEEDUP Matrice Matrice MATRICE GRAFICI DIMENSIONE NUMERO PROCESSORI EFFICIENZA Matrice Matrice MATRICE VALUTAZIONE BILANCIAMENTO Matrice Matrice CARATTERISTICHE DEL SISTEMA ELENCO FILE PROGETTO RAPPRESENTAZIONE MATRICE FUNZIONI DI UTILITÀ IMPLEMENTAZIONE DELLA FUNZIONE F DI RALLENTAMENTO MANUALE D USO COMPILAZIONE ATTRAVERSO MAKEFILE MODIFICA HEADER DEI FILE UTILIZZO... 7 DOCUMENTAZIONE DELLE MISURE DELLE PRESTAZIONI

3 PRIMITIVE MPI PRIMITIVE GESTIONE AMBIENTE MPI MPI_Init( ) MPI_Comm_size MPI_Comm_rank MPI_Abort MPI_Get_Processor_Name MPI_Wtime MPI_Finalize PRIMITIVE COMUNICAZIONE POINT TO POINT MPI_Send( ) MPI_Recv( ) MPI_Sendrecv_replace COLLETTIVE DI COMUNICAZIONE MPI_Barrier MPI_Bcast MPI_Scatter MPI_Gather MPI_Allgather PRIMITIVE PER LA GESTIONE DEI COMUNICATORI MPI_Comm_Split TIPI PREDEFINITI IN MPI RISULTATI TEST ALGORITMO MATRIX MATRIX ALGORITMO CANNON ALGORITMO PROCESSOR FARM ALGORITMO SEQUENZIALE CONCLUSIONE APPENDICE GRAFICI NUMERO PROCESSORI TEMPO Matrice Matrice Matrice Matrice GRAFICI RITARDO TEMPO Matrice Matrice Matrice Matrice GRAFICI DIMENSIONE MATRICE TEMPO Funzione di rallentamento disattivata Funzione di rallentamento attivata : 5 cicli Funzione di rallentamento attivata : 1 cicli Funzione di rallentamento attivata : 4 cicli... 1 GRAFICI NUMERO PROCESSI SPEEDUP Matrice Matrice Matrice Matrice GRAFICI NUMERO PROCESSORI EFFICIENZA Matrice Matrice Matrice Matrice GRAFICI BILANCIAMENTO DEL CARICO Matrice Matrice

4 Introduzione Il progetto consiste nell implementazione di tre algoritmi paralleli per la moltiplicazione delle matrici. Gli algoritmi implementati differiscono in base al processo di parallelizzazione realizzato: Matrix-Matrix Multiplication: assegnazione statica del job ai processi; sono necessari meccanismi di comunicazione per fornire il sottoblocco posseduto a tutti i processi che hanno un blocco che è nella stessa riga o colonna di quello posseduto. : assegnazione statica del job ai processi; prima di applicare l algoritmo bisogna allineare le matrici. Lo scambio dei sottoblocchi tra processi avviene tramite una rotazione dei sottoblocchi posseduti dai processi. : mappatura dinamica dei job ai processi; l assegnazione dei blocchi è eseguita dal master e non si ha nessuna iterazione tra i worker. Il progetto è stato implementato tramite lo standard MPI (Massage Passing Interface). MPI è lo standard de facto per la comunicazione tra processi in ambiente distribuito tra nodi appartenenti ad un cluster, che eseguono il programma parallelo secondo il modello SIMD (Single Istruction Multiple Data). Tale libreria ha il vantaggio di essere portabile poiché esistono implementazioni per diverse architetture e veloce, infatti è ottimizzata in base all architettura presente. L implementazione più diffusa di MPI, che è quella che è stata adotta nel progetto, è MPICH: opensource, testata in svariate piattaforme (incluse Linux (on IA32 and x86-64), Mac OS/X (PowerPC and Intel), Solaris (32- and 64-bit), e Windows). Requisiti del progetto: Le matrici di input devono essere accedute solamente dal processo Le matrici sono di tipo FP e sono memorizzate nel formato row-major come ASCII file nel disco Nell algoritmo 1 e 2, i blocchi devono essere trasmessi dal processo che ha il compito di recuperare i blocchi calcolati dai worker Nell algoritmo 3, il master è responsabile della distribuzione dei dati a tutti gli slave La matrice di output deve essere ricomposta dal master che provvederà poi a salvarla sul disco Deve essere possibile disabilitare l input dei dati dal/al disco Obiettivi: Valutare l eterogeneità e lo sbilanciamento del cluster Valutare lo speedup con differenti granularità e differenti dimensioni del problema Siccome la moltiplicazione delle matrici non è sufficiente per ottenere un vantaggio nell utilizzo degli algoritmi paralleli, computare C = f(a) B invece che C = A B. La funzione f deve essere indipendentemente applicata a tutti gli elementi A[i,j] per permettere l incremento della granularità minima dei task. 4

5 Implementazione Viene ora spiegato il funzionamento degli algoritmi e l implementazione che è stata realizzata. Matrix-Matrix Multiplication Funzionamento Consideriamo la moltiplicazione di due matrici quadrate di dimensione n n : C = A B. Il primo passo eseguito dall algoritmo è quello di partizionare le matrici A e B in p sottoblocchi, dove p è il numero dei processi che eseguono l algoritmo. Ogni sottoblocco A i,j della matrice A e B i,j della matrice B ( i, j<p) ha dimensione (n/ p ) (n/ p ) ciascuno: tale blocco è assegnato dal master al processo P i,j. A questo punto, il processo P i,j per essere in grado di calcolare il blocco Ci,j della matrice C, deve perciò possedere tutti i sottoblocchi A i,k e B k,j ( k< p ), cioè tutti i sottoblocchi che appartengono alla stessa riga del sottoblocco posseduto della matrice A e di tutti i sottoblocchi che appartengono alla stessa colonna del sottoblocco posseduto della matrice B. Per fare ciò, i processi si scambiano i sottoblocchi mancanti per poter eseguire la moltiplicazione: I sottoblocchi mancanti della riga per la matrice A I sottoblocchi mancanti della colonna per la matrice B Ogni processo a questo punto possiede tutti gli elementi necessari per il calcolo del blocco C ij di competenza al processo. Terminata la computazione del sottoblocco, ogni processo P i,j invia tale blocco al processo master che ha il compito di assemblare i blocchi ricevuti ed ottenere la matrice C. In base alla dimensione delle matrici A e B, poiché i sottoblocchi devono essere quadrati, non è possibile eseguire l algoritmo con un numero casuale di processi. Per chiarire tale limitazione, viene fornito un esempio con una matrice di dimensione 48. Il numero dei processi che sono congrui con tale dimensione sono: 1 processo 1 sottoblocco di dimensione 48 4 processi 4 sottoblocchi di dimensione 24 9 processi 9 sottoblocchi di dimensione processi 16 sottoblocchi di dimensione 12 5

6 Riassumendo: [master] Lettura matrice A e B [master] Partizionamento delle matrici A e B [master] Spedizione sottoblocchi ai processi [master e slave] Ricezione dei sottoblocchi [master e slave] Scambio blocchi mancanti tra processi [master e slave] Moltiplicazione sottoblocchi (calcolo sottoblocco della matrice C) [master e slave] Spedizione blocco calcolato al master [master] Raccolta di tutti i blocchi e creazione della matrice C Graficamente, le operazioni eseguite da un certo processo sono: [master] Lettura e partizionamento matrici A e B Il master è l unico che può accedere alle matrici A e B. La lettura di tali matrici avviene da disco se è settata la variabile FROM_FILE altrimenti vengono generate automaticamente della dimensione specificata in DIM. Viene controllato che se sia la matrice A che la matrice B possano essere suddivise in sottoblocchi quadrati, in base alla loro dimensione e al numero dei processi sui quali si intende eseguire l algoritmo. Tale compito è eseguito dalla funzione computabile. Si procede inoltre all allocazione delle spazio necessario a contenere a matrice C e delle strutture dati necessarie all esecuzione dell algoritmo. A questo punto si deve procedere al partizionamento delle matrici. Sono state, a tale scopo, realizzate le funzioni getcoordx e getcoordy; la prima data la dimensione della matrice e il rank del processo restituisce la coordinata dell asse X dell angolo più in alto a sinistra del sottoblocco della matrice assegnata al processo; la seconda calcola la coordinata Y. 6

7 Viene chiarito tutto ciò con un esempio: Supponiamo di voler eseguire l algoritmo con 4 processi e di avere la seguente matrice A: Quello che si vorrebbe ottenere è il seguente partizionamento: Rank Rank 1 Rank 2 Rank 3 Per ottenere ciò, le funzioni getcoordx e getcoordy restituiscono le seguenti coordinate: Rank processo Coordinata X Coordinata Y [master] Spedizione sottoblocchi ai processi Conosciute le coordinate assegnate al processo, il passo seguente è quello di creare un array contenente tutti i dati che devono essere spediti. Per prima cosa si inseriscono nell array gli elementi del sottoblocco assegnato al processo, poi gli elementi del sottoblocco assegnati al processo 1 e così via; tale funzionalità è implementata dalla funzione mat2array Per effettuare la distribuzione dei blocchi, siccome siamo in presenza di un contesto distribuito, è necessaria per prima cosa comunicare a tutti gli slave quale è la dimensione del sottoblocco che gli viene assegnato tramite la funzione MPI_BCast(): // area di ogni sottoblocco della matrice assegnato ad un processo b=(int)(n/num_proc); //distribuzione della dimensione del sottoblocco MPI_Bcast(&b,1,MPI_INT,,MPI_COMM_WORLD); 7

8 Per la distribuzione vera e propria dei sottoblocchi è stata utilizzata un operazione di MPI_Scatter(): tale funzione prende in ingresso l array, lo divide e lo distribuisce automaticamente a tutti i processi (compreso il master stesso), garantendo l ordinamento rispetto al numero di rank. //conversione matrice A in array arra=(double *)mat2array(mata,num_proc); //conversione matrice B in array arrb=(double *)mat2array(matb,num_proc); //scatter dei sottobolcchi di A ai processi MPI_Scatter(arrA,b,MPI_DOUBLE,subArrA,b,MPI_DOUBLE,,MPI_COMM_WORLD); //scatter dei sottobolcchi di B ai processi MPI_Scatter(arrB,b,MPI_DOUBLE,subArrB,b,MPI_DOUBLE,,MPI_COMM_WORLD); Rank Rank 1 Rank 2 Rank 3 [master e slave] Ricezione dei sottoblocchi Tutti gli slave e il master, invocando la funzione MPI_Scatter, memorizzano il sottoblocco ricevuto in un array di double (subarra per matrice A e subarrb per matrice B). // allocazione spazio per i sottobloblocchi della matrice A e B subarra=(double*)calloc((int)b,sizeof(double)); subarrb=(double*)calloc((int)b,sizeof(double)); //ricezione del sottoblocco di A e B MPI_Scatter(arrA,b,MPI_DOUBLE,subArrA,b,MPI_DOUBLE,,MPI_COMM_WORLD); MPI_Scatter(arrB,b,MPI_DOUBLE,subArrB,b,MPI_DOUBLE,,MPI_COMM_WORLD); 8

9 Rank possiede Rank 1 possiede Rank 2 possiede Rank 3 possiede [master e slave] Scambio blocchi mancanti tra processi Tutti i processi hanno così ottenuto il proprio sottoblocco della matrice; ora è necessaria la fase di scambio dei sottoblocchi (ricevuti sotto forma di array) tra processi. A questo proposito, ogni processo determina, sempre tramite le funzioni getcoorx e getcoordy, le coordinate dell asse delle X e Y dell angolo più in alto a sinistra del sottoblocco assegnatoli: mycoordx e mycoordy. Quindi ogni processo crea un comunicatore MyComm_row contenente tutti e solo i processi che hanno la stessa coordinata X e MyComm_col la stessa coordinata Y. MyComm_row sarà utilizzato per lo scambio dei sottoblocchi tra processi che hanno il blocco ricevuto nella stessa riga della matrice A mentre MyComm_col per lo scambio dei sottoblocchi tra processi che hanno il blocco ricevuto nella stessa colonna della matrice B. Abbiamo la seguente situazione: Rank Processo MyComm_row MyComm_col,1,2 1,1 1,3 2 2,3,2 3 2,3 1,3 Infatti, ad esempio, il processo e il processo 1 hanno il sottoblocco della matrice A che è nella stessa riga e perciò hanno lo stesso comunicatore MyComm_row. // coordinata x e y del processo mycoordx= getcoordx(rank,lato_mat,(int)sqrt(b)); mycoordy= getcoordy(rank,lato_mat,(int)sqrt(b)); //creazione di nuovi comunicatori MPI_Comm_split(MPI_COMM_WORLD,myCoordX,rank,&MyComm_row); MPI_Comm_split(MPI_COMM_WORLD,myCoordY,rank,&MyComm_col); 9

10 Per la comunicazione dei sottoblocchi tra processi è stata utilizzata la funzione MPI_Allgather; tramite l utilizzo di tale funzione ogni processo memorizza due array : rowa contiene tutti i sottoblocchi della stessa riga della matrice A del blocco associato processo colb possiede tutti i sottoblocchi della stessa colonna della matrice B del blocco associato processo Ad esempio, l array rowa (degli elementi della matrice A) posseduto dal processo e dal processo 1 sono uguali mentre sono identici l array colb del processo e 2. Processo : Processo 1: rowa colb rowa colb //array di tutte le righe ricevute MPI_Allgather(subArrA,b,MPI_DOUBLE,rowA,b,MPI_DOUBLE,MyComm_row); //array di tutte le colonne ricevute MPI_Allgather(subArrB,b,MPI_DOUBLE,colB,b,MPI_DOUBLE,MyComm_col); A questo punto ogni processo possiede la riga della matrice A e la colonna della matrice B: è quindi in grado di calcolare il sottoblocco della matrice C di sua competenza. [master e slave] Moltiplicazione sottoblocchi (calcolo sottoblocco della matrice C) L ultimo passo prima della moltiplicazione è trasformare l array rowa e colb nella forma di un array di sottomatrici, denominati rispettivamente riga e colonna 1

11 rowa riga colb riga Adesso è possibile effettuare la moltiplicazione tra l array riga e colonna ottenendo la matrice calc : il blocco della matrice C che il processo dove calcolare. matrice *calc, *ris_temp; for(i=;i<sqrt(num_proc);i++){ ris_temp=prodottomat(riga[i],colonna[i],((int)sqrt(b))); } if(i==) calc=ris_temp; else SommaMat(calC,ris_temp); Il codice della funzione ProdottoMat è riportato qui sotto. Si può notare che se non è settata SLOW non viene applicata la funzione di ritardo. Quando invece tale variabile è settata, la variabile RITARDO specifica il numero di cicli da eseguire; variando tale valore è possibile verificare il comportamento dell algoritmo con diversi livelli di granularità dei task. 11

12 // calcolo del prodotto tra due matrici matrice* ProdottoMat(matrice * a, matrice* b, int d){ double somma=.; int i,j,h; } matrice *calc=(matrice*)malloc(sizeof(matrice)); calc->dim = d; calc->val = allocamatrice(d); for(i=; i<d;i++){ for(j=;j<d; j++){ somma=.; for(h=;h<d;h++){ if(slow){ int g, s=; for(g=;g<ritardo;g++) s++; } somma=somma+(a->val[i][h]*b->val[h][j]); } } return calc; } calc->val[i][j]= (double) somma; [master e slave] Spedizione blocco calcolato al master Ogni processo possiede il sottoblocco da spedire al master e per prima cosa lo deve convertire in array per la spedizione. double *subarrc; // conversione del blocco della matrice C calcolata dal processo subarrc=submat2subarray(calc); subarrc Attraverso la funzione MPI_Gather ogni processo spedisce il proprio array al master. // spedizione del sottoblocco calcolato della matrice C e ricezione dei sottoblocchi MPI_Gather(subArrC,b,MPI_DOUBLE,arrC,b,MPI_DOUBLE,,MPI_COMM_WORLD); 12

13 [master] Raccolta di tutti i blocchi e creazione della matrice C Il master tramite l invocazione della funzione MPI_Gather raccoglie tutti i sottoblocchi (spediti sottoforma di array) e li memorizza nell array arrc, ordinati per numero del rank dei processi mittenti (prima quelli del processo, poi quelli del processo 1 e così via). MPI_Gather(subArrC,b,MPI_DOUBLE,arrC,b,MPI_DOUBLE,,MPI_COMM_WORLD); Rank Rank Rank Rank arrc Ottenuto l array rimane da convertirlo in matrice: la matrice finale C = A B. Tale conversione viene realizzata dalla funzione array2matformatted. // conversione dell'array in matrice matc=array2matformatted(arrc,mata->dim,num_proc); arrc

14 Funzionamento Consideriamo ancora la moltiplicazione di due matrici quadrate di dimensione n, C = A B. Anche in questo algoritmo, come nel precedente, le matrici A e B vengono partizionate in p sottoblocchi quadrati, dove p è il numero di processi sul quale si intende eseguire l algoritmo. I processi vengono etichettati da P, a P p -1, p -1 ed inizialmente viene associato il sottoblocco A i,j e B i,j al processo P i,j. Ogni processo della riga i-esima richiede tutte le p sottomatrici A i,k ( k< p ); è possibile schedulare la computazione dei p processi nell i-esima riga in moda tale che, in un certo istante di tempo, ogni processo usa un differente sottoblocco A i,k. Questi blocchi possono così essere ruotati sistematicamente tra i processi dopo ogni moltiplicazione delle sottomatrici così che ogni processo possiede in ogni rotazione un nuovo sottoblocco A i,k. Se una identica schedulazione è applicata per le colonne nessun processo necessita di più di un sottoblocco di ogni matrice alla volta, ottenendo un risparmio della memoria necessaria per la computazione. Il passo iniziale consiste nell allineamento delle matrici A e B in modo che ogni processo possa moltiplicare i propri sottoblocchi posseduti in maniera indipendente. A tale scopo viene applicato uno shift a sinistra (con wraparound) di i step a tutti i sottoblocchi A i,j della matrice A. Inoltre, tutti i sottoblocchi B i,j della matrice B sono shiftati in alto di j step (con wraparound). Tali operazioni fanno si che il processo Pi,j abbia associato il sottoblocco A i,(j+i)mod B (i+j)mod p,j. p e A questo punto ogni processo è pronto per eseguire la prima moltiplicazione tra le sottomatrici. Dopo aver eseguito la moltiplicazione, ogni blocco della matrice A si muove di uno step a sinistra e ogni blocco della matrice B si muove di uno step in alto (ancora con wraparound). Ogni processo esegue la moltiplicazione dei sottoblocchi ricevuti, somma il risultato a quello ottenuto nel passo precedente e si ripete tale meccanismo fino a che tutti i processi non hanno eseguito tutte p moltiplicazioni. Terminata la rotazione, ogni processo P i,j invia il blocco calcolato della matrice C i,j al processo master che ha il compito di assemblare i blocchi ricevuti ed ottenere la matrice C. Come per l algoritmo precedente, in base alla dimensione delle matrici A e B, poiché i sottoblocchi devono essere quadrati, non è possibile eseguire l algoritmo con un numero casuale di processi. 14

15 Riassumendo: [master] Lettura delle matrici A e B [master] Partizionamento delle matrici A e B [master] Allineamento delle matrici A e B [master] Spedizione sottoblocchi ai processi [master e salve] Ricezione dei sottoblocchi [master e slave] for k=1 to p [master e slave] Esecuzione prodotto sottoblocchi [master e slave] Somma risultato con quello ottenuto al passo precedente [master e slave] Spedizione blocco della matrice A al processo a sinistra [master e slave] Ricezione blocco della matrice A dal processo a destra [master e slave] Spedizione blocco della matrice B al processo sopra [master e slave] Ricezione blocco della matrice B dal processo sotto [master e slave] Spedizione blocco calcolato al master [master] Raccolta di tutti i blocchi e creazione della matrice C Graficamente, l algoritmo può essere spiegato nel seguente modo: Allineamento iniziale delle matrici A e B eseguita dal master 15

16 Matrici A e B dopo l allineamento eseguito dal master (c) e dopo il primo shift Matrici A e B dopo il secondo shift (e) e dopo il terzo shift (f) 16

17 [master] Lettura e partizionamento matrici A e B Come per l algoritmo precedente, il master è l unico che può accedere alle matrici A e B. La lettura di tali matrici avviene da disco se è settata la variabile FROM_FILE altrimenti vengono generate automaticamente della dimensione specificata da DIM. Viene controllato se sia la matrice A che la matrice B possono essere suddivise in sottoblocchi quadrati, in base alla loro dimensione e al numero dei processi sui quali si intende eseguire l algoritmo. Tale compito è eseguito dalla funzione computabile. Si procede inoltre all allocazione delle spazio necessario a contenere la matrice C e delle strutture dati necessarie all esecuzione dell algoritmo. [master] Allineamento delle matrici A e B Prima di consegnare il sottoblocchi della matrice A e B bisogna procedere all allineamento delle matrici. L allineamento della matrice A è eseguito dalla funzione SwapRow mentre quello della matrice B è realizzato dalla funzione SwapCol. // passo iniziale: allinemento della matrice A e B SwapRow(matA,num_proc); SwapCol(matB, num_proc); Consideriamo ad esempio la matrice A partizionata nel seguente modo: Rank Rank 1 Rank 2 Rank 3 Ogni sottoblocco A i,j viene spostato a sinistra di i posizioni (con wraparound). I sottoblocchi della prima riga rimangono nella posizione dove sono, quelli della seconda riga si spostano a sinistra di una posizione. Quello che si vuole ottenere quindi è la seguente situazione: Rank Rank 1 Rank 2 Rank 3 17

18 Per ottenere ciò è stata realizzata una funzione che, date le coordinate dell angolo più in alto a sinistra del sottoblocco, calcola le nuove coordinate del blocco (siccome avviene uno spostamento a sinistra la coordinata dell asse delle x rimane uguale). Rank processo Coordinata X Coordinata Y Rank processo Coordinata X Coordinata Y A questo punto sono disponibili le nuove coordinate di ogni processo; per eseguire lo spostamento vero e proprio e realizzare tutto ciò con un utilizzo limitato di memoria, si procede per righe e si utilizza un array di sottoblocchi temporaneo (utilizzato per contenere i blocchi della riga considerata nella posizione corretta): viene presa in considerazione la prima riga e vengono ricopiati i sottoblocchi nell array in posizione corretta e quando tutti i sottoblocchi sono stati copiati, viene ricopiato il contenuto dell array nella prima riga della matrice. Si procede successivamente con la seconda riga, si ricopiano i sottoblocchi nell array in posizione corretta e poi si ricopia il contenuto dell array nella seconda riga della matrice. Vediamo l esempio con la seconda riga, i sottoblocchi devono essere spostati di una posizione a sinistra Riga presa in considerazione I blocchi vengono copiati nell array temporaneo in posizione corretta: Il contenuto dell array viene copiato nella seconda riga della matrice ottenendo il risultato voluto. 18

19 Un procedimento simile è realizzato per la matrice B ma invece di procedere per righe si procede per colonne. [master] Spedizione sottoblocchi ai processi Il passo seguente è quello di creare un array contenente tutti i dati che devono essere spediti: la matrice deve essere convertita in array per la spedizione. Per prima cosa si inseriscono nell array gli elementi del sottoblocco assegnato al processo, poi gli elementi del sottoblocco assegnati al processo 1 e così via; tale funzionalità è implementata dalla funzione mat2array Per effettuare la distribuzione dei blocchi è necessaria per prima cosa comunicare a tutti gli slave quale è la dimensione del sottoblocco che gli viene assegnato tramite la funzione di MPI_BCast(): // area di ogni sottoblocco della matrice assegnato ad un processo b=(int)(n/num_proc); //distribuzione della dimensione del sottoblocco MPI_Bcast(&b,1,MPI_INT,,MPI_COMM_WORLD); Per la distribuzione vera e propria dei sottoblocchi è stata utilizzata un operazione di MPI_Scatter(): tale funzione prende in ingresso l array, lo divide e lo distribuisce automaticamente a tutti i processi (compreso il master stesso), garantendo l ordinamento rispetto al numero di rank. //conversione matrice A in array arra=(double *)mat2array(mata,num_proc); //conversione matrice B in array arrb=(double *)mat2array(matb,num_proc); //scatter dei sottobolcchi di A ai processi MPI_Scatter(arrA,b,MPI_DOUBLE,subArrA,b,MPI_DOUBLE,,MPI_COMM_WORLD); //scatter dei sottobolcchi di B ai processi MPI_Scatter(arrB,b,MPI_DOUBLE,subArrB,b,MPI_DOUBLE,,MPI_COMM_WORLD); 19

20 Rank Rank 1 Rank 2 Rank 3 [master e slave] Ricezione dei sottoblocchi Tutti gli slave e il master, invocando la funzione MPI_Scatter, memorizzano il sottoblocco ricevuto in un array di double (subarra per la matrice A e subarrb per la matrice B). // allocazione spazio per i sottobloblocchi della matrice A e B subarra=(double*)calloc((int)b,sizeof(double)); subarrb=(double*)calloc((int)b,sizeof(double)); //ricezione del sottoblocco di A e B MPI_Scatter(arrA,b,MPI_DOUBLE,subArrA,b,MPI_DOUBLE,,MPI_COMM_WORLD); MPI_Scatter(arrB,b,MPI_DOUBLE,subArrB,b,MPI_DOUBLE,,MPI_COMM_WORLD); Rank possiede Rank 1 possiede Rank 2 possiede Rank 3 possiede [master e slave] Rotazione sottoblocchi e calcolo blocco della matrice C L array ricevuto (sia quello della matrice A che B) viene convertito in matrice tramite la funzione array2mat. /* conversione del blocco della matrice A ricevuto da array in matrice l: lato del sottoblocco */ rica=(matrice*)malloc(sizeof(matrice)); int l=(int)(sqrt(b)); array2mat(rica,subarra,l); 2

21 // conversione del blocco della matrice B ricevuto da array in matrice ricb=(matrice*)malloc(sizeof(matrice)); array2mat(ricb,subarrb,l); Ad esempio il processo converte subarra in matrice: [master e slave] for k=1 to p 1. [master e slave] Esecuzione prodotto sottoblocchi 2. [master e slave] Somma risultato con quello ottenuto al passo precedente 3. [master e slave] Spedizione blocco della matrice A al processo a sinistra 4. [master e slave] Ricezione blocco della matrice A dal processo a destra 5. [master e slave] Spedizione blocco della matrice B al processo sopra 6. [master e slave] Ricezione blocco della matrice B dal processo sotto Vengono eseguiti p cicli, in ogni ciclo ogni processo esegue la moltiplicazione del sottoblocco posseduto della matrice A con quello della matrice B; eseguito ciò bisogna sommare il risultato con quello ottenuto nelle fasi precedenti. Viene allocata, a tale scopo, la matrice c_final utilizzata per memorizzare i risultati calcolati fino al passo precedente e c_parz per contenere il prodotto delle matrici eseguito nel ciclo; tale prodotto deve essere sommato al risultato ottenuto nelle fasi precedenti, il quale è presente nella matrice c_final. Il risultato di tale somma viene memorizzato nella matrice c_final. In ogni ciclo quindi: c_parz = (A i,j ricevuto) * (B i,j ricevuto) c_final = c_final + c_parz // calcolo del prodotto del sottoblocco della matrice A e B ricevute c_parz=(matrice*)prodottomat(rica,ricb,l); // somma del risultato dell'iterazione corrente con quelli ottenuti nelle iterazioni precedenti c_final=(matrice*)sommamat2(c_parz,c_final); Come per l algoritmo precedente, dato che viene utilizzata la stessa funzione di moltiplicazione delle matrici, se non è settata SLOW non viene applicata la funzione di ritardo. Quando invece tale variabile è settata, la variabile RITARDO specifica il numero di cicli da eseguire; variando tale valore è possibile verificare il comportamento dell algoritmo con diversi livelli di granularità dei task. 21

22 Per eseguire lo scambio dei blocchi della matrice A, ogni processo deve spedire il sottoblocco della matrice A al processo a sinistra e deve ricevere il nuovo blocco dal processo a destra. Per fare ciò sono state implementate due funzioni: getrankrowdest determina il rank del processo a cui devo inviare il sottoblocco della matrice A getrankrowmit specifica il rank del processo da cui devo ricevere il sottoblocco della matrice A // determinazione del rank del processo a cui devo inviare il sottoblocco di A posseduto row_dest=getrankrowdest(rank,num_proc); // determinazione del rank del processo da cui devo ricevere il sottoblocco di A row_mit=getrankrowmit(rank,num_proc); Ad esempio, consideriamo una esecuzione con 16 processi: Rank processo Da chi devo ricevere A chi devo spedire Il processo a cui inviare il blocco è quello a sinistra tranne il caso particolare in cui il blocco si trova nella prima posizione della riga: il processo destinatario è l ultimo della riga. Nell esempio, il processo 1 deve inviare il blocco posseduto al processo int getrankrowdest(int rank, int np){ int rank_dest; int proc_lato=(int)sqrt(np); //caso elemento ad inizio riga if((rank%proc_lato)==) rank_dest=rank+(proc_lato-1); else rank_dest = rank-1; } return rank_dest; 22

23 Il processo da cui ricevere il blocco è quello a destra tranne il caso particolare dove il processo è nell ultima posizione della riga: il processo mittente è quello all inizio della riga. Nell esempio fornito, il processo 4 deve ricevere il blocco dal processo // determinazione del rank del processo da cui ricevere il sottoblocco della matrice A int getrankrowmit(int rank, int np){ int rank_mit; int proc_lato=(int)sqrt(np); if((rank+1)%proc_lato==) // se siamo sull'ultima colonna rank_mit=rank-(proc_lato-1); else rank_mit=rank+1; } return rank_mit; Per realizzare invece lo scambio dei blocchi tra processi della matrice B, ogni processo spedisce il sottoblocco posseduto a quello in alto e riceve il nuovo blocco dal processo in basso. A tale scopo sono state implementate due funzioni: getrankcoldest determina il rank del processo a cui devo inviare il sottoblocco della matrice B getrankcolmit specifica il rank del processo da cui devo ricevere il sottoblocco della matrice B // determinazione del rank del processo a cui devo inviare il sottoblocco di B posseduto col_dest=getrankcoldest(rank,num_proc); // determinazione del rank del processo da cui ricevere il sottoblocco di B col_mit=getrankcolmit(rank,num_proc); Ad esempio, consideriamo una esecuzione con 16 processi: Rank processo Da chi devo ricevere A chi devo spedire

24 Il processo a cui inviare il blocco è quello in alto tranne il caso particolare in cui il blocco si trova nella prima posizione della colonna: il processo destinatario è l ultimo della colonna. Nell esempio, il processo 1 deve inviare il blocco posseduto al processo // determinazione del rank del processo a cui inviare il proprio sottoblocco della matrice B int getrankcoldest(int rank,int np){ int rank_dest; int proc_lato=(int)sqrt(np); if (rank < proc_lato) rank_dest=np-(proc_lato-rank); else rank_dest=rank-proc_lato; } return rank_dest; Il processo da cui ricevere il blocco è quello in basso tranne il caso particolare nel quale il processo è nell ultima posizione della colonna: il processo mittente è quello all inizio della colonna. Nell esempio fornito, il processo 13 deve ricevere il blocco dal processo 1. // determinazione del rank del processo da cui ricevere il sottoblocco della matrice B int getrankcolmit(int rank, int np){ int rank_mit; int proc_lato=(int)sqrt(np); if(rank>=(np-proc_lato)) rank_mit=(rank+proc_lato)%np; else rank_mit=rank+proc_lato; return rank_mit; } Conosciuti i rank dei mittenti e dei destinatari, il passo successivo è la spedizione e la ricezione dei blocchi corrispondenti. Per realizzate tutto questo è stata utilizzata la funzione MPI_Sendrecv_replace. 24

25 // invio e ricezione del blocco A MPI_Sendrecv_replace(subArrA,b,MPI_DOUBLE,row_dest,1,row_mit,1,MPI_COMM_WO RLD,&statA); // invio e ricezione del blocco B MPI_Sendrecv_replace(subArrB,b,MPI_DOUBLE,col_dest,1,col_mit,1,MPI_COMM_WO RLD,&statB); E stato deciso di adottare MPI_sendrecv_replace perché MPI_Send e MPI_recv non possono essere utilizzati per la comunicazione punto a punto poiché se tutti i processi invocano MPI_Send o MPI_Recv, in un qualche ordine, si può verificare una situazione di deadlock. L ultimo passo all interno del ciclo for è quello di convertire i due sottoblocchi ricevuti (uno della matrice A e l altro della matrice B) in forma matriciale dato che sono stati ricevuti due array. Tale compito è realizzato dalla funzione array2mat. // conversione dell'array corrispondente al blocco della matrice A ricevuto in matrice array2mat(rica,subarra,l); // conversione dell'array corrispondente al blocco della matrice B ricevuto in matrice array2mat(ricb,subarrb,l); Ad esempio se è stato ricevuto il seguente array subarra viene convertito nella seguente matrice: Al termine del ciclo for, la matrice c_final contiene il sottoblocco della matrice C che il processo doveva calcolare. [master e slave] Spedizione blocco calcolato al master Ogni processo possiede il sottoblocco da spedire al master e per prima cosa lo deve convertire in array per la spedizione. double *subarrc; // conversione del blocco della matrice C calcolata dal processo subarrc=submat2subarray(calc); 25

26 subarrc Attraverso la funzione MPI_Gather ogni processo spedisce il proprio array al master. // spedizione del sottoblocco calcolato della matrice C e ricezione dei sottoblocchi MPI_Gather(subArrC,b,MPI_DOUBLE,arrC,b,MPI_DOUBLE,,MPI_COMM_WORLD); [master] Raccolta di tutti i blocchi e creazione della matrice C Il master tramite l invocazione della funzione MPI_Gather raccoglie tutti i sottoblocchi (spediti sottoforma di array) e li memorizza nell array arrc ordinati per numero del rank dei processi mittenti. MPI_Gather(subArrC,b,MPI_DOUBLE,arrC,b,MPI_DOUBLE,,MPI_COMM_WORLD); Rank Rank Rank Rank arrc Ottenuto l array rimane da convertirlo in matrice: la matrice finale C = A B. Tale conversione viene realizzata dalla funzione array2matformatted. // conversione dell'array in matrice matc=array2matformatted(arrc,mata->dim,num_proc); 26

27 arrc

28 Funzionamento Nell algoritmo (o Worker Pool), a differenza degli altri due algoritmi, l assegnazione dei task avviene in maniera dinamica, consentendo così un miglior bilanciamento del carico. In questo algoritmo il processo master non si occupa di eseguire i calcoli parziali delle matrici, ma solo di distribuire i task agli slaves e di raccogliere i risultati. I processi slaves invece si occupano dei calcoli parziali della matrice C inviando poi i risultati al processo master. Il primo passo di questo algoritmo consiste nel replicare la matrice B a tutti i worker. Successivamente, il processo master distribuisce a tutti gli altri processi, ad ogni passo, una riga della matrice A. Gli slaves, una volta ricevuta la riga, effettuano il calcolo vettore per matrice, tra la riga ricevuta e la matrice B e spediscono il risultato al processo master che a sua volta spedisce un altra riga di A se ne sono disponibili ancora. L algoritmo termina una volta esaurite le righe della matrice A. In particolare: Viene replicata la matrice B a tutti i worker. I task consistono nel calcolare k righe della matrice C con k < (n / p ), dove n è la dimensione del lato della matrice e p è il numero di processi. Il processo master assegna dinamicamente i task ai worker inviando k righe della matrice A. 28

29 C A B K Riga di C Master Riga di C Riga di A Riga di A B B Slave 1 Slave n Riassumendo: [master] Lettura delle matrici A e B [master] Replica della matrice B a tutti gli altri worker [master] Invio deii task a tutti i worker disponibili (k righe) [slaves] Ricezione della riga della matrice A [slaves] Prodotto vettore per matrice (riga di A per matrice B) [slaves] Invio dei risultati e attesa di una eventuale nuova riga [master] Finché non ho ricevuto tutte le righe della matrice A [master] Ricezione dei risultati parziali e aggiornamento della matrice C [master] Invio di eventuali altre righe della matrice A 29

30 [master] Lettura delle matrici A e B e replica della matrice B Il master è l unico che può accedere alle matrici A e B. La lettura di tali matrici avviene da disco se è settata la variabile FROM_FILE altrimenti vengono generate automaticamente della dimensione specificata in DIM. La matrice B viene spedita tramite la funzione MPI_BCast( ); prima della spedizione della matrice vengono effettuate due operazioni: 1. Per effettuare la distribuzione della matrice B, siccome siamo in presenza di un contesto distribuito, è necessaria per prima cosa comunicare a tutti gli slave quale è la dimensione della matrice che gli viene assegnato tramite la funzione di MPI_BCast(): // assegno a dim la dimensione della matrice B dim= matb->dim // distribuzione della dimensione della matrice MPI_Bcast (&dim, 1, MPI_INT,, MPI_COMM_WORLD); 2. La matrice B viene convertita in array tramite la funzione submat2subarray(matb). // conversione matrice B in array arrb = (double*) submat2subarray(matb); L array arrb, che rappresenta la matrice B,viene poi spedito a tutti gli altri worker tramite la funzione MPI_BCast() //spedizione e ricezione della matrice MatB MPI_Bcast(arrB, dim*dim, MPI_DOUBLE,, MPI_COMM_WORLD); [master] Invia i task a tutti i worker disponibili (k righe) In questa fase, la prima cosa fatta è controllare se il numero di processi allocati sia sufficiente affinché possa essere eseguito l algoritmo. Il numero di processi deve essere almeno due: uno per il master e uno che effettua la computazione. Successivamente avviene l assegnazione statica dei task ai vari processi. Questo problema si divide in due casi: 1. Il numero di righe della matrice A è minore rispetto al numero di processi allocati. In questo caso tutti i processi che non eseguano la computazione devono essere settati subito allo stato di IDLE 2. Il numero di righe della matrice A è maggiore o uguale al numero di processi allocati. In questo caso tutti i processi partecipano alla computazione. 3

31 Viene creato un array (map) per mantenere la corrispondenza tra il processo e il numero di riga assegnata. In questo modo è possibile sapere in ogni momento quale processo computa una determinata riga della matrice A. Quindi map [i] = j significa che il processo i ha computato la riga j della matrice A. //Map mantiene la corrispondenza tra processo e riga della matrice assegnata map=(int*)calloc(num_proc,sizeof(int)); // il master non effettua il prodotto delle matrici map[]=; Viene poi effettuata l operazione di assegnamento delle righe ai processi: for (i=;i<limite;i++){ prelevariga(mata, i, rowa); MPI_Send(rowA, dim, MPI_DOUBLE, i+1, INVIO, MPI_COMM_WORLD); //corrispondenza riga--->processo map[i+1]=i } L i-esima riga della matrice A viene prelevata tramite la funzione prelevariga( ) e inviata al processo i+1-esimo (i+1 perché il processo essendo il master non effettua la computazione). Inoltre viene aggiornata la corrispondenza processo riga. Come detto in precedenza nel caso in cui il numero di righe sia inferiore al numero di processi allocati, tutti quelli che non lavorano vengono settati a IDLE. Tutto questo viene fatto inviando al processo un array contenete tutti valori nulli (il vettore riga_zero); tale messaggio inviato ha tag IDLE. //caso numero processori maggiore del numero di righe della matrice, setto a idle tutti i processori che non lavorano if(dim <= num_proc-1){ int q; for(q=limite+1;q<num_proc;q++){ MPI_Send(riga_zero, dim, MPI_DOUBLE, q, IDLE, MPI_COMM_WORLD); } [slaves] operazioni lato slaves I processi slaves compiono queste operazioni: 1. ricevono la dimensione della matrice B e tutta la matrice B; 2. ricevono la riga della matrice A; 3. effettuano il prodotto vettore per matrice (riga della matrice A per matrice B); 4. inviano il vettore risultato al master e si mettono in attesa di una nuova riga da calcolare finché non vengono settati dal master allo stato di IDLE. La ricezione della dimensione della matrice B e di tutta la matrice stessa avviene tramite l operazione di collettiva MPI_BCast( ); I processi non ricevono la matrice vera e propria ma un 31

32 vettore che rappresenta la matrice. Tale array verrà poi convertito in matrice da ogni worker attraverso la funzione arraytomat(). MPI_Bcast (&dim, 1, MPI_INT,, MPI_COMM_WORLD); arrb = (double *) calloc(dim*dim, sizeof(double)); //ricezione della matrice Matrice B MPI_Bcast(arrB, dim*dim, MPI_DOUBLE,, MPI_COMM_WORLD); ricb = (matrice *) malloc (sizeof(matrice)); array2mat(ricb,arrb,dim); La seconda operazione è quella di ricevere una riga della matrice A per poi successivamente farne il prodotto con la matrice B. Tale operazione continua ad avvenire fino a che il worker continua ricevere dati dal master. Quando il master ha terminato le righe, il processo worker riceve un vettore nullo e viene settato allo stato di IDLE riga_temp = (double*) calloc (dim, sizeof(double)); riga_ris = (double*) calloc (dim, sizeof(double)); MPI_Recv(riga_temp, dim, MPI_DOUBLE,, MPI_ANY_TAG, MPI_COMM_WORLD, &stata); // Fino a che ricevo dati while (stata.mpi_tag == INVIO){ //Esecuzione del prodotto della riga della matrice A ricevuto con la matrice B ProdVetMat(riga_temp, ricb, riga_ris); //Invio della riga calcolata e attesa della prossima riga MPI_Send(riga_ris, dim, MPI_DOUBLE,, RICEZIONE, MPI_COMM_WORLD); MPI_Recv(riga_temp, dim, MPI_DOUBLE,,MPI_ANY_TAG,MPI_COMM_WORLD, &stata); } La riga ricevuta dal processo master viene memorizzata nell array riga_temp, mentre il risultato del prodotto riga per matrice che viene calcolato attraverso la funzione ProdVetMat() e viene memorizzato nell array riga_ris. Il risultato viene spedito al processo master attraverso la funzione MPI_Send(), mentre la ricezione delle righe viene effettuata attraverso la funzione MPI_Recv(). Il controllo sul tipo di dato ricevuto o inviato viene fatto attraverso la verifica dello stato del valore del tag associato al messaggio: i valori del tag sono tre: 1. INVIO significa che sono stati spediti dei dati da computare (da master a slaves); 2. RICEZIONE significa che sono stati spediti dati già computati (da slaves a master); 3. IDLE significa che è un messaggio che setta a IDLE un processo (da master a slaves). Il processo, se non è idle, si mette poi in attesa di un nuovo messaggio. I messaggi che può ricevere sono di due tipi: 1. un altra riga della matrice A da computare. In questo caso il messaggio ha tag di tipo INVIO; 2. un messaggio contenente un array nullo con associato un tag di tipo IDLE. In questo caso il processo viene settato allo stato di IDLE. Il processo, quindi non sapendo a priori quale tipo di messaggio può ricevere, associa alla primitiva MPI_Recv( ) il tag di tipo MPI_ANY_TAG. In questo modo il tag del messaggio ricevuto può essere qualsiasi. 32

33 [master] Raccolta dei risultati In questa sezione il master attraverso la funzione MPI_Recv ( ) attende tutti i risultati delle righe della matrice A spedite precedentemente e calcolati dai processi slaves. L attesa procede finché il numero di righe ricevute non raggiunge il numero di righe (la dimensione del lato) della matrice A. In questo caso il messaggio ha tag di tipo RICEZIONE. Infatti il processo è in attesa di una riga già calcolata. Il processo master non conosce a priori nemmeno da chi riceverà la riga calcolata, visto che distribuisce le righe a più processi. Quindi il campo mittente della funzione MPI_Recv ha valore MPI_ANY_SOURCE che identifica che il mittente del messaggio può essere uno qualsiasi. //Fino a il master non ha ricevuto tutte le righe dagli slaves while (num_righe_rec < dim){ MPI_Recv(riga_temp,dim,MPI_DOUBLE,MPI_ANY_SOURCE,RICEZIONE,MPI_COMM_WORLD, &statb); Ricevuta una riga calcolata, il processo master inserisce la righe nella matrice C (lo spazio necessario per la matrice deve essere già stato allocato). L inserimento avviene attraverso l utilizzo della funzione settariga( ) che inserisce la riga riga_temp nella posizione specificata dall array map che era stato precedentemente aggiornato. L indice di map, che rappresenta il processo che ha calcolato la riga, può essere trovato estraendo dallo stato del messaggio appena ricevuto il valore MPI_SOURCE che rappresenta il mittente del messaggio. settariga(matc, riga_temp, map[statb.mpi_source]); Riassumendo nella matrice C, alla posizione map[statb.mpi_source], viene inserita la riga calcolata riga_temp. A questo punto, se sono disponibili altre righe della matrice A da calcolare, al processo che ha inviato l ultima riga calcolata, viene spedita un altra riga oppure viene inviato un messaggio che lo setta a IDLE. //Se sono disponibili ancora righe da inviare /calcolare if(num_righe_send < dim){ prelevariga(mata, num_righe_send, rowa); MPI_Send(rowA, dim, MPI_DOUBLE, statb.mpi_source, INVIO, MPI_COMM_WORLD); map[statb.mpi_source]=num_righe_send; //aggiorno il numero di righe inviate num_righe_send++; } else{ //altrimenti setto a IDLE i processi che hanno finito di lavorare MPI_Send(riga_zero,dim,MPI_DOUBLE,statB.MPI_SOURCE,IDLE,MPI_COMM_WORLD); } 33

34 Algoritmi Sequenziali per la moltiplicazione delle matrici Algoritmo normalmente utilizzato Il prodotto C delle matrici A e B è definito come n ij = 1 k= c a b ik kj, dove a ij, b ij, and c ij sono gli elementi dell i-esima riga e della j-esima colonna delle matrici A, B e C rispettivamente. Per poter eseguire la moltiplicazione delle matrici, la dimensione di AB=C deve soddisfare ( n m)( m p) = ( n p). Per semplicità, supponiamo di utilizzare matrici quadrate: in tal caso le matrici A, B e C sono tutte n n. L algoritmo sequenziale per la moltiplicazione della matrici può essere descritto nel seguente modo: for i = to n-1 for j = to n-1 c ij = for k = to n-1 c ij = c ij + a ik b kj Tale algoritmo richiede n 3 addizioni e moltiplicazioni: la complessità è dell ordine di O(n 3 ). Algoritmo di Strassen L algoritmo di Strassen reduce la complessità a O(n 2.81 ). In questo algoritmo, le matrici n n sono suddivise in quattro n/2 n/2 sottomatrici. La figura sotto riportata mostra una moltiplicazione di matrici 2 2. Poiché tale algoritmo divide le matrici in 2 e le moltiplica ricorsivamente, per poter eseguire tali operazioni, le matrici devono essere quadrate e la loro dimensione deve essere una potenza di 2. Tale limitazione può essere superata tramite l utilizzo dell algoritmo di Winograd, una variante dell algoritmo di Stassen. Se le matrici A e B sono della dimensione 2 d m 2 d m, l algoritmo di Stassen viene eseguito ricorsivamente d volte. Dopo d ritorsioni, l algoritmo standard è utilizzato per la moltiplicazione delle matrici m m. 34

35 Un esempio di esecuzione dell algoritmo di Stassen per la moltiplicazione delle matrici di dimensione 2 2 è riportato qui sotto. Necessita di 7 moltiplicazioni e 18 addizioni/sottrazioni. c c 1 c c 1 11 a = a 1 a a 1 11 b b 1 b b 1 11 S 1 = a 1 + a 11 T 1 = b 1 b S 2 = S 1 a T 2 = b 11 T S 3 = a a 1 T 1 = b 11 b 1 S 4 = a 1 S 2, T 1 = b 1 T 1 P 1 = a b U 1 = P 1 + P 2 P 2 = a 1 b 1 U 2 = P 1 + P 4 P 3 = S 1 T 1 U 3 = U 2 + P 5 P 4 = S 2 T 2 U 4 = U 3 + P 7 P 5 = S 3 T 3 U 5 = U 3 + P 3 P 6 = S 4 b 11 U 6 = U 2 + P 3 P 1 = a 11 T 4 Algorito di Stassen per la mo U 7 = U 6 + P 6 c = U 1 c 1 = U 7 c 1 =U 4 c 11 =U 5 35

36 Test progetto Gli obiettivi dei test è la valutazione delle seguenti caratteristiche: l eterogeneità e lo sbilanciamento del cluster lo speedup con differenti granularità e differenti dimensioni del problema Per tale motivo, le dimensioni delle matrici (dense) scelte sono: Questo permette di valutare ogni algoritmo con una variazione consistente della dimensione delle matrici e quindi del relativo costo computazionale: si parte da una matrice di dimensioni ridotte fino ad arrivare ad una di dimensioni elevate. Dato che la moltiplicazione delle matrici non è sufficiente per ottenere un vantaggio sull utilizzo degli algoritmi paralleli è stata implementata una funzione f, detta di rallentamento, in modo da eseguire C = f(a) B invece che C = A B. Tale funzione di rallentamento può eseguire il seguente numero di cicli: (non presenza) Il cluster sul quale sono stati eseguiti i test utilizza macchine Linux con kernel accesso remoto a tale cluster avviene attraverso mazinkaiser@dsi.unive.it. Principali grafici realizzati con relativi commenti Di seguito vengono riportati i grafici delle prestazioni dei 3 algoritmi implementati, ottenuti attraverso i test effettuati. 36