IMPLEMENTAZIONE SU PIATTAFORMA EMBEDDED DI ALGORITMI PER L'ESTRAPOLAZIONE DI CONTENUTO SEMANTICO DA IMMAGINI

Transcript

1 UNIVERSITÀ DEGLI STUDI DI GENOVA FACOLTÀ DI INGEGNERIA TESI DI LAUREA IN INGEGNERIA ELETTRONICA IMPLEMENTAZIONE SU PIATTAFORMA EMBEDDED DI ALGORITMI PER L'ESTRAPOLAZIONE DI CONTENUTO SEMANTICO DA IMMAGINI Relatore: Correlatore: Chiar.mo Prof. Ing. RODOLFO ZUNINO Ing. PAOLO GASTALDO Candidati: GAGGERO LORENZO PIAZZE MATTEO Genova, 17 Dicembre 2010

2 Abstract This thesis concerns the implementation of a known algorithm called SIFT (Scale Invariant Features Transform) on the NVIDIA Quadro FX 580 device. The purpose of this algorithm is the extrapolation of the semantic content of images. Each objects can be represented by particular features that describe itself. This points called keypoints are highly descriptive and they are invariant to many transformations like image rotation, scale and traslation. For this reason they can be used into application like object recognition, motion tracking, image stitching, robotic mapping and many others. In this thesis we focus on CUDA (an acronym for Compute Unified Device Architecture), a parallel computing architecture developed by NVIDIA which enables dramatic increases in computing performance by harnessing the power of the GPU (graphics processing unit). The purpose of this thesis is the optimization of the SIFT implementation in order to make it usable for the purposes it is intended. The work has been developed in the SEALAB laboratory at the Biophysics and Electronic Engineering Department (DIBE). II

3 Alla Commissione di Laurea e di Diploma Sottopongo la tesi redatta dagli studenti Gaggero Lorenzo e Matteo Piazze dal titolo Implementazione su piattaforma embedded di algoritmi per l estrapolazione di contenuto semantico da immagini. Ho esaminato, nella forma e nel contenuto, la versione finale di questo elaborato scritto, e propongo che la tesi sia valutata positivamente. Il Relatore Accademico Prof. Rodolfo Zunino III

4 Ringraziamenti Ringrazio il mio relatore Prof. Rodolfo Zunino per la sua grande disponibilità e professionalità. Un grazie a Ing. Paolo Gastaldo, che con i suoi consigli ci ha permesso di portare a termine con soddisfazione questo lavoro. Infine un grazie speciale ai nostri genitori per averci supportati in tutti questi anni di studio, con l augurio di non doverlo fare ancora per molto. Lorenzo e Matteo IV

5 Prefazione Il lavoro affrontato durante lo sviluppo della tesi concerne l'implementazione su scheda video di un noto algoritmo (SIFT Scale invariant features transform [1]) che permette di determinare i punti salienti di un immagine, detti keypoint. Solitamente i keypoint sono localizzati nei perimetri degli oggetti contenuti nelle immagini o dove si sofferma maggiormente l attenzione dell osservatore. Particolarità di questi punti è l invarianza alla traslazione, alla rotazione e alla luminosità ed è proprio per questa ragione che questo algoritmo è utilizzato nel riconoscimento automatico delle immagini ed è in grado di riconoscere oggetti anche parzialmente ostruiti alla vista. Il dispositivo usato per questa tesi è una scheda grafica NVIDIA serie Quadro FX 580; l'implementazione software è stata realizzata con Microsoft Visual Studio La tesi si è svolta interamente al D.I.B.E., Dipartimento di Ingegneria Biofisica ed Elettronica, presso la sede di Albaro della Facoltà di Ingegneria di Genova nel laboratorio SEALAB sotto la supervisione del relatore Rodolfo Zunino e il correlatore Paolo Gastaldo. V

6 Indice Abstract... II Ringraziamenti... IV Prefazione... V Introduzione... 1 Obiettivo della tesi... 1 Capitolo I... 2 Scale invariant features transform - SIFT Descrizione dell'algoritmo Detection of scale-space extrema Keypoint localization Sviluppi futuri Applicazioni Riconoscimento di oggetti Video sorveglianza Catalogazione d immagini Robotica (robotic mapping) Riconoscimento della gestualità umana Match moving Image stitching (o photo stitching) Capitolo II VI

7 Compute Unified Device Architecture Architettura Modello di esecuzione Memoria Organizzazione gerarchica Global Memory Shared Memory Register memory Local Memory Constant Memory Texture Memory Applicazioni Primitive Il kernel Gli identificatori del kernel Invocazione Dim L'identificatore di un thread L'asincronia della chiamata del kernel Coalescenza degli accessi in memoria Capitolo III Implementazione in CUDA Caratteristiche tecniche Convoluzione Implementazione Shared Memory e pixel al contorno Evitare thread inattivi Aumentare l efficienza Ottimizzazione per la coalescenza in memoria Il filtro delle righe Filtro delle Colonne VII

8 3.4 Dettagli sull implementazione Il codice Unrolling Loops del ciclo più interno del filtro Performance Crea DoG Note sulla implementazione Il codice Numero di thread Conclusioni Capitolo IV Conclusioni e sviluppi futuri Bibliografia VIII

9 Introduzione La tesi si è svolta in due fasi: Parte teorica: Studio dell architettura CUDA e delle relative librerie sviluppate da NVIDIA e apprendimento dell algoritmo detto SIFT (Scale Invariant Feature Transform). Parte operativa: Implementazione e stesura delle parti di codice più critiche utilizzando le potenzialità di calcolo parallelo della GPU. Il linguaggio di programmazione usato è il C per CUDA (C con estensioni NVIDIA). Obiettivo della tesi Lo scopo della tesi è quello d implementare l algoritmo SIFT nel modo più performante possibile su una piattaforma embedded in modo tale da poter essere utilizzato per applicazioni pratiche. Il raggiungimento dello scopo della tesi è stato possibile grazie ad uno studio approfondito dell algoritmo da implementare, all analisi dell architettura CUDA e all uso delle primitive messe a disposizione dal linguaggio C per CUDA. 1

10 Capitolo I Scale invariant features transform - SIFT Scale-invariant feature transform (o SIFT) è un algoritmo pubblicato da David Lowe nel 1999 [1] che permette di individuare e descrivere le caratteristiche locali di una immagine. Le applicazioni sono molteplici e includono il riconoscimento di oggetti, la mappatura per la navigazione robotica, la videosorveglianza, il matching di oggetti in movimento etc. Per ogni oggetto presente in un immagine, infatti, è possibile estrarre i punti più interessanti, detti keypoint, per fornire una descrizione caratteristica dell oggetto che poi può essere utilizzata per identificare lo stesso in contesti diversi. Perché questo procedimento sia affidabile è importante che le caratteristiche estratte dall immagine siano invarianti ai cambiamenti di scala, al rumore e all illuminazione dell immagine. In particolare il SIFT permette di identificare in modo corretto gli oggetti anche nel disordine e sotto occlusione parziale e i punti che estrae sono invarianti ai cambiamenti di scala, di rotazione e in parte invarianti anche ai cambiamenti di illuminazione e del punto di vista. Solitamente questi punti si trovano in regioni ad alto contrasto delle immagini, come i bordi dell oggetto. Il costo computazionale di estrazione dei keypoint è ridotto al minimo attraverso un approccio a cascata di filtraggio in cui le operazioni più onerose sono applicate solo ai punti che superano un test iniziale. 2

11 1.1 Descrizione dell'algoritmo Le principali tappe del calcolo per generare l insieme dei keypoint dell immagine sono le seguenti: 1- Scale-space extrema detection: è la prima fase di ricerca computazionale su tutte le scale e posizioni dell immagine. 2- Keypoint localization: per ogni punto candidato a diventare keypoint, un modello dettagliato è in grado di determinare la posizione e la scala. La selezione dei Keypoint è basata sulla misura della loro stabilità. 3- Orientation assignment: ad ogni keypoint vengono assegnate una o più orientazioni in base alle direzioni locali del gradiente dell immagine. Tutte le operazioni successive sono effettuate sulle parti dell immagine che sono state trasformate rispetto ad una data orientazione, scala e posizione garantendo così l invarianza di queste trasformazioni. 4- KeyPoint descriptor: i gradienti misurati dell immagine sono posti nelle regioni vicine ad ogni keypoint. Questi sono trasformati in una rappresentazione che permette significanti livelli di distorsione e cambi d illuminazione Detection of scale-space extrema Come scritto nell introduzione i keypoint vengono rilevati utilizzando un approccio a cascata di filtraggio che usa algoritmi efficienti per identificare la posizione dei punti candidati. Il primo passo di estrazione del keypoint consiste nel rilevare la posizione e la scala che possono essere assegnate ripetitivamente sotto differenti punti di vista dello stesso oggetto. Per trovare punti invarianti al cambio di scala dell immagine si cercano le caratteristiche stabili attraverso tutte le possibili scale, utilizzando una funzione continua di scala detta scale-space. 3

12 In particolare lo scale-space è definito come una funzione, L(x, y, σ), che viene prodotta dalla convoluzione di una variable-scale gaussiana, G(x, y, σ), con un immagine di input, I(x, y): dove * è l operazione di convoluzione in x e y, e (1.1) (1.2) Quindi, nell'algoritmo SIFT, viene utilizzata la tecnica di smoothing Gaussiano [2] per fornire una pre-elaborazione alle immagini al fine di individuare le caratteristiche stabili. L'effetto della convoluzione di un immagine con un filtro di Gauss ( smoothing Gaussiano) è tipicamente quello di un passa-basso. Nello specifico consente di ridurre le alte frequenze dovute ai pixel scuri isolati sullo sfondo o alle brusche variazioni fra i pixel vicini ai contorni. L'effetto visivo di questa tecnica è quello della sfocatura come si può vedere nell'immagine qui riportata. Figura 1.1: Esempio di applicazione di filtro Gaussiano 4

13 Il processo di convoluzione viene iterato più volte fino ad ottenere un insieme di matrici filtrate con filtri di Gauss caratterizzati da varianza crescente. Tale insieme è detto ottava ed è caratterizzato da un numero di matrici n prefissato uguale per ogni ottava e da un numero n-1 di intervalli. Anche il numero delle ottave e degli intervalli è stabilito a priori e varia a seconda della dimensione dell'immagine. All'ottava successiva le dimensioni dell'immagine precedente vengono dimezzate in ampiezza e in lunghezza con eccezione della prima ottava in cui vengono raddoppiate (interpolate adeguatamente) e infine sottoposte al procedimento di filtraggio come descritto precedentemente. Una volta ottenuto un insieme di ottave costruite nel modo appena descritto si procede al passo successivo: viene creato un nuovo insieme di matrici, detto DoG, ottenuto sottraendo tra loro a gruppi di due le matrici adiacenti delle varie ottave. (1.3) Il procedimento può essere più chiaro se si prende visione della rappresentazione grafica seguente: Figura 1.2: a sinistra matrici dell'immagine convoluite con filtri di Gauss a varianza crescente; a destra differenza tra matrici contigue all'interno di un ottava (DoG) 5

14 Una volta ottenuti gli insiemi DoG si passa alla determinazione dei keypoint. Perché un pixel possa essere considerato keypoint deve essere un punto di massimo o di minimo locale tra gli 8 pixel adiacenti nella matrice DoG corrente, e nei 9 corrispondenti nella matrice DoG superiore e inferiore (vedi figura 1.3). Di conseguenza tale punto viene selezionato solo se è più grande di tutti questi vicini o più piccolo di tutti. Il costo di questo controllo è ragionevolmente basso dovuto al fatto che la maggior parte dei punti candidati sarà eliminata dopo i primi controlli. Figura 1.3: I massimi e i minimi vengono rilevati confrontando un pixel (indicato con X) con i 26 pixel adiacenti (contrassegnati con cerchi) Keypoint localization Dopo che un punto candidato a diventare keypoint è stato individuato col metodo precedente di confronto del pixel con i suoi vicini, il passo successivo consiste nell effettuare una misura dettagliata della posizione, della scala e sul rapporto delle curvature principali. Queste informazioni consentono di rigettare quei punti che hanno basso contrasto (e sono quindi sensibili al rumore) o che non sono localizzati lungo un contorno. Infatti non tutti keypoint trovati possono essere mantenuti tali, esistono perciò dei procedimenti detti di scrematura tratti dai testi di David Lowe che consentono di eliminare i keypoint in eccesso. 6

15 Esistono principalmente tre procedimenti di scrematura: 1. (1.4) Tramite la formula qui riportata, applicata su ogni probabile keypoint dove D è uguale alla matrice DoG, x (vettore) e uguale al valore degli indici del keypoint, otteniamo un valore di offset ( ) tale che se maggiore 0.5 per entrambi gli indici, determina l eliminazione del keypoint. 2. Nel caso in cui l offset del keypoint calcolato al passo precedente sia minore di 0.5 si passa alla seconda scrematura, in cui la funzione: (1.5) è calcolata nel valore (offset).se il risultato di questa equazione è minore di 0.03 il keypoint è scartato perché considerato a basso contrasto. 3. Infine l ultima scrematura viene introdotta a causa della forte risposta dell algoritmo ai perimetri degli oggetti nelle immagini, per eliminare i keypoint in eccesso non localizzati sugli angoli ed evitare cosi la formazione di lunghe righe di keypoint (edge detection): Le principali curvature possono essere calcolate tramite una matrice Hessiana 2x2 le cui derivate sono calcolate nell intorno 3x3 del keypoint. Una volta calcolata la traccia e il determinante di questa matrice, se quest ultimo risulta negativo il keypoint è eliminato. Inoltre se la disequazione: (1.6) 7

16 La (1.6) risulta essere verificata per r = 10 allora il keypoint viene scartato. Al termine di queste procedure rimangono solo i keypoint corretti. 1.2 Sviluppi futuri Il programma può essere eventualmente sviluppato per migliorare l accuratezza nella scelta dei keypoint, riuscendo ad affinare le tecniche di scrematura e rendendo quindi l'algoritmo ancora più robusto e selettivo. Inoltre può essere utile riuscire a mettere in evidenza i diversi gradi di importanza che i punti chiave possono assumere anche in relazione alle diverse applicazioni in cui verranno utilizzati. 1.3 Applicazioni Questo algoritmo può essere applicato in moltissimi campi [3]: Riconoscimento di oggetti In computer vision consiste nel trovare un determinato oggetto in un immagine o in una sequenza video. Gli esseri umani riconoscono una moltitudine di oggetti con poco sforzo, nonostante l'immagine di questi ultimi possa variare leggermente a seconda dei diversi punti di vista, della loro dimensione, traslazione o rotazione. Gli oggetti possono essere anche riconosciuti in condizione di parziale ostruzione alla vista: questo compito è ancora una sfida per i sistemi di visione artificiale in generale. L'algoritmo SIFT ha la capacità di estrapolare i keypoint distintivi che sono invarianti rispetto alla posizione, alla scala e alla rotazione, robusti a trasformazioni affini (cambiamenti di scala, rotazione e a cambiamenti di posizione) e alle variazioni d illuminazione; sono quindi utilizzabili per il riconoscimento degli oggetti. I passi sono i seguenti: In primo luogo, le caratteristiche SIFT sono ottenute dall'immagine in ingresso utilizzando l'algoritmo precedentemente descritto. 8

17 Tali caratteristiche vengono confrontate con il database di caratteristiche SIFT ottenute da immagini campione. Il confronto avviene attraverso la distanza euclidea basata sull'approccio del vicino meno distante. Figura 1.4: Esempio di applicazione - object recognition Come si può vedere in figura 1.4 a sinistra sono presenti gli oggetti da identificare. Al centro l'immagine complessa su cui vengono ricercati (anche sotto parziale occlusione alla vista). A destra il risultato della ricerca: i quadrilateri più grossi mettono in evidenza l'oggetto trovato, quelli più piccoli i keypoint utilizzati al fine dell'identificazione Video sorveglianza Il monitoraggio video è uno dei processi di localizzazione di uno o più oggetti in tempo reale usando una video camera. L algoritmo SIFT analizza i fotogrammi del video riportando in uscita la locazione degli oggetti in movimento. La difficoltà maggiore di questo problema è quella di associare la locazione dei target nei fotogrammi consecutivi del video, in particolar modo quando l'oggetto si muove relativamente veloce paragonato al frame rate; in tal caso i sistemi di monitoraggio video utilizzano modelli che descrivono il movimento dell oggetto al variare del tempo. 9

18 1.3.3 Catalogazione d immagini L'algoritmo SIFT è in grado di distinguere gli oggetti presenti in un immagine e quindi può determinare la natura di una foto. Può ad esempio distinguere facilmente un paesaggio da un viso in primo piano. La catalogazione d immagini può essere notevolmente velocizzata attraverso l'utilizzo di questo algoritmo. Basti pensare ad un database composto da migliaia di foto che può essere suddiviso in diversi sottoinsiemi grazie alle proprietà appena descritte Robotica (robotic mapping) Il problema del mapping robotico è legato alla cartografia. L'obiettivo è quello di un robot autonomo in grado di costruire (o di utilizzare) la pianta di un palazzo e di localizzarsi in esso. Una strategia un po' più elaborata di navigazione al contrario migliora notevolmente le capacità del robot. Mappe cognitive (Tolman 1948) attivano la capacità di pianificazione, l'uso delle percezioni in tempo reale di eventi memorizzati e delle conseguenze di eventi previsti. Un buon algoritmo di mapping robotico può combinare le informazioni dal passato, del presente e del futuro (Trullier et al. 1997). In particolare in questa applicazione, un sistema trinoculare stereo viene utilizzato per determinare stime 3D per le posizioni keypoint. Questi vengono utilizzati solo quando appaiono in tutte e tre le immagini con disparità coerente. Come il robot si muove localizza se stesso utilizzando il confronto con le caratteristiche della mappa 3D esistente, e successivamente ne aggiunge di nuove mentre ricarica la propria posizione 3D usando un filtro di Kalman. Ciò fornisce una soluzione robusta e precisa al problema della localizzazione di robot in ambienti sconosciuti. 10

19 1.3.5 Riconoscimento della gestualità umana Il riconoscimento della gestualità umana è un argomento d informatica e della tecnologia del linguaggio. Ha l'obiettivo di interpretare la gestualità umana attraverso algoritmi matematici. I gesti possono provenire da qualsiasi movimento o posizione del corpo, ma comunemente provengono dal volto o dalle mani. Attualmente si concentra l'attenzione nel settore dei dispositivi per il riconoscimento di emozioni del viso e il riconoscimento gestuale. Il riconoscimento del gesto può essere visto come un modo per i computer per cominciare a capire il linguaggio del corpo umano, creando così un collegamento più stabile tra le macchine e gli esseri umani. Queste tecniche consentirebbero all'uomo di interfacciarsi con la macchina (HMI) e interagire naturalmente senza dispositivi meccanici. Utilizzando il concetto di riconoscimento del gesto, è possibile puntare il dito contro lo schermo del computer in modo che il cursore si sposti di conseguenza. Ciò potrebbe rendere i dispositivi d input tradizionali, come mouse, tastiere e anche schermi touch inutili Match moving In cinematografia è una tecnica di computer grafica che permette l'inserimento di oggetti virtuali in veri e propri filmati rispettando il fattore di scala, il corretto orientamento e movimento. Il termine è anche usato liberamente per riferirsi alle diverse tecniche utilizzate al fine di estrarre da una sequenza d immagini informazioni riguardo il movimento. Questa tecnica a volte è denominata motion tracking. Il match moving è principalmente utilizzato per tracciare il movimento di una telecamera in modo che un identico movimento possa essere riprodotto da una videocamera virtuale in un programma di animazione 3D. 11

20 1.3.7 Image stitching (o photo stitching) E' il processo di combinazione di molteplici immagini fotografiche, con sovrapposizione delle varie aree al fine di produrre o un panorama segmentato o un'immagine ad alta definizione. Comunemente eseguita mediante l'utilizzo di software per computer la maggioranza degli approcci all'image stiching richiede la sovrapposizione esatta tra due immagini per produrre risultati senza interruzioni. Figura 1.5: figura ricomposta tramite la tecnica dell''image stitching 12

21 Capitolo II Compute Unified Device Architecture Oggi le GPU parallele hanno cominciato a contendere alla CPU funzioni computazionali e un sottosettore della ricerca, chiamato GPGPU (acronimo di General Purpose Computing on GPU), ha trovato impiego in tantissimi campi tra cui si citano l'esplorazione petrolifera, l'elaborazione di immagini scientifiche e la determinazione del prezzo delle opzioni sulle azioni di borsa[4]. Tuttavia scrivere software per le GPU significa programmare nel linguaggio delle GPU e ciò rende la programmazione GPGPU molto complessa. La programmazione CUDA invece permette di implementare algoritmi eseguiti dalle GPU con un linguaggio ad alto livello come il C (con alcune estensioni) ed ottenere così un incremento di prestazioni paragonabili a quelli ottenuti con processori multi-core. CUDA, acronimo di Compute Unified Device Architecture, è sia un modello architetturale, una Application Programming Interface (API) per sfruttare tale architettura e una serie di estensioni (C for CUDA) al linguaggio C per descrivere un'applicazione parallela in grado di girare sulle GPU che adottano quel modello. La potenza computazionale di queste architetture sta crescendo in maniera considerevole se comparata con i normali processori (Central Processing Unit - CPU), perché nate con uno specifico orientamento, quello della grafica, dove centinaia di migliaia di operazioni 13

22 vengono eseguite in parallelo senza necessità di dover spendere transistor per gestire la logica di controllo. La maggioranza delle operazioni, infatti, è estremamente ripetitiva e le condizioni per cui delle parti di codice vengono eseguite o meno sono molto rare. A grandi linee, infatti, possiamo dire che nelle CPU standard, con un numero di core che oggigiorno arriva generalmente ad 8 o poco più, la maggior parte dei transistor è spesa per gestire il controllo (con le cache e la logica di salto), mentre nel caso delle GPU i core sono molto più semplici (effettivamente solo delle unità in virgola mobile molto veloci) e quasi tutta l'area è spesa per implementarli[5]. Figura2.1: Incremento prestazionale delle GPU nel tempo 14

23 2.1 Architettura CUDA lavora sul modello strutturale raffigurato in figura 2.2 [6]. Figura2.2: Modello architetturale CUDA. DP=double precision, SP=single precision, SFU=special functional unit, SM= stream multiprocessor La GPU accede ad una memoria locale ed è connessa alla CPU, tramite un bus (normalmente, il PCI Express). Il chip grafico, nel modello di CUDA, è costituito da una serie di multiprocessori, denominati Streaming MultiProcessor. Il numero di multiprocessori dipende dalle caratteristiche specifiche e dalla classe di prestazioni di ciascuna GPU. Ciascun multiprocessore è a sua volta formato da 8 Stream Processor. In questo caso, invece, il numero è fisso, indipendente dalla fascia di mercato del chip grafico. Ognuno di questi processori può eseguire un operazione matematica fondamentale (addizione, moltiplicazione, sottrazione, ecc) su interi o su numeri in virgola mobile in singola precisione (32 bit). In ciascun multiprocessore ci sono anche due unità per funzioni speciali (che eseguono operazioni trascendenti come seno, coseno, inverso ecc.) e, solo per i chip basati su architettura GT200, una singola unità in virgola mobile a doppia precisione (64 bit). Già da questo fattore, è evidente che le prestazioni massime a 64 bit saranno un ottavo rispetto a quelle a 32 bit, supposto di poter sfruttare appieno le capacità computazionali dell'architettura. In un multiprocessore è anche presente una shared 15

24 memory, accessibile da tutti gli streaming processor, delle cache per le istruzioni e per i dati e, infine, una unità di decodifica delle istruzioni. Vi è una sola unità di decodifica delle istruzioni ogni 8 processori, quindi siamo in una situazione di tipo Single Instruction, Multiple Data (SIMD), dove un'istruzione viene eseguita per una serie di dati diversi. NVIDIA la denomina con SIMT, Single Instruction Multiple Thread, perché di fatto nel modello CUDA vengono eseguite le stesse istruzioni da thread diversi. Per fornire dei dati più precisi la decodifica di un istruzione avviene ogni 4 cicli di clock dei processori. Ciascun processore, invece, al massimo può lanciare un istruzione per ogni ciclo di clock. Questo significa che ad ogni istruzione decodificata corrispondono 32 esecuzioni di quella stessa istruzione (8 stream processor per i cicli di clock necessari per una codifica). 2.2 Modello di esecuzione Un'applicazione CUDA è composta da parti seriali, normalmente eseguite dalla CPU di sistema, o host, e da parti parallele, denominate kernel, che vengono invece eseguite dalla GPU, o meglio ancora nei termini usati da NVIDIA, dal device. Vedi figura 2.3. Figura2.3: applicazione in CUDA 16

25 Un kernel è definito come una grid (griglia), e può a sua volta essere decomposto in blocchi, che vengono assegnati, sequenzialmente, ai vari multiprocessori. All'interno dei blocchi, c'è l'unità di computazione fondamentale, il thread. Vedi figura 2.4. Figura2.4: Struttura di una Grid Un thread appartiene ad un solo blocco ed è identificato da un indice univoco per tutto il kernel e, come illustrato in figura 2.5, è possibile assegnargli indici tridimensionali. Per i blocchi invece si utilizzano indici bidimensionali. 17

26 Così ogni thread può lavorare su dati specifici e si semplifica notevolmente l indirizzamento della memoria quando si processano dati multidimensionali. Figura 2.5: Organizzazione 3D dei thread I kernel sono eseguiti sequenzialmente tra loro, mentre i blocchi e i thread sono eseguiti in parallelo. Il numero di thread fisici in esecuzione in parallelo dipende dalla loro organizzazione in blocchi e dalle loro richieste in termini di risorse rispetto a quelle disponibili nel device. I blocchi sono pensati per garantire la scalabilità: supponendo di avere un'architettura con solo due multiprocessori (Device A nella figura 2.6) e un'altra con quattro (Device B) e un'applicazione decomposta in otto blocchi, essa potrà essere eseguita su entrambe, ovviamente con tempi e livelli di parallelismo diversi. 18

27 Nel caso si renda successivamente disponibile un'architettura con otto multiprocessori, l'applicazione automaticamente si adatterà ad essa e potenzialmente avrà prestazioni ancora migliori. Figura 2.6: Scalabilità dei blocchi su diverse device La caratteristica fondamentale di CUDA, che rende il modello di programmazione sostanzialmente differente da altri modelli paralleli normalmente usati dalle CPU, è che per essere efficiente richiede migliaia di thread, ciò è reso possibile dalla struttura tipica delle architetture grafiche, che impiegano thread molto leggeri. 19

28 2.3 Memoria Organizzazione gerarchica L'architettura di memoria è illustrata dalla figura 2.7 e mostra come un thread eseguito sulla device abbia accesso ai diversi tipi di memoria. Figura2.7: Struttura della memoria La GPU (o device) può accedere alla sua memoria privata, o global memory. L'host ha la possibilità di spostare i dati in questa memoria. Ciascun multiprocessore può poi accedere alla propria shared memory, che invece non può in alcun modo essere gestita dall'host. I dati allocati in shared memory hanno una visibilità limitata al singolo blocco di thread CUDA. Esistono altre classi di memoria le cui peculiarità sono indicate nella tabella riassuntiva 2.1 e che verranno illustrate in seguito. 20

29 Memoria Location Chached Accesso Campo di applicazione Register On-Chip No Lettura/Scrittura Un solo thread Local Off-Chip No Lettura/Scrittura Un solo thread Shared On-Chip N/A Lettura/Scrittura Tutti i thread del blocco Global Off-Chip No Lettura/Scrittura Tutti i thread e l host Constant Off-Chip Si Solo lettura Tutti i thread e l host Texture Off-Chip Si Solo Lettura Tutti i thread e l host Tabella 2.1: Caratteristiche dei vari spazi di memoria CUDA Global Memory Potenzialmente 150 volte più lenta dei registri o della shared memory (a meno di non coalescenza o di bank conflict). Accessibile sia da host che da device e il tempo di vita è pari a quello dell applicazione Shared Memory Questo tipo di memoria è approssimativamente cento volte più veloce della global memory ed è condivisa tra i thread di uno stesso blocco. La shared memory è divisa in banchi ognuno dei quali può servire un thread per ciclo di clock. Il numero di banchi stabilisce quanti thread possono accedere simultaneamente a questo tipo di memoria. Di conseguenza un accesso simultaneo a banchi differenti avviene in parallelo (un ciclo di clock), mentre un accesso simultaneo allo stesso banco causa un bank conflict e quindi tale accesso viene serializzato. E consigliabile l utilizzo di questa memoria poiché se non vi sono conflitti è veloce come i registri. 21

30 2.3.4 Register memory E il tipo di memoria più veloce. E on-chip ed è visibile da parte di un solo thread Local Memory La memoria locale è un astrazione della memoria e sta per "locale nell'ambito di ciascun thread" [7]. Non è un componente hardware del multi-processore e in realtà è una parte della global memory allocata dal compilatore e offre le stesse prestazioni di qualsiasi altra regione di memoria globale. Normalmente le variabili dichiarate in automatico da un kernel risiedono nei registri che forniscono un accesso molto veloce; il compilatore però potrebbe scegliere di allocare queste variabili nella local memory in alcuni casi: Ci sono troppe variabili nei registri e la memoria non è sufficiente. Una structure potrebbe occupare uno spazio eccessivo nei registri. Il compilatore non può determinare se un array è indicizzato con quantità costante. Si prega di notare che i registri non sono indirizzabili perciò un array viene allocato nella local memory,anche se di dimensioni ridotte, quando l'indirizzamento della matrice non è nota a momento di compilazione Constant Memory La Constant memory è una memoria read-only ed è accessibile solo dal kernel. Possiede un hardware che ottimizza il caso in cui tutti i thread leggano nella stessa locazione. Sorprendentemente, la constant memory prevede un ciclo di latenza quando vi è un cache hit, anche serisiede nella memoria del dispositivo (DRAM). Se i thread leggono da più locazioni differenti, gli accessi vengono serializzati. La costant cache può essere scritta solo dall'host (non dalla device perché perderebbe la sua connotazione costante) con la funzione cudamemcpytosymbol() ed è persistente tra le varie chiamate al kernel purché sia all'interno della stessa applicazione. La costant cache ha una capienza di 64kB perciò ciascun multiprocessore ha a disposizione 8kB. 22

31 L'accesso ai dati nella costant memory può variare a seconda della locazione della cache e da sottolineare che il primo accesso in memoria non genera un cache miss grazie ad un da un pre-fetching Texture Memory I processori grafici forniscono una texture memory per accelerare operazioni eseguite frequentemente, come la mappatura, il deforming o impiantare una texture 2d su un modello 3D poligonale. I produttori di schede grafiche per rimanere competitivi hanno fornito l'hardware aggiuntivo (ad esempio le unità texture unit) per effettuare tali operazioni molto velocemente. La texture cache è condivisa da tutti i processori e fornisce uno speed up in lettura della texture memory, che è implementata come una regione di sola lettura della memoria della device. CUDA fornisce ai programmatori la possibilità di sfruttare alcune delle funzionalità aggiunte offerte dall hardware delle texture unit sui dispositivi CUDA. Il modo più semplice per descrivere la texture memory è quello di un percorso alternativo per accedere alla memoria che il programmatore CUDA può utilizzare per raggiungere le regioni della memoria della device. Ogni unità texture ha della memoria interna (on-chip) che tramite buffer prende dati dalla memoria globale. Dal punto di vista del programmatore, la texture memory fornisce una combinazione insolita di memoria cache (separato dalla memoria register, global e shared), capacità di elaborazione locale (separato dal processore scalare), e un modo di interagire con le funzionalità di visualizzazione della GPU. Un accesso ai dati ottimizzato è molto importante per le prestazioni delle GPU; l'uso della texture memory può, in determinate circostanze, fornire un forte incremento delle prestazioni. Le prestazioni migliori si ottengono quando i thread di una griglia leggono locazioni contigue. CUDA fornisce fetch 1D, 2D e 3D utilizzando la texture memory. Dal momento che una texture esegue un'operazione di lettura da memoria globale solo quando vi è un cache miss, 23

32 è possibile superare la larghezza di banda di memoria massima teorica della global memory attraverso l'uso giudizioso della cache della texture memory. La figura 2.8 mette in evidenza come ciascun membro della gerarchia acceda ad aree differenti di memoria. Figura2.8: Accessi in memoria 2.4 Applicazioni Si noti che il modello di CUDA si adatta a specifiche classi di applicazione [8]. In particolare, le caratteristiche principali di queste applicazioni risiedono nella presenza di molte operazioni matematiche (grande intensità aritmetica), elevato grado di parallelismo (le stesse operazioni vengono ripetute per una grande quantità di dati), elevata richiesta di banda di memoria e condizioni di controllo molto limitate. Possiedono queste caratteristiche algoritmi che appartengono ai campi più disparati: da applicazioni per gestione di oleodotti e individuazione di petrolio o gas, a crittografia, da chimica all'analisi di immagini e audio. Gli algoritmi di codifica e decodifica audio e 24

33 video, analisi del traffico di rete fino alla gestione di database si sposano anche molto bene con il modello di CUDA. Nonostante CUDA sia una tecnologia relativamente nuova ci sono già molti esempi in letteratura e su Internet che mettono in evidenza un aumento notevole delle prestazioni scaturito dall utilizzo degli attuali hardware GPU. Le tabelle seguenti (2.2 e 2.3) mostrano i risultati pubblicati sul sito web dell NVIDIA [9] e del Beckman Institute. Il vero vantaggio di CUDA, abilmente sfruttato dai programmatori, è la possibilità di mantenere migliaia di thread occupati. Contando il fatto che l'attuale generazione di GPU NVIDIA possono supportare in modo efficiente un gran numero di thread, il risultato è che si ottengono 1-2 ordini di grandezza in termini di prestazioni di certe applicazioni. Applicazioni URL Speedup Seismic Database 66x to 100x Mobile Phone Antenna Simulation 45x Molecular Dynamics 21x to 100x Neuron Simulation 100x MRI processing 245x to 415x Atmospheric Cloud Simulation 50x Tabella 2.2: fonte NVIDIA da 25

34 GPU Performance Results, March 2008 GeForce8800GTX w/ CUDA 1.1, Driver Algoritmo Classe algoritmo Speedup vs. Intel QX6700 CPU Fluorescencemicrophotolysis Iterative matrix / stencil 12x Pairlist calculation Particle pair distance test 10x to 11x Pairlist update Particle pair distance test 5x to 15x Molecular dynamics nonbonded force calculation N-body cutoff force calculations 10x to 20x Cutoff electron density sum Particle-grid w/ cutoff 15x to 23x Cutoff potential summation Particle-grid w/ cutoff 12x to 21x Direct Coulomb summation Particle-grid 44x Tabella 2.3: Beckman Institute da Attenzione, i processori grafici CUDA operano come co-processori all'interno del computer host. Questo significa che ogni GPU ha una propria memoria e i dati da processare sono separati dall host. Quest ultimi devono essere trasferiti dall host al/ai dispositivo/icuda e per questo motivo, i risultati delle prestazioni devono includere questa attività di trasferimento dati per essere realmente informativi. Nei documenti a cui si fa riferimento sopra tali tempi di I/O prendono il nome di "Honest flop" perché riflettono al meglio le reali performance dell applicazione. 26

35 Si ritiene che uno o due ordini di grandezza d incremento di prestazioni rispetto alla tecnologia esistente è un cambiamento dirompente che può modificare radicalmente alcuni aspetti del computing. Ad esempio, operazioni di calcolo che in precedenza avrebbero richiesto un anno si possono ora completare in pochi giorni, calcoli di ore vengono completati in pochi secondi e con questa nuova tecnologia molte applicazioni che prima non erano trattabili, ora possono esserlo attraverso una elaborazione in tempo reale. 2.5 Primitive Il concetto base di CUDA, e di qualsiasi applicazione di tipo GPGPU, è che si sta eseguendo un offloading di una parte di computazione ad un coprocessore, rispetto al processore (la CPU) del sistema. Tale coprocessore accede ad una memoria privata (la global memory) nella quale devono essere mossi i dati prima di poter eseguire le operazioni. Al termine della computazione, i risultati sono copiati dalla memoria del device alla memoria dell'host. Per eseguire queste operazioni, sono necessarie delle apposite primitive [10] per allocare la memoria sul device e eseguire la copia dall'host al device. La memoria sull'host è allocata nelle modalità standard del C, con variabili automatiche o, nel caso di allocazione dinamica, con la classica malloc. Per eseguire l'allocazione dinamica della memoria sul device, CUDA offre la seguente primitiva: CudaMalloc(void** pointer, size_tn_bytes) Dove va specificato il nome del puntatore all'area di memoria che si sta allocando e la grandezza in bytes dell'area di memoria da allocare. Per eseguire le operazioni di copia invece si usa: CudaMemcpy(void *dst, void *src, size_tnbytes, enumcudamemcpykinddirection); Dove si specificano puntatore ad area di memoria sorgente, puntatore ad area di memoria 27

36 destinazione, la grandezza in byte dei dati da copiare, e la direzione dell'operazione di copia. La direzione può essere uno dei seguenti tipi: cudamemcpyhosttodevice cudamemcpydevicetohost cudamemcpydevicetodevice La prima copia i dati dall'host al device, la seconda dal device all'host e la terza i dati in due aree di memoria 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. Esiste anche una primitiva: cudamemset(void *pointer, intvalue, size_tcount); che serve ad inizializzare ad un valore voluto (value) un'area di memoria di grandezza (in numero di elementi) count. Con queste primitive, è possibile realizzare il primissimo programma, che esegue una copia dei dati dall'host al device, una copia di dati sul device, e poi riporta tali dati sull'host. I file sono tratti da uno dei training disponibili sul sito di NVIDIA, per consistenza con la documentazione prodotta dalla società stessa: void checkcudaerror(const char *msg); int main( int argc, char** argv) { //puntatore all'area di memoria sull'host float *h_a; //dimensioni di tale area di memoria int dima; //variabile contatore int n; // puntatori alle aree di memoria sul device float *d_a, *d_b; // allocazione ed inizializzazione della memoria sull'host // definizione delle dimensioni 28

37 dima = 8; //esecuzione della malloc h_a = (float *) malloc(dima*sizeof(float)); //inizializzazione for (n=0; n<dima; n++) { h_a[n] = (float) n; } // Allocazione della memoria sul device size_t memsize = dima*sizeof(float); cudamalloc( (void**)&d_a, memsize ); cudamalloc( (void**)&d_b, memsize ); // Memcopy dall'host al device cudamemcpy( d_a, h_a, memsize, cudamemcpyhosttodevice ); // Memcopy da device a device cudamemcpy( d_b, d_a, memsize, cudamemcpydevicetodevice ); // Cancellazione dei dati nell'area di memoria sull'host for (n=0; n<dima; n++) { h_a[n] = 0.f; } // Copia dal device all'host cudamemcpy( h_a, d_b, memsize, cudamemcpydevicetohost ); // Check errori CUDA checkcudaerror("cudamemcpy fallisce"); // verifica che i dati copiati sull host siano corretti for (n=0; n<dima; n++) { assert(h_a[n] == (float) n); } // Liberazione della memoria sul device cudafree( d_b ); cudafree( d_a ); // Verifica di eventuali errori in CUDA checkcudaerror("cudafree"); // liberazione della memoria dell'host free(h_a); return 0; } void checkcudaerror(const char *msg) { cudaerror_t err = cudagetlasterror(); if( cudasuccess!= err) { fprintf(stderr, "Cuda error: %s: %s.\n", msg, cudageterrorstring( err) ); exit(-1); } } 29

38 2.6 Il kernel Un kernel CUDA è una particolare funzione C che, invocata dall'host, viene eseguita sul device. I kernel hanno delle caratteristiche ben precise. Devono avere void come tipo di ritorno, non possono essere ricorsive, non possono avere un numero di parametri variabile e non possono usare variabili di tipo statico. Inoltre, in generale, è bene considerare che possano accedere solo alla memoria della GPU, dunque a strutture dati che siano allocate nella global memory del device Gli identificatori del kernel Nel C for CUDA le funzioni facenti parte di un kernel vanno identificate tramite appositi qualificatori da anteporre alla loro dichiarazione. Esistono tre qualificatori: global : identifica la funzione invocata dal codice dell'host, è effettivamente la funzione principale del kernel per la quale valgono le caratteristiche sopra elencate. device : identifica una funzione chiamata dal codice che gira sulla GPU, si comporta come una normale funzione C (dunque non valgono le limitazioni per i kernel), ma non può essere invocata dall'host. host : è una funzione chiamata dall'host, si comporta come una normale funzione C, ma viene eseguita solo sull'host. Le funzioni device ed host possono essere combinate, per esempio per generare codice che funzioni sia sulla GPU che sulla CPU, sfruttando il meccanismo di overloading degli operatori Invocazione L'invocazione di un kernel avviene all'interno del codice eseguito sulla CPU, chiamandone il nome e specificando la configurazione di esecuzione all'interno di appositi identificatori (<<< e >>>) con la seguente sintassi: Kernel<<<dim3 grid, dim3 block>>>(argomento1, argomento2,...); grid e block sono delle variabili che specificano il numero di blocchi in cui è diviso il 30

39 kernel e il numero di thread all'interno di ciascun blocco. Volendo, possono essere direttamente sostituite con dei numeri, variante particolarmente utile nella fase di test. Ad esempio: Kernel<<<16,256>>>(argomento1); Questo comando permette di lanciare un kernel composto da 16 blocchi ognuno dei quali con 256 thread al suo interno Dim3 dim3 è uno dei tipi predefiniti di CUDA. E un tipo vettore che permette di specificare fino a tre valori per la variabile dichiarata. Valori eventualmente non dichiarati vengono posti a 1 di default. Come già precedentemente detto, un kernel dal punto di vista del codice è anche definito grid (griglia). La griglia è composta da un insieme di blocchi, ed infine costituiti da thread, che possono essere organizzati tridimensionalmente. Dunque, specificare una configurazione di esecuzione, significa dichiarare delle variabili dim3 che forniscono le coordinate dei thread; ad esempio le seguenti variabili: dim3 grid(16,16); dim3 block(16,16); permettono di lanciare il kernel che verrà eseguito da 256 blocchi (si può pensare ad una griglia da 16x16 blocchi) che all interno hanno 256 thread ciascuno. Kernel<<<grid, block>>>(parametro1); L'identificatore di un thread Per individuare l'identificatore (il numero identificativo) di un thread che sta operando su un determinato dato o insieme di dati, C for CUDA integra delle variabili sempre accessibili all'interno di funzioni di tipo global e device. Sempre accessibili significa che non c'è bisogno di alcuna dichiarazione per poter utilizzare queste variabili, che sono sempre attive e inizializzate ai valori corretti all'interno 31

40 delle funzioni che stiamo scrivendo. Esse sono: dim3 griddim:ritorna le dimensioni della griglia in numero di blocchi. Poiché la grandezza della griglia è espressa in due dimensioni, il terzo valore è sempre 1. 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. Per accedere ai differenti campi,visto che si tratta variabili di tipo dim3,il quale assegna tre valori alla variabile,si aggiunge al nome della stessa l'identificatore del campo richiesto, per esempio: blockdim.x: ritorna la dimensione sull'asse x del blocco. Importante dire che con x s identifica l'asse orizzontale e con y l'asse verticale, esattamente come avviene sul piano cartesiano. Nel caso di spazi tridimensionali, ovviamente l'asse z è quello della profondità. Per determinare l'indice di uno specifico thread all'interno di un kernel, la formula che in generale viene usata è: NumThread = threadidx.x + threadidx.y * blockdim.x + threadidx.z * blockdim.y * blockdim.x; L'asincronia della chiamata del kernel Come già detto i kernel sono eseguiti sequenzialmente tra loro, ma una volta che la CPU lancia un kernel è libera di fare altre operazioni mentre esso viene eseguito dalla GPU. La chiamata è quindi asincrona, ed è dunque possibile far eseguire alla CPU altre parti di codice in parallelo alla GPU. Con le memcopy invece ciò non accade poiché entrambi gli elementi di elaborazione sono coinvolti nell'operazione, che dunque è sincrona. Se si vuole mettere la CPU in attesa della terminazione di tutte le operazioni in esecuzione sul device, si può usare la primitiva: cudathreadsynchronize(); 32

41 2.7 Coalescenza degli accessi in memoria Rendere possibili degli accessi coalescenti in memoria significa riuscire ad accorpare più accessi (letture o scritture) in un'unica transazione del controller di memoria. Gli accessi in memoria dei chip grafici compatibili con CUDA devono seguire delle regole ben precise per minimizzare il numero di transazioni[11]. L'unità a cui fare riferimento è quella dell'half-warp, cioè di 16 thread facenti parti dello stesso gruppo di 32 thread (warp) tenuti in esecuzione per ciascun ciclo di clock su un multiprocessore. A seconda della compute capability supportata dal dispositivo, cambiano anche le linee guida da seguire nell'organizzare gli accessi di un half warp per ottenere la loro coalescenza. Per i chip grafici con compute capability 1.0 o 1.1 come quello utilizzato nel nostro caso, gli accessi di un half-warp sono coalescenti se leggono un'area contigua di memoria di: 64 byte ogni thread legge una word: int, float, byte ogni thread legge una double-word: int2, float2, byte ogni thread legge una quad-word: int4, float4,... In più, devono essere rispettate le seguenti restrizioni: L'indirizzo iniziale di una regione deve essere multiplo della grandezza della regione stessa. L i-esimo thread di un half-warp deve accedere all i-esimo elemento di un blocco (letto o scritto), gli accessi devono cioè essere perfettamente allineati tra i thread. Vi è anche un'eccezione: Gli accessi rimangono coalescenti se alcuni thread non partecipano (cioè non eseguono la lettura o la scrittura in esame) Riportiamo qua di seguito alcuni casi di accessi coalescenti(figura 2.10) o non coalescenti (figura 2.9) mostrati nel manuale di programmazione di CUDA [12]. 33

42 Figura 2.9: Esempio di non coalescenza in memoria Nell immagine di sinistra notiamo due thread che incrociano il loroaccesso in memoria, mentre in quella di destra gli accessi in memoria partono dall'indirizzo 132 (invece che 128). In entrambi i casi non sono rispettate le condizioni per la coalescenza degli accessi dal punto di vista dell'allineamento: nel primo caso, non c'è una corrispondenza sequenziale tra gli accessi, nel secondo non si parte da un multiplo della granularità della transazione (64 byte). 34

43 Figura 2.10: Esempio di coalescenza in memoria La seconda immagine presenta invece due casi di accessi coalescenti. A sinistra, vediamo 16 accessi a 32 bit, che partono dall'indirizzo 128, con corrispondenza uno a uno. A destra, la situazione è simile, ma alcuni thread non eseguono accessi e si rientra nel caso dell eccezione concessa. 35

44 Capitolo III Implementazione in CUDA 3.1 Caratteristiche tecniche La tesi è stata svolta utilizzando come ambiente di sviluppo Microsoft Visual Studio 2005 e la scheda video a nostra disposizione è stata una Quadro FX 580 della NVIDIA con le specifiche riportate in tabella 3.1. CUDA Cores 32 Compute Capability 1.1 Memory Size Total 512 MB GDDR3 Memory Interface 128-bit Memory Bandwidth (GB/sec) 25.6 Tabella 3.1: Scheda tecnica Il linguaggio di programmazione utilizzato è stato il C con le estensioni per CUDA. Nella fase di sviluppo è stata ottimizzata la parte di codice più critica ovvero quella riguardante la convoluzione e la creazione delle matrici DoG. 36

45 Queste funzioni infatti sono chiamate frequentemente nel corso del programma e di conseguenza una loro ottimizzazione comporta un incremento delle prestazioni dell intera applicazione. Viste le potenzialità offerte da CUDA le parti di codice in questione sono state riscritte utilizzando tale architettura. 3.2 Convoluzione Matematicamente si definisce convoluzione di f e g la funzione definita nel seguente modo: dove f(t) e g(t) sono funzioni (3.1) e denota l integrale definito su tutto l'insieme dei numeri reali. Per funzioni discrete, si può usare la versione discreta della convoluzione: (3.2) La convoluzione può essere estesa anche a due dimensioni introducendo gli indici: (3.3) 37

46 3.3 Implementazione Nell ambito di elaborazione d immagini, un filtro di convoluzione è il prodotto scalare dei pesi del filtro d ingresso con i pixel all'interno di una finestra che circonda ognuno deipixel in uscita. Il prodotto scalare è un'operazione parallela, che ben si adatta alla computazione su un hardware parallelo quale la GPU. Figura3.1: Convoluzione con filtro 3x3 Generalmente, una convoluzione bidimensionale richiede n*m moltiplicazioni per ogni pixel di uscita, dove n ed m sono la larghezza e l'altezza del kernel del filtro. Si può pensare di scomporre tale operazione applicando due filtri monodimensionali, uno per le righe dell'immagine, e uno sulle colonne. Questo metodo prende il nome di Convolution Separable ed è caratterizzato da due operazioni consecutive di convoluzione monodimensionale sui dati richiedendo solo n + m moltiplicazioni per ogni pixel in uscita. I vantaggi sono quelli di offrire una maggiore flessibilità nella implementazione, una riduzione della complessità aritmetica e un impiego di larghezza di banda di calcolo minore per ogni dato. L'approccio più semplice per implementare la convoluzione in CUDA è quello di caricare un blocco dell immagine in un array su shared memory, effettuare una moltiplicazione punto per punto di un blocco di grandezza pari al filtro di convoluzione, e poi scrivere la somma risultante all interno del pixel corrispondente dell immagine di output nella device memory. 38

47 Ogni blocco di thread elabora in parallelo un blocco dell immagine. E importante sottolineare che ogni thread è in grado di generare un pixel di output. Vedi figura 3.2. Figura 3.2: Un blocco di pixel dell immagine viene caricata in un array nella shared memory. Per elaborare e calcolare il pixel di uscita (rosso), una regione dell immagine in ingresso (arancione) viene moltiplicata elemento per elemento con il kernel (viola) e poi i risultati vengono sommati. Il pixel di uscita risultante viene poi scritto nuovamente dentro l immagine Shared Memory e pixel al contorno Indipendentemente dalle dimensioni del filtro, i pixel di output ai bordi non dipenderanno dai pixel nella shared memory. Infatti intorno ad ogni blocco ci sono dei pixel di confine (tanti quanti la dimensione del kernel) che sono richiesti per filtrare tale blocco dell immagine. Così, ogni blocco di thread carica nella shared memory i pixel che devono essere filtrati (che poi andranno nella matrice di output) e i pixel di contorno (necessari 39

48 all applicazione del filtro). Questo è chiarito nella Figura 3.3. Come si può notare i pixel di contorno di un blocco si vanno a sovrapporre con i pixel di contorno dei blocchi adiacenti. I pixel di contorno dei blocchi che sono ai bordi dell immagine si estendono al di fuori dell immagine stessa. Questi pixel vengono quindi settati al colore del pixel di bordo dell immagine o possono essere settati a zero. Figura 3.3: Modifica all algoritmo in figura3.2 per includere le regioni di confine dei blocchi dell immagine Evitare thread inattivi Tuttavia se ogni singolo thread viene utilizzato per elaborare un pixel caricato nella shared memory allora i thread che si occupano dei pixel al contorno saranno inattivi durante l elaborazione del filtro. Come il raggio del filtro aumenta, la percentuale di thread inattivi cresce. Questo è un effetto negativo e da evitare in quanto riduce gran parte del parallelismo. 40

49 Si può però ridurre il numero di thread inattivi, riducendo il numero totale di thread per blocco e usando ogni thread per caricare più pixel nella shared memory Aumentare l efficienza Oltre a ridurre il numero di thread inattivi è possibile ridurre la quantità di dati caricati dividendo il procedimento in due parti ognuna delle quali è eseguita per ambedue le dimensioni del filtro. I dati così caricati sono in quantità minore rispetto al procedimento con un unico filtro in quanto vi è una minore sovrapposizione di blocchi e i pixel appartenenti al confine dell immagine vengono caricati meno volte. Sperimentalmente separando il calcolo per righe e per colonne, con una scrittura sulla global memory tra le due fasi di calcolo, si ha effettivamente un miglioramento di prestazioni. Il vero vantaggio si ha perché non è più necessario caricare i pixel nelle regioni superiori e inferiori del bordo (per la fase orizzontale). Questo permette di caricare più pixel da elaborare per ogni blocco di thread. La limitazione deriva quindi dalla dimensione dei blocchi e non più dalla dimensione della shared memory. Per ottenere una maggiore efficienza, infatti, ogni thread deve elaborare più di un pixel. E possibile aumentare la larghezza del blocco d immagine processato da un blocco di thread facendo uso di questo approccio separato Ottimizzazione per la coalescenza in memoria La larghezza di banda della DRAM (Dinamic Random Access Memory) presente nella device è molto superiore rispetto a quella della memoria della CPU. Tuttavia per raggiungere un throughput elevato, la GPU tenta di unire l accesso da più thread in una singola lettura della memoria. Se tutti i thread di un warp (32 thread) leggono simultaneamente parole consecutive allora una singola lettura di 32 valori può essere ottimizzata. Se invece non si accede a locazioni di memoria contigue o l'indirizzo di base per i thread di warp non è allineato a 64 byte non si riesce a sfruttare l intera larghezza di banda della 41

50 DRAM con relativo degrado delle prestazioni. L approccio usato nel filtro riga è stato quello di avere alcuni thread inattivi sulla parte che si sta elaborando al fine di leggere sempre correttamente in memoria in modo da rispettare i vincoli di allineamento della global memory per tutti i thread di warp. Questo potrebbe sembrare uno spreco di thread, ma è di poca importanza nel contesto dell intero blocco di dati, visto che le prestazioni decrescono solo per i pixel di confine. Figura 3.4: blocco di thread con thread inattivi per realizzare l allineamento richiesto per lettura dati coalescente nella fase di applicazione del filtro righe. Durante l applicazione del filtro di convoluzione colonna, i pixel al confine non influenzano l'allineamento in memoria, a condizione che la larghezza del ROW_TILE_W dell immagine (indicata in figura 3.4) sia un multiplo di 16. La convoluzione di un immagine è suddivisa in due parti dove si applicano il filtro riga e il filtro colonna attraverso i rispettivi kernel CUDA. In una prima fase vengono caricati i dati dalla global memory nella shared memory, nella seconda fase viene applicato il filtro e il risultato viene ritornato alla global memory. Nei casi in cui l elaborazione per riga o colonna delle varie parti dell immagine giunge ai bordi dell'immagine, gli indici degli array della memoria condivisa devono essere inizializzati ai valori corretti. 42

51 Gli indici che corrispondono ai pixel di confine dell immagine d ingresso sono inizializzati con zero o con valori corrispondenti dei pixel di contorno. Tra le due fasi c'è un syncthreads () che garantisce che tutti i thread abbiano scritto nella shared memory prima che ogni altra operazione abbia inizio. Questo è necessario perché i thread utilizzano i dati elaborati da altri thread in precedenza Il filtro delle righe Figura 3.5: Illustrazione della grid per la fase di filtraggio delle righe Ogni thread attivo sia nella fase di carica che in quella di elaborazione carica/manda in output un solo pixel. Nella fase di elaborazione ogni thread viene iterato su una larghezza pari a due volte il raggio del filtro più 1, moltiplicando ogni pixel con il coefficiente corrispondente del filtro allocato nella constant memory. Ogni thread nell half-warp accede sempre allo stesso indirizzo costante e quindi non c è alcuna penalizzazione dovuta ai conflitti di accesso nella costant memory. Per lo stesso motivo anche i thread consecutivi accedono sempre a indirizzi contigui nella shared memory. 43

52 3.3.6 Filtro delle Colonne Figura 3.6: Illustrazione della grid per la fase di filtraggio delle colonne Il filtro colonna in figura 3.6 funziona in modo del tutto simile al filtro riga. La differenza principale è che il numero identificativo di ogni di thread (ThreadID) s incrementa lungo la larghezza del filtro, invece che lungo l altezza di esso. Come nel filtro riga, i thread in un singolo half-warp accedono sempre a differenti locazioni nella shared memory ma il calcolo dell indirizzo precedente/successivo comporta decremento/incremento di COLUMN_TILE_W, piuttosto che semplicemente di uno. Nel filtro colonne non si hanno thread inattivi dovuti all allineamento in memoria nella fase di carica dei dati, perché si suppone che la larghezza del blocchetto d immagine che si sta processando è un multiplo della dimensione dei dati letti in modo coalescente. Al fine di diminuire il rapporto tra bordo dell immagine in ingresso e pixel di uscita risultanti vogliamo che il blocco dell immagine sia il più alto possibile. Quindi per sfruttare al massimo la shared memory cercheremo un immagine il più sottile (magra) possibile. 44