O QUE É CUDA?

APIs gráficas, até que um grupo de pesquisadores da Stanford University se

CUDA™ é uma plataforma de computação paralela e um modelo de reuniu para reformular a GPU como um "processador de transmissão".
programação inventados pela NVIDIA. Ela permite aumentos significativos Em 2003, uma equipe de pesquisadores liderada por Ian Buck anunciou o
de performance computacional ao aproveitar a potência da unidade de Brook, o primeiro modelo de programação de ampla adoção a ampliar a
processamento gráfico (GPU). linguagem C com construções de paralelismo de dados. Usando conceitos
Com milhões de GPUs habilitadas para CUDA já vendidas até hoje, os como fluxos, kernels e operadores de redução, o compilador Brook e um
desenvolvedores de software, cientistas e pesquisadores estão descobrindo sistema de tempo de execução revelaram a GPU como um processador de
usos amplamente variados para a computação com GPU CUDA. Aqui estão propósito geral em uma linguagem de alto nível. E, ainda mais importante,
alguns exemplos: os programas em Brook não apenas eram mais fáceis de serem codificados
Identificação de placas ocultas em artérias: Ataques cardíacos são a que os códigos de GPU ajustados manualmente, mas também eram sete
maior causa de mortes no mundo todo. A Harvard Engineering, a vezes mais rápidos que os códigos similares existentes.
Harvard Medical School e o Brigham & Women's Hospital se reuniram A NVIDIA sabia que um hardware extremamente rápido tinha que ser
para usar GPUs com o objetivo de simular o fluxo sanguíneo e combinado a ferramentas intuitivas de software e hardware, e por isso
identificar placas arteriais ocultas sem fazer uso de técnicas de convidou Ian Buck para juntar-se à empresa e começar a desenvolver uma
imageamento invasivas ou cirurgias exploratórias. solução para executar o C na GPU de forma fluida. Juntando o software e o
Análise do fluxo de tráfego aéreo: O National Airspace System hardware, a NVIDIA apresentou a CUDA em 2006, a primeira solução do
(Sistema de Espaço Aéreo Nacional) gerencia a coordenação do fluxo mundo para computação de propósito geral em GPUs.
de tráfego aéreo em âmbito nacional. Modelos computacionais ajudam ECOSSISTEMA
a identificar novas maneiras de aliviar congestionamentos e manter o Ferramentas e treinamento
tráfego de aeronaves fluindo de forma eficiente. Utilizando o poder Atualmente, o ecossistema CUDA cresce com rapidez à medida que cada
computacional das GPUs, uma equipe da NASA obteve grande ganho vez mais empresas fornecem ferramentas, serviços e soluções de classe
de performance, reduzindo o tempo de análise de dez minutos para mundial.
três segundos. Se você quiser escrever seu próprio código, a forma mais fácil de aproveitar
Visualização de moléculas: Uma simulação molecular denominada a performance das GPUs será usar o CUDA Toolkit, que oferece um
NAMD (dinâmica molecular em nanoescala) alcança um grande ambiente de desenvolvimento abrangente para desenvolvedores C e C++.
aumento de performance com o uso de GPUs. Essa aceleração é O CUDA Toolkit inclui um compilador, bibliotecas de matemática e
resultado da arquitetura paralela das GPUs, que permite que ferramentas para depuração e otimização da performance de seus
desenvolvedores NAMD migrem partes de aplicativos com alta aplicativos. Você encontrará também exemplos de código, guias de
demanda computacional para a GPU utilizando o CUDA Toolkit. programação, manuais do usuário, referências de APIs e outras
HISTÓRICO documentações para ajudá-lo a começar.
Computação com GPU: A Revolução A NVIDIA oferece tudo isso gratuitamente, incluindo o NVIDIA Parallel Nsight
Você enfrenta desafios: melhorar a performance, resolver problemas mais for Visual Studio, o primeiro ambiente de desenvolvimento da indústria para
rapidamente. O processamento em paralelo seria mais rápido, mas a curva aplicativos de processamento paralelo massivo que utilizam tanto GPUs
de aprendizado é alta, não é? quanto CPUs.
Não é mais. Com a CUDA, você pode enviar código em C, C++ e Fortran Aprender a utilizar a CUDA é fácil, com o abrangente treinamento on-
diretamente à GPU, sem precisar usar uma linguagem de compilação. linedisponível, bem como outros recursos como seminários via web e livros.
Desenvolvedores em empresas como Adobe, ANSYS, Autodesk, MathWorks Mais de 400 universidades ensinam a programação CUDA, incluindo
e Wolfram Research estão acordando o gigante adormecido — a GPU — vários Centros de Excelência CUDA e Centros de Pesquisa e Treinamento
para executar computação científica de propósito geral e de engenharia em CUDA.
uma ampla variedade de plataformas. Soluções para Fortran, C#, Python e outras linguagens encontram-se
Usando linguagens de alto nível, aplicativos acelerados por GPU executam disponíveis. Explore o Ecossistema de Computação com GPU no CUDA
as partes sequenciais de suas cargas de trabalho na CPU – que é otimizada Zone para saber mais.
para performance com um único segmento (thread) – ao mesmo tempo em Tutorial - Instalando CUDA e rodando exemplos
que aceleram o processamento em paralelo da GPU. Isso é chamado de Breve tutorial explicando
"computação com GPU". como instalar CUDA e
A computação com GPU é possível porque a GPU de hoje faz muito mais executar exemplos
do que processar imagens: ela lida com um teraflop de performance de 1. Vá ao site do
ponto flutuante e processa tarefas de aplicativos projetados para tudo, NVIDIA CUDA
desde finanças, até medicina. (http://www.nvidia.com/object
A CUDA está amplamente implementada por meio de milhares de /cuda_home.html)
aplicativos e artigos de pesquisa publicados, e é suportada por uma base
instalada de mais de 375 milhões de GPUs habilitadas para CUDA em 2. Entre na seção
notebooks, estações de trabalho, clusters de computação e download CUDA
supercomputadores. (http://www.nvidia.com/object/cuda_get.html )
Acesse o CUDA Zone para ver exemplos de aplicações em vários mercados
verticais… e despertar sua GPU.
Histórico da computação com GPU 3. Os componentes
As primeiras GPUs foram projetadas como aceleradores gráficos, chave para iniciar
suportando somente pipelines de função fixa específicos. A partir do final desenvolvimento em CUDA
dos anos 90, o hardware tornou-se cada vez mais programável, culminando são os seguintes:
na primeira GPU NVIDIA em 1999. Menos de um ano após a NVIDIA ter 4. Driver do CUDA
cunhado o termo GPU, artistas e desenvolvedores de jogos não eram os 5. CUDA Toolkit
únicos a realizar trabalhos inovadores com a tecnologia: pesquisadores 6. CUDA SDK (que
estavam tirando proveito de sua excelente performance de ponto flutuante. vem com os exemplos)
Nascia o movimento da GPU de Propósito Geral (GPGPU). 7. O Driver do CUDA
Mas a GPGPU não era nada fácil naquela época, nem mesmo para aqueles e o CUDA Toolkit são pré-
que conheciam linguagens de programação gráficas como a OpenGL. Os requesitos para rodar os exemplos pré-compilados ou para compilar os
desenvolvedores tinham que mapear cálculos científicos a problemas que exemplos
poderiam ser representados por triângulos e polígonos. A GPGPU era algo
praticamente fora de questão para quem não havia memorizado as últimas
 8. Escolha o sistema operacional e clique em search, os links para os está usando, seja ele compilado, instalado pelo apt-get / synaptic ou pelo
drivers de seu SO serão mostrados Env.
Vá até a página de download do Cuda , selecione uma versão de
sistema operacional e em seguida a sua distribuição linux. Se você usa um
Ubuntu 8.04 ou 8.10, pode baixar a versão para Ubuntu 7.10 que funcionará
sem problemas. Baixe o driver, o toolkit e o SDK.
Numa shell, dê permissão de execução para os três arquivos. run baixados:

chmod 777 <nome do arquivo>

Instalando o Driver
Saia do X (Ctrl + Alt + F1) e logue-se como root (ou logue-se com o seu
9. A instalação do Toolkit é bem simples, basta apenas executar o usuário e torne-se root através do comando su).
instalador e digitar a pasta em que o Toolkit será instalado. Derrube o GDM ou KDM:
killall gdm
e execute o arquivo de driver baixado:
sh NVIDIA-Linux-x86-177.73-pkg1.run
Siga as instruções (Sim para todas as opções) e reiniciar.
Instalando o Toolkit
Logue-se como root e instale o toolkit para desenvolvimento:
sh NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86.run
O programa irá te perguntar onde você deseja instalar, grave este diretório,
pois será necessário na instalação do SDK.
Instalando o SDK
10. Instalado o Toolkit, devemos configurar 3 variáveis de ambiente Atenção, este passo não deve ser feito como root. Abra um terminal e
para podermos usá-lo diretamente em qualquer pasta: execute o arquivo com o seu usuário normal. O SDK deverá ser instalado
11. Adicionar à variável PATH: _pasta_da_instalação_/cuda/bin/ preferencialmente em seu diretório de usuário.
12. Adicionar à variável LD_LIBRARY_PATH:
sh NVIDIA_CUDA_SDK_2.02.0807.1535_linux.run
_pasta_da_instalação_/cuda/lib/
Você pode escolher outro diretório, mas eu não recomendo alterar. Durante
13. Adicionar à variável CUDA_INSTALL_PATH:
os próximos passos usarei NVIDIA_CUDA_SDK para me referir a raiz da
_pasta_da_instalação_/cuda/
instalação do SDK. Depois da instalação concluída, entre no diretório do
14. A instalação do SDK é igualmente simples, basta apenas executar
SDK e execute:
o instalador e digitar a pasta em que o SDK será instalado. Na
make
instalação do SDK deverá ser detectado o diretório de instalação do
Ele irá compilar todos os demos que estarão disponíveis na pasta:
toolkit.
~/NVIDIA_CUDA_SDK/bin/linux/release
Pronto, você pode testar a instalação executando os exemplos. Alguns
interessantes:
~/NVIDIA_CUDA_SDK/bin/linux/release/nbody
~/NVIDIA_CUDA_SDK/bin/linux/release/particles
~/NVIDIA_CUDA_SDK/bin/linux/release/oceanFFT
Se as animações estiverem pulando ou travando pode ser problema de
sincronia (seu frame rate é diferente do refresh rate do monitor). Para
corrigir, instale o nVidia Settings:
sudo apt-get install nvidia-settings
15. Com tudo instalado podemos partir para a compilação/execução Execute com super usuário:
dos exemplos. Entre na pasta do SDK e execute o comando make. sudo nvidia-settings
Todos os exemplos deverão ser compilados e os executáveis estarão na E ligue a opção Sync to VBlank
X Screen Y -> OpenGL Settings -> Sync to VBlank
Criando um Projeto de Desenvolvimento Cuda
Numa seção de shell vá para a pasta:
cd ~/NVIDIA_CUDA_SDK/projects/
E copie o projeto template, mantendo a nova pasta dentro do diretório
projects. Como você irá usar algumas facilidades do SDK, é necessário que
o seu projeto fique dentro do SDK.
cp -r template/ myproject
Altere o nome do executável editando o Makefile:
pasta bin/ também do SDK. cd myproject
gedit Makefile
Tudo pronto para começar a programar em CUDA!!! Modifique a linha
EXECUTABLE := template
Espero ter ajudado... para
EXECUTABLE := myproject
José Ricardo Mello Viana - Zezim Agora basta compilar
make
E executar
Instalar o Cuda no Ubuntu e Configurar o Ambiente de ~/NVIDIA_CUDA_SDK/bin/linux/release/myproject
Dev Configurando Eclipse
Colocar o Cuda para rodar e configurar o ambiente de desenvolvimento no Se você utiliza o Eclipse CDT para compilar programas em C + +, pode
Ubuntu é bem simples. Primeiramente, remova o driver da nVidia que você usá-lo também para compilar programas Cuda. O único problema é que
você precisa manter o projeto dentro da pasta projects do SDK. Nesse caso
você pode criar um link no SO para dentro do seu workspace ou importar
diretamente o projeto no Eclipse. Para criar um projeto novo, vá em:
New -> C++ Project
Desmarque Use default location . Configure a localização para:
/home/yourusername/NVIDIA_CUDA_SDK/projects/foobar
E selecione Project types : Executable e Empty Project.
Clique em Next. Desmarque a opção Debug . Selecione Release, clique
em Advanced Settings e em C / C + + build . Na tabBuilder
Settings desmarque Generate Makefiles . Configure o Build
Directory para:
${workspace_loc:/foobar}
Na tab Behaviour , no item Build (incremental build) remova
o all. Em
C/C++ build -> Environment
Adicione uma variável com o nome PATH e valor
/usr/local/cuda/bin
E clique em OK. Selecione o PATH, clique em Edit e modifique o valor
(repare no ponto e vírgula.) de
;/usr/local/cuda/bin
para
:/usr/local/cuda/bin
Clique em Ok e Finish.
Para configurar a execução do projeto por dentro do Eclipse vá em
Run -> Run Configurations -> C/C++ Local Application -> New launch config
uration
Informe o nome da configuração: Foobar Release . Informe o projeto:
Foobar. E o diretório para o binário:
/home/yourusername/NVIDIA_CUDA_SDK/bin/linux/release/foobar
Clique em Apply e Close. Para ativar o Syntax Highlighting:
Window -> Preferences -> C/C++ -> File Types
Clique em New, informe *. cu como extensão e selecione C + + Source File.
Pronto. Basta compilar, rodar e brincar a vontade.
Posted in Dec 14, 2008 by Vitor Pamplona - Edit - History
Showing Comments
teste

- - 228
- - Posted in Nov 6, 2008 by 208.99.75.32
teste

- - 706
- - Posted in Nov 7, 2008 by 208.99.75.32
Tudo bem por aí?

- - Vitor Pamplona
- - Posted in Nov 7, 2008 by 143.54.13.191
tengo un problema cuando quiero correr el ejemplo

root @ cristian-laptop: ~ / NVIDIA_CUDA_SDK # ~ / NVIDIA_CUDA_SDK /

bin / linux / release / myproject
/ home / cristian / NVIDIA_CUDA_SDK / bin / linux / release / myproject:
error while loading shared libraries: libcudart.so.2: cannot open shared
object file: No such file or directory

soy nuevo en ubuntu y la verdad no tengo idea a q se debe este error

alguna ayuda porfavor?
I Escola Regional de Alto Desempenho de SP Grade → blocos → threads
ERAD-2010 Hierarquia de memória:
MINI-CURSO: - Registradores por thread
Introdução à Programação em CUDA - Memória compartilhada
Prof. Raphael Y. de Camargo por bloco
Centro de Matemática, Computação e Cognição - Memória Global acessível
Universidade Federal do ABC (UFABC) a todas as threads
raphael.camargo@ufabc.edu.br Execução de Aplicações
Parte I Cada bloco é alocado a um
Introdução às GPUs multiprocessador da GPU,
Placas Gráficas que pode executar 1 ou mais
Jogos 3D evoluíram muito nos blocos simultaneamente
últimos anos e passaram a Cada multiprocessador
exigir um poder computacional executa 16 threads
gigantesco no modelo SIMT:
Jogos modernos: GPUs Single Intruction,
Além de gerar o cenário 3D, é Multiple Thread
preciso aplicar texturas, iluminação, Modelo de Execução
sombras, reflexões, etc. Execução do programa controlada pela CPU que pode
As folhas individuais das plantas lançar kernels, que são trechos de código executados
são desenhadas em paralelo por múltiplas threads na GPU
Sombras são calculadas A execução de programas CUDA é composta por ciclos
dinamicamente CPU, GPU, CPU, GPU, … , CPU, GPU, CPU.
Para tal, as placas Aplicações que rodam bem em GPUs
gráficas passaram Programas que conseguem bons speedups em GPUs:
a ser cada vez mais Podem ser subdivido em pequenos subproblemas, que são
flexíveis e poderosas alocados a diferentes blocos e threads
NVIDIA GTX480: 480 núcleos → preço US$ 500 Cada thread mantém uma pequena quantidade de estado
Desempenho máximo: 0.5 TFLOP (double) e 1.3 TFLOP (float) Alta razão (operações de ponto flutuante) / (memória)
Intel Core i7 980X: 6 núcleos → preço US$ 1000 Os subproblemas são fracamente acoplados
Desempenho máximo: 0.1 TFLOP (double) Acoplamento: quando um problema pode ser dividido em
NVIDIA GTX480: 480 núcleos → preço US$ 500 subproblemas menores, o acoplamento indica o quanto os
1.5GB de Memória com acesso a 177 GB/s subproblemas são dependentes entre si.
Intel Core i7 980X: 6 núcleos → preço US$ 1000 Retirado de http://www.nvidia.com/cuda
Acesso à memória a 25.6 GB/s Retirado de http://www.nvidia.com/cuda
Arquitetura da GPU Retirado de http://www.nvidia.com/cuda
GPUs utilizam um maior número de transistores para colocar Retirado de http://www.nvidia.com/cuda
mais ALUs (Arithmetic Logic Unit) simplificadas Retirado de http://www.nvidia.com/cuda
Permite fazer um maior número de cálculos ao mesmo tempo GPUs vs Supercomputadores
Controle de fluxo mais simples: Sistemas de multiprocessadores: Conjunto de unidades de
- Feita para aplicações paralelas onde as mesmas operações processamento e memória conectados por uma rede de
são aplicadas sobre um grande conjunto de dados interconexão
Arquitetura da Sistemas classificados como:
GPU Fermi Memória compartilhada
16 Multiprocessadores: Troca de mensagens
32 processadores Exemplos:
16 unidades Load/Store Supercomputadores
4 unidades funções especiais Aglomerados (clusters)
64 kB Memória compartilhada Exemplos de Redes Estáticas
32768 registradores Alta tolerância a falhas
Cache de constantes e textura No de conexões: O(N²)
Arquitetura da GPU Ponto único de falha e gargalo
Os multiprocessadores No de conexões: O(N)
compartilham uma Exemplos de Redes Estáticas
memória global, onde são k-cubo: nós: O (2k),
armazenados texturas Conexões: O (2k*k/2)
ou dados de aplicações Hypercubo 10-dim
Host Memory 1024 nós e 5120 conexões
CPU Malha com k dimensões
TESLA S2070 No de conexões: O(N*k/2)
4 x 448 processadores Mais fácil de construir
O que é CUDA Exemplos de Redes Estáticas
É uma arquitetura paralela de propósito geral destinada a Árvore
utilizar o poder computacional de GPUs nVidia Conexões: O(N)
Extensão da linguagem C, e permite controlar a execução Atraso: O(log N)
de threads na GPU e gerenciar sua memória Nó raiz é gargalo e ponto
Arquitetura de uma GPU nVidia único de falha
Hierarquia de Memória Árvore Gorda
Cada execução do kernel é Nós mais altos com maior
composta por: largura de banda
Normalmente implementadas Extensão da linguagem C, que permite o uso de GPUs:
com múltiplas conexões - Suporte a uma hierarquia de grupos de threads
Rede Dinâmica: Barramento Simples - Definição de kernels que são executados na GPU
Todas os processadores ligados à memória por um - API com funções, que permitem o gerenciamento da
barramento simples memória da GPU e outros tipos de controle
Fácil e barato de implementar Obtendo o CUDA
Mas o barramento rapidamente se torna um gargalo CUDA pode ser obtido gratuitamente no site da nVidia:
Múltiplos Barramentos http://www.nvidia.com/object/cuda_get.html
Exemplo: SGI Altix 4700 Disponível para Windows (XP, Vista e 7), Linux e MacOS X,
● Fabricante: Silicon Graphics, Inc em versões de 32 e 64 bits. É composto por:
● Memória: 272 GB CUDA Driver: Permite o acesso ao hardware
● Processadores: 68 Dual-Core CUDA Toolkit: Ferramentas e bibliotecas para
Itanium 9000 (64 bits) programação em CUDA
● Sistemas Operacionais: Linux CUDA SKD: Exemplos de código
(SUSE) e Enterprise Server 10 Exemplo de Instalação do CUDA
● Capacidade de Disco: 30TB Para instalar o toolkit, basta rodar o instalador:
(InfiniteStorage 350 e 120) > chmod +x cudatoolkit_2.3_linux_64_ubuntu9.04.run.sh
● Custo: R$ 2 milhões > ./cudatoolkit_2.3_linux_64_ubuntu9.04.run.sh
Fonte: http://www.ufabc.edu.br Digite os comandos para configurar a instalação:
Detalhes do Altix 4700 > export PATH=$PATH:/home/raphael/cuda/bin
● Projeto modular > export LD_LIBRARY_PATH=
● Placas blade com 2 sockets e 8 DIMM $LD_LIBRARY_PATH:/home/raphael/cuda/lib64
● Memória de até 128TB e até centenas de processadores Agora o Toolkit está instalado e configurado!
● Software Vamos para o primeiro exemplo.
● C/C++ e Fortran, Depuradores, ferramentas de análise Modelo de Execução
● MPI, OpenMP, Ferramentas de threading Execução do programa controlada pela CPU que pode
● Rede de Interconexão SGI NUMAlink 4 lançar kernels, que são trechos de código executados
● Topologia árvore gorda (fat tree) em paralelo por múltiplas threads na GPU
● 6.4GB/sec bidirectional bandwidth per link A execução de programas CUDA é composta por ciclos
Fonte: http://www.sgi.com CPU, GPU, CPU, GPU, … , CPU, GPU, CPU.
Fonte: http://www.embedded-computing.com/articles/woodacre/ Hierarquia de Memória
Supercomputador Moderno Cada execução do kernel é
● Jaguar: Oak Ridge National Laboratory composta por:
Supercomputador Moderno Grade → blocos → threads
Extraído de http://www.ks.uiuc.edu/Research/namd/motivation/ Hierarquia de memória:
Aplicações para Supercomputadores - Registradores por thread
Qualquer tipo de aplicação - Memória compartilhada
Quanto menor o acoplamento, maior o desempenho por bloco
Mas normalmente são aplicações com alto grau acoplamento - Memória Global acessível
Justificam o alto preço da rede de interconexão a todas as threads
Exemplos: Exemplo Simples
- Previsão do tempo, evolução do clima Neste primeiro exemplo iremos aprender como criar um
- Mecânica dos Fluidos (projeto de carros e aviões) kernel simples, que realiza a soma de 2 vetores.
- Biologia Computacional: enovelamento de proteínas, redes Veremos as principais operações usadas em CUDA:
de interação gênica, etc. Alocação e liberação de memória, transferência de
TESLA M2070 dados, lançamento do kernel
448 processadores O código abaixo contém erros e limitações que iremos resolver na aula.
TESLA S2070 // Device code
4 x 448 processadores __global__ void VecAdd(float* A, float* B, float* C, int n)
Barramento de GPUs {
Barramento de memória compartilhado int i = threadIdx.x;
Todos os processadores acessam a memória global if (i < n)
utilizando o mesmo barramento C[i] = A[i] + B[i];
Mecanismos primitivos de sincronização entre threads }
Acesso à memória do computador: PCI-Express (8 GB/s) // Host code
Aplicações que rodam bem em GPUs int main() {
Programas que conseguem bons speedups em GPUs: int n = 5;
Podem ser subdivido em pequenos subproblemas, que são size_t size = n * sizeof(float);
alocados a diferentes blocos e threads float *d_A, *d_B, *d_C;
Cada thread mantém uma pequena quantidade de estado cudaMalloc((void**)&d_A, size);
Alta razão (operações de ponto flutuante) / (memória) cudaMalloc((void**)&d_B, size);
Os subproblemas são fracamente acoplados cudaMalloc((void**)&d_C, size);
Exemplos: Algoritmos genéticos, codificação de vídeo, float h_A[] = {1,2,3,4,5};
processamento de imagens médicas, etc. float h_B[] = {10,20,30,40,50};
Parte II float h_C[] = {0,0,0,0,0};
Introdução à Programação em cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
CUDA cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
O que é CUDA int nThreadsPerBlock = 256;
É uma arquitetura paralela de propósito geral destinada a int nBlocks = n / nThreadsPerBlock;
utilizar o poder computacional de GPUs nVIDIA VecAdd<<<nBlocks, nThreadsPerBlock>>>(d_A, d_B, d_C);
cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost); } Matrix;
cudaFree(d_A); cudaFree(d_B); cudaFree(d_C); __global__ void MatMulKernel(Matrix A, Matrix B, Matrix C)
} {
Avaliação do Exemplo I // Each thread computes one element of C
Para compilar o código, basta utilizar o comando: float Cvalue = 0;
nvcc -o ex1 ex1.cu int row = blockIdx.y * blockDim.y + threadIdx.y;
Perguntas: int col = blockIdx.x * blockDim.x + threadIdx.x;
1) O programa funciona corretamente? Teste seu C.elements[ ] = Cvalue;
funcionamento imprimindo o resultado obtido }
2) Corrija o programa Exercício
3) Aumente o tamanho dos vetores para, por exemplo, 1024. 1) O kernel está correto? Inspecionando o código, procure
Teste o resultado e, se não for o esperado, corrija o por erros que impeçam seu funcionamento e o corrija
programa. 2) Escreva o código da CPU que chama o kernel.
Obs: Você deve manter o número de threads por bloco em 256. Dica: Use os seguintes comandos para lançar o kernel
Dica: O valor de blockIdx.x devolve o bloco ao qual a thread pertence dim3 dimBlock(BLOCK_SIZE_X, BLOCK_SIZE_Y);
Arquitetura da GPU dim3 dimGrid(GRID_SIZE_X, GRID_SIZE_Y);
Multiprocessadores, com M MatMulKernel<<<dimGrid, dimBlock>>>(d_A, d_B, d_C);
processadores em cada 3) Escreva um teste para seu exemplo
Registradores Uso da Memória Compartilhada
Memória compartilhada A otimização que traz o maior
Cache de constantes e textura desempenho é o uso da
Memória Global memória compartilhada de
Host Memory cada multiprocessador
CPU - O acesso à memória global
Execução de Aplicações demora centenas de ciclos
Cada bloco é alocado a um Host Memory
multiprocessador da GPU, CPU
que pode executar 1 ou mais Otimizações de código
blocos simultaneamente Multiplicação de matrizes com
Cada multiprocessador memória compartilhada
executa 16 threads Pedaços da matriz
no modelo SIMT: são colocados na
Single Intruction, memória de cada
Multiple Thread multiprocessador
CUDA Runtime vs Driver API
Programas em CUDA normalmente utilizam o CUDA Runtime,
que fornece primitivas e funções de alto-nível Otimizando o código
Além disso, é possível Otimizar o código é a parte mais difícil e trabalhosa
utilizar também a durante o desenvolvimento de um programa CUDA.
API do driver, que Hoje este processo ainda é “artesanal”, com a necessidade
permite um melhor de tentarmos diferentes estratégias.
controle da aplicação Alguns pontos importantes a considerar são:
CUDA 3.1 (Junho de 2010) - Divergência do controle de fluxo
Suporte a múltiplos (16) kernels simultâneos - Ocupação dos processadores
Melhorias no CUDA: - Acesso combinado (coalesced) à memória global
- Suporte a printf no código do dispositivo - Conflitos de bancos da memória compartilhada
- Suporte a ponteiros com endereços de funções - Sobrecarga da chamada do Kernel
- Suporte a funções recursivas Divergência do Controle de Fluxo
Interoperabilidade entre API do driver e CUDA Runtime As thread de cada bloco são divididas em warps, contendo
Melhorias em bibliotecas matemáticas 16 ou 32 threads
Arquitetura FERMI → GPUs permitem a execução simultânea de todas as threads
Melhoria no desempenho de dupla precisão do warp, desde que todas executem o mesmo código
Suporte a memória ECC Quando threads executam códigos diferentes, dizemos que
Suporte a múltiplos kernels simultâneos houve uma divergência na execução do código.
Modo de Emulação Exemplos: comandos if, else, while, for, etc.
Neste tutorial, executaremos os códigos em modo emulação. __global__ void VecAdd(float* A, float* B, float* C, int n)
Existem 2 motivos principais para utilizar o modo emulação: {
- Quando não temos uma placa gráfica compatível :-) int i = threadIdx.x;
- Para realizar debugging (GDB e printf) if (i < n)
Mas existem grandes desvantagens: C[i] = A[i] + B[i];
- Desempenho muito inferior }
- Difícil avaliar qualidade da implementação Ocupação dos Multiprocessadores
- Pode mascarar bugs no código (especialmente memória) O segredo para obter um bom desempenho é manter os
Hoje é possível realizar debugging diretamente na GPU, de processadores da GPU sempre ocupados. Para tal:
modo que a emulação está sendo descontinuada. - Os blocos devem ter tamanhos múltiplos de 32
Exemplo 2: Multiplicação de Matrizes Assim, coincidem com o tamanho dos warps
// M(row, col) = *(M.elements + row * M.width + col) - Usar o menor número possível de registradores por thread
typedef struct { O número de blocos por multiprocessador será maior
int width, height; Com mais blocos por multiprocessador, haverão mais opções
float *elements; de threads para execução
Especialmente quando as threads estiverem esperando por - 1.2 TFlop (single),
dados da memória global 240 GFlop (double)
Ocupação dos Multiprocessadores 3o trimestre/2010
Acesso Combinado (Coalesced) - FireStream 9370 e 9350
Quando 16 threads de um warp acessam a memória ao mesmo - 4GB RAM
tempo, CUDA combina os acessos em uma única requisição - 2.64 TFlop (single), 528 GFlop (double)
Para tal, todas os endereços devem estar localizados em um Cyprus
único intervalo de 128 bytes Architecture
Acesso Combinado (Coalesced) 10 SIMD units
É melhor que os dados a serem lidos sejam adjacentes with 16 stream
No caso de dados com separações de 2 ou mais posições, o cores with 5
desempenho cai consideravelmente ALUs on each
Dados com separação de 2 = 1600 ALUs
Acesso Combinado (Coalesced) - Difícil de
Qual é a melhor opção? usar as 5 ALUs
Um array de estruturas? - Relógio das
struct Dados { ALUs é igual
int chave; ao do chip
int valor; AMD Fusion
}; Irá combinar em um chip:
Dados *vetorDados; - Núcleos x86
Ou uma estrutura de arrays? - Núcleos SIMD para
struct Dados { processamento paralelo
int *chave; APU (Accelerated Processing Unit)
int *valor; Diferentes tipos de configurações poderão ser criadas a
}; partir de blocos básicos.
Dados estruturaDados; ATI Stream SDK
Bancos de Memória Compartilhada O acesso ao poder computacional é feito através do uso da
A memória compartilhada é dividida em 16 bancos, com palavras de ATI Stream SDK.
32 bits, que podem ser acessados simultaneamente Compatível com as arquiteturas FireStream e Fusion
Bancos de Memória Compartilhada Programação através da linguagem OpenCL 1.0
Quando ocorrem conflitos, a GPU serializa as requisições Anteriormente utilizava o Brooks+
Reduza as Chamadas do Kernel OpenCL
As chamadas ao Kernel causam um overhead Diferentes hardwares utilizam diferentes plataformas:
Além disso, muitas vezes precisamos passar dados para o - CUDA para nVIDIA e Brooks+ para AMD/ATI
kernel ou obter resultados da execução - OpenMP para programação de múltiplos processadores
Uma maneira de melhorar o desempenho é agrupar um OpenCL
maior número de tarefas em uma chamada O objetivo é permitir que um mesmo programa possa ser
Exemplo: Se for preciso resolver diversos sistemas executado em múltiplas plataformas de hardware.
lineares, é melhor resolver todos em uma única chamada - Padrão aberto, totalmente livre de royalties.
do kernel - Suporte da Apple, nVIDIA, AMD, Intel e outras.
Parte III - Falta a Microsoft, que tem sua solução própria :-)
FireStream, OpenCL e - DirectCompute, que faz parte do DirectX 10 e 11
Bibliotecas para CUDA - Alguém lembra da disputa DirectX vs OpenGL?
NVIDIA Performance Primitives (NPP) OpenCL
Biblioteca de funções utilizáveis em aplicações para GPUs Apesar das vantagens, existe um certo ceticismos sobre a
No momento possui primariamente funções para adoção do OpenCL
processamento de imagem e vídeo. Exemplos: - Diferentes arquiteturas tem características específicas,
- Filtros que precisam ser levadas em conta na otimização
- Redimensionamento - Programas genéricos acabariam sendo nivelados por baixo
- Histogramas - Quando comparado com CUDA, a sintaxe de OpenCL é
- Aplicação de limiares mais complicada, dado que ela precisa trabalhar com
- Detecção de bordas, etc. múltiplas plataformas
GPU Accelerated Linear Algebra Parte IV
Biblioteca de funções para álgebra linear. Exemplos: Aplicação:
- Solução de sistemas lineares Simulação de Redes Neuronais
- Rotinas para autovalores Neurociência Computacional
- Triangularizações Hoje temos a visão macro e micro do cérebro, mas ainda não
- Decomposição em valores singulares, etc. somos capazes de ligar adequadamente estas visões
Interfaces com C/C++, Fortran, Matlab, Python: Objetivo da neurociência computacional:
- Chamadas realizadas diretamente da aplicação para CPU Entender como um conjunto de neurônios e sua
- Não é preciso programar em CUDA conectividade geram funções cognitivas complexas.
Desempenho Para tal, criamos modelos matemáticos de áreas cerebrais e
Aplicação de Fatorização com precisão simples e dupla simulamos estes modelos em computadores
AMD FireStream Modelos podem ser compostos por até milhões de neurônios
As placas da AMD (antiga ATI) também fornecem suporte Simulação exige um grande poder computacional provindos
a GPGPU, através das placas da Série FireStream de grandes aglomerados ou supercomputadores
FireStream 9270 Modelagem de Neurônios
- 1 GPU com 800 núcleos Neurônios são um tipo altamente especializado de célula
- 2GB RAM, 108 GB/s Possuem corpo celular, dendritos e axônio
Mantém um potencial de membrana Comunicação entre Neurônios
Se comunicam com outros neurônios Hoje a comunicação é coordenada pela CPU
Fonte: Dayan and Abbott. Theoretical Neuroscience. MITPress Gera um grande gargalo no desempenho
Modelagem de Neurônios Desafio: Comunicação utilizando GPU
Cada compartimento é modelado por um circuito elétrico 1 GPU: Comunicação entre threads de diferentes blocos
Capacitor Tem que ser feita pela memória global
- membrana Uso de primitivas como AtomicAdd()
Resistências 2 ou mais GPUs em 1 computador:
- membrana É preciso passar necessariamente pela CPU
- canais iônicos 2 ou mais GPUs em múltiplos computadores:
- ligações entre É preciso passar necessariamente pela rede
compartimentos Hardware Utilizado
Canais Iônicos Ativos Computador Intel Core i7 920, de 2.66GHz,
Canais iônicos ativos: Canais dependentes da voltagem que 6 GB de memória RAM
permitem a geração de potencias de ação 2 duas placas gráficas nVidia GTX 295,
São constituídos por portões que possuem com 2 GPUs e 1892 MB em cada
uma dinâmica de abertura e fechamento Ubuntu 9.04 de 64 bits
dependente da voltagem: Fonte: N. Carlson, Physiology of Behavior Pearson CUDA versão 2.2, com
Ed. drivers 185.18.14.
Integração Numérica Compilador g++, com
É preciso integrar uma equação diferencial por neurônio opção -O3.
Integração implícita gera melhor estabilidade Resultados: Tempo de execução
[ A ] x [ V(t+dt) ] = [ C ] Cresce linearmente com o número de neurônios
Através de uma cuidadosa numeração dos compartimentos e uma Mas quando incluímos conexões → tempo 10 vezes maior
triangularização, a solução do sistema pode ser eficiente Comunicação entre neurônios é coordenada pela CPU
Simulação utilizando GPUs Resultados: Speedup
Programas que conseguem bons speedups em GPUs: Sem conexões: ganho de 40x
Subdivido em pequenos subproblemas, que são alocados a Com 100 conexões / neurônio: ganho de 10x
diferentes blocos e threads Resultados
Cada thread mantém uma pequena quantidade de estado CPU: maior parte do tempo usada na integração numérica
Alta razão (operações de ponto flutuante) / (memória) GPU: maior parte do tempo é usada para comunicação
Os subproblemas são fracamente acoplados Estado da Arte em Simulações
Característica de nosso problema Supercomputador IBM BlueGene
Dezenas de variáveis de estado por thread com 4096 processadores
Cada thread deve representar um neurônio Simulação de 4 milhões de
Limite no número de neurônios por bloco (entre 64 e 128) neurônios de 6 compartimentos
Acoplamento entre neurônios durante a comunicação e 2 bilhões de sinapses
Padrão de conexões pode ser irregular Cluster com 60 processadores de
Atraso no tempo de comunicação entre neurônios 3GHz and 1.5 GB of RAM
Neurônios são diferentes entre si Simulação de 1 milhão de neurônios
Mas podem ser categorizados em diferentes classes e meio bilhão de sinapses.
Implementação do Simulador → 10 minutos para inicializar e
A simulação é divididas em rodadas controladas pela CPU: 1 minuto para simular 1 segundo
Inicialização da simulação de funcionamento da rede
Enquanto (tempoAtual < tempoTotal) Modelos de Grande Escala
Lança execução do kernel Já estão sendo realizadas
Coleta de resultados da simulação simulações de modelos com
Envio de dados à GPU 22 milhões de neurônios e
Fim da simulação 11 bilhões de sinapse
Implementação do Kernel Supercomputadores
Cada neurônio é implementado por uma thread distinta com dezenas de
Esta thread executa a diagonalização da matriz e faz milhares de
substituição dos valores finais processadores
Código para a execução de cada neurônio é igual, de modo Parte V
que não há divergência de execução Conclusões
Versão para CPU portada para GPU: Conclusões
Usava dados diretamente da memória global. Vimos que as GPUs permitem a obtenção de um excelente
O desempenho era ruim, inferior ao da CPU desempenho a um baixo custo
Otimizações Composta por centenas processadores simples e um
→ Uso da memória compartilhada barramento compartilhado para acesso a memória
Memória compartilhada é pequena para armazenar dados Mas:
de todos os neurônios de um bloco Não fornecem bom desempenho para qualquer tipo de
Armazenamos os dados que são utilizados múltiplas vezes aplicação
por passo de integração (leitura e escrita) Conclusões
→ Leituras conjunta (coalesced) A plataforma CUDA permite o uso de GPUs para executar
Organização dos dados de modo que leitura de dados de aplicações paralelas
múltiplos neurônios seja feita de modo simultâneo Extensão da linguagem C, sendo de fácil aprendizado
Comunicação entre Neurônios Mas para rodar de modo eficiente, é essencial que o código
Neurônios geram spikes, que são entregues a outros neuônios seja otimizado!
Cada neurônio se conecta a centenas ou milhares de neurônios A linguagem OpenCL permite criar programas que rodam
em múltiplas arquiteturas
Mas é difícil fazer um programa genérico que seja eficiente
em arquiteturas diferentes
Onde Aprender Mais
Existem uma grande quantidade de material na Internet
sobre CUDA. No site da nVidia existe links para diversos
tutoriais e cursos online sobre a arquitetura CUDA
http://www.nvidia.com/object/cuda_education.html
- Para quem domina o inglês falado, neste site tem um curso
em vídeo sobre CUDA dado por um engenheiro da nVidia na
Universidade de Illinois
- Outra opção é um curso online (texto) publicado no site
Dr. Dobbs.
- A distribuição do CUDA vem com 2 guias:
CUDA Programming Guide e CUDA Best Practices