La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Introduzione al Calcolo Parallelo GPGPU – CUDA Girolamo Giudice Seminario di Bioinformatica.

Presentazioni simili


Presentazione sul tema: "Introduzione al Calcolo Parallelo GPGPU – CUDA Girolamo Giudice Seminario di Bioinformatica."— Transcript della presentazione:

1 Introduzione al Calcolo Parallelo GPGPU – CUDA Girolamo Giudice Seminario di Bioinformatica

2 Introduzione al calcolo parallelo Cenni sul calcolo sequenziale Cenni sul calcolo parallelo Perché usare il calcolo parallelo Architettura hardware GPU - CUDA Modello Software Cuda Esempio pratico

3 Introduzione al calcolo parallello Benchmark di alcuni tool Bioinformatici Vento sulla GPU

4 Evoluzione della CPU Negli ultimi 20 anni i microprocessori basati su una singola CPU hanno avuto un rapido incremento nelle prestazioni e una diminuzione dei costi. Questa corsa ha subito una battuta d arresto a causa dei consumi e dei problemi di riscaldamento 15 nov 2004 p4 3,8ghz 28 mag 2011 I7extreme 3,6ghz

5 Evoluzione della CPU I produttori di microprocessori si sono orientati verso modelli con più unità di processo (multi core),allo scopo di aumentare la potenza di calcolo. Intel ha presentato un 80 core

6 Problemi dei Multi-core Tradizionalmente i programmi sono stati scritti per essere eseguiti su un computer con una singola CPU ( modello Von Neuman). La stragrande maggioranza delle applicazioni sono costituite da programmi sequenziali I processori dual core sono praticamente lo standard attuale

7 Cenni di calcolo sequenziale Un problema viene suddiviso in sequenze discrete di istruzioni che vengono eseguite (di solito) una dopo laltra In un dato istante di tempo solo una istruzione è in esecuzione sulla CPU

8 Cenni di calcolo parallelo Il calcolo parallelo è luso di più unità di computazione ( CPU multi core o multi CPU) per risolvere problemi Storicamente è stato sempre un paradigma costoso e di alto livello

9 Cenni di calcolo parallelo Il calcolo viene eseguito su più CPU o su CPU multicore o dual thread Il problema viene decomposto in componenti discrete che possono essere eseguite concorrentemente Le istruzioni sono eseguite simultaneamente su CPU differenti

10 Tassonomia di Flynn

11 SISD SIMD MISDMIMD

12 Perché usare il calcolo parallelo Risolvo un problema più grande nello stesso tempo (SCALE – UP) Lo stesso problema in minor tempo (SPEED- UP) Contenere i costi Sfruttare meglio la RAM Aumentare laffidabilità Utilizzare risorse distribuite

13 GPGPU / CUDA GPGPU: utilizzare il processore della scheda grafica (GPU) per scopi diversi dalla tradizionale creazione di unimmagine tridimensionale. Le GPU sono processori multicore ad elevate prestazioni, il loro avvento è relativamente recente. Le prime soluzioni programmabili risalgono al 2006,precedentemente erano dedicate solo allo sviluppo della grafica e dei videogiochi. Le GPU sono diventate processori paralleli general purpose con interfacce di programmazione con supporto ai linguaggi di programmazione come il C.

14 Differenze Macroscopiche CPU / GPU

15 Architettura CUDA G80 Host = CPU Device = GPU C: Compute U: Unified D: Device A: Architecture

16 Architettura Cuda Ciascun Streaming Multiprocessor contiene al suo interno: 8 Stream Processor (add sub,mul su int e float) SFU(super funciton unit): seno,coseno,log,inv,exp Shared memory per tutti i thread in esecuzione sul SM Cache per dati e istruzioni Unità per la decodifica delle istruzioni (decodifica una istruzione ogni 4 cicli di clock)

17 Architettura hardware Mascherare la latenza della memoria globale con migliaia di thread Struttura di memoria semplice ma a bassa latenza, anziché ad accesso ottimizzato, ma complesso Nessuna priorità sui thread No context switch No overhead SIMT (single instruction multiple thread) tutti i thread eseguono la stesso istruzione ma su dati diversi

18 Cuda: Modello di esecuzione Un codice Cuda alterna porzioni di codice seriale, eseguito dalla CPU e di codice parallelo eseguito dalla GPU. Le porzioni di codice eseguite sulla GPU sono note come kernel (~ funzione in C/C++) Il kernel, è definito come una griglia di blocchi che vengono assegnati ai vari multiprocessori, e rappresentano un parallelismo a grana grossa. Ogni blocco esegue lunità di computazione fondamentale, il thread. Un thread può appartenere ad un solo blocco ed è univocamente identificato da un ID.

19 Multidimensionalità degli IDs Il codice parallelo viene lanciato, dalla CPU, sulla GPU, questa esegue un solo kernel alla volta. La dimensione della griglia si misura in blocchi questi possono essere: Block: 1-D o 2-D La dimensione dei blocchi si misura in thread Thread 1-D,2-D,3-D

20 Cuda memory model Tipi di memoria Global (device) memory (R/W) Shared memory (R/W) Registers (R/W locale per thread) Constant (R/O) Texture (R/O) Global,costant e texture memory sono persistenti a diversi lanci di kernel Si minimizza il transfer rate bottleneck

21 Classi di applicazioni Presenza di molte operazioni matematiche(grande intensità aritmetica) Elevato grado di parallelismo (le stesse operazioni vengono ripetute per una grande quantità di dati) Condizioni di controllo limitate Minima dipendenza tra i dati

22 Linguaggi che supportano cuda

23 Esempio 2 vettori da elementi Su ogni elemento del vettore dobbiamo eseguire questa operazione log(h_a[i]*h_b[i]) Quanti blocchi? Quanti thread? Fissiamo per esempio 512 thread Dimensione del blocco = /512= Arrotondiamo a 196 n°thread=196*512=100352

24 #include // implementazione del kernel __global__ void Kernel(float *d_a,float *d_b,float *d_c) { // calcolo dell'indice di thread int idx = blockIdx.x*blockDim.x + threadIdx.x; if(idx<100000) d_c[idx] =log(d_a[idx]*d_b[idx]); } // Dichiariamo il main int main( int argc, char** argv) { int n=100000; time_t begin,end; // puntatore per la struttura dati sull'host float *h_a=(float*) malloc(sizeof(float)*n); float *h_b=(float*) malloc(sizeof(float)*n); float *h_c=(float*) malloc(sizeof(float)*n); //inizializzo il vettore numeri casuali for(int i=0;i>( d_a,d_b,d_c ); // blocca la CPU fino al completamento del kernel sul device cudaThreadSynchronize(); // Esegue la copia dei risultati dalla memoria del device a quella dell'host cudaMemcpy( h_c, d_c, n, cudaMemcpyDeviceToHost ); end = clock(); } float time_gpu = (double)(end-begin)/CLOCKS_PER_SEC; printf("GPU time %.20lf\n",time_gpu); // libera la memoria sul device cudaFree(d_a); cudaFree(d_b); cudaFree(d_c); // libera la memoria sull'host free(h_a); free(h_b); free(h_c); return 0; }

25 Inizialmente: Array h_a Array h_b Array h_c CPU GPU Hosts memory Devices memory float *h_a=(float*) malloc(sizeof(float)*n); float *h_b=(float*) malloc(sizeof(float)*n); float *h_c=(float*) malloc(sizeof(float)*n);

26 Allocare memoria sulla GPU Array h_a Array h_b Array h_c CPU Hosts memory Devices memory GPU Array d_a Array d_b Array d_c cudaMalloc( (void**) &d_a, sizeof(float)*n) ;

27 Copiare il contenuto dalla host memory alla device memory Array h_a Array h_b Array h_c CPU Hosts memory Devices memory GPU Array d_a Array d_b Array d_c cudaMemcpy( d_a, h_a, sizeof(float)*n, cudaMemcpyHostToDevice) ; cudaMemcpy( d_b, h_b, sizeof(float)*n, cudaMemcpyHostToDevice) ; cudaMemcpy( d_c, h_c, sizeof(float)*n, cudaMemcpyHostToDevice) ;

28 Eseguire il contenuto sulla GPU GPU MPs Array h_a Array h_b Array h_c CPU Hosts memory Devices memory GPU Array d_a Array d_b Array d_c __global__ void Kernel( float *d_a,float *d_b,float *d_c) { // calcolo dell'indice di thread int idx = blockIdx.x*blockDim.x + threadIdx.x; if(idx<100000) d_c[idx] =log(d_a[idx]*d_b[idx]); } Kernel >>( d_a,d_b,d_c );

29 In the GPU Thread 1 Thread 2 Thread 512 Thread 0 Thread 1 Thread 2 Thread 512 Thread 0 d_c[idx]= Log(d_a[idx] +d_b[idx] d_c[idx]= Log(d_a[idx] +d_b[idx] d_c[idx]= Log(d_a[idx] +d_b[idx] d_c[idx]= Log(d_a[idx] +d_b[idx] d_c[idx]= Log(d_a[idx] +d_b[idx] Block 0 Block 196 …… … … … … … d_c[idx]= Log(d_a[idx] +d_b[idx] d_c[idx]= Log(d_a[idx] +d_b[idx]

30 Restituire il risultato Hosts MemoryGPU Cards Memory Array d_c Array h_c cudaMemcpy( h_c, d_c, n, cudaMemcpyDeviceToHost ); Tempi CPU 0.01 GPU el Tempi CPU 0.8 GPU el Tempi CPU 0.1 GPU el

31 Applicazioni tipiche Elaborazione video Astrofisica Finanza Fisica di gioco Modellazione fisica Analisi numerica DSP Imaging medicale Data mining Dinamica molecolare Bioinformatica

32

33

34

35

36 Mcode:Finds clusters in a network

37 Subgraph isomorphism Subgraph matching. Un grafo G(V,E) e un sottografo isomorfo a G 1 (V 1,E 1 ) se esiste una funzione iniettiva f:V V 1 tale che (u,v) E se e solo se (f(u),f(v)) E 1. La ricerca di sottostrutture allinterno di un grafo target è un processo estremamente oneroso dal punto di vista computazionale (problema NP-completo). Il processo di ricerca di una query si articola in tre fasi Preprocessing Filtering Matching

38 Esempio #Graph

39 #graph Esempio

40 Grafo Query #Query

41 Preprocessing Nodo iniziale / Nodo finale #graph Nodo iniziale / Nodo finale #Query

42 Applichiamo CUDA Nodo iniziale / Nodo finale #graph Nodo iniziale / Nodo finale #Query Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16 Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16

43 1° kernel 6950 Nodo iniziale / Nodo finale #graph Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16 Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16

44 2° kernel 698 Nodo iniziale / Nodo finale #graph Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16 Tid 1 Tid 2 Tid 3 Tid 4 Tid 5 Tid 6 Tid 7 Tid 8 Tid 9 Tid 10 Tid 11 Tid 12 Tid 13 Tid 14 Tid 15 Tid 16

45 Pruning Query Foresta di grafi

46 Ricapitolando CUDA

47 2° pruning

48 VF2

49 Risultati Rete utilizzata: Scalefree2000 Composta da 2000 nodi e 3997 archi Query Test: Query4 Query16 Query64 Hardware utilizzato: Intel Core 2 duo E4400 (2 GHz) Nvidia Geforce Gts 250 (128 Cuda cores)

50

51

52

53

54 Rete utilizzata: YeastNetworkRand Composta da 5589 nodi e archi Query Test: Query4 Query8 Query16 Query32 Query64 Query128 Hardware utilizzato: Intel Core 2 duo E4400 (2 GHz) Nvidia Geforce Gts 250 (128 Cuda cores)

55

56 Query 8

57 Query 16 Guadagno da 6x a 164x

58 Query 16

59 Query 32

60

61

62

63

64 Lelaborazione della query128_036,da parte di ventoCPU, è stata interrotta dopo oltre 7 ore di elaborazione

65 Confronto con SING Rete:ScaleFree_2000_128 n° Query4 : 100 n° Match Effettivi: 31 Query da valutare con VentoGPU:32 Falsi positivi VentoGPU:1 Query da valutare con Sing: 99 Falsi positivi Sing: 68

66

67 Rete:ScaleFree_2000_128 n° Query16 : 100 n° Match Effettivi: 49 Query da valutare con VentoGPU:49 Falsi positivi VentoGPU:0 Query da valutare con Sing: 50 Falsi positivi Sing: 1

68

69 Rete:ScaleFree_2000_128 n° Query64 : 100 n° Match Effettivi: 40 Query da valutare con VentoGPU:40 Falsi positivi VentoGPU:0 Query da valutare con Sing: 42 Falsi positivi Sing: 2

70

71 Rete:Yeastnetworkrand n° Query4 : 100 n° Match Effettivi: 68 Query da valutare con VentoGPU:75 Falsi positivi VentoGPU:7

72

73 Rete:Yeastnetworkrand n° Query16 : 100 n° Match Effettivi: 35 Query da valutare con VentoGPU:61 Falsi positivi VentoGPU:26

74

75 Rete:Yeastnetworkrand n° Query64 : 100 n° Match Effettivi: 34 Query da valutare con VentoGPU: 60 Falsi positivi VentoGPU:26

76

77 Questions?


Scaricare ppt "Introduzione al Calcolo Parallelo GPGPU – CUDA Girolamo Giudice Seminario di Bioinformatica."

Presentazioni simili


Annunci Google