Facolt a di Scienze Matematiche, Fisiche e Naturali Corso ... Universit a degli Studi di Perugia Facolt a di Scienze Matematiche, Fisiche e Naturali Corso di Laurea Triennale in Informatica

Universita degli Studi di Perugia

Facolta di Scienze Matematiche, Fisiche e Naturali

Corso di Laurea Triennale in Informatica

Tesi di Laurea sperimentale

Utilizzo di MPI e Pthread nella

parallelizzazione multi-GPU di algoritmi di

identificazione di segnali gravitazionali

Laureando: Relatori:

Lanfranco Fontana Leonello Servoli

Loriano Storchi

Leone Bosi

Anno Accademico 2010/2011

Indice

Introduzione ii

1 Architettura delle GPU e CUDA computing 11.1 MacGo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Evoluzione delle GPU . . . . . . . . . . . . . . . . . . . . . . 21.3 Il GPU Computing . . . . . . . . . . . . . . . . . . . . . . . . 31.4 La tassonomia di Flynn . . . . . . . . . . . . . . . . . . . . . . 41.5 TESLA C1060 . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.5.1 Il flusso delle operazioni . . . . . . . . . . . . . . . . . 61.5.2 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . 71.5.3 Un insieme di multiprocessori SIMT . . . . . . . . . . 7

1.6 NVIDIA, progetti in corso . . . . . . . . . . . . . . . . . . . . 81.6.1 L’architettura FERMI . . . . . . . . . . . . . . . . . . 8

1.7 C.U.D.A.(Compute Unied Device Architecture) . . . . . . . . 101.7.1 Il modello architetturale C.U.D.A. . . . . . . . . . . . . 111.7.2 C.U.D.A. kernel . . . . . . . . . . . . . . . . . . . . . . 141.7.3 Gestione dei thread . . . . . . . . . . . . . . . . . . . . 151.7.4 Gerarchia di memoria . . . . . . . . . . . . . . . . . . . 171.7.5 C.U.D.A. primitive di programmazione . . . . . . . . . 181.7.6 NVCC . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2 DSP e identificazione dei segnali 222.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.2 Processori di segnali digitali . . . . . . . . . . . . . . . . . . . 23

2.2.1 Il segnale . . . . . . . . . . . . . . . . . . . . . . . . . 262.2.2 Segnale digitale . . . . . . . . . . . . . . . . . . . . . . 28

2.3 Algoritmi DSP . . . . . . . . . . . . . . . . . . . . . . . . . . 332.3.1 La trasformata di Fourier . . . . . . . . . . . . . . . . 342.3.2 La libreria CUFFT . . . . . . . . . . . . . . . . . . . . 362.3.3 La libreria FFTW . . . . . . . . . . . . . . . . . . . . . 37

2.4 Rivelazione del segnale . . . . . . . . . . . . . . . . . . . . . . 39

1

Indice 2

2.4.1 Filtri . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392.4.2 Matched filter . . . . . . . . . . . . . . . . . . . . . . . 42

2.5 Onde gravitazionali . . . . . . . . . . . . . . . . . . . . . . . . 45

3 Parallelizzazione del codice 493.1 Processi e Thread . . . . . . . . . . . . . . . . . . . . . . . . . 513.2 POSIX thread . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.2.1 Creazione e terminazione . . . . . . . . . . . . . . . . . 533.2.2 Sincronizzazione . . . . . . . . . . . . . . . . . . . . . . 543.2.3 Implementazione multi-GPU con i thread . . . . . . . . 56

3.3 MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633.3.1 Routine di base MPI . . . . . . . . . . . . . . . . . . . 643.3.2 Comunicazione point-to-point . . . . . . . . . . . . . . 653.3.3 Comunicazioni collettive . . . . . . . . . . . . . . . . . 663.3.4 Analisi del codice MPI . . . . . . . . . . . . . . . . . . 69

4 Risultati 724.1 Speedup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724.2 Numero di threads per la FFTW . . . . . . . . . . . . . . . . 734.3 Tempi e speedup . . . . . . . . . . . . . . . . . . . . . . . . . 754.4 Conclusioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Conclusioni 86

Bibliografia 88

Elenco delle figure

1 Legge di Moore. . . . . . . . . . . . . . . . . . . . . . . . . . . iii

1.1 Tassonomia di Flynn. . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Architettura Tesla C1060. . . . . . . . . . . . . . . . . . . . . . 61.3 Architettura Fermi. . . . . . . . . . . . . . . . . . . . . . . . . . 91.4 Linguaggi GPU computing supportati. . . . . . . . . . . . . . . . 101.5 Linguaggi GPU vs CPU. . . . . . . . . . . . . . . . . . . . . . . 111.6 Flusso di esecuzione di un programma CUDA. . . . . . . . . . . . 121.7 Kernel, griglie e blocchi CUDA. . . . . . . . . . . . . . . . . . . 131.8 Gerarchia di memoria di una GPU. . . . . . . . . . . . . . . . . 171.9 estensioni supportate dal compilatore NVCC. . . . . . . . . . . . 21

2.1 Trasformazione di segnale. . . . . . . . . . . . . . . . . . . . . . 232.2 Funzione di periodo T. . . . . . . . . . . . . . . . . . . . . . . . 302.3 Composizione di armoniche. . . . . . . . . . . . . . . . . . . . . 322.4 Dominio nel tempo e nella frequenza di una sinusoide. . . . . . . . 332.5 Trasformazione del segnale nel domino delle frequenze. . . . . . . 352.6 finestra di troncamento. . . . . . . . . . . . . . . . . . . . . . . 402.7 spettro della finestra di troncamento. . . . . . . . . . . . . . . . 402.8 filtraggio di un segnale con una finestra di troncamento. . . . . . . 402.9 spettro della finestra di troncamento applicato al segnale impulsivo. 412.10 ricerca di un template all’interno di rumore stocastico tramite

matched filter. . . . . . . . . . . . . . . . . . . . . . . . . . . . 422.11 Masse in movimento accelerato che modificano la struttura spa-

zio/tempo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.12 rappresentazione nel dominio del tempo dell’onda gravitazionale. . 462.13 Correlatore in output al filtro. . . . . . . . . . . . . . . . . . . . 47

3.1 Pipeline seriale di cuInspiral. . . . . . . . . . . . . . . . . . . . . 503.2 Tecnica di time sharing. . . . . . . . . . . . . . . . . . . . . . . 513.3 pipeline cuInspiral. . . . . . . . . . . . . . . . . . . . . . . . . . 563.4 FFT su GPU e CPU. . . . . . . . . . . . . . . . . . . . . . . . . 63

3

Elenco delle figure 4

3.5 Flusso del programma con MPI. . . . . . . . . . . . . . . . . . . 69

4.1 Speedup relativo ad un buffer da 219. . . . . . . . . . . . . . . . 764.2 Speedup relativo ad un buffer da 220. . . . . . . . . . . . . . . . 784.3 Speedup relativo ad un buffer da 221. . . . . . . . . . . . . . . . 804.4 Speedup relativo ad un buffer da 222. . . . . . . . . . . . . . . . 824.5 Speedup relativo ad un buffer da 223. . . . . . . . . . . . . . . . 84

Ringraziamenti

Giunto al termine del mio percorso di studi desidero ringraziare innanzituttoi miei relatori che mi hanno permesso di svolgere questo lavoro di tesi. Inparticolare, al Dr. Loriano Storchi va la mia piu profonda gratitudine perl’aiuto costante che mi ha dato in tutti questi mesi, senza il quale non sareimai riuscito a raggiungere questo obiettivo.Inoltre vorrei ringraziare tutte le persone care che mi sono e mi sono statevicine durante questi anni di universita. Vorrei ringraziare Federica, Filippo,Ivo, Khalid, Nicola, Raffaele, Stefano e Tommaso per tutti i momenti vissutiinsieme, belli e meno belli, per avermi aiutato ad affrontare con il sorrisosulle labbra le dure prove che la vita ogni tanto riserva. So che potro semprecontare su di voi. Grazie di cuore per essermi stati sempre vicini.Anche se hai resto tutto piu difficile nel momento piu delicato ritengo dove-roso ringraziare anche te : grazie Simona. Sei istintiva di natura e hai fattoquello che sentivi, non posso biasimarti.Infine, il ringraziamento piu importante e sentito va alla mia famiglia, allaquale dedico questo lavoro di Tesi. Senza il vostro aiuto non avrei mai rag-giunto questa meta. Vi sono grato per il sostegno economico che mi avetedato in questi anni, per avermi dato la forza e il coraggio di vincere la ma-lattia, di essere sempre presenti nel bene e nel male. Mi auguro che tuttii sacrifici spesi siano in questo modo, o almeno in parte, ripagati..vi vogliobene. Ora basta con i sentimentalismi passiamo alle cose serie...

i

Introduzione

Nel 1965 Gordon Moore, cofondatore della Intel Corporation, predisse chela densita dei transistor nei circuiti integrati sarebbe raddoppiata ogni dueanni circa [1]. Quest’affermazione, nota come Legge di Moore, fino ad oggiha descritto con buona approssimazione l’evoluzione dei microprocessori. Ta-le legge prevede che le prestazione dei processori raddoppiano ogni 18 mesi.Tutto cio va inoltre inserito in un contesto nel quale la richiesta di potenza dicalcolo aumenta enormemente anno dopo anno e le stime attuali prevedonoun limite del processo di miniaturizzazione (attestato attualmente a 45-32nm) nei 16-11 nm da raggiungersi attorno al 2015. Tale limite e imposto siada motivi legati ai costi di sviluppo e realizzazione delle relative tecnologieche da evidenti limitazioni di natura fisica. Cio che emerge da queste consi-derazioni e che presto il limite della Legge di Moore sara raggiunto. Quindi,al fine di garantire comunque un costante incremento delle prestazioni dellepiattaforme di calcolo, i produttori hanno recentemente deciso di adottarearchitetture multi-core, ovvero singoli chip contenenti due o piu nuclei dielaborazione(core). Inoltre, tali processori sono frutto di uno sviluppo tec-nologico che ha visto un sempre maggior utilizzo del concetto di parallelismoapplicato ai processori, con livelli di implementazione sempre piu profondi.

Nonostante le variazioni architetturali apportate alle CPU (pipeline, SSE,SIMD, multi/many core) e necessario adattare ogni volta la logica di CPUal caso specifico per sfruttarne appieno le potenzialita. Proprio per questomotivo si stanno sempre piu affermando le tecnologie legate alle GPU, acro-nimo di Graphic Processing Unit. Infatti, sebbene le GPU siano nate peressere utilizzate come supporti alla visualizzazione grafica, realta virtuale eapplicazioni ingegneristiche, attualmente esse hanno trovato applicazione an-che nelle scienze naturali come la fisica e la chimica computazionale, graziealle loro enormi potenzialita di calcolo. I concetti sopra esposti relativamentealla evoluzione delle CPU trovano applicazione nelle GPU. Infatti, le GPUsono costituite da centinaia di core di elaborazione montati su di un’unicochip (con memoria propria). I produttori di GPU hanno adottato da tempodelle architetture basate su molteplici unita di calcolo parallele. Infatti, le

ii

INTRODUZIONE iii

Figura 1: Legge di Moore.

operazioni piu pesanti che avvengono nell’ambito della grafica tridimensio-nale sono di tipo SIMD ed un elevato numero di core e fondamentale per laloro velocizzazione.Chiaramente, per sfruttare al meglio queste nuove tecnologie, diventa fon-damentale adottare paradigmi, tecniche e strumenti di programmazione pa-rallela e distribuita. Infatti, secondo la Legge di Amdahl la frazione serialedi un’applicazione che sfrutta piu risorse di calcolo contemporaneamente nelimita superiormente le prestazioni: in altre parole, maggiore e la frazioneche si riesce a parallelizzare, migliori saranno le prestazioni.Per quanto riguarda le GPU, al fine di supportare la diffusione del propriohardware per il calcolo scientifico NVIDIA ha fornito un’infrastruttura soft-ware per poter utilizzare appieno la potenzialita delle proprie GPU. Questoframework chiamato SDK (Software Development Kit), insieme al linguag-gio di programmazione CUDA, permette l’implementazione di programmi ingrado di sfruttare le GPU NVIDIA per calcoli non necessariamente legatialla grafica.Nel mio lavoro di tesi ho affrontato il problema di parallelizzare un program-

INTRODUZIONE iv

ma di identificazione di un segnale gravitazionale su piu GPU mediante l’usodelle librerie <pthread> e <MPI>. La tesi e articolata in 5 capitoli: nelprimo si analizzano le caratteristiche e il funzionamento delle moderne GPUe l’utilizzo del modello architetturale CUDA, nel secondo si descrivono i DSP,gli algoritmi che effettuano la rilevazione e la trasfomazione del segnale e siintroduce il concetto di onda gravitazionale, nel terzo presento gli approccidi parallelizzazione che ho implementato sul codice e nel quarto evidenzio irisultati ottenuti.

Capitolo 1

Architettura delle GPU eCUDA computing

1.1 MacGo

L’incremento di prestazioni dei processori nei prossimi anni, sara fortementecaratterizzato da un sempre maggior numero di nuclei di elaborazione(core)implementati in uno stesso processore e piu processori implementati in unostesso nodo di calcolo, portando l’era tecnologia attuale multi-core alla cosıdetta era many-core, dove centinaia, di core di elaborazione saranno con-centrati su di un singolo processore. Questo sviluppo ovviamente andra adinfluire pesantemente sulla scrittura e l’implementazione di un algoritmo,dato che la logica alla base del calcolatore verra completamente rivista. Leprestazioni quindi saranno legate al tipo di algoritmo che verra utilizzato,al grado di parallelizzazione che verra implementato e soprattutto al tipo dihardware utilizzato. Le moderne GPU possono contenere piu di 200 cores,permettendo di realizzare nodi di calcolo con circa 1000 cores di elaborazionecon picchi nominali di performance dell’ordine del TeraFlop.La sezione INFN di Perugia(presso la quale ho svolto il mio lavoro di tesi) sista interessando a questo tipo di architetture, dando vita al progetto MaCGO(Many-core Computing for future Gravitational Observatories). Il progettosi propone di sfruttare architetture multi-core per la ricerca del segnale gra-vitazionale emesso da coppie di stelle binarie di masse variabili, verificandol’eventuale presenza di tale segnale all’interno di rumore gaussiano bianco.L’esperimento in concreto stima la probabilita, piu o meno alta, che nel se-gnale preso in considerazione siano presenti variazioni piu o meno evidenti,che possiamo classificare come onde gravitazionali. L’obiettivo specifico delmio lavoro di Tesi e stata la parallelizzazione di codice del programma ideato

1

1.2 Evoluzione delle GPU 2

dai miei relatori su piu GPU sfruttando le librerie mpi.h e pthread.h perpremettere di delegare l’analisi del segnale a piu GPU favorendo un’ulterioreparallelismo al codice gia sviluppato per una computazione su singola GPU.La tesi e articolata su 4 capitoli di cui il primo descrive l’architettura delleGPU e i vari approcci di programmazione con esse, il secondo analizza letecniche attuali di Digital Signal Processing, nel terzo analizzo il mio lavorodi programmazione parallela e nel quarto evidenzio i risultati ottenuti.

1.2 Evoluzione delle GPU

La GPU o Graphical Processing Unit e la componente hardware che eseguele operazioni di rendering 1 all’interno di una moderna scheda video. I primichip grafici risalgono all’inizio degli anni ’80 e le loro funzioni erano limitate:mancavano funzioni per l’elaborazione di scene tridimensionali e avevano uninsieme limitato di funzioni per il disegno di scene bidimensionali. Negli anni’90, invece, i chip grafici furono sostituiti con vere e proprie CPU, opportuna-mente modificate e programmate per fornire le funzioni di disegno, richiestesopratutto da applicazioni di tipo CAD(Computer Aided Design).Negli anni seguenti vennero sviluppati i chip grafici integrati che fornivanotutte le funzioni di accelerazione richieste dalle applicazioni di disegno in duedimensioni. Sebbene fossero meno flessibili delle CPU programmabili, la lo-ro diffusione fu rapida grazie al costo inferiore, alla maggiore semplicita difabbricazione e all’avvento di Microsoft. Windows, infatti, stimolo significa-tivamente l’interesse per la grafica bitmap tanto che, pochi anni dopo, la S3Graphicsc introdusse sul mercato il primo chip di accelerazione 2D; in brevetempo le piu costose CPU grafiche vennero commercializzate.A meta degli anni ’90 l’uso della grafica tridimensionale inizio a diffondersisia nel mercato dei videogiochi che in quello dei PC, spingendo i produttoriad integrare nei chip grafici diverse funzioni di accelerazione 3D. Una fortespinta all’implementazione di queste ultime e stata data dall’uso della libre-ria grafica OpenGL[2] (Open Graphics Library). Un’altra libreria che, pi/’utardi negli anni, ha inuenzato l’evoluzione delle GPU e stata la DirectXTM[3]2

di Microsoft, nella quale a partire dalla versione 7.0 vennero introdotti i sup-porti per l’accelerazione hardware alle trasformazioni ed alle illuminazionidelle scene. Fu uno dei primi passi a segnare la trasformazione della pipeline

1Definiamo rendering come la generazione di un’immagine a partire da una descrizionematematica di una scena tridimensionale interpretata da algoritmi che definiscono il coloredi ogni punto dell’immagine.

2E una collezione di API per lo sviluppo semplificato di videogiochi per Windows. Ilkit di sviluppo (SDK) e disponibile gratuitamente sul sito della Microsoft.

1.3 Il GPU Computing 3

grafica all’interno di una GPU, che avrebbe visto rapidamente l’introduzionedello shading3 . Oggi le GPU parallele (CrossFire e SLI)4 hanno comin-ciato a contendere alla CPU funzioni computazionali, e viste le potenzialitadi calcolo il futuro della computazione scientifica sara fortemente connessoall’acronimo GPGPU.

1.3 Il GPU Computing

L’idea di sfruttare le capacita di calcolo delle GPU per compiti differenti dalrendering come gia accennato, ha portato alla nascita del GPU Computing.A differenza di una CPU infatti, la GPU nasce per l’esecuzione in paral-lelo di semplici istruzioni operanti su una grande quantita di dati (SIMD).Queste implementazioni si incontrano spesso nelle elaborazioni di dati mul-timediali, ed e intuitivo come siano molto piu vantaggiose rispetto ai sistemiCPU oriented. Ad esempio per cambiare la luminosita di un’immagine unmicroprocessore dovrebbe caricare ogni pixel che compone l’immagine neisuoi registri, effettuare la modifica della luminosita e poi salvare i risultati inmemoria. Un processore SIMD eseguirebbe prima un’ istruzione che cariche-rebbe con un’unica operazione un certo numero di pixel (il numero precisodipende dall’architettura) poi il processore GPU modificherebbe tutti i datiin parallelo e in seguito li salverebbe tutti contemporaneamente in memoria.Eseguire le operazioni a blocchi invece che agire sui singoli pixel rende le ope-razioni molto piu efficienti dato che i moderni computer sono progettati pertrasferire i dati a blocchi e sono inefficienti nei singoli accessi alla memoria.Un altro vantaggio deriva dal fatto che tipicamente le istruzioni SIMD so-no sempre in grado di manipolare tutti i dati caricati contemporaneamente:Quindi se un processore SIMD e in grado di caricare 8 dati, questo sara an-che in grado di processarli tutti contemporaneamente[4], inoltre la densita diminiaturizzazione ha un peso meno rilevante rispetto ad una CPU, dato chenon serve spendere transistor per la logica di controllo. Nelle CPU standardcon numero di core che arriva a 8, la maggior parte dei transistor e spesa pergestire i controlli(con cache e logica di salto), mentre con le GPU i core sonomolto piu semplici e veloci e tutta l’area della GPU e spesa per implemen-tarli. Viste le premesse se un’applicazione diversa dal render di un’immaginerichiede l’esecuzione di una stessa istruzione su piu dati, il GPGPU risultaessere sicuramente la soluzione piu performante.

3Un insieme di istruzioni che denisce un algoritmo di trasformazione cromatiche egeometriche.

4Implementazioni multi-gpu con le quali, rispettivamente ATI e NVIDIA sonoapprodate sul mercato.

1.4 La tassonomia di Flynn 4

1.4 La tassonomia di Flynn

Figura 1.1: Tassonomia di Flynn.

Per confrontarne le caratteristiche principali delle unita di calcolo si ri-correre alla tassonomia di Flynn, la quale classifica i sistemi di calcolo in baseal numero dei flussi di istruzioni e di dati che sono in grado di gestire. Lecategorie principali sono rappresentate in Figura 1.1 e si distinguono in :

• SISD (Single Instruction Single Data): categoria che contiene l’archi-tettura tradizionale della macchina di Von Neumann, utilizzata da tuttii calcolatori convenzionali, in cui un solo processore esegue un singoloflusso di istruzioni (programma sequenziale) ed esegue queste istruzioniogni volta su un singolo flusso di dati.

• SIMD (Single Instruction Multiple Data): alla categoria SIMD appar-tengono le architetture composte da piu unita di elaborazione che ese-guono contemporaneamente la stessa istruzione su un insieme di datidifferenti. Generalmente il modo di implementare queste architettureconsiste nell’avere un processore principale che invia le istruzioni in pa-rallelo ad un insieme di unita di elaborazione, le quali provvedono adeseguirli.

• MISD (Multiple Instruction Single Data): classe di architetture maisviluppata sul piano commerciale ma solo in alcuni progetti di ricercaper l’elaborazione dei segnali.

1.4 La tassonomia di Flynn 5

• MIMD (Multiple Instruction Multiple Data): categoria che rappresen-ta una evoluzione della categoria SISD, comprende le architetture ingrado di eseguire piu flussi di istruzioni su piu flussi di dati contempo-raneamente. Infatti la realizzazione di queste architetture avviene at-traverso l’interconnessione di un numero elevato di elaboratori conven-zionali, facendo si che a questa classe appartengano sistemi di calcolomultiprocessore e sistemi di calcolo distribuiti.

A livello implementativo, sia l’architettura AMD che quella NVIDIA ap-partengono alla classe dei sistemi SIMD, mentre a livello funzionale NVIDIAha scelto un approccio differente: infatti, se nella propria GPU AMD usadei processori vettoriali, NVIDIA adotta degli Stream Multiprocessor (SM).Questi non sono altro che processori multicore, ovvero processori contenentipiu unita di elaborazione in grado di lavorare in parallelo e di comunicaretra loro. Tale scelta e motivata dal fatto che negli ultimi anni la grafica 3Dha puntato molto su istruzioni di trasformazione scalare piu che vettoria-le, pertanto una delle chiavi del successo NVIDIA sta proprio nella facilitad’esecuzione di questo tipo di operazioni.

1.5 TESLA C1060 6

1.5 TESLA C1060

Figura 1.2: Architettura Tesla C1060.

Nel progetto cui ho preso parte sono potuto accedere in remoto tramiteprotocollo SSH-RSA5 all’hardware di MaCGO e in particolar modo alle GPUcomputazionali Tesla C1060.

1.5.1 Il flusso delle operazioni

L’Host Interface e la componente che si occupa della comunicazione tra hoste device, ovvero tra il personal computer e la periferica fisicamente connes-sa a questo, sulla quale risiede la GPU. Fra i suoi compiti principali c’equello di iniziare i trasferimenti dei dati da e verso la memoria della CPU,l’interpretazione dei comandi dell’host ed il controllo sulla loro consistenza.Successivamente il Compute work distribution si occupa della distribuzio-ne sullo SPA2 del flusso di informazioni generato dall’esecuzione dei kernel,ovvero le funzioni che vengono eseguite sulla GPU. Al termine dell’elabora-zione, nel caso fossero state eseguite operazioni di rendering, i risultati deicalcoli passano al ROP (Raster Operation Processor), che ha il compito dieseguire le funzioni non programmabili di colorazione dei pixel. I ROP opera-no direttamente sulla memoria DRAM (Dynamic Random Access Memory)cui sono connessi.

5SSH (Secure Shell) e un protocollo che permette di stabilire una sessione remota cifratatramite autenticazione RSA, algoritmo che genera una coppia di chiavi pubblica e privata

1.5 TESLA C1060 7

1.5.2 Hardware

Tesla C1060 dispone di 240 CUDA core, o singole unita di elaborazione, di-sposti su 30 Streaming Multiprocessor. All’interno di ogni core sono presentiuna completa unita di calcolo aritmetico logico (ALU) ed una floating pointunit (FPU) che garantiscono un’elevata potenza nei calcoli floating-pointIEEE 754-2008 e con le istruzioni di tipo FMA (Fused Multiply-Add), siacon numeri a singola che doppia precisione. La ALU supporta una precisio-ne a 32-bit per tutte le istruzioni ed e anche ottimizzata per l’esecuzione diistruzioni a 64-bit. All’interno del singolo SM troviamo anche 16 registri diLoad/Store che permettono di calcolare gli indirizzi sorgente e destinazioneper un massimo di 16 thread per ciclo di clock. Sono altresı presenti 4 Spe-cial Function Units (SFU) che calcolano istruzioni trascendentali come seno,coseno, radice quadrata, etc.

1.5.3 Un insieme di multiprocessori SIMT

A livello funzionale gli 8 SIMD core di ogni SP non operano eseguendo ottovolte la stessa istruzione per un flusso di esecuzione come farebbero le SI-MD tradizionali. Esse, infatti, gestiscono otto flussi di esecuzione differenti,eseguendo un un’istruzione per ciascuno di essi. In questo modo, i singolicore si comportano come unita scalari e non come unita di esecuzione di unprocessore vettoriale. Per sottolineare questa differenza, NVIDIA parla diun’architettura SIMT (Single Instruction Multiple Threads). A differenzadelle unita SIMD, questa e in grado di massimizzare l’uso delle proprie unitadi calcolo, sopratutto quando l’applicazione e eseguita su molti thread. LaGPU infatti viene utilizzata al massimo solo quando i thread attivi sono del-l’ordine delle migliaia, grazie al fatto che questi hanno un costo di creazione egestione praticamente nullo. L’architettura lavora assegnando ad ogni flussodi istruzioni un SP core, in modo che ogni thread venga eseguito indipenden-temente dagli altri, conservando il proprio stato dei registri e indirizzo delleistruzioni.Ogni SM gestisce ed esegue simultaneamente fino a 24 gruppi, chiamati Warp,di 32 thread ciascuno, per i quali la MT Issue (Multi Threaded instructionFetch and Issue Unit) si occupa di selezionare e inoltrare le istruzioni. Duran-te l’esecuzione di un programma e possibile che, in presenza di un costruttocondizionale (if-then-else), due o piu thread di un Warp seguano percorsidifferenti, Quando i 32 threads di un Warp seguono lo stesso ramo di ese-cuzione, questa architettura raggiunge il massimo dell’efficienza per il fattoche tutti gli SP di un SM eseguono la medesima istruzione. Invece, se th-read all’interno di un Warp divergono, le prestazioni decadono. Scrivere un

1.6 NVIDIA, progetti in corso 8

software che tenga conto di questa caratteristica e fondamentale se si vuo-le ottenere il massimo delle prestazioni dalla GPU. Nonostante la maggioreeffcienza, NVIDIA non vede in un’architettura SIMT la soluzione definitivaper le proprie GPU, poiche essa introduce diversi problemi rispetto ad archi-tetture piu semplici. Facendo un confronto con la classe dei sistemi SIMDeinfatti richiesta una maggiore logica di controllo, che comporta un aumentodella supercie del chip ed un maggiore consumo di energia.

1.6 NVIDIA, progetti in corso

Nvida ha da sempre dominato il mercato mondiale delle GPU. Ha fatto ca-pire al mondo intero la reale potenza della grafica computerizzata e del GPUcomputing quando ha inventato la prima GPU nel 1999. Da allora, ha costan-temente definito nuovi standard per il visual computing con nuove soluzionidi grafica interattiva mozzafiato rese disponibili su tablet, lettori multime-diali portatili, notebook e workstation. La grande esperienza di NVIDIAnell’ambito delle GPU programmabili ha portato a scoperte rivoluzionarienell’elaborazione in parallelo, che hanno reso il supercomputing molto piuconveniente e abbordabile. La societa e proprietaria di oltre 1,600 brevettiinternazionali, fra cui quelli di progetti e intuizioni essenziali per il compu-ting moderno, pertanto sforna costantemente nuove architetture hardware esoftware sempre piu aggiornati e innovativi.

1.6.1 L’architettura FERMI

La prima GPU basata sull’architettura Fermi e implementata con tre milionidi transistor e composta da 512 core CUDA. Questi core sono organizzati in16 SM di 32 core ciascuno. La GPU ha sei partizioni di memoria a 64 bit esupporta fino a un totale di 6 GB di memoria DRRAM GDDR5. Una hostinterface connette la GPU alla CPU tramite PCI-Express1. Lo schedulerglobale, chiamato GigaThread, distribuisce i thread agli scheduler degli SM.Dalla creazione della GPU G80 l’architettura Fermi e stata il piu significativopasso in avanti nelle architetture GPU. NVIDIA ha utilizzato un approcciototalmente nuovo per la Fermi, creando la prima GPU computazionale. Imiglioramenti si sono focalizzati nelle seguenti aree:

• Miglioramento delle performance per operazioni in doppia precisione:mentre le performance delle operazioni in virgola mobile a singola pre-cisione erano 10 volte superiori a quelle delle CPU, molte applicazionidi calcolo su GPU necessitavano di alte prestazioni anche per i calcoliin doppia precisione.

1.6 NVIDIA, progetti in corso 9

• Aumento della memoria condivisa: aumento di memoria condivisa, dai16KB della serie GTX 200 fino a 64 KB, per velocizzare le applicazioni.

• Velocizzazione del context switching: velocizzazione del cambiamentodi contesto tra applicazioni e dell’interoperabilita tra grafica e calcolo.

• Velocizzazione delle operazioni atomiche: velocizzazione delle operazio-ni atomiche di lettura, modifica e scrittura.

Figura 1.3: Architettura Fermi.

1.7 C.U.D.A.(Compute Unied Device Architecture) 10

1.7 C.U.D.A.(Compute Unied Device Archi-

tecture)

E il nuovo modello di programmazione parallela implementato da NVIDA chesfrutta il motore di calcolo della GPU per risolvere problemi complessi in mo-do piu efficiente rispetto ad una CPU. CUDA prevede un ambiente softwareche consente agli sviluppatori di utilizzare C ed OpenCL come linguaggiodi programmazione ad alto livello[5]. Come illustrato nella figura, altri lin-guaggi o interfacce di programmazione per applicazioni saranno supportatein futuro, (come FORTRAN, C++ e DirectX Compute).

Figura 1.4: Linguaggi GPU computing supportati.

Il compilatore di CUDA e basato sul compilatore open source Open64 6. Edi fatto innegabile che CUDA sia la piattaforma piu sviluppata e matura perpoter progettare le proprie applicazioni su GPU, disponibile ormai da moltotempo per lo scaricamento gratuito e con una grande mole di chip graciin grado di supportarlo. Infatti, qualsiasi GPU NVIDIA, a partire dallaGenerazione GeForce 8 (G80), puo da subito eseguire applicazioni scrittein CUDA, anche le schede con chip grafici di generazione equivalente della

6Open64 e ottimizzato per architetture Itanium e microprocessori x86 64, deriva daicompilatori SGI per i processori MIPS R10000. E stato rilasciato sotto licenza GNU GPLnel 2000 ed ora e per lo piu utilizzato come piattaforma di ricerca per gruppi di sviluppodi compilatori.


famiglia Quadro (dedicate principalmente al video e alla grafica industriale)e ovviamente, della famiglia Tesla.Le motivazioni che spingono (o spingeranno) sempre piu utenti verso l’uso dipiattaforme di calcolo alternative (come le GPU appunto) sono illustrate infigura:

Figura 1.5: Linguaggi GPU vs CPU.

Come si puo vedere, la potenza computazionale di queste architetture stacrescendo in maniera considerevole, se comparata con i normali processori,perche nate con uno specifico orientamento, quello delle grafica, dove centi-naia di migliaia di operazioni vengono eseguite in parallelo senza necessita didover utilizzare transistor per gestire la logica di controllo. La maggioran-za delle operazioni, infatti, e estremamente ripetitiva e le condizioni per cuidelle parti di codice vengono eseguite o meno sono molto rare.

1.7.1 Il modello architetturale C.U.D.A.

Dal punto di vista tecnico CUDA lavora sulla base del modello architetturaleriportato in figura. La GPU accede ad una memoria locale ed e connessa alsistema, e quindi alla CPU, tramite un bus (PCI Express). Il chip graco,nel modello di CUDA, e costituito da una serie di SMP. Il numero di SMPdipende dalle caratteristiche architetturali di ciascuna GPU. Ciascun SMPe a sua volta formato da otto SP (Tesla C1060). Ognuno di questi SP puoeseguire un’operazione matematica fondamentale (addizione, moltiplicazione,sottrazione, ecc) su interi o su numeri in virgola mobile in singola precisione(32 bit). In ciascun SMP sono anche presenti due unita per funzioni speciali


(che eseguono operazioni trascendenti come seno, coseno, inverso) e, solo peri chip basati su architettura GT200, un alto numero di unita in virgola mobilea doppia precisione (64 bit). In un SMP sono anche presenti una memoriacondivisa, accessibile da tutti gli SP, delle memorie cache per le istruzioni eper i dati e una un unita di decodifica delle istruzioni.

Figura 1.6: Flusso di esecuzione di un programma CUDA.

Un’applicazione CUDA e composta da parti seriali, che vengono eseguitedalla CPU di sistema, o host, e da parti parallele denominate kernel, chevengono invece eseguite dalla GPU o dal device.


Figura 1.7: Kernel, griglie e blocchi CUDA.

Un kernel e definito come una griglia e puo a sua volta essere decompo-sto in blocchi che vengono assegnati sequenzialmente ai vari multiprocessori,implementando cosi un parallelismo a grana grossa7. All’interno dei blocchic’e l’unita di computazione fondamentale, il thread, ad una granularita diparallelismo molto fine8. Un thread puo appartenere ad un solo blocco, ede identificato da un indice univoco per tutto il kernel. Per comodita, c’e lapossibilita di utilizzare indici bidimensionali per i blocchi e tridimensionaliper i thread. I kernel vengono eseguiti sequenzialmente tra loro. I blocchi ei thread, invece, sono eseguiti in parallelo. Il numero di thread in esecuzione(in parallelo) dipende dalla loro organizzazione in blocchi e dalle loro richiestein termini di risorse rispetto alle risorse disponibili nel device. I blocchi sonopensati per garantire la scalabilita: supponendo di avere un’architettura consolo due multiprocessori e un’altra con quattro, un’applicazione decomposta

7parallelismo tra processi differenti non strettamente connessi.8parallelismo tra processi fortemente connessi che condividono le stesse risorse (contest

switch istantaneo).


in otto blocchi potra essere eseguita su entrambe, ovviamente con tempi (elivelli di parallelismo) diversi.La caratteristica fondamentale di CUDA che rende il modello di programma-zione sostanzialmente differente da altri modelli paralleli (normalmente usatisulle CPU), e che per essere efficiente richiede che siano attivi migliaia dithread. Cio e reso possibile dalla struttura tipica delle architetture grafiche,che impiegano thread molto leggeri e permettono inoltre di creare e cambiarei contesti di esecuzione in maniera molto rapida ed efficiente (nessun ciclo diclock).Dal punto di vista dell’architettura di memoria, la GPU puo accedere allasua memoria privata, o global memory. L’host ha la possibilita di sposta-re i dati in questa memoria, attraverso delle primitive messe a disposizionedal linguaggio. Ciascun multiprocessore puo accedere alla propria memoriacondivisa, che invece non puo in alcun modo essere gestita dall’host. I da-ti allocati nella memoria condivisa hanno una visibilita limitata al singoloblocco di thread. Si comprende facilmente che il modello di CUDA si adattaa specifiche classi di applicazioni. In particolare, le caratteristiche che de-vono presentare tali applicazioni riguardano la presenza di molte operazionimatematiche, elevato grado di parallelismo (la stessa sequenza di operazionivengono ripetuta su grandi quantita di dati), una elevata richiesta di bandadi memoria e condizioni di controllo molto limitate. I campi di applicazioneche possiedono queste caratteristiche appartengono soprattutto alle scien-ze: applicazioni per gestione di oleodotti e individuazione di petrolio o gas,crittografia, chimica computazionale, analisi di immagini e soprattutto deisegnali. Anche gli algoritmi di codifica e decodifica audio e video, analisi deltraffico di rete e gestione di database si sposano molto bene con il modellodi CUDA.

1.7.2 C.U.D.A. kernel

Come gia accennato un kernel CUDA e una particolare funzione C che, in-vocata dall’host, viene eseguita su device[6]. I kernel hanno delle caratteri-stiche ben precise. Innazitutto, devono avere void come tipo di ritorno (nondevono ritornare valori), non possono essere ricorsivi, non possono avere unnumero di parametri variabile e non possono usare variabili di tipo statico.Inoltre i thread possono accedere solo alla memoria della GPU, dunque astrutture dati che siano allocate nella global memory del device. Nel C perCUDA le funzioni facenti parte di un kernel vanno identificate tramite ap-positi qualificatori da anteporre alla loro dichiarazione. Esistono tre tipi diqualificatori:


• global : identica la funzione invocata dal codice dell’host. e lafunzione principale del kernel;

• device : identica una funzione chiamata dal codice che viene eseguitasulla GPU, si comporta come una normale funzione C ma non puoessere invocata dall’host;

• host : e una funzione chiamata dall’host, si comporta come unanormale funzione C ma viene eseguita solo sull’host.

Le funzioni device ed host possono essere combinate, per generare codiceche funzioni sia sulla GPU che sulla CPU, sfruttando il meccanismo di over-loading degli operatori. L’invocazione di un kernel avviene all’interno delcodice eseguito sulla CPU, chiamandone il nome e specificando la configura-zione di esecuzione all’interno di appositi identificatori (<<< e>>>) con laseguente sintassi:

Kernel < < < dim3 grid, dim3 block > > >(parameter1, paramenter2,...);

grid e block sono delle variabili che specificano il numero di blocchi in cui esuddiviso il kernel e il numero di thread all’interno di ciascun blocco.

1.7.3 Gestione dei thread

Per poter realizzare un kernel effettivamente funzionante bisogna saper gesti-re e capire come individuare l’identificatore (il numero) di un thread che staoperando su un determinato dato (o insieme di dati). Per fare cio, C per CU-DA integra variabili sempre accessibili all’interno di funzioni di tipo globa edevice . Non c’e bisogno di alcuna dichiarazione per poter utilizzare questevariabili, che sono sempre attive e inizializzate ai valori corretti all’internodelle funzioni. Esse sono:

• dim3 gridDim : ritorna le dimensioni della griglia in numero di bloc-chi. Poiche la grandezza della griglia e espressa in due dimensioni, ilterzo valore e sempre uno.

• dim3 blockDim : ritorna le dimensioni del blocco in numero di thread.

• dim3 blockIdx : ritorna l’indice del blocco corrente.

• dim3 threadIdx : ritorna l’indice del thread corrente.

Si tratta di variabili di tipo dim3, e dunque tridimensionali. Per accedere aidifferent campi, si aggiunge al nome della variabile l’identificatore del camporichiesto:


• blockDim.x : ritorna la dimensione sull’asse x del blocco (numero dithread prendendo come riferimento l’asse x).

• blockDim.y : ritorna l’indice del thread corrente muovendosi sull’assey.

• blockDim.z : ritorna l’indice del thread corrente muovendosi sull’assez.

Per determinare l’indice di uno specico thread all’interno di un kernel, laformula base usata all’interno dei programmi CUDA e la seguente:

Tid = threadIdx.x + threadIdx.y * blockDim.x + threadIdx.z * blockDim.y*blockDim.x;

Ci sono alcuni particolari da tenere in considerazione quando si stabiliscel’esecuzione di un kernel. Le griglie possono avere al massimo 65.536 elemen-ti sia sull’asse x che sull’asse y, con un numero massimo di blocchi pari alprodotto tra i due. Per i blocchi, invece, si possono avere al massimo 512threads sull’asse x, 512 sull’asse y e 64 sull’asse z (ma il totale dei threads inun blocco non puo superare le 512 unita). Questo vale per tutte le versionidi hardware attualmente disponibili da parte di NVIDIA[8]. Un altro fattoda sottolineare e che i kernel sono eseguiti sequenzialmente tra loro, ma unavolta che la CPU lancia un kernel e libera di fare altre operazioni mentreesso viene eseguito sulla GPU. La chiamata e infatti asincrona, ed e quindipossibile far eseguire alla CPU altre parti di codice in concorrenza alla GPU.Se si vuole mettere la CPU in attesa della terminazione di tutte le operazioniin esecuzione sul device si puo usare la primitiva:cudaThreadSynchronize(); che attende la terminazione di tutte le chiamateCUDA precedenti.


1.7.4 Gerarchia di memoria

Figura 1.8: Gerarchia di memoria di una GPU.

In figura possiamo vedere lo schema generale della struttura della memo-ria nella GPU. Ogni thread ha accesso, in lettura e scrittura, a piu spazi dimemoria durante la sua esecuzione :

1. Registri : su ogni SM sono allocati un certo numero di registri e, adogni thread, ne e concesso solo un numero limitato. Le operazioni suiregistri hanno latenza praticamente nulla, anche se possono avere deiritardi di lettura-dopo-una-scrittura dovuti all’aggiornamento del lorocontenuto. Il numero di registri disponibili per ogni thread varia inbase alla configurazione di esecuzione che si sceglie.

2. Memoria globale : Questa e la memoria che i thread utilizzano perleggere i dati da elaborare e per scrivere i risultati delle loro operazioni.e implementata con tecnologia DRAM, quindi i tempi di accesso sonocentinaia di volte superiori a quelli dei registri e percio importante


ridurne l’utilizzo il piu possibile. Quando l’accesso alla memoria globalee inevitabile, conviene usare delle tecniche per leggere o scrivere i dati inblocchi (accessi coalescenti). Nelle GPU della serie G80, un’operazionedi lettura o scrittura coalesced si ha quando almeno la meta dei threaddi un warp (half-warp) effettua un accesso alla memoria, in modo taleche il thread i-esimo acceda alla locazione i-esima di uno spazio allineatoad un indirizzo multiplo delle dimensioni di un half-warp. Operazionidi lettura e scrittura coalesced hanno tempi inferiori di circa10 volterispetto ad operazioni di lettura e scrittura non strutturate.

3. Memoria condivisa : Questa memoria e accessibile a tutti i threaddello stesso blocco ed e generalmente utilizzata per condividere i risul-tati intermedi dei processi di calcolo. e implementata mediante banchidi memoria condivisa contenuti all’interno di ogni SM, quindi la la-tenza e leggermente maggiore di quella dei registri. Spazi contigui dimemoria condivisa sono allocati su banchi differenti in modo da ridurrei conflitti di accesso e, di conseguenza, anche i tempi di latenza.

4. Memoria costante : E uno spazio di memoria che contiene quei valoriche restano costanti in tutta l’esecuzione del kernel. I tempi di laten-za sono analoghi a quelli per l’accesso alla memoria globale; tuttaviaquesto spazio di memoria dispone di una cache: la sua presenza riducedrasticamente i tempi di attesa nel caso si acceda molte volte allo stessoelemento.

5. Memoria delle texture : Questo spazio di memoria e accessibile at-traverso l’unita delle texture. Nonostante le latenze siano superiori agliaccessi di tipo coalesced verso la memoria globale, l’uso della memoriadelle texture puo essere vantaggioso. Tramite questo spazio di memo-ria, infatti, si possono eseguire operazioni di lettura che, o non possonoessere rese coalesced, o coinvolgono un insieme di dati sufficientementepiccolo da essere contenuto interamente nella cache.

1.7.5 C.U.D.A. primitive di programmazione

Il concetto base di CUDA, e di qualsiasi applicazione di tipo GPGPU, e chesi sta eseguendo un offloading di una parte di computazione ad un copro-cessore, rispetto al processore (la CPU) del sistema. Tale coprocessore, cheviene chiamato device, accede ad una memoria privata (la global memory)nella quale devono essere mossi i dati prima di poter eseguire la computazio-ne. La CPU e la memoria di sistema vengono identificati come host. L’host,prima di far iniziare una computazione al device, muove i dati nella global


memory. Al termine della computazione, i risultati sono copiati dalla memo-ria del device alla memoria dell’host. Per eseguire queste operazioni, sononecessarie delle apposite primitive per per selezionare il device, allocarvi lamemoria necessaria ed eseguire le copia dall’host al device[7]. La memoriasull’host e allocata nelle modalita standard del C, con variabili automaticheo, nel caso di allocazione dinamica, con la classica malloc. Per selezionare eottenere informazioni su un determinato device CUDA mette a disposizionedei programmatori le seguenti primitive:

• CudaGetDeviceCount(int * count)

Ritorna in *count il numero dei devices con capacita computazionalemaggiore o uguale a 1.0 che sono disponibili per l’esecuzione. Se nonc’e nessun device, CudaGetDeviceCount() ritorna 1 e imposta il device0 come device di default. Tale device verra utilizzato per tentare diemulare le caratteristiche hardware di una GPU con capacita di calcolopari a 1.0.

• CudaSetDevice(int *device)

Imposta device come il dispositivo sul quale l’host thread attivo va adeseguire il device code. Se device e gia stato assegnato a un altro threadla chiamata ritorna cudaErrorSetOnActiveProcess.

• CudaGetDevice(int *current device)

Ritorna in *device il dispositivo sul quale l’host thread esegue il devicecode.

• CudaGetDeviceProperties(CudaDeviceProp *prop, int device)

Ritorna in *prop le caratteristiche del dispositivo device fornendo cosi’una descrizione dettagliata di tutte le caratteristiche del dispositivo pre-so in considerazione come ad esempio nome, dimensione della memoriaglobale e condivisa, numero di registri per blocco, numero massimo dicuda threads nelle 3 dimensioni ecc..

• CudaChooseDevice(int *device, const struct cudaDeviceProp *prop)

si assegna allo struct puntato da *prop le caratteristiche desiderate diun dispositivo e la funzione ritorna in *device l’indice del dispositivoche piu si adatta alle caratteristiche richieste.

Per eseguire l’allocazione della memoria sul device, CUDA offre la seguenteprimitiva:


• CudaMalloc(void ** pointer, size t n bytes)

Dove va specificato il nome del puntatore all’area di memoria che si staallocando (** pointer), e la grandezza in bytes dell’area di memoria daallocare (size t n bytes).

Per eseguire le operazioni di copia invece si usa la primitiva:

• CudaMemcpy(void *dst, void *src, size t nbytes, cudaMemcpyKind di-rection);

La direzione puo essere uno dei seguenti tipi:

1. cudaMemcpyHostToDevice

2. cudaMemcpyDeviceToHost

3. cudaMemcpyDeviceToDevice

La prima copia i dati dall’host al device, la seconda dal device all’host(per esempio, per leggere i risultati) e la terza i dati in due aree dimemoria diverse sul Device.

Per liberare l’area di memoria usata, si usa invece la primitiva:

• cudaFree(void *pointer);

nella quale basta specificare il puntatore all’area di memoria da liberare.

Con la primitiva:

• cudaMemset(void *pointer, int value, size t count);

Si puo inizializzare ad un valore voluto (value) un’area di memoria digrandezza (in numero di elementi) count.

Con queste primitive, e possibile realizzare qualsiasi programma cuda cheseleziona un device, eseguire una copia dei dati dall’host e riportare i risultatialla CPU.


1.7.6 NVCC

I kernel possono essere scritti utilizzando un linguaggio ad alto livello comeil C, oppure utilizzando un set di istruzioni messe a disposizione dall’archi-tettura CUDA chiamate PTX (Parallel Thread eXecution). In ogni caso, ikernel devono essere compilati in machine code tramite il compilatore nvcc.Il flusso di lavoro del compilatore nvcc consiste essenzialmente nella separa-zione del codice host da quello device, compilando il codice device in assembly(PTX) o in codice binario (cubin). La lista delle estensioni supportate dalcompilatore nvcc e riporta in Tabella:

Figura 1.9: estensioni supportate dal compilatore NVCC.

Oltre al C il compilatore supporta pienamente anche programmi scrittiin C++ (per quanto riguarda il codice host), ma e’ solo il sottoinsieme C delC++ ad essere pienamente supportato per il codice device; alcune caratte-ristiche come la definizione di classi, ereditarieta e la definizione di variabilinon sono supportate. E’ importante notare che il compilatore nvcc di defaultcompila in singola precisione, quindi per i device che supportano operazioniin doppia precisione (Tesla C1060) e’ necessario inserire un’opzione da rigadi comando o nel makefile : -arch=sm 13.

Capitolo 2

DSP e identificazione deisegnali

2.1 Introduzione

Uno dei piu importanti settori di applicazione dell’elettronica digitale in si-stemi dedicati (embedded) riguarda l’elaborazione numerica (digitale) delsegnale (e dell’immagine, che sostanzialmente costituisce un segnale bidimen-sionale). Una definizione elementare della elaborazione numerica del segnaleconsiste nell’applicazione di operazioni matematiche a segnali rappresentatiin forma numerica. I segnali sono rappresentati numericamente come sequen-ze di campioni ottenuti da segnali fisici mediante trasduttori (ad esempio,un microfono!) e convertitori analogico-digitale (ADC). I segnali numericivengono poi riconvertiti in forma analogica (se occorre) mediante converti-tori digitale-analogico (DAC). Algoritmi tipici di elaborazione numerica deisegnali sono quelli di filtraggio, trasformazione nel dominio delle frequen-ze (FFT) e correlazione. Questo settore e distinto da alcune caratteristichefondamentali: in genere, sono necessari:

• calcoli numerici ripetitivi, ripetuti con continuita su grandi masse didati, che giungono a frequenza fissa e nota;

• precisione elevata;

• elevata banda di memoria;

• elaborazione in real time;

• elevata frequenza (throughput) di elaborazione.

22

2.2 Processori di segnali digitali 23

I microprocessori programmabili per l’elaborazione digitali dei segnali pos-sono essere raggruppati nelle seguenti categorie:

• Microprocessori general-purpose : Questi microprocessori devonosupportare le piu disparate applicazioni, quindi la loro architetturaviene progettata per l’ottimizzazione della gestione della memoria; leloro prestazioni nell’elaborazione digitale dei segnali risultano tuttaviamediocri.

• Microcontrollori : Questi strumenti implementano singole parti di unelaboratore, ad esempio apparecchi per l’input-output, memorie RAM eROM; l’architettura e generalmente funzionale all’ottimizzazione dellecaratteristiche input-output.

• Processori specializzati per l’elaborazione dei segnali (DSP): Un Digital Signal Processor e un microprocessore ottimizzato pereseguire in maniera estremamente efficiente sequenze di istruzioni ri-correnti (come ad esempio somme, moltiplicazioni e traslazioni) nelcondizionamento di segnali digitali. I DSP utilizzano un insieme ditecniche, tecnologie, algoritmi che permettono di trattare un segnalecontinuo dopo che e stato campionato.

2.2 Processori di segnali digitali

Figura 2.1: Trasformazione di segnale.

Un DSP e un microprocessore appositamente studiato per ottimizzare leprestazioni nell’elaborazione di un segnale. Poiche gli algoritmi per la simu-lazione di sistemi per segnali consistono spesso nella iterazione di sequenzedi semplici operazioni aritmetiche, grande attenzione e posta nell’ottimizza-zione dell’unita aritmetico-logica (ALU): i primi DSP sono addirittura statimotivati dalla necessita di accelerare l’esecuzione dell’operazione di moltipli-cazione, rispetto agli usuali microprocessori.La necessita di grande velocita di elaborazione imposte dalle applicazioni in


real-time richiede inoltre l’introduzione di architetture che sfruttino l’inerenteparallelismo di alcune funzionalita, pur sacricando la semplicita realizzativee la flessibilita rispetto alle applicazioni.Molto spesso, in un sistema complesso un DSP programmabile puo comparireaffiancato ad altri dispositivi programmabili di tipo generale (microcontrol-lori, ad esempio) cui vengono delegate funzioni piu generali, di servizio e dicontrollo globale del sistema. E interessante rilevare come nei DSP si ri-trovino alcune soluzioni architetturali che sono poi state adottate nelle piurecenti CPU di tipo generale; in effetti, gli algoritmi di elaborazione del se-gnale hanno caratteristiche intrinseche di parallelismo che si prestano bene asfruttare soluzioni architetturali quali il pipelining e il parallelismo a livellodi istruzioni.Le applicazioni piu estese per l’elaborazione del segnale tramite DSP sitrovano in campi quali:

• le telecomunicazioni

• l’elaborazione audio e video

• operazioni di streaming di dati

• la grafica, o rendering tridimensionale

• applicazioni radar, GPS, in genere per il controllo della navigazione

La disponibilita di dispositivi DSP e essenziale per molti tipi di prodottielettronici: gli algoritmi di elaborazione del segnale sono spesso un collo dibottiglia in molte moderne applicazioni dei calcolatori, e le specifiche delleapplicazioni ”DSPintensive” diventano quotidianamente piu stringenti. Pe-raltro, in molte applicazioni embedded i microprocessori generali ad alte pre-stazioni non risultano competitivi con processori DSP specifici. Val la penadi accennare che nel ’97 il mercato mondiale dei processori di DSP valeva 3miliardi di dollari[9] e da allora la crescita e stata esponenziale. In confrontoa un microprocessore di tipo generale, un dispositivo DSP ha un sistema ope-rativo molto piu semplice (in genere, c’e un unico programma da eseguire!),non ricorre a soluzioni di memoria virtuale e opera su un flusso continuo eseriale di dati in ingresso.Alcune ipotesi che caratterizzano il progetto dei primi DSP sono le seguenti:

• le istruzioni vengono avviate all’esecuzione/eseguite/completate in or-dine;

• a ogni ciclo di clock la CPU avvia all’escuzione un’istruzione;


• Il CPI1 per istruzione e 1;

• l’aritmetica in virgola mobile e lenta e costosa e si tende a evitarla.

L’insieme delle istruzioni permetteva di scrivere codice molto compatto perapplicazioni quali il filtraggio dei segnali. Gia questo prefigura molte dellecaratteristiche oggi comuni alla maggior parte dei DSP:

• il Data Path2 e configurato per l’elaborazione del segnale;

• l’insieme delle istruzioni e specializzato;

• ci sono piu banchi di memoria e corrispondenti bus di accesso;

• i modi di indirizzamento sono specializzati;

• il controllo dell’esecuzione e specializzato in modo da semplificare almassimo la programmazione e la gestione dei cicli;

Visto il livello prestazionale, i campi di applicazione e i costi contenuti rispet-to a soluzioni general-purpose, la ricera ha sempre piu favorito lo svilupponel settore dei DSP.Avendo come obbiettivo miglioramenti signicativi nelle prestazioni, l’attualetendenza nelle architetture per DSP e di aumentare sia il numero di opera-zioni compiute per istruzione che il numero di istruzioni eseguite per ogniciclo[10]. Di conseguenza, le architetture dei nuovi DSP devono saper sfrut-tare in modo intelligente le tecniche di elaborazione parallela. Analizziamodi seguito i due approcci: architetture SIMD e architetture superscalari.

• Architetture SIMDI sistemi con architettura SIMD (Single Instruction Multiple Data) de-vono permettere l’esecuzione parallela della stessa operazione su diffe-renti dati. Per ottenere questo obbiettivo, il DSP deve contenere diversibus dati e diverse unita di elaborazione: in questo modo in un ciclo lastessa istruzione puo essere eseguita dalle varie unita di elaborazionesu differenti dati. In figura viene evidenziata la presenza di due unitadi elaborazione e di due bus dati nello stesso DSP.

• Architetture superscalariL’elaborazione superscalare e una tecnica per aumentare la velocita di

1Cycle Per Instruction: indica il numero di cicli di clock necessari al microprocessoreper eseguire un istruzione.

2Il Data Path e un unita di calcolo che contiene tutte le unita di elaborazione ALU edi registri necessari per l’esecuzione delle istruzioni nella CPU


calcolo sfruttando invece il potenziale parallelismo a livello di istruzio-ni. E’ noto infatti che, in certe circostanze, alcune istruzioni possonoessere eseguite in modo indipendente: avendo a disposizione un ade-guato numero di unita di elaborazione, la loro esecuzione in parallelosulle varie unita accelera il calcolo. Per chiarire con un esempio, siconsideri la sequenza di istruzioni:x = x + 1;x = y;In questo caso le istruzioni non possono essere eseguite in modo indi-pendente, perche in particolare il risultato dipende dall’ordine di ese-cuzione. Se invece consideriamo la sequenza:x = x + 1;y = z;Le due istruzioni possono essere eseguite in maniera indipendente: at-tribuendo a due distinte unita di elaborazione le due istruzioni ed ese-guendole in parallelo, si ottiene il risultato corretto diminuendo il tem-po di esecuzione. Questo e il principio generale: in una architetturasuperscalare, differenti unita concorrono all’avanzamento del calcoloeseguendo differenti istruzioni in parallelo. E ovvio che nella program-mazione superscalare deve essere effettuata in maniera continua un con-trollo sulla schedulazione delle istruzioni che eviti i problemi di conflitto(hazard) creati dalle dipendenze nei dati. Nonostante le tecniche piu’affermate per evitare conflitti sui dati (stallo, Branch Target Buffer)siano sempre piu’ precise, l’utilizzo di tecnologie SIMD per l’analisi deisegnali digitali e sicuramente la soluzione piu’ performante.

2.2.1 Il segnale

Il signal processing e una branca dell’ingegneria elettronica e matematicaapplicata che si occupa dell’analisi dei segnali (in un dominio di temporalediscreto o continuo) per ottenere trasformazioni mirate del segnale stesso. Isegnali di interesse sono di vario tipo come segnali audio, video, segnali bio-logici (elettrocardiogrammi), segnali di telecomunicazione come segnali radioe molti altri.Un segnale e dunque una vibrazione prodotta da una sorgente che si pro-paga nel mezzo (aria, acqua, solido, vuoto..). I Segnali impiegati nelletelecomunicazioni, in base alla loro natura fisica possono essere divisi in:

• segnali elettrici

• segnali elettromagnetici


• segnali acustici

• segnali ottici

I segnali elettrici sono legati alla corrente elettrica, cioe al movimento di or-dinato delle cariche elettriche all’interno di un conduttore, mentre quelli dinatura elettromagnetica, acustico ed ottica si propagano attraverso onde. Leonde elettromagnetiche vengono studiate per la prima volta da James ClercMaxwell.Le onde elettromagnetiche, ipotizzate Maxwell nel 1864, sperimentate in la-boratorio da Hertz e utilizzate nella Radio da Marconi nel 1895, sono co-stituite da oscillazioni, del campo elettrico e del campo magnetico, che sipropagano nel vuoto alla velocita di circa:

c = 299.792,458 m / s

Le onde elettromagnetiche sono classificabili a seconda delle loro caratteri-stiche e del loro impiego nei vari campi della tecnica, in base alla lunghezzad’onda od anche alla frequenza, in quanto queste grandezze sono legate fraloro dalla seguente espressione:

λ = c/f 3

dove:

• λ = lunghezza d’onda (metri)

• c = 3 * 108 velocita della luce nel vuoto (metri/sec)

• f = frequenza (Hertz = sec-1)

I segnali RF4 trasmessi da una sorgente, viaggiando nello spazio subisconouna attenuazione proporzionale alla distanza che questi percorrono. Vedia-mo ora come si determina il valore di potenza che arrivera ad una ipoteticastazione ricevente posta ad una certa distanza dal trasmettitore. Supponia-mo di avere una sorgente che trasmette utilizzando un’antenna isotropica.Il segnale emesso si propaga in tutte le direzioni come se fosse in una sfera,pertanto tutta la potenza emessa verra diluita su questa sfera in proporzionealla distanza che il segnale percorre nello spazio. Per antenna isotropica siintende un’antenna ideale che propaga il suo segnale uniformemente in tutte

3Quest’eguaglianza ha senso solo se il mezzo di trasmissione e il vuoto4RF acronimo di Radio Frequenza cioe con una frequenza compresa tra 0 e 300 Ghz,

ovvero con lunghezza d’onda compresa tra 1mm e infinito


le direzioni. Tale antenna e puramente teorica e non realmente esistente[11],pero questo principio viene preso come base per la determinazione del campopropagato.Una facile analogia potrebbe essere quella di una lampadina che emette lucein tutte le direzioni, in questo caso noteremo che con il progressivo allonta-namento da questa sorgente l’intensita di luce diminuisce con la distanza.Inoltre, quando si parla di detection di segnale bisogna distinguere due cir-costanze totalmente diverse:

• Propagazione delle onde elettromagnetiche nel vuoto al di la dell’atmo-sfera terrestre.

• Propagazione delle onde elettromagnetiche all’interno dell’atmosferaterrestre.

Nel vuoto interplanetario o intergalattico, quindi lontano dall’atmosfera ter-restre, da corpi materiali e da ostacoli, il mezzo e isotropo ed omogeneo,quindi il comportamento delle onde elettromagnetiche e assolutamente indi-pendente dalla frequenza e quindi dalla lunghezza d’onda. In questo ambien-te, le onde elettromagnetiche si muovono tutte e sempre in linea retta e sipropagano tutte alla stessa velocita. Viceversa, entro l’atmosfera terrestre,poiche l’aria che noi respiriamo non e un mezzo ne isotropo, ne omogeneo, lapropagazione delle onde elettromagnetiche e soggetta a:

• Attenuazione

• Riflessione

• Rifrazione

• Diffrazione

• Diffusione

• Fading

La ricezione di un segnale dovra quindi prevedere tecniche di pulizia del se-gnale stesso tramite degli algoritmi di filtraggio che vengono applicati propriodai DSP.

2.2.2 Segnale digitale

La digitalizzazione e il processo di conversione che applicato alla misurazionedi un fenomeno fisico ne determina il passaggio dal campo dei valori continui


a quello dei valori discreti. Tale processo viene oggi comunemente sintetiz-zato nei termini di conversione analogico al digitale. In effetti l’operazionecomporta una perdita di informazioni, che pero in alcuni casi e accettabilein quanto si guadagna in semplicita di rappresentazione o in altri casi non ecomunque percepita.Nel campo dell’informatica e dell’elettronica, con digitalizzazione si intendeil processo di trasformazione di un’immagine, di un suono o di un segnale inun formato digitale, interpretabile da un computer, dove per formato digitalesi intende un codice binario in cui tutto e rappresentato da combinazioni dizero od uno. Un disco in vinile su cui e registrata una canzone rappresenta unesempio di riproduzione analogica di un suono; la stessa canzone riprodottatramite un computer ne rappresenta il formato digitale. Per digitalizzare unsegnale occorre processare il segnale analogico in 3 trasformazioni:

• Campionamento Definiamo campionamento come una tecnica checonsiste nel convertire un segnale continuo nel tempo(che richiedereb-be una memoria infinita per essere campionato) in un segnale discreto,valutandone l’ampiezza a intervalli di tempo regolari. In questo modo,a seguito di una successiva operazione di quantizzazione e conversione,e possibile ottenere una stringa digitale (discreta nel tempo) che ap-prossimi quella continua originaria. In parole povere il campionamentoconsiste nell’andare misurare il valore del segnale analogico in diversiistanti di tempo. Il tempo T che intercorre tra una valutazione e l’altrasi chiama periodo di campionamento.

• Quantizzazione Il processo di quantizzazione consiste nel rappresen-tare l’ampiezza del segnale campionato mediante valori discreti. Perottenere cio i valori possibili della grandezza in questione vengono li-mitati tra un massimo ed un minimo intorno a dei valori discreti pre-ventivamente definiti: in tal modo il valore analogico della grandezzaoriginaria, in corrispondenza del valore campionato in ascissa, verraricondotto al piu prossimo dei valori discreti preventivamente definititramite il processo di decisione.

• Troncamento Per troncamento si intende l’eliminazione di alcuni datida una sequenza. Essendo un segnale continuo e rappresentando, inteoria, una sequenza infinita di informazioni e necessario troncare ilsegnale per discretizzarlo.

Nonostante la conversione da analogico a digitale sia una trasformazione ditipo lossy5, minore sara il periodo di campionamento e maggiore sara il nu-

5Trasformazione di un dato che porta ad una perdita definitiva di partedell’informazione trattata


mero di bit utilizzati per campionare il segnale, tanto piu’ fedele risulteraessere la conversione AD (Analogico Digitale), ma di contro tanto piu’ pe-sante risultera essere il segnale digitale convertito.Ma come scegliere la frequenza di campionamento? Deve essere scelta inmaniere tale da:

• Ridurre al massimo la quantita di dati da memorizzare

• Rendere il segnale campionato il piu fedele possibile al segnale originale

Con il termine Alta fedelta (High Fidelity), meglio conosciuto come tec-nologia HI-FI definiamo proprio la capacita maggiore di discriminare dellospettro di certe frequenze da parte di chi fruisce il segnale, ad esempio lafrequenza di campionamento di un normale CD-R / RW e’ di 44khz, ovveroin un secondo di riproduzione, il segnale in esso contenuto sara suddiviso in44.000 campioni. Il segnale che viaggia su linea telefonica, ad esempio, e’invece espressione di tecnologia LO-FI essendo campionato ad una frequenzadi 8khz. Consideriamo il seguente segnale unidimensionale:

Figura 2.2: Funzione di periodo T.

Una funzione di questo tipo puo’ essere espressa come una somma diarmoniche di differenti frequenze e ampiezze. Tale sommatoria prende ilnome di serie di Fourier e ha una forma del tipo:

y = A sin (ω x + ϕ)y = A cos (ω x + ϕ)

Dove:

• A = Ampiezza


• ω = Pulsazione (2π/T)

• ϕ = Fase

Per cui:

A sin ( ωx +ϕ) = a cos ωx + b sin ωxA cos ( ωx +ϕ) = b cos ωx + c sin ωx

Dove:

• a = sinϕ

• b = cosϕ

• c = -sinϕ

Fatte queste premesse , tornando all’esempio iniziale, notiamo che lafunzione considerata e’ una funzione periodica di periodo T, che possiamorappresentare come una serie di armoniche sovrapposte:


Figura 2.3: Composizione di armoniche.

2.3 Algoritmi DSP 33

La sommatoria di tutte le armoniche definisce la Serie di Fourier espressadalla seguente formula:

f(x) =a02

+∞∑k=1

(ak cos kx+ bk sin kx)

2.3 Algoritmi DSP

Come gia accennato l’utilizzo di un DSP risulta vantaggioso quando occorreoperare su dati che presentano carattersitiche di ripetitivita di calcolo e con-tinuita su grandi masse di dati, elaborazione in real-time uniti ad un elevatafrequenza di elaborazionie. Nell ambito del settore delle telecomunicazioni,medicina, telefonia si sono standardizzati degli algoritmi progettati ad hocper sfruttare a pieno le potenzialita dei Digital Signal Processors. Durante ilmio percorso di tesi ho potuto constatare l’utilita di tali algoritmi e la facilitadi una loro implementazione.I principali algoritmi di analisi dei segnali possono essere riassunti nei con-cetti di analisi nel dominio del tempo e analisi nel dominio della frequenza.E importante osservare che questi due modi di affrontare un problema sonotra loro intercambiabili, nel senso che, sotto opportune condizioni, nessunainformazione viene persa nel passare da un dominio all’altro. Il vantaggioche deriva dall’introduzione dei due domini e la possibilita di cambiare laprospettiva con la quale si osserva un dato fenomeno. In questo modo unproblema che appare di difficile soluzione in un dominio puo risultare moltopiu semplice nell’altro.Lo strumento matematico che consente di trasferire lo studio dei segnali e deisistemi dal dominio del tempo al dominio della frequenza e la trasformata diFourier.

Figura 2.4: Dominio nel tempo e nella frequenza di una sinusoide.


2.3.1 La trasformata di Fourier

La trasformata di Fourier X(f) di una funzione continua nel tempo x(t) edata dalla relazione:

X(f) =

∫ +∞

−∞x(t)e−j2πftdt

La trasformata di Fourier consente quindi di rappresentare un segnale con-tinuo come somma di infiniti esponenziali periodici pesati da X(f)df. Poichein generale la X(f) complessa, essa puo essere descritta mediante gli spettridi ampiezza e fase.Si osservi che l’unita di misura di X(f) coincide con quella di x(t) diviso lafrequenza (espressa in hertz). La relazione che definisce la trasformata diFourier non e direttamente implementabile mediante un elaboratore digitaledi segnale, sia perche essa richiede l’analisi di segnali continui, x(t) e X(f),sia perche l’integrale si estende all’infinito e richiederebbe dunque un numeroinfinito di dati da elaborare. Per poter effettuare tale trasformazione con unsistema digitale sono dunque necessarie tre operazioni fondamentali: il cam-pionamento, il troncamento del segnale e la discretizzazione dell’asse dellefrequenze (quantizzazione). Ciascuna di queste operazioni puo influenzaresignificativamente l’attendibilita del risultato dell’analisi.La trasformata di Fourier e largamente utilizzata nell’analisi in frequenza deisistemi dinamici, nella risoluzione delle equazioni differenziali e nella teoriadei segnali, in cui la trasformata di Fourier e lo strumento che permette discomporre e successivamente ricombinare, tramite la formula inversa o an-titrasformata, un segnale generico in una somma infinita di sinusoidi confrequenze, ampiezze e fasi diverse, il cui insieme di valori in funzione dellafrequenza, continuo o discreto, e detto spettro di ampiezza e spettro di fase.

Volendo applicare la trasformata alla serie di armoniche viste precedente-mente otteniamo i seguenti domini in frequenza:


Figura 2.5: Trasformazione del segnale nel domino delle frequenze.


2.3.2 La libreria CUFFT

FFT e un algoritmo divide-et-impera per il calcolo efficiente della trasformatadi Fourier di un set di dati complessi o reali. E uno degli algoritmi numericipiu importanti e maggiormente utilizzati per applicazioni dinamiche e fisichesu DSP. La libreria CUFFT[8] fornisce una semplice interfaccia per calcolarela FFT in modo distribuito su una GPU NVIDIA, permettendo di sfruttare ilparallelismo della GPU senza dover sviluppare una propria implementazionedella FFT .Le librerie FFT supportano diversi tipi di dato e dimensioni della trasformata.La versione utilizzata in questo lavoro di tesi supporta le seguenti funzioni:

• trasformate 1D, 2D e 3D su tipi di dato complessi e reali su di un setarbitrario di punti;

• esecuzione batch per eseguire trasformate multiple 1D in parallelo;

• trasformate 2D e 3D aventi per ogni dimensione un massimo di elementipari a 16348;

• il numero di elementi massimo per una trasformata 1D pari a 8 milioni;

• trasformazioni di tipi di dato complesso e reale in-place e out-of-place6

• trasformazioni in doppia precisione per hardware compatibili

Come detto precedentemente la libreria CUFFT supporta trasformate contipi di dato reali o complessi. Le trasformazioni piu utilizzate sono le seguenti:

• CUFFT R2C trasformata da valori reali in singola precisione a valoricomplessi;

• CUFFT C2R trasformata da valori complessi a valori reali;

Piano di esecuzioneIl modello da seguire per eseguire una trasformata prevede una configurazioneiniziale chiamata plan, dove vengono specificati il tipo di dato, la direzione egli elementi della trasformata (FORWARD o INVERSE), fornendo all’utenteuna semplice interfaccia per definire i parametri in input. Come accennato inprecedenza CUFFT supporta trasformate 1D, 2D e 3D, quindi sono presentidelle API per la creazione e successiva eliminazione di spazi 1D, 2D, 3D:

6Per trasformata in-place si intende che l’output della chiamata viene restituito nell’areadati di input, mentre out-of-place sta a significare che l’output viene ritornato in un’areadati separata


• cufftPlan1d(cufftHandle *plan, int nx, cufftType type, int batch): conquesta chiamata viene creato uno spazio 1D con un numero di elementipari a nx, tipo di dato specificato da type e il numero di volte che deveessere eseguita l’operazione specificato da batch.

• cufftPlan2d(cufftHandle *plan, int nx, int ny, cufftType type): con que-sta chiamata viene creato uno spazio 2D con un numero di elementi paria nx lungo l’asse X ed ny lungo l’asse Y e con il tipo di dato specificatoda type.

• cufftPlan3d(cufftHandle *plan, int nx, int ny, int nz, cufftType type):con questa chiamata viene creato uno spazio 3D con un numero dielementi pari a nx lungo l’asse X, ny lungo l’asse Y ed nz lungo l’asseZ, con il tipo di dato specificato da type.

• cufftDestroy(cufftHandle plan): questa chiamata libera tutte le risorseassociate agli spazi generati.

Una volta creato lo spazio ci sono delle API per l’esecuzione della trasfor-mata in base al tipo di dato in input. In particolare, si illustra la cufftExe-cR2C che, come vedremo in seguito, sara utilizzata per il calcolo della FFTsu GPU per la trasformazione del segnale nel dominio delle frequenze.

cufftExecR2C(cufftHandle plan, cufftReal *idata, cufftComplex *odata)

Questa chiamata esegue una FFT nello spazio specificato e nella direzionedefinite nel piano di esecuzione su dati complessi in singola precisione. Vieneutilizzato il puntatore alla memoria della GPU dei dati in input tramite ilparametro idata. I coefficienti della trasformata vengono quindi memorizzatinell’array odata (se idata e odata sono gli stessi questo metodo esegue unatrasformazione in-place).

2.3.3 La libreria FFTW

La libreria FFTW(Fastest Fourier Transform in the West)[13] e una libreriaC per il calcolo della Fast Fourier Transform che esegue la trasformazione suCPU. Come per la CUFFT prevede un semplice meccanismo di configurazio-ne della trasformata chiamato plan, dove vengono specificati il tipo di dato,la direzione e gli elementi della trasformata, fornendo all’utente una sempliceinterfaccia per definire i parametri in input.

FFTW multi-threaded


Questa routine trasforma sia dati reali e complessi in maniera mono o mul-tidimensionale utilizzando un implementazione multi-threaded. Un sistemache utilizza FFTW multi-threaded sfrutta piu processori che eseguono tra-sformazioni simultandee. Funziona proprio come il corrispondente CUFFTsalvo che vi e una routine per impostare il numero di thread da utilizzare.Qualsiasi programma che utilizza il monoprocessore FFTW puo quindi es-sere modificato per utilizzare il multi-threaded FFTW. Prima di chiamarequalsiasi routine FFTW, e necessario chiamare la funzione:

fftw init threads int (void);

Questa funzione, che necessita di essere chiamata solo una volta, inizia-lizza le risorse per utilizzare i thread sul sistema. Restituisce zero in caso dierrore altrimenti, un valore diverso da zero.Inoltre, prima di creare un piano che si desidera eseguire in parallelo, enecessario chiamare:

fftw plan with nthreads void (nthreads int);

Dove nthreads indica il numero dei thread che FFTW andra ad utilizzareper eseguire la FFT su CPU. E possibile creare piu piani con un numerovariabile di thread. Ad ogni esecuzione del piano, la FFT verra eseguita conil numero di thread precedentemente dichiarati.La dichiarazione del piano di esecuzione avviene in maniera analoga allaCUFFT con la sola differenza che nel piano basta definire la sola direzionedi trasformata:

fftw plan(cufftHandle plan)

L’esecuzione del piano creato e si articola in 2 fasi:

• Definire la modalita della trasformazione

fftw plan fftw plan dft tipo di trasformazione spazio di trasformazione(intn, dtype *in, dtype *out, unsigned flags);

Questa trasformazione e analoga alla rispettiva trasformazione su GPU.L’attributo tipo di trasformazione definisce la modalita di trasforma-zione del dato (R2C o C2R), mentre tipo di trasformazione definisce lospazio della trasformazione che puo essere a 1, 2 o 3 dimensioni.

• Eseguire il piano

Per eseguire il piano creato basta lanciarne l’esecuzione:

2.4 Rivelazione del segnale 39

fftw execute(cufftHandle plan)

Per distruggere il piano si utilizza la primitiva seguente:

fftw destroy plan(cufftHandle plan)

2.4 Rivelazione del segnale

Ci sono sostanzialmente due tecniche che consentono di effettuare una rive-lazione di un segnale:

• filtraggio (teoria statistica della stima)E la ricostruzione della forma originale del segnale per consentire lastima di alcuni parametri: ampiezza, periodo,..

• correlazione (teoria statistica della rivelazione)Consiste nel rivelare la presenza di un segnale di forma nota senzaricostruirne la forma.

Desideriamo ricostrure o stabilire la presenza di un segnale s(t) attraversouna sua osservazione sperimentale x(t) con:

x(t) = s(t) + n(t)

dove n(t) e rumore additivo.

2.4.1 Filtri

Il compito di un filtro e quello di eliminare le componenti spettrali del segnalex(t) che non contengono alcuna informazione sul segnale che indendiamo sti-mare. Bisogna sempre considerare il tipo di segnale (armonico, impulsivo,..)e il tipo di comportamento del filtro al rumore e ai disturbi.La forma piu semplice di filtro che possiamo considerare e un integratore suun intervallo di tempo detto finestra mobile o di troncamento[14]. In praticase lo spettro del segnale originario x(t) contiene delle transizioni nette, adesempio componenti armoniche impulsive come nel caso di un segnale pe-riodico nel tempo, tali transizioni vengono smussate e lo spettro del segnaleperiodico viene filtrato e si disperde in frequenza, tanto piu quanto piu estretta la finestra.

La finestra di troncamento di tipo rettangolare, rappresentata in figura edefinita dalla seguente relazione:

w(t) =

{1 se −Tw

2≤ t ≤ Tw

2

0 altrove


Figura 2.6: finestra di troncamento.

Lo spettro W(f) del segnale di troncamento e del tipo sin(x)/x, comerappresentato dalla figura:

Figura 2.7: spettro della finestra di troncamento.

Si consideri, ad esempio, un segnale sinusoidale x(t) di frequenza f0,che quindi presenta uno spettro costituito da due impulsi a frequenza +-f0,filtrato con una finestra rettangolare w(t) di durata T0.

Figura 2.8: filtraggio di un segnale con una finestra di troncamento.


La convoluzione7 degli impulsi in frequenza con la funzione W(f) producegli effetti illustrati in figura:

Figura 2.9: spettro della finestra di troncamento applicato al segnale impulsivo.

L’entita della dispersione in frequenza dipende dalla durata Tw della fi-nestra di osservazione e dal suo andamento temporale. In particolare l’an-damento nel tempo della finestra di troncamento determina l’ampiezza deilobi laterali della dispersione e risulta quindi direttamente responsabile dellaaccuratezza con cui viene stimato lo spettro del segnale filtrato. Sotto que-sto aspetto, concreti vantaggi possono essere ottenuti ampliando, entro limitiaccettabili dal punto di vista pratico, la durata Tw o utilizzando finestre tem-porali non rettangolari, ma con transizione piu graduale delle estremita.

7E un operazione tra le 2 funzioni trasformate nei rispettivi domini delle frequenze chegenera una terza funzione che viene vista come la versione modificata di una delle duefunzioni di partenza.


2.4.2 Matched filter

Figura 2.10: ricerca di un template all’interno di rumore stocastico tramitematched filter.

Nelle telecomunicazione un matched filter o filtro adattato si ottiene cor-relando un segnale noto (template) con un segnale incognito per rilevarne lapresenza in ampiezza e tempo di occorrenza , entrambi sconosciuti. L’obiet-tivo quindi non e estrarre il segnale dal rumore stimandone l’andamento neltempo, cioe ricostruire il segnale, ma individuarne un eventuale presenza estimarne i parametri incogniti.ll matched filter e un filtro lineare, ottimo per massimizzare il rapporto se-gnale rumore SNR (Signal to Noise Radio) in presenza di rumore stocasticoadditivo. I matched filter sono comunemente usati in ambito R.A.D.A.R incui il segnale noto viene trasmesso e il segnale riflesso viene esaminato per laricerca di elementi comuni con il segnale trasmesso. Sono inoltre usati nellarivelazione di segnali ad esempio, nel caso in cui si voglia misurare la distanzada un oggetto analizzando il tempo impiegato da un segnale trasmesso su diesso a ritornare indietro. Trasmettendo una sinusoide pura, si puo assumereche il segnale ricevuto sia una versione attenuata e ritardata del segnale tra-smesso con una componente di rumore additivo.Per valutare la distanza dall’oggetto, bisogna correlare il segnale ricevuto conun matched filter, che, nel caso di rumore bianco, e un’altra sinusoide allastessa frequenza di quella trasmessa. Quando l’uscita del filtro supera unacerta soglia, si puo concludere con alta probabilita che il segnale ricevuto estato riflettuto dall’oggetto. Utilizzando la velocita di propagazione delle on-de elettromagnetiche ed il tempo trascorso tra la trasmissione e la ricezione,si puo stimare la distanza dall’oggetto.I matched filter possono essere impiegati in problemi di stima di parametro;nell’esempio precedente, infatti, puo essere interessante calcolare anche lavelocita dell’oggetto, sulla base della stima del parametro di frequenza delsegnale ricevuto e della conoscenza dell’effetto Doppler. Per fare cio e ne-cessario correlare il segnale ricevuto con molti filtri adattati a sinusoidi confrequenza differenti. Il filtro adattato con la risposta maggiore rivelera, conalta probabilita, la frequenza del segnale riflesso. Su tale principio si basa latecnica chiamata moving target indication.


CaratteristicheIl matched filter e dunque un filtro che utilizza tecniche di correlazione e unasua particolarita e quella di tenere conto della fase del segnale in ingresso.La sua applicazione puo essere riassunata nei seguenti punti:

• la forma dell’impulso del segnale s(t) che si vuole analizzare e conosciu-ta;

• obiettivo: determinare l’occorrenza di un evento impulsivo, la suaampiezza A e l’istante di occorrenza t0;

x(t) = A s(t - t0) + n(t)

Come gia accennato il prodotto algebrico nel dominio temporale di due se-gnali corrisponde al prodotto di convoluzione nel dominio delle frequenze[15],pertanto calcoliamo il prodotto di convoluzione fra il segnale x(t) e unafunzione di filtro w(t):

m(t) =

∫ t

−∞w(t− α)x(α)dα =

∫ +∞

0

w(α)x(t− α)dα

La relazione dimostra che quando w(t) = s(-t), ovvero la risposta impul-siva del filtro e uguale alla forma invertita nel tempo:

• il filtro fornisce il miglior rapporto segnale/rumore (nel caso di rumorebianco).

• la funzione di trasferimento del filtro W(f) e la trasformata di fourierdi w(t) = s(-t), cioe W(f) = S*(f)

L’espressione W(f) = S*(f) indica che il modulo della funzione di trasferimen-to del filtro e massima proprio per quelle frequenze a cui abbiamo il maggiorcontributo del segnale e allo stesso modo, dove il segnale ha un contenutospettrale trascurabile la funzione di trasferimento del filtro e bassa.

rapporto segnale rumore

• segnale: il quadrato del valore massimo del segnale m(t), all’uscita delfiltro, cioe m2 (t0);

• rumore: la varianza σ2 del rumore all’uscita del filtro;

Quindi il rapporto tra segnale e rumore e dato dalla seguente relazione:


SNR = m2(t0)/ σ2

Pertanto il segnale di uscita A s(t - t0) sara l’antitrasformata del prodotto:

A W(f) S(f) exp (-j2πft0);

Mentre la varianza del rumore sara data dall’integrale dello spettro delrumore di uscita:

Sn(f)∣∣∣W (f)

∣∣∣2Il rapporto segnale/rumore sara quindi:

SNR = A

∣∣∣ ∫ +∞−∞ S(f)W (f)e−j2πftdf

∣∣∣2∫ +∞−∞

∣∣∣W (f)∣∣∣2Sn(f)df

Se il rumore e bianco cioe (sn(f) = costante) si dimostra che SNR emassimo per W(f) = S*(f):

SNR =A

Sn

∫ +∞

−∞

∣∣∣S(f)∣∣∣2dfUn’implementazione matched filter e ottimale se analizza un segnale di

rumore bianco, perche cio massimizza il rapporto tra segnale e rumore.La porzione di codice che lancia il kernel su GPU per eseguire il matchedfilter sul segnale trasformato e la seguente:

Codice 2.1: CuInspiral matched filter

signaldetection kernel ( i , &(data−>wp template grid),&(data−>gridtypemap), data−>d threshold2,data−>samplefreq, data−>d dt, data−>d vector size,data−>d max correlator, data−>d correlator,data−>d omega0, data−>d phase0, data−>d scalefactor,data−>d inv psd, data−>threadsPerGrid math,data−>threadsPerBlock math, data−>d w signal,data−>d HCp out, data−>d HCc out, data−>d hcp out,data−>d hcc out, &data−>planC2R, data,data−>d mass indexes);

L’applicazione del filtro ricerca l’esistenza del template dell’onda (wp template grid)all’interno del segnale trasformato nel dominio delle frequenze(d w signal).I campioni del correlatore che superano un valore di soglia (d threshold)vengono salvati in (d max correlator).

2.5 Onde gravitazionali 45

2.5 Onde gravitazionali

Quando nel 1687 Isaac Newton pubblica I principi della dinamica (tutt’oggibase concettuale di quella branca della fisica che studia e descrive le relazionitra il movimento di un corpo e gli enti che lo modificano) afferma che quan-do il sole o la luna o tutti e due i corpi, sono allo Zenit si ha la massimaattrazione gravitazionale. In realta l’esatto momento reale dell’allineamentosizigiale avviene 8 minuti e mezzo prima della congiunzione visibile ai nostriocchi; il tempo cioe che la luce solare impiega per arrivare al nostro occhio.Noi vediamo la Luna dove era e come era poco piu di un secondo prima e ilsole dove era otto minuti e mezzo prima. Insomma se avesse ragione Newton, secondo i cui studi la forza di gravita e istantanea, le maree solari dovreb-bero arrivare in anticipo rispetto a quelle lunari. Se il sole infatti sparisse,noi lo vedremmo ancora 8 minuti e mezzo nel cielo. Ma le maree sizigialicome dimostrano le formule di emeriti studiosi in materia (Bernoulli, Laurin,Eulero, La Place, Proudman e ovviamente Newton), avvengono esattamenteal momento dell’allineamento visibile (ma non reale) dell’astro[16]. Si deducepertanto che la gravita viaggia con la stessa velocita della luce.Possiamo pertanto definire la forza di gravita come una vera e propria on-da, cioe la propagazione alla velocita della luce di piccole increspature dellospazio tempo prodotte dalle masse in movimento accelerato.

Figura 2.11: Masse in movimento accelerato che modificano la strutturaspazio/tempo.

Nonostante la loro presenza sia stata ipotizzata da Albert Einstein comeconseguenza della teoria della relativita, a tutt’oggi non vi e stata una dimo-strazione tangibile della loro esistenza.


Le onde gravitazionali sono simili alle onde elettomagnetiche, ma hanno unafrequenza molto inferiore e nonostante trasportino una grossa quantita dienergia, la loro interazione con la materia e pressoche nulla. Fatte que-ste premesse e facile intuire quanto sia difficile una loro rilevazione. Volendoanalizzare la forma dell’onda possiamo rappresentarla con il seguente grafico:

Figura 2.12: rappresentazione nel dominio del tempo dell’onda gravitazionale.

Come possiamo vedere l’onda ha una forma ”a trombetta” e aumenta infrequenza e ampiezza in maniera molto repentina e poi muore improvvisa-mente (il tempo in cui l’onda sparisce e detto tempo di coalescenza). L’unicomodo per rilevarne la presenza all’interno di un segnale e di captare il piccoenergetico.Infatti sulla terra e ipotizzabile rivelare solo le onde prodotte dagli eventi piuenergetici dell’universo, come sistemi di stelle binarie, esplosione di superno-vae e lo scontro tra buchi neri.A tutt’oggi il modello teorico piu accreditato e quello sviluppato da Einstein,detto a struttura tensoriale. In base a questo modello si pensa che la quan-tita di radiazione gravitazionale emessa da un corpo dipenda dal grado didisomogeneita nella distribuzione della sua massa (in termini di deviazionedel corpo dalla simmetria sferica); la grandezza fisica che misura questa di-somogeneita e il momento di quadrupolo. Quando il momento di quadrupolodi un corpo di grande massa subisce variazioni molto rapide viene emesso ungran numero di onde gravitazionali, di intensita e quantita proporzionali alla


velocita delle variazioni. La cosa piu importante e che la sorgente deve muo-versi con rapidita in modo tale da accentuare la sua componente non sferica;per esempio, una stella ovale che ruoti intorno all’asse maggiore non produceonde gravitazionali, ma se ruota intorno all’asse minore diventa un’emitten-te.La teroria afferma che tali sistemi dovrebbero produrre onde gravitazionalicontinue. L’emissione gravitazionale piu intensa dovrebbe avere un’intensitapari ad h = 1020 Hz-1/2; la larghezza di banda del ricevitore ideale dovrebbeessere di 1500 hertz[17].Il programma cuInspiral genera un correlatore dell’onda per ogni coppia dimasse (definito nel dominio delle frequenze) che viene correlato con il sengaleper effettuarne l’analisi. Il filtro adattato massimizza poi il rapporto segnalerumore e l’output del correlatore si presenta come segue:

Figura 2.13: Correlatore in output al filtro.

Come possiamo vedere, il correlatore dell’onda (in verde) si ”nasconde”all’interno del segnale (in rosso) ma presenta dei picchi massimi in corrispon-denza della massima intensita energetica delle onde. Il correlatore in outputal filtro viene scansionato e quando il valore in ampiezza del campione Tn

supera un valore di soglia, questo viene scritto in d max correlator. La po-tenza di cuInspiral risiede nell’applicazione di questa operazione a moltissimi


template differenti. Il file delle masse che il programma prende in input ha unnumero variabile di coppie di masse stellari (ad ogni linea del file corrispondeuna coppia di masse differente). Tramite un apposita funzione ogni coppiagenera un template dell’onda. Questo, oltre a ricercare l’onda nel segnale,ci permette di sapere quali coppie di masse hanno generato il template estima la probabilita che tali masse producano realmente onde gravitazionali(le masse corrispondenti ai valori massimi del correlatore vengono scritte sud mass index).

Capitolo 3

Parallelizzazione del codice

L’algoritmo iniziale sul quale ho effettuato il lavoro di parallelizzazione sfrut-tava una singola GPU ed effettuava le seguenti operazioni:

• Prendere in input un file di rumore bianco ed un file contenente coppiedi masse di stelle binarie;

• Inizializzare e allocare le risorse necessarie su GPU;

• Leggere il segnale in ingresso e trasformarlo nel dominio delle frequenze;

• Per ogni coppia di masse contenute nel rispettivo file applicare unafunzione generante un template di onda gravitazionale;

• Lanciare il kernel su GPU per eseguire il matched filter sul segnale perricercare la presenza del template;

• Stampare i valori che superano una certa soglia;

Questo tipo di applicazione ben si adatta alla trasformazione paralleladistribuita su piu GPU, infatti le caratterische delle operazioni sono del tipo:

• calcoli ripetitivi e ripetuti su grandi masse di dati;

• richiesta di elaborazione in real-time;

• richiesta di un elevato throughput di elaborazione

E infatti possibile distribuire il carico computazionale del loop del file dellemasse e dell’applicazione del filtro su piu GPU.Il diagramma a blocchi delle operazioni che effettua l’algoritmo su singolaGPU e mostrato in figura:

49

50

Figura 3.1: Pipeline seriale di cuInspiral.

3.1 Processi e Thread 51

3.1 Processi e Thread

Tutti i moderni sistemi operativi multiprogrammati adottano il modello aprocessi, questi ultimi vengono gestiti dal sistema operativo il quale schedulai loro tempi di esecuzione ed assegna ad ogni uno una porzione di memoriaprotetta, ma alcuni OS supportano anche il modello multithreading, secondoil quale un processo viene diviso in piu thread indipendenti che condividonola stessa memoria del processo. Le principali differenze tra i 2 modelli sonole seguenti:

• Processo Un sistema operativo esegue diversi programmi definiti neisistemi batch jobs e nei sistemi time-shared programmi utente. Ilprocesso e quindi un programma in esecuzione la cui esecuzione e se-quenziale. Un processo comprende tutte le risorse di cui necessita tracui:

– istruzioni programma

– program counter

– stack

– sezione dati

– dispositivi di I/O

La strategia oggi adottata per rendere parallela l’esecuzione di piu pro-cessi e detta Multiprogrammazione, ovvero piu processi in memoriatengono occupate piu CPU. Tramite la tecnica del Time-Sharing leCPU vengono multiplexate tra vari processi il che rende l’illusione diuna esecuzione simultanea dei processi

Figura 3.2: Tecnica di time sharing.

Quando la CPU passa da un processo ad un altro effettua un cambiodi contesto detto context switch e il sistema salva lo stato del vec-chio processo e carica quello del nuovo processo. Lo stato del processo

3.1 Processi e Thread 52

viene salvato nel Process Control Block (PCB) che contiene tutte leinformazioni associate al processo sospeso tra cui:

– stato del processo

– dati identificativi (del processo, dell’utente)

– program counter

– registri della CPU

– informazioni di scheduling

– informazioni per la gestione della memoria

– informazioni di utilizzo delle risorse

– stato dei segnali

Il tempo di context-switch porta un certo overhead e il sistema non falavoro utile mentre cambia contesto. Il cambio di contesto e un collodi bottiglia per sistemi operativi ad alto parallelismo.

• Thread Un thread o lightweight process e una unita di esecuzionecomposta da:

– program counter e insieme di registri

– stack del processore

– stato di esecuzione

Un thread condivide con i suoi pari (peer threads) una unita di alloca-zione di risorse composta da:

– codice eseguibile

– dati

– risorse richieste al sistema operativo

Definiamo task come una unita di risorse piu i thread che vi accedo-no. Ogni thread condivide tutte le risorse associate al task che lo hagenerato, ha una sua area di memoria privata e comunica con gli al-tri peer thread attraverso lo spazio di memoria globale. Lo svantaggiomaggiore nell’uso di programmazione multithread sta nella necessitadi programmare operazioni di sincronizzazione per garantire la mutuaesclusione: evitare che nello stesso istante, piu di un thread cerchi diaggiornare una stessa locazione di memoria globale.Fatte queste premesse e facile intuire che i thread, avendo un address

3.2 POSIX thread 53

space comune, hanno costi di creazione e di cambio di contesto no-tevolmente meno costosi rispetto ai corrispondenti meccanismi per lagestione dei processi (da 100-1000 volte meno informazioni da dupli-care/creare/cancellare), lo scheduling tra thread dello stesso processoe molto piuveloce che tra i processi e la cooperazione nello stesso taskporta maggiore throughput e performance.I vantaggi dovuti all’uso dei thread sono maggiormente visibili nei siste-mi multiprocessore, ma anche nei sistemi con un unica CPU si hannonotevoli benefici. Infatti e possibile sfruttare i tempi di latenza delleoperazioni di I/O di un thread per eseguirne nel frattempo un altro.

3.2 POSIX thread

La libreria <pthread.h> mette a disposizione tutto l’occorrente per la ge-stione dei thread nell’ambiente UNIX

3.2.1 Creazione e terminazione

Per creare un thread ce’ bisogno di 2 operazioni fondamentali, dichiarare ilthread ed utilizzare la funzione pthread create(), che e cosı definita:

int pthread create(pthread t * thread, pthread attr t * attr, void * (*start routine)(void*), void * arg);

I parametri in input:

• pthread t * thread : puntatore al nuovo thread

• pthread attr t * attr : attributi da applicare al thread

• void * (*start routine)(void *) : funzione che andra ad eseguire il thread

• void * arg : dati da passare al thread che verranno utilizzati nellastart routine

Il numero massimo di thread utilizzabili in un programma e 64, definitoanche nella variabile PTHREAD THREADS MAX della libreria <limit.h>.

Quando si creano numerosi thread, bisogna anche attenderne la termina-zione, in UNIX questo equivale a fare una join del thread.la funzione pthread join() quando lanciata aspetta la fine di un determinatothread di conseguenza permette di gestirne la terminazione e di conoscere il

3.2 POSIX thread 54

valore di ritorno.

int pthread join(pthread t thread, void **rval ptr);


• pthread t * thread : thread di cui si vuole attendere la fine

• void **rval ptr : contiene il codice di uscita ritornato dalla start routine.Se il thread viene cancellato, la locazione di memoria sara settata aPTHREAD CANCELED

3.2.2 Sincronizzazione

I vari thread presenti in un processo condividono la stessa area di memoria,farli operare allo stesso tempo su di una stessa risorsa puo portare a risultatisbagliati quindi la loro convivenza e basata sul concetto di mutua esclusione.Ovvero uno e un solo thread puo accedere ad una variabile per un determi-nato periodo di tempo.Le pthread forniscono un’interfaccia che implementa questo meccanismo, es-sa e chiamata mutex e permette di bloccare, a favore di un thread, una certarisorsa o sbloccarla rendendola disponibile a tutti gli altri. Cio che ho appenadetto equivale a fare un pthread mutex lock su una risorsa quando il threadvuole garantirne la mutua esclusione, ed con un pthread mutex unlock la ri-sorsa viene rilasciata e resa disponibile agli altri thread.In alcuni casi quando vengono lanciati molti thread concorrenti per eseguireuno stesso programma e necessario sincronizzarli al fine di realizzare un con-trollo sul flusso di esecuzione. In parole povere, se in un determinato istantevoglio raccogliere i risultati intermedi di un pool di thread, ho la necessitache questi si blocchino ad un un determinato punto di esecuzione del pro-gramma in attesa che tutti quanti i thread appartenenti al pool effettuino lachiamata a tale routine. Pthread barrier e il meccanismo UNIX che realizzaqueste funzioni.Per creare una barriera si utilizza il seguente costrutto:

int pthread barrier init (pthread barrier t *barrier, const pthread barrierattr t*attr, unsigned count);


• pthread barrier t *barrier : e il nome della barriera che si sta inizializ-zando

3.2 POSIX thread 55

• const pthread barrierattr t *attr : e l’attributo associato alla barriera,di default e NULL

• unsigned count : e un numero che definisce il numero di thread cheappartengono alla barriera creata

Per sincronizzare i thread appartenenti ad una barriera si usa il costrutto:

int pthread barrier wait(pthread barrier t *barrier);


• pthread barrier t *barrier : e il nome della barriera che, posizionata inun determinato punto del flusso di esecuzione del programma, metterain attesa i thread appartenenti a tale barriera finche tutti gli altri nonavranno effettuato una chiamata a tale routine.

Per distruggere la barriera si usa il costrutto:

int pthread barrier destroy(pthread barrier t *barrier);


• pthread barrier t *barrier : e il nome della barriera che viene distrutta

3.2 POSIX thread 56

3.2.3 Implementazione multi-GPU con i thread

Ora che si dispone di tutti gli strumenti necessari per l’analisi del codiceposso illustrare i miglioramenti apportati al codice cuInspiral. Il mio lavorodi parallelizzazione sulla pipeline di cuInspiral puo essere schematizzata nelseguente modo:

Figura 3.3: pipeline cuInspiral.

Ci siamo resi conto che il metodo migliore per parallelizzare il codice etramite l’uso di thread con un approccio di tipo master-slave. Il main threadsi occupa di leggere il file del segnale e quello delle masse, definire i dati,creare i thread e inizializzare la struttura dati da passare ai thread. Poiviene lanciata l’esecuzione della funzione thread function e il main continuaa leggere il segnale sincronizzandosi con i worker thread tramite barriereper comunicargli l’avvenuta lettura. I worker threads eseguono la funzionethread function, allocando i dati passati dal main thread su GPU e lanciandoil kernel che effettua il matched filter per ogni template. Una volta eseguito ilkernel, i worker threads copiano i risultati da GPU a CPU e si sincronizzanocon il main thread per passargli il risultato ottenuto. Tutto questo avvieneall’interno di un ciclo while che continua ad esegure il kernel matched filter

3.2 POSIX thread 57

finche il main thread non comunica ai worker che il segnale e stato letto perintero. Dopodiche il main thread stampa gli output e libera le risorse:

Codice 3.1: signaldetection.cu

/∗definizione globale delle barriere∗/pthread barrier t correlator barrier ;pthread barrier t signal is ready barrier ;

int main(int argc, char ∗argv[]){/∗ Definizione variabili e costanti locali ∗/

/∗ inizializzazione delle barriere ∗/pthread barrier init (&correlator barrier , NULL, num of thread+1);pthread barrier init (& signal is ready barrier , NULL, num of thread+1);

for ( i=0; i<num of thread; i++){/∗ inizializzazione della struttura dati da passare al thread ∗/

pthread create (&threads[i ], NULL, per thread run, (void ∗) &thread data[i]);}

/∗ Lettura del segnale ∗/

/∗ comunica ai thread che il segnale e’ stato letto ∗/pthread barrier wait(& signal is ready barrier );

do{/∗ Attende che i thread ritornino i correlatori ∗/pthread barrier wait(&correlator barrier );


/∗ Comunica ai thread che il segnale e’ stato letto ∗/pthread barrier wait(& signal is ready barrier );

/∗ Trova i massimi del correlatore ∗/}while (/∗ il segnale e’ terminato ∗/);

/∗ Stampa i risultati globali ∗/

/∗ join dei threads ∗/for ( i=0; i<num of thread; i++){pthread join (threads[ i ], NULL)

}

3.2 POSIX thread 58

/∗ distruzione delle barriere ∗/pthread barrier destroy(&correlator barrier );pthread barrier destroy(& signal is ready barrier );

/∗ free delle risorse allocate su CPU∗/}

Come si evince dal codice il meccanismo di sincronizzazione con la th-read function e definito tramite barriere globali. Una volta inizializzate le va-riabili e popolata la struttura dati da passare ai thread (con tutti i dati neces-sari per l’allocazione su GPU), vengono creati un numero di thread, ognunodei quali andra a richiamare la stessa funzione su una diversa GPU. Una voltacreati i worker-thread, il main thread, legge una parte del segnale che copiain un buffer condiviso tra i vari thread e comunica agli stessi, mediante unabarriera di sincronizzazione (pthread barrier wait(&signal is ready barrier))che il segnale e pronto per essere elaborato .La parallelizzazione del codice viene cosı definita in quanto mentre il main th-read legge il segnale, i vari thread eseguono il matched filter su piu GPU. Unavolta eseguito il processo di matched filtering i vari thread copiano il correla-tore risultante da GPU a CPU. A questo punto tutti i thread in esecuzione sisincronizzano tramite una barriera (pthread barrier wait(&correlator barrier))cosicche il main thread puo collezionare tutti i correlatori per poi eseguire laricerca dei massimi.

Il flusso di controllo delle operazioni e regolato da un ciclo do-while cheeffettua le operazioni appena descritte finche il segnale non e stato processatointeramente. A questo punto tramite una variabile di condizione globale(finalize), il main thread esce dal ciclo e comunica ai worker che il segnalee stato processato interamente. Il main thread stampa i risultati globali eavviene un ultima sincronizzazione tramite una join.

La funzione richiamata dai thread

E la porzione di codice chiamata dai thread al momento della pthread create(). Un generico funzionamento e gia stato reso noto nella sezione realtiva almain thread ma volendola analizzare piu approfonditamente possiamo no-tare che i dati realtivi al segnale, barriere di sincronizzazione e variabile difine lettura, vengono dichiarate extern per permetterne la visibilita a tuttii thread. La funzione prende in ingresso la struttura inizializzata dal mainthread e come prima cosa assegna il device i-esimo al thread i-esimo trami-te una cudaSetDevice. Questo garantisce l’associazione tra GPU e thread.

3.2 POSIX thread 59

Successivamente la funzione alloca le risorse su GPU tramite cudaMalloc evi copia i dati tramite cudaMemcpy.Il flusso di controllo e regolato da un ciclo che si sincronizza tramite una bar-riera. Questo impedisce l’avanzamento delle operazioni finche il main threadnon ha letto il segnale. Una volta letto, il segnale viene copiato su GPU etrasformato nel dominio delle frequenze. Ogni thread esegue il processo dimatched filtering per le masse a lui assegnate. I risultati ottenuti vengonoinfine copiati su CPU tramite una cudaMemcpy e la funzione si sincronizzacon il main thread tramite un ulteriore barriera che comunica che i calcolisono stati eseguiti. Infine vengono rilasciate le risorse allocate su GPU tra-mite la primitiva cudaFree.Di seguito uno snippet del codice della funzione:

Codice 3.2: thread function.cu

/∗ variabili esterne ∗/extern struct time signal input signal;extern pthread barrier t correlator barrier ;extern pthread barrier t signal is ready barrier ;extern int finalize ;

void ∗ per thread run (void ∗ datain){/∗ aggancia il thread i−esimo alla GPU i−esima ∗/cudaSetDevice(data−>devicenumber);

/∗ allocazione e trasferimento dei dati su GPU ∗/

while(1){/∗ attendi la lettura del segnale da parte del main thread ∗/pthread barrier wait(& signal is ready barrier );

/∗ Esegue la FFT su GPU ∗/

for ( i=data−>threadid; i<data−>gridtypemap.dim; i+=data−>numofthread){/∗ Lancia il kernel che esegue il matched filter su un template di indice

iniziale threadid e periodicita ’ ”numofthread” ∗/}

/∗ copia i risultati su CPU ∗/

/∗ comunica al main thread che il correlatore e’ pronto ∗/pthread barrier wait(&correlator barrier );

}

∗/ rilascia le risorse allocate su GPU∗/

3.2 POSIX thread 60

pthread exit (NULL);}

FFT su CPU e GPU

Uno step successivo nella parallelizzazione del codice e stata l’implementa-zione della FFT su CPU nel tentativo di migliorare ulteriormente i tempi diesecuzione sovrapponendo i tempi di calcolo CPU-GPU. E un dato di fat-to che la versione iniziale di cuInspiral definisce il miglior algoritmo con ununico thread: legge un segnale, lo trasforma nel dominio delle frequenze suGPU e lancia il kernel.

Il mio compito e stato quello di implementare una versione del programmamultithread che eseguisse la FFT su CPU, nel tentativo di un ottimizzazioneulteriore del codice. Dando per assodato che la FFT su GPU e genralmentepiu veloce di quella su CPU, nel caso specifico dell’implementazione sopradescritta si puo sperare di ottenere un miglioramento sovrapponendo tempodi calcolo host-GPU.

Di fatto, per come e stato implementato il codice, ci aspettiamo cheeffettuando la FFT su CPU, all’aumentare del carico di lavoro su GPU,l’algoritmo si comporti meglio di quello che effettua la FFT su GPU. Comesi vede dal codice 3.3 la FFT viene eseguita parallelamente su tutte le GPUutilizzate.

Codice 3.3: Codice con FFT su GPU

void ∗ per thread run (void ∗ datain){

cudaSetDevice(data−>devicenumber);

/∗ Definizione dei dati per la FFT su GPU ∗/cufftPlan1d (&(data−>plan), data−>h vector size, CUFFT R2C, 1);

cudaMalloc ((void ∗∗) &(data−>d t signal), (data−>h vector size)∗ sizeof (cufftReal ));

while(1){pthread barrier wait(& signal is ready barrier );

/∗ Copia su GPU il segnale letto dal main ∗/cudaMemcpy (data−>d t signal, input signal.signal, sizeof (cufftReal)

∗ (data−>h vector size), cudaMemcpyHostToDevice);

3.2 POSIX thread 61

/∗ Esegue la FFT su GPU ∗/cufftExecR2C (data−>plan, data−>d t signal, data−>d w signal);

for ( i=data−>threadid; i<data−>gridtypemap.dim; i+=data−>numofthread){/∗ Lancia il kernel che esegue il matched filter ∗/}


pthread barrier wait(&correlator barrier );}

/∗ rilascia le risorse allocate su GPU∗/cufftDestroy (data−>plan);


Mentre, come si puo vedere in 3.4 ho modificato il codice in modo chesia il main thread ad effettuare la FFT su CPU per poi passare il segnaletrasformato ai vari thread che eseguiranno il matched filtering.

Codice 3.4: FFT su CPU

int main(int argc, char ∗argv[]){/∗ Definizione del piano ∗/fftwf plan planR2C;

for ( i=0; i<num of thread; i++){pthread create (&threads[i ], NULL, per thread run, (void ∗) &thread data[i]);

}


/∗ definizione della FFT multithreaded ∗/fftwf init threads ();

fftwf plan with nthreads(numoffftthreads);

input signal .h w signal = (fftwf complex ∗) fftwf malloc (sizeof (fftwf complex) ∗( h vector size / 2 + 1))) == NULL)

planR2C = fftwf plan dft r2c 1d (h vector size , input signal . signal ,input signal .h w signal, FFTW ESTIMATE);

3.2 POSIX thread 62

fftwf execute (planR2C);

/∗ comunica ai thread che il segnale e’ stato letto ∗/pthread barrier wait(& signal is ready barrier );

do{pthread barrier wait(&correlator barrier );


/∗ esecuzione FFT su CPU ∗/fftwf execute (planR2C);

pthread barrier wait(& signal is ready barrier );

}while (/∗ il segnale e’ terminato ∗/);

/∗ join dei threads ∗/}

Codice 3.5: funzione FFT su CPU

extern struct time signal input signal;

void ∗ per thread run (void ∗ datain){

cudaSetDevice(data−>devicenumber);

while(1){pthread barrier wait(& signal is ready barrier );

/∗ Copia su GPU il segnale trasformato dal main ∗/cudaMemcpy (data−>d w signal, input signal.h w signal,

sizeof (cufftComplex) ∗ (data−>h vector size / 2 + 1),cudaMemcpyHostToDevice);

for ( i=data−>threadid; i<data−>gridtypemap.dim; i+=data−>numofthread){/∗ Lancia il kernel che esegue il matched filter ∗/}


pthread barrier wait(&correlator barrier );}

3.3 MPI 63


Figura 3.4: FFT su GPU e CPU.

Come vedremo nel capitolo successivo, e facile intuire che per un numeroelevato di coppie di masse il tempo necessario ad effettuare FFT su cpu puoessere sovrapposto all’esecuzione del mathced filtering su GPU ottenendo unmiglioramento dei tempi di calcolo.

3.3 MPI

Un approccio diverso rispetto a un implementazione multi-threaded puo es-sere adottato utilizzando un architettura multi-processo che anziche condivi-dere tramite memoria globale codice, dati e risorse, crea un numero variabiledi processi, ognuno con la propria area di memoria privata, che eseguono inmaniera autonoma e asincrona le operazioni richieste e scambiano i risultatiutilizzando delle apposite primitive di comunicazione tra processi basate sul-l’invio di messaggi.Ovviamente l’uso di tale implementazione e subordinato algrado di parallelizzazione del problema, dato che una grossa dipendenza trai dati necessita di numerose operazioni di scambio di messaggi interprocesso

3.3 MPI 64

che risultano molto onerose a livello prestazionale. Il sistema che realizzaquesto tipo di gestione dei processi in UNIX e il protocollo MPI acronimo diMessage Passing Interface.Il protocollo MPI mette a disposizione dell’utente una serie di routine chepermettono lo scambio di informazioni tra processi concorrenti[18].

3.3.1 Routine di base MPI

Le routine fondamentali per permettere l’esecuzione di un programma con ilprotocollo MPI sono:

• MPI Init(int argc, char *argv[ ]);

Routine che gestisce l’inizializzazione dell’esecuzione in ambiente MPI.Questa routine non ha nessun parametro di output e ha per parametridi input i parametri di input della funzione main.

• MPI Finalize( );

Routine per la terminazione dell’esecuzione in ambiente MPI. Questaroutine non ha nessun parametro di input e nessun parametro di output.

• MPI COMM WORLD

Definisce un comunicatore globale, ovvero un handler che rappresentaun gruppo di processi in grado di comunicare.

1. Ogni processo puo utilizzare MPI COMM WORLD solo dopo lachiamata a MPI Init

2. All’interno di un comunicatore ogni processo ha un identificativounico

3. Il nome del comunicatore da utilizzare e un argomento obbligatoriodi tutte le funzioni di comunicazione

4. E possibile utilizzare nello stesso programma piu di un comunica-tore

5. Due processi possono comunicare solo se fanno parte dello stessocomunicatore

• MPI Comm size(MPI Comm comm, int *size);

Routine che determina il numero size di processi associati al comuni-catore comm

3.3 MPI 65

• MPI Comm rank(MPI Comm comm, int *rank);

Routine che determina l’identificativo rank del processo appartenente alcomunicatore comm che esegue la routine. Lo stesso processo puo avereidentificativi differenti al variare del comunicatore a cui e associato.

• MPI Get processor name(char *name, int *length);

Routine che determina il nome del processore su cui e in esecuzione ilprocesso chiamante. I parametri ritornati sono name che contiene ilnome del processore e length che contiene il numero di caratteri checompongono name

3.3.2 Comunicazione point-to-point

MPI offre vari approcci per la comunicazione tra processi. La cominicazionepoint-to-point e la funzionalita di comunicazione fondamentale in MPI. Ilprincipio di funzionamento di questo tipo di comunicazione e molto semplice:

• Un processo invia un messaggio

• Un altro processo lo riceve

Nella pratica il ritorno da una primitiva di comunicazione (ovvero la possi-bilita di eseguire l’istruzione successiva) puo avvenire in modalita:

• bloccante (blocking send) : il controllo e restituito al processo che hainvocato la primitiva di comunicazione solo quando la stessa e statacompletata

• non bloccante (non-blocking send) : il controllo e restituito al processoche ha invocato la primitiva di comunicazione quando la stessa e stataeseguita. Il controllo sull’effettivo completamento della comunicazionedeve essere fatto in seguito, nel frattempo il processo puo eseguire altreoperazioni.

Nel mio lavoro di tesi la modalita di comunicazione scelta e quella dellaStandard Send il cui funzionamento equivale a quello di una non-blockingsend che e completata quando il processo sender puo riutilizzare l’area dimemoria contenente i dati oggetto del trasferimento.Le primitive di comunicazione tra processi che implementano una standardsend sono le seguenti:

3.3 MPI 66

• MPI Send(void *buf, int count, MPI Datatype type, int rank, int tag,MPI Comm Comm);

Questa primitiva permette ad un processo di inviare un messaggio adun altro processo. I parametri di input sono i seguenti:

– buf : indirizzo del primo elemento del send buffer;

– count : numero di elementi del send buffer;

– type : tipo di dato di ogni elemento send del buffer;

– rank : identificativo del processo destinatario;

– tag : tag del messaggio;

– comm : nome del comunicatore a cui devono appartenere i processicomunicanti;

• MPI Recv(void *buf, int count, MPI Datatype type, int rank, int tag,MPI Comm Comm, MPI Status info);

Questa primitiva permette ad un processo di ricevere un messaggio daun altro processo. I parametri di input sono i seguenti:

– buf : indirizzo del primo elemento del receive buffer;

– count : numero di elementi del receive buffer;

– type : tipo di dato di ogni elemento del receive buffer;

– rank : identificativo del processo sorgente;

– tag : tag del messaggio;


– info : informazioni sulla comunicazione;

3.3.3 Comunicazioni collettive

• sincronizzazione

Come per nel caso dei pthread, anche i processi MPI si sincronizzanomediante l’uso delle barriere:

MPI Barrier(MPI comm comm);

Blocca il processo chiamante fino a quando tutti i processi associati alcomunicatore comm non effettuano la chiamata a questa routine

3.3 MPI 67

• MPI Reduce

A differenza delle comunicazioni point-to-point le comunicazioni collet-tive non hanno bisogno di esplicitare la receive dato che tutti i processiappartenenti al comunicatore sono coinvolti nello scambio di dati. Visono vari tipi di routine di comunicazione collettiva che variano a secon-da di come i processi si scambiano i messaggi. Le modalita di scambiosono le seguenti:

– All to One : Ogni processo appartenente al comunicatore in-via il contenuto del proprio send buffer allo stesso processo didestinazione.

– One to All : Un unico processo sorgente invia il contenuto delproprio send buffer a tutti i processi destinatari appartenenti alcomunicatore.

– All to All : E un operazione di broadcast, tutti i processi invia-no il contenuto del proprio send buffer a tutti gli altri processiappartenenti al comunicatore.

Nel caso specifico e stata utilizzata una collettiva All to One:

MPI Reduce(void *sbuf, void *rbuf, int count, MPI Datatype type, MPI Opop, int root, MPI Comm Comm);

– sbuf : E l’indirizzo del send buffer

– rbuf : E l’indirizzo del receive buffer

– count : E di tipo int e contiene il numero di elementi del send/re-ceive buffer

– type : tipo di dato di ogni elemento del receive/send buffer

– Op : E di tipo MPI Op e referenzia l’operatore di reduce dautilizzare

– root : E di tipo int e contiene il rank del processo root della reduce


L’operazione di MPI Reduce e consente di:

– Raccogliere da ogni processo i dati provenienti dalla medesimalocazione di memoria

– Ridurre i dati ad un solo valore attraverso un operatore associativo

3.3 MPI 68

– Salvare il risultato in una locazione di memoria del processo root

Queste caratteristiche ben si adattano per la ricerca dei valori massimidei correlatori calcolati dai processi, infatti, utilizzando una reduce conuna MPI Op che ricerca il massimo tra ogni elemento dei correlatoricalcolati e lo invia al processo root, ottengo una soluzione piu perfor-mante rispetto ad una MPI send dei correlatori ad un processo root cheeffettua una MPI receive che poi deve effettuare un ulteriore operazio-ne di ricerca dei massimi tra tutti i correlatori ricevuti. Purtroppo none stato possibile implementare una collettiva di questo tipo, poiche allaricerca del valore massimo tra i correlatori, non corrispondeva necessa-riamente il valore massimo dell’indice della massa stellare. Per ovviarea questo problema sarebbe stato necessario definire una operazione adhoc tramite una MPI Op Create che trovava il massimo tra ogni valoredel correlatore e vi associava il rispettivo indice della massa, ma perragioni di tempo non e stato implementato e non verra mostrato nelcodice.

3.3 MPI 69

3.3.4 Analisi del codice MPI

Figura 3.5: Flusso del programma con MPI.

L’implementazione del codice mediante MPI, differisce dall’implementa-zione multi-threaded in primo luogo perche non adotta un approccio di tipomaster-slave. Ovvero non c’e un main process che delega compiti ai processworker, bensı tutti i processi copiano il file del segnale e quello delle masseed eseguono in maniera indipendente il flusso di programma fino ad una sin-cronizzazione finale.

3.3 MPI 70

Ogni programma MPI inizia con una serie di chiamate necessarie all’i-nizializzazione dell’ambiente di esecuzione. Quete chiamate sono appuntoMPI Init , MPI Comm size necessaria a determinare il numero di processifacenti parti del comunicatore e MPI Comm rank necessaria all’identificazio-ne del processo(rank) all’interno del comunicatore. Viene quindi associatauna GPU ad ogni processo mediante cudaSetDevice(rank).

A questo punto i vari processi copiano i dati nella memoria della GPU,generano i template ed eseguono il kernel del matched filter copiando alla fineil correlatore calcolato da GPU a CPU. Infine i processi sender (quelli cioecon rank diverso da 0), inviano il correlatore al processo di rank 0. A questopunto il processo con rank 0 inizia la ricerca dei massimi tra tutti i correlatoriricevuti e si occupa della scrittura-stampa dei risultati. Tutti i processi dopola fase di send/receive continuano a leggere il segnale e ad eseguire il kernelfinche il segnale non e stato elaborato completamente. L’esecuzione terminacon la deallocazione delle risorse GPU e CPU.

In 3.6 riporto uno snippet del codice sopra descritto

Codice 3.6: Versione del programma con MPI

int main (int argc, char ∗argv[]){int rank, size ;

/∗ inizializzazione dell ’ambiente MPI ∗/MPI Init (&argc, &argv);MPI Comm size (MPI COMM WORLD, &size);MPI Comm rank (MPI COMM WORLD, &rank);MPI Status status;

/∗ aggancia il processo identificato alla relativa GPU ∗/cudaSetDevice (rank);

/∗ allocazione e trasferimento dei dati su GPU ∗/

/∗ leggi del segnale ∗/

/∗ copia file delle masse su GPU ∗/

do{/∗ Esegui la FFT su GPU ∗/

for (int i = rank; i < gridtypemap.dim; i += size){

3.3 MPI 71

/∗ Lancia il kernel : ogni processo, esegue il matched filter su un templatediverso con rank come indice iniziale e periodicita ’ ”size” ∗/

}


/∗ attendi che tutti i processi effettuino la chiamata alla barriera ∗/MPI Barrier (MPI COMM WORLD);

if (rank == 0){for (int i = 1; i < size; i++){/∗ effettua una receive dei correlatori e degli indici di massa relativicalcolati dagli altri processi ∗/

MPI Recv (recvbuffer, h vector size , MPI FLOAT, size − i, 10,MPI COMM WORLD, &status);

MPI Recv (recvmasses, h vector size, MPI INT, size − i, 10,MPI COMM WORLD, &status);

/∗ trova i massimi dei correlatori e associa ad ognuno l’indice della massa ∗/}

/∗ Leggi il segnale ∗/}

else{/∗ tutti i processi inviano correlatori e indici di massa al processo root ∗/MPI Send (h correlator, h vector size , MPI FLOAT, 0, 10, MPI COMM WORLD);MPI Send (h mass indexes, h vector size, MPI INT, 0, 10, MPI COMM WORLD);

/∗ Leggi il segnale ∗/}}while (/∗ il segnale e’ terminato ∗/);

/∗ Stampa i risultati globali ∗/

/∗ rilascia le risorse allocate su GPU e CPU ∗/

MPI Finalize ();}

Capitolo 4

Risultati

Di seguito prenderemo in considerazione il variare dello speedup al varia-re dell’implementazione utilizzata, delle dimensioni dei file del segnale, delnumero di coppie di masse e del numero delle GPU utilizzate.

4.1 Speedup

Come noto lo speedup e definito dalla seguente formula:

Sn =T1

Tp(n)

dove:

• T1 e il tempo di esecuzione impiegato dal miglior algoritmo serialeconosciuto;

• Tp(n) e il tempo di esecuzione dell’algoritmo parallelo su n processori;

Il miglior algoritmo parallelo del mondo presenta uno speedup lineare[19],quindi Sn = n, ma questo limite e difficilmente raggiungibile. In linea diprincipio l’andamento dello speedup dei nostri test dovrebbe crescere al cre-scere del numero dell GPU.

72

4.2 Numero di threads per la FFTW 73

4.2 Numero di threads per la FFTW

Il numero ottimale di thread da usare dipende in sostanza dalle dimensionidel buffer da trasformare e dal numero di processori che si hanno a disposi-zione.

I tempi di esecuzione sono infatti legate alle variabili:

• Dimensione del buffer di lettura del segnale

• Dimensione del file di masse da iterare

• Numero dei thread (e quindi delle GPU) coinvolti nel processo di ese-cuzione

Come si evince dal grafico sguente, aumentare il numero di threads ri-spetto ai core fisici che si hanno genera dei miglioramenti. Questo e vero peruna grossa quantita di dati da calcolare. Se la dimensione del problema etroppo piccola, si consiglia di usare un numero di thread inferiore al numerodei processori disponibili per non creare overheading.

La figura mostra l’andamento dei tempi della fftw su CPU con un bufferda 223. Per gli altri buffer otteniamo i tempi minori con un numero variabiledi threads che sono i seguenti:

• buffer size 219 : 15 threads;



4.2 Numero di threads per la FFTW 74



Nelle tabelle successive i tempi realativi all’esecuzione della FFT su CPUsono sempre riferiti ad un numero di thread come sopra riportato.

4.3 Tempi e speedup 75

4.3 Tempi e speedup

(a) Numero masse : 120

Seriale 5.8682

GPU 2 3 4

Ftt GPU 2.9764 3.0623 2.9746Ftt CPU 2.9884 2.5239 2.4965MPI 3.9440 3.4120 3.1960

(b) Numero masse : 240

Seriale 9.4684

GPU 2 3 4


(c) Numero masse : 480

Seriale 17.0325

GPU 2 3 4


(d) Numero masse : 960

Seriale 32.2845

GPU 2 3 4


(e) Numero masse : 1920

Seriale 63.6757

GPU 2 3 4


(f) Numero masse : 3840

Seriale 130.4037

GPU 2 3 4


(g) Numero masse : 7680

Seriale 283.2923

GPU 2 3 4


(h) Numero masse : 15360

Seriale 958.3010

GPU 2 3 4


Tabella 4.1: Tabella dei tempi per un buffer da 219


Figura 4.1: Speedup relativo ad un buffer da 219.



Seriale 11.1030

GPU 2 3 4



Seriale 17.9472

GPU 2 3 4



Seriale 31.8741

GPU 2 3 4



Seriale 59.7449

GPU 2 3 4



Seriale 116.9317

GPU 2 3 4



Seriale 245.0447

GPU 2 3 4



Seriale 535.0661

GPU 2 3 4



Seriale 1310.739

GPU 2 3 4







Seriale 22.1716

GPU 2 3 4



Seriale 35.4578

GPU 2 3 4



Seriale 63.1378

GPU 2 3 4



Seriale 118.1351

GPU 2 3 4



Seriale 228.9081

GPU 2 3 4



Seriale 455.3940

GPU 2 3 4



Seriale 930.5219

GPU 2 3 4



Seriale 2175.9317

GPU 2 3 4







Seriale 44.7436

GPU 2 3 4



Seriale 71.9226

GPU 2 3 4



Seriale 126.8452

GPU 2 3 4



Seriale 238.9445

GPU 2 3 4



Seriale 460.7651

GPU 2 3 4



Seriale 909.1778

GPU 2 3 4



Seriale 1854.8515

GPU 2 3 4



Seriale 3956.0258

GPU 2 3 4







Seriale 90.1750

GPU 2 3 4



Seriale 145.7496

GPU 2 3 4



Seriale 257.3812

GPU 2 3 4



Seriale 482.4708

GPU 2 3 4



Seriale 932.5264

GPU 2 3 4



Seriale 1835.1795

GPU 2 3 4



Seriale 3651.2806

GPU 2 3 4



Seriale 7578.0552

GPU 2 3 4





4.4 Conclusioni 85

4.4 Conclusioni

Dall’andamento globale dei grafici possiamo dedurre che, come ipotizzato,il valore dello speedup e monotonicamente crescente al crescere del numerodi GPU. Questo dimostra che uno smistamento del carico di lavoro su piudevices rende l’algoritmo sempre piu performante. Limitandosi ad un’analisiche confronti le 2 implementazioni in cui la FFT viene eseguita una volta suCPU e poi su GPU, possiamo affermare che l’esecuzione della FFT su CPUsi e dimostrata una scelta vincente. Infatti, come ipotizzato, all’aumentaredel carico di lavoro su GPU, vedi figura 4.4 e 4.5, l’esecuzione della FFTsu CPU realizza una sovrapposizione dei tempi di calcolo host/GPU, che sitraduce in miglioramento dello speedup.

Analizzando lo speedup per buffer di piccole/medie dimensioni, vedi fi-gura 4.1 e 4.2, la situazione non cambia molto. Ma come atteso nel caso incui si usi un file delle masse di dimensione piccola, la scelta di eseguire la fftsu GPU si dimostra vincente.

L’implementazione MPI, tanto piu per grosse quantita di dati, e quellache garantisce una prestazione migliore. Questi risultati, anche se non deltutto attesi, possono essere ricercati nell’efficacia dello scheduling dei proces-si all’interno del sistema operativo. Inoltre, la differente organizzazione delcodice che elimina le barriere di sincronizzazione, garantisce probabilmenteun miglioramento delle prestazioni.

Un’ulteriore sviluppo del software, anche nella direzione di una migliorcomprensione dei tempi di esecuzione della versione MPI, potrebbe esserequella di adottare un approccio master/slave cosi come nell’implementazio-ne con i thread. In questo caso sarebbe il main process a leggere il segnaleed eseguire la FFT su CPU, mentre i processi slave eseguirebbero il caricocomputazionale piu pesante su GPU. Un ulteriore vantaggio di questa imple-mentazione e sicuramente la possibilita di eseguire il codice in un architetturamulti-nodo cioe una situazione in cui piu nodi con all’interno una o piu GPUsono interconnessi mediante una rete ethernet o infiniband[21].

Vogliamo in conclusione sottolineare la bonta dei risultati riportando chese l’implementazione dello stesso algoritmo su CPU e in grado di elaborare3 template al secondo, sfruttando 4 GPU riusciamo ad ottenere un miglio-ramento di ben 2 ordini di grandezza, riuscendo ad elaborare circa 400 tem-plate al secondo. Questo rende l’idea dei benefici computazionali apportatidal lavoro di parallelizzazione.

Conclusioni

Questo lavoro di tesi e stata un’ottima occasione per esplorare l’uso dellearchitetture multi-GPU nell’ambito di un problema reale come quello dellarilevazione di onde gravitazionali. Il lavoro che ho svolto, oltre ad avalla-re previsioni ottimistiche sulla crescita di queste tecnologie, puo essere unabuona base di partenza per progetti e sviluppi futuri.

Durante il mio lavoro di tesi ho preso confidenza con il modello di pro-grammazione CUDA e le principali tecniche di analisi di segnale su piatta-forme GPGPU. Il programma cuInspiral prendeva in ingresso un segnale edeseguiva il matched filter per ricercare un template di onda all’interno delsegnale trasformato nel dominio delle frequenze.

Durante il mio lavoro di tesi mi sono occupato di fare il porting di taleprogramma su piattaforme muti-GPU e si e rivelato un’approccio vincente.Quello che ho fatto e stato parallelizzare il codice tramite librerie pthreade MPI per distribuire il carico computazionale su piu GPU. Da un imple-mentazione che eseguiva la FFT su GPU, abbiamo poi ipotizzato che unimplementazione della FFT su CPU potesse sovrapporre i tempi di calcolotra host e GPU. Anche questa scelta si e rivelata corretta dato che una so-vrapposizione dei tempi di calcolo, per grosse quantita di masse e segnale,riduce il tempo di esecuzione dell’algoritmo di un fattore minimo, ma checomunque conferma le ipotesi teorizzate.E importante far notare che tramite implementazione MPI abbiamo ottenutotempi piu bassi delle rispettive versioni multithread.E probabile che i beneficiderivanti da tale implementazione siano dovuti ad una migliore efficacia discheduling dei processi del sistema operativo. Tutto cio fa pensare che conun implementazione MPI/master-slave in cui il main process esegue la FFTsu CPU e gli altri eseguono il resto della computazione su GPU, sovrappo-nendo i tempi di calcolo CPU/GPU, vi possano essere ulteriori benefici. Unulteriore vantaggio di questa implementazione e quello di un implementazio-ne multi-nodo del programma, cioe la possibilita di eseguire il codice in un

86

INTRODUZIONE 87

architettura in cui piu nodi con all’interno una o piu GPU sono interconnessimediante una rete ethernet o infiniband[21].

Vogliamo in conclusione sottolineare la bonta dei risultati riportando chese l’implementazione dello stesso algoritmo su CPU e in grado di elaborare 3template al sec, sfruttando 4 GPU riusciamo ad ottenere un miglioramento diben 2 ordini di grandezza, riuscendo ad elaborare circa 400 template al secon-do. Questo apre nuove prospettive nella rilevazione delle onde gravitazionalisoprattutto legate al progetto E.T. (Einstein Telescope)[20]. Si ipotizza chenel giro di 10 anni ci sara una dimostrazione diretta dell’esistenza delle ondegravitazionali. Questo confermerebbe senza ombra di dubbio la relativitagenerale di Einstein cambiando il modo di osservare l’universo. Infatti comeoggi si osserva il cosmo utilizzando le onde di luce visibile e le onde radio, infuturo potremo studiarlo anche in funzione delle onde gravitazionali con unapproccio di osservazione completamente nuovo che cambierebbe la concezio-ne che abbiamo dell’universo e aprirebbe nuove frontiere alle ricerche spaziali.

Ringrazio sentitamente i miei relatori per avermi permesso di compierequesta esperienza.

Bibliografia

[1] E. Moore, Electronics Magazine, Cramming more components ontointegrated circuits (2009).

[2] Munshi, Khronos OpenCL Working Group, The OpenCL Specification1.0 (2009).

[3] Microsoft, Microsoft DirectX 11, http://www.microsoft.com/games/en-US/aboutGFW/pages/directx.aspx (2010).

[4] Single Instruction, Multiple Data (SIMD),http://it.wikipedia.org/wiki/Single instruction multiple data

[5] Loriano Storchi, GPGPU, http://www.thch.unipg.it/ redo/lecturenote-s/mca/slides gpgpu.pdf

[6] NVIDIA, NVIDIA CUDA programming Guide (2009).

[7] NVIDIA, NVIDIA CUDA programming Guide (2009).

[8] GPGPU, Tutorial CUDA, primo kernel, http://www.gpgpu.it

[9] architetture DSP http://home.dei.polimi.it/silvano/FilePDF/Lezioni Sami/dsp.pdf

[10] Dispense DSP http://ens.dsi.unimi.it/dispensa/cap6.pdf

[11] Trasmissioni a Radiofrequenza (RF) e onde elettromagnetiche (EMC)http://digilander.libero.it/Calleri Giovanni/trasmissioneRF.html

[12] NVIDIA, NVIDIA CUFFT Librar (2009).

[13] FFTW, FFTW library, http://www.fftw.org

[14] Analis di segnali campionati, http://www.diee.unica.it/misure/Dispense/Misure elettroniche/Analisi di segnali campionati 07.pdf

88

Bibliografia 89

[15] Rivelazione dei segnali http://www.inrim.it/ brida/SegnaleRumore/ri-velazione 2007.pdf

[16] DISCOVERY OF GRAVITATIONAL WAVES,http://digilander.libero.it /gravitazioneonde

[17] Onda gravitazionale, http://it.wikipedia.org/wiki/Onde gravitazionali

[18] Loriano Storchi, ACR, http://www.thch.unipg.it/ redo/lecturenotes/a-cr/index.html

[19] Loriano Storchi, ACR, http://www.thch.unipg.it/ redo/lecturenotes/m-ca/slides7.pdf

[20] Einstein Telescope, http://www.et-gw.eu/

[21] Infiniband, http://www.infinibandta.org/

Documents

Facolt a di Scienze Matematiche, Fisiche e Naturali Corso ... Universit a degli Studi di Perugia Facolt a di Scienze Matematiche, Fisiche e Naturali Corso di Laurea Triennale in Informatica