Download - Introduzione al Calcolo Parallelo
Introduzione al Calcolo Parallelo
GPGPU – CUDAGirolamo Giudice
Seminario di Bioinformatica
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
Introduzione al calcolo parallello
• Benchmark di alcuni tool Bioinformatici• Vento sulla GPU
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
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
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
Cenni di calcolo sequenziale
• Un problema viene suddiviso in sequenze discrete di istruzioni che vengono eseguite (di solito) una dopo l’altra
• In un dato istante di tempo solo una istruzione è in esecuzione sulla CPU
Cenni di calcolo parallelo
• Il calcolo parallelo è l’uso di più unità di computazione ( CPU multi core o multi CPU) per risolvere problemi
• Storicamente è stato sempre un paradigma costoso e di alto livello
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
Tassonomia di Flynn
Tassonomia di FlynnSISD SIMD
MISD MIMD
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 l’affidabilità• Utilizzare risorse distribuite
GPGPU / CUDA
• GPGPU: utilizzare il processore della scheda grafica (GPU) per scopi diversi dalla tradizionale creazione di un’immagine 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.
Differenze Macroscopiche CPU / GPU
Architettura CUDA G80Host = CPUDevice = GPU
C: ComputeU: UnifiedD: DeviceA: Architecture
1 2 3 4 5 6 7 8 13 14 15 169 10 11 12
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 istruzioneogni 4 cicli di clock)
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
Cuda: Modello di esecuzioneUn 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 l’unità di computazione fondamentale, il thread.Un thread può appartenere ad un solo blocco ed è univocamente identificato da un ID.
Multidimensionalità degli IDsIl 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-DLa dimensione dei blocchi si misura in threadThread 1-D,2-D,3-D
Cuda memory modelTipi 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 kernelSi minimizza il transfer rate bottleneck
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
Linguaggi che supportano cuda
Esempio
• 2 vettori da 100.000 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 threadDimensione del blocco = 100000/512=195.31Arrotondiamo a 196
n°thread=196*512=100352
#include <stdio.h>
// 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 mainint 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 casualifor(int i=0;i<n;i++){
h_a[i]=rand();h_b[i]=rand();
}begin = clock();for(int i=0;i<n;i++)h_c[i] =log(h_a[i]*h_b[i]);end=clock();float time_cpu = (double)(end-begin)/CLOCKS_PER_SEC;printf("CPU time %.20lf\n",time_cpu);
// puntatore per la struttura dati sul device float *d_a=NULL;
float *d_b=NULL;float *d_c=NULL;//verifico al secondo lancio del kernelfor(int i=0;i<2;i++){
begin = clock(); //malloc e memcopy host to device
cudaMalloc( (void**) &d_a, sizeof(float)*n) ;cudaMalloc( (void**) &d_a, sizeof(float)*n) ;cudaMalloc( (void**) &d_a, sizeof(float)*n) ;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) ;
// definizione della grandezza della griglia e dei blocchi int numBlocks = 196; int numThreadsPerBlock = 512; // Lancio del kernel dim3 dimGrid(numBlocks); dim3 dimBlock(numThreadsPerBlock); Kernel<<< dimGrid, dimBlock >>>( 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;}
Inizialmente:
Array h_a
Array h_b
Array h_c
CPU GPU
Host’smemory
Device’smemory
float *h_a=(float*) malloc(sizeof(float)*n);float *h_b=(float*) malloc(sizeof(float)*n);float *h_c=(float*) malloc(sizeof(float)*n);
Allocare memoria sulla GPU
Array h_a
Array h_b
Array h_c
CPU
Host’smemory
Device’smemory
GPU
Array d_a
Array d_b
Array d_c
cudaMalloc( (void**) &d_a, sizeof(float)*n) ;cudaMalloc( (void**) &d_a, sizeof(float)*n) ;cudaMalloc( (void**) &d_a, sizeof(float)*n) ;
Copiare il contenuto dalla host memory alla device memory
Array h_a
Array h_b
Array h_c
CPU
Host’smemory
Device’smemory
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) ;
Eseguire il contenuto sulla GPU
GPU MPs
Array h_a
Array h_b
Array h_c
CPU
Host’smemory
Device’smemory
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<<< 196, 512 >>>( d_a,d_b,d_c );
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]
Restituire il risultato
Host’s Memory GPU Card’s Memory
Array d_cArray h_c
cudaMemcpy( h_c, d_c, n, cudaMemcpyDeviceToHost );
TempiCPU 0.01GPU 0.002100.000 el
TempiCPU 0.8GPU 0.03710.000.000 el
TempiCPU 0.1GPU 0.0071.000.000 el
Applicazioni tipiche• Elaborazione video• Astrofisica• Finanza• Fisica di gioco• Modellazione fisica• Analisi numerica• DSP• Imaging medicale• Data mining• Dinamica molecolare• Bioinformatica
http://gpu.epfl.ch/sw.html
Mcode:Finds clusters in a network
Subgraph isomorphismSubgraph matching.
Un grafo G(V,E) e un sottografo isomorfo a G1(V1,E1) se esiste una funzione iniettiva f:VV1 tale che (u,v)E se e solo se (f(u),f(v))E1.
La ricerca di sottostrutture all’interno 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
Esempio
#Graph4 718327443 0 10 22 3
71
27 44
8301
23
#graph156972372297955088885069128136
160 70 17 110 111 1011 1311 611 311 911 811 511 211 411 1214 11
8
37 22
72
0
5069
81
69
36
95
97
1250
888
1
2
3
4
5
6
7810 9
11
1213
14
Esempio
Grafo Query
#Query36950820 10 2
69
8
5001
2
PreprocessingNodo iniziale / Nodo finale#graph168 698 7269 7250 7269 5069 8169 5069 2269 869 8869 9569 3769 9769 1236 69
Nodo iniziale / Nodo finale#Query269 5069 8
Applichiamo CUDANodo iniziale / Nodo finale#graph168 698 7269 7250 7269 5069 8169 5069 2269 869 8869 9569 3769 9769 1236 69
Nodo iniziale / Nodo finale#Query269 5069 8
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
1° kernel69 50
Nodo iniziale / Nodo finale#graph168 698 7269 7250 7269 5069 8169 5069 2269 869 8869 9569 3769 9769 1236 69
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
2° kernel69 8
Nodo iniziale / Nodo finale#graph1669 88 7269 7250 7269 5069 8169 5069 2269 869 8869 9569 3769 9769 1236 69
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
Tid 1Tid 2Tid 3Tid 4Tid 5Tid 6Tid 7Tid 8Tid 9Tid 10Tid 11Tid 12Tid 13Tid 14Tid 15Tid 16
Pruning
50
69
50
8
69
8
5001
2
69
8Query
Foresta di grafi
Ricapitolando
CUDA
2° pruning
VF2
RisultatiRete utilizzata:
Scalefree2000Composta da 2000 nodi e 3997 archi
Query Test:Query4Query16Query64
Hardware utilizzato:Intel Core 2 duo E4400 (2 GHz)Nvidia Geforce Gts 250 (128 Cuda cores)
Rete utilizzata:YeastNetworkRand
Composta da 5589 nodi e 92835 archiQuery Test:
Query4Query8
Query16Query32Query64
Query128Hardware utilizzato:
Intel Core 2 duo E4400 (2 GHz)Nvidia Geforce Gts 250 (128 Cuda cores)
Query 8
Query 16Guadagno da 6x a 164x
Query 16
Query 32
• L’elaborazione della query128_036,da parte di ventoCPU, è stata interrotta dopo oltre 7 ore di elaborazione
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
• 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
• 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
• Rete:Yeastnetworkrand• n° Query4 : 100
• n° Match Effettivi: 68• Query da valutare con VentoGPU:75
• Falsi positivi VentoGPU:7
• Rete:Yeastnetworkrand• n° Query16 : 100
• n° Match Effettivi: 35• Query da valutare con VentoGPU:61
• Falsi positivi VentoGPU:26
• Rete:Yeastnetworkrand• n° Query64 : 100
• n° Match Effettivi: 34• Query da valutare con VentoGPU: 60
• Falsi positivi VentoGPU:26
Questions?