Introdução a GPU e CUDA.

Apresentação em tema: "Introdução a GPU e CUDA."— Transcrição da apresentação:

1 Introdução a GPU e CUDA

2 CPU X GPU CPU Execução sequencial Processamento genérico
Maior quantidade de memória principal Poucos núcleos (cores) Poucas threads por núcleo GPU Execução paralela Processamento especifico (gráfico) Menor quantidade de memória Maior velocidade de tráfego de memória Muitos núcleos Várias threadas por núcleo

3 VELOCIDADE GPU

4 Vazão memória gpu

5 GPGPU General-purpose computing on Graphics Processing Units
Programação de instruções para serem executadas diretamente na GPU Aplicações: simulação dinâmica de fluídos, análise sísmica, resolução de problemas matemáticos e segmentação de imagens.

6 GPGPU Linguagens GLSL (OpenGL Shading Language)
HLSL (High Level Shading Languag) Cg (C for Graphics) CUDA (Compute Unified Device Archtecture) OpenCL (Open Computing Language)

7 GPGPU Dois fatores importantes para criação de um programa em GPU.
Quais instrucões executarão em CPU e GPU Conjunto limitado de instrucões Funções matemáticas Organizacão e quais dados executarão em GPU Tamanho e tipos de memória da GPU Organizacão das threads Evitar trocas constantes entre a memória RAM e a memória da placa gráfica

8 CUDA Compute Unified Device Architecture Criada pela NVIDIA
Novembro de 2006 Não necessita conhecimento de OpenGL, hardware gráfico ou uso de textura Proprietária Exclusiva para placas NVIDIA A partir da geração GeForce 8, Tesla e Quadro Sintaxe semelhante a C/C++ Fortran, Java (JaCUDA), Python (PyCUDA) e .Net (CUDA.NET)

9 CUDA Não suporta recursão Funções próprias para medição de tempo

10 Camadas CUDA CUDA Libraries Funções matemáticas
Primitivas de computação gráfica Marcadores Diretivas especiais para linguagem C

11 Camadas CUDA CUDA Runtime CUDA Driver
Gerencia as operações entre CPU (host) e a GPU (device) CUDA Driver Otimiza e gerencia os recursos da GPU

12 CUDA Stream Processor: streams e kernels Streams Kernels
Fluxos de dados que são a entrada para os kernels Kernels Código executado em GPU Processa os dados e gera uma saída Pode ser usado como entrada para outro kernel

13 Organização processamento
Cada kernel é executado em uma thread Os kernels são agrupados em blocos Cada bloco pode conter no máximo 512 threads Organizados em matriz: 512 x 1 ou 22 x 22 ou 8 x 8 x 8 Os blocos são organizados em grids Organizada em uma matriz bidimensional de tamanho máximo x 65535 A quantidade e organização das threads é feita pelo programados

14 Organização processamento
A organização é feita com variáveis do tipo dim3 dim3 dimBlock(4,3) dim3 dimGrid(3,2)

15 Organização processamento
Váriaveis pré-definidas usadas na organização Dimensões do bloco blockDim.x, blockDim.y e blockDim.z Dimensões do grid gridDim.x e gridDim.y Índice do bloco blockIdx.x e blockIdx.y, Índice da thread threadIdx.x, threadIdx.y e threadIdx.z As variáveis pré-definidas são usadas também para obtenção do índice nas matrizes de dados indice = dimensaoDoBloco * indiceDoBloco + indiceDaThread

16

17 Organização processamento
Uma função para ser executada em GPU deve conter um dos marcadores _global_ : a função é invocada por uma função do host _device_ : a função é invocada por uma função da GPU Uma função para ser executada em CPU deve conter ou não o marcador _host_ Devem retornar void e ter uma configuração de execução

18 Hierarquia de memória marcadores especiais para variáveis _device_
Memória global _constant_ _shared_ Memória compartilhada (“shared”)

19 EXEMPLO #include <stdlib.h> #include <stdio.h> __global__void kernel(int*array) { //do work } Int main(void) { Int num_elements= 256; Int num_bytes= num_elements* sizeof(int); //ponteiro para a memória do host Int *host_array= 0; //aloca memória no host host_array= (int*)malloc(num_bytes); //ponteiro para a memória do device int* device_array= 0; //aloca memória no device cudaMalloc((void**)&device_array, num_bytes); // configuracao de bloco e grid Int block_size= 128; Int grid_size= num_elements/ block_size; //chamada do kernel kernel<<<grid_size,block_size>>>(device_array); //transfere os dados resultantes da GPU p/ CPU cudaMemcpy(host_array, device_array, num_bytes, cudaMemcpyDeviceToHost); //percorre os dados resultantes for(int i=0; i < num_elements; ++i){ printf("%d ", host_array[i]); } //libera a memória free(host_array); cudaFree(device_array);