Curso CUDA

Curso de CUDA no Simulation-Based Engineering Laboratory. Contém os slides e áudio do curso, além de exercícios, projetos da turma, e uma excelente introdução sobre colisão/detecção de corpos.

Sugestão do Luís Ramirez para a lista GPUBrasil.

Instalação do emulador CUDA

Roteiro para instalação do CUDA em modo de emulação (para quem não tem uma placa da série 8000 ou superior) no Ubuntu 7.10, 8.04 e 8.10 32/64 bits.
Obs.: Ainda não há suporte do NVIDIA/CUDA para as versões do Ubuntu 8.04 (em fase de desenvolvimento) e 8.10 (inexistente). Portanto, para todas as versões do Ubuntu serão usados os arquivos da última revisão estável, no caso 7.10 (32/64 bits).

1. Baixar os seguintes arquivos do site da NVIDIA e salvá-los na pasta raiz da sua área de usuário:

a) O kit de ferramentas (Toolkit): NVIDIA_CUDA_Toolkit_2.0_Ubuntu7.10_x86.run (ou o mais novo);

b) O kit para desenvolvimento de software (SDK): NVIDIA_CUDA_sdk_2.02.0807.1535_linux.run (ou o mais novo).

2. Instale os pacotes de compilação em linguagem C necessários com o seguinte comando:

sudo apt-get install build-essential libglut3-dev libc6-dev-i386 libstdc++6 -y

3. * SOMENTE PARA UBUNTU 8.10 * – O Ubuntu 8.10 possui como compilador padrão o gcc 4.3, que não é compatível com a versão estável do SDK do CUDA. Portanto, deve-se instalar o gcc 4.1 e configurá-lo como sendo uma alternativa de mecanismo de compilação. Isto é feito através dos comandos:

sudo apt-get install gcc-4.1 g++-4.1 –y

sudo update-alternatives –install /usr/bin/gcc gcc /usr/bin/gcc-4.1 60 –slave /usr/bin/g++ g++ /usr/bin/g++-4.1

4. Para proceder com a instalação do toolkit, altere a propriedade do arquivo .run para que seja interpretado como arquivo executável e invoque sua execução através do shell:

sudo chmod +x NVIDIA_CUDA_Toolkit_2.0_Ubuntu7.10_x86.run

sudo ./NVIDIA_CUDA_Toolkit_2.0_Ubuntu7.10_x86.run auto

5. Rode o editor gedit no modo superusuário para acrescentar as seguintes linhas ao final do arquivo de configuração .bashrc

sudo gedit .bashrc

6. Após o editor abrir o arquivo, mova o cursor até a última linha e digite:

export PATH=$PATH:/usr/local/cuda/lib

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib

7. Salve o arquivo e saia do editor.

8. Feche o terminal digitando exit, para que a alteração tenha efeito.

9. Para instalar o SDK, abra novamente o terminal de texto e digite:

sudo chmod +x NVIDIA_CUDA_sdk_2.02.0807.1535_linux.run

sudo ./NVIDIA_CUDA_sdk_2.02.0807.1535_linux.run

10. Entre na pasta do SDK:

cd NVIDIA_CUDA_SDK

11. Compile o SDK utilizando a diretiva de emulação (emu = 1)

sudo make emu=1

12. Entre na pasta dos programas-exemplo compilados

cd bin/linux/emurelease

13. Veja a lista de programas digitando

ls

14. Execute os programas de sua preferência. Por exemplo:

./clock

ou

./dwtHaar1D

Parte ou todo esse roteiro não funcionou pra você? Deixe comentário!

Instalação do CUDA no Ubuntu

Roteiro para instalação do CUDA no Ubuntu 7.10 e 8.04 de 64 bits.

1. Baixar os seguintes arquivos do site da NVIDIA (http://www.nvidia.com/object/cuda_get.html) e salvá-los na pasta raiz da sua área de usuário (como os arquivos são atualizados constantemente no site, seu nome pode variar com freqüência. Adapte a instalação para os nomes atuais):

a) O driver da GPU: NVIDIA-Linux- x86_64-177.13-pkg2.run;

b) O kit de ferramentas (Toolkit): NVIDIA_CUDA_Toolkit_2.0beta2_Ubuntu7.10_x86.run;

c) O kit para desenvolvimento de software (SDK): NVIDIA_CUDA_sdk_2.0beta2_linux.run.

2. Remover os drives proprietários de placa de vídeo NVIDIA por acaso instalados no Ubuntu.

a) Abra uma janela de console;

b) Execute o comando:

sudo apt-get –purge remove nvidia-glx-new nvidia-settings nvidia-kernel-common

3. Instale os pacotes de compilação em linguagem C necessários com o seguinte comando:

sudo apt-get install build-essential libglut3-dev libc6-dev-i386 -y

4. Feche o terminal:

exit

5. Feche o sistema de janelas pressionando simultanamente as teclas CTRL ALT F1.

6. Digite seu nome de usuário e pressione ENTER.

7. Digite sua senha e pressione ENTER

8. Interrompa a execução do servidor do sistema de janelas X: digite

sudo /etc/init.d/gdm stop

9. Habilite a execução do programa de instalação do driver da placa NVidia: digite

sudo chmod +x NVIDIA-Linux-x86_64-177.13-pkg2.run

10. Extraia os arquivos de instalação do driver: digite

./NVIDIA-Linux-x86_64-177.13-pkg2.run -x

11. Instale o arquivo auxiliar libcuda.so: digite

sudo cp NVIDIA-Linux-x86_64-177.13-pkg2/usr/lib/libcuda.so.177.13 /usr/lib/libcuda.so

12. Instale o driver: digite

sudo sh NVIDIA-Linux-x86_64-177.13-pkg2.run

13. Dê um reboot no computador digitando

sudo reboot

14. Após o reboot, entre na sua área e abra um console de texto para instalar o Toolkit e o SDK

15. Para instalar o toolkit, digite:

sudo chmod +x NVIDIA_CUDA_Toolkit_2.0beta2_Ubuntu7.10_x86.run

sudo ./NVIDIA_CUDA_Toolkit_2.0beta2_Ubuntu7.10_x86.run auto

16. Rode o editor gedit no modo superusuário para acrescentar as seguintes linha ao final do arquivo de configuração .bashrc

sudo gedit .baschrc

Após o editor abrir o arquivo, mova o cursor até a última linha e digite

export PATH=$PATH:/usr/local/cuda/lib

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib

Salve o arquivo e saia do editor.

17. Digite exit e feche o terminal digitando exit, para que a alteração tenha efeito.

18. Para instalar o SDK, abra novamente o terminal de texto e digite

sudo chmod +x NVIDIA_CUDA_sdk_2.0beta2_linux.run

./NVIDIA_CUDA_sdk_2.0beta2_linux.run

19. Entre na pasta do SDK

cd NVIDIA_CUDA_SDK

20. Rode o compilador dos programas-exemplo digitando

Comentário da Liliana Pozzo: Se você estiver instalando o CUDA 2.1, ocorrerá um erro neste passo. Algo como:

(/usr/bin/ld: cannot find –lXmu

collect2: ld returned 1 exit status  make: *** [../../bin/linux/release/fluidsGL] Error 1

Neste caso, instale também estas duas bibliotecas:

sudo apt-get install libxmu-dev libxmu6

21. Entre na pasta dos programas-exemplo compilados

cd bin/linux/release

22. Veja a lista de programas digitando

ls

1. Execute os programas de sua preferência. Por exemplo:

./particles

ou

./fluidsGL

Parte ou todo esse roteiro não funcionou pra você? Deixe comentário!

Curso de GPGPU no ICMC/USP

Por Anderson Marco.

AGM_apresentacao

Cuidados na medição de tempo

Adaptado da mensagem enviada por Daniel Medina à lista GPUBrasil.

Pessoal, já faz algum tempo que estou para reviver este tópico e sempre esqueço. Quero compartilhar com vocês um detalhe que me consumiu alguns dias quebrando a cabeça em cima disso.

Ao implementar em meu programa o algoritmo sugerido pelo Labaki para realizar a análise do tempo de execução, notei que o desempenho da GPU estava muito ruim comparado ao da CPU (com volume pequeno de dados estava até maior). Após procurar muito a causa, descobri que o vilão da história é a API do CUDA. Esta camada de software não é inicializada durante a inicialização do programa principal. Ela só é instanciada no momento da primeira chamada a alguma função da API (no meu caso ocorria quando eu chamava a função cuda_malloc pela primeira vez).

# include <stdlib.h>

# include <stdio.h>

# include <cutil.h>

int main()

{

float tempo;

unsigned int timer = 0;

CUT_SAFE_CALL( cutCreateTimer( &timer));

CUT_SAFE_CALL( cutStartTimer( timer));

// Primeiro comando para a GPU (cudaMalloc, por exemplo).

// …

// Região de execução: aqui vai o trecho de código cujo

// tempo de execução queremos medir.

tempo = CUT_SAFE_CALL( cutGetTimerValue(timer));

printf(“A execução durou %5.3f milissegundos\n”, tempo);

CUT_SAFE_CALL(cutDeleteTimer(timer));

}

Ao receber a primeira instrução, a API se inicializa e isto leva um tempo considerável. Empiricamente levantei que esse tempo é de aproximadamente 40ms em uma GTX  280 e 70ms em uma GT 8800.

Para aplicações que duram dias ou semanas, este tempo não chega a ser um problema, mas para aplicações como a minha, cujo tempo de execução é da ordem de milissegundos, este delay é algo altamente indesejável.

Como solução, eu coloquei uma instrução “dummy” (malloc de 0 bytes) no início do algoritmo só para inicializar a placa, e desconsiderei este tempo do cálculo utilizado para comparação entre CPU e GPU. Por ser um custo de tempo intrínseco e que acontece somente uma vez em toda a execução do software, ele pode ser desconsiderado do benchmark. Veja um exemplo.

# include <stdlib.h>

# include <stdio.h>

# include <cutil.h>

int main()

{

float tempo;

unsigned int timer = 0;

CUT_SAFE_CALL( cutCreateTimer( &timer));

// Um comando dummy, sem efeito no programa, só para

// inicializar a placa. Esse passa a ser então o primeiro

// comando de GPU do programa.

float* dummy;

CUDA_SAFE_CALL( cudaMalloc((void**) &dummy, sizeof(float)));

// Só então o cronômetro é ligado:

CUT_SAFE_CALL( cutStartTimer( timer));

// Região de execução: aqui vai o trecho de código cujo

// tempo de execução queremos medir.

tempo = CUT_SAFE_CALL( cutGetTimerValue(timer));

printf(“A execução durou %5.3f milissegundos\n”, tempo);

CUT_SAFE_CALL(cutDeleteTimer(timer));

}

Parte ou todo esse roteiro não funcionou pra você? Deixe comentário!

Programando CUDA pelo NetBeans

Introdução

A plataforma CUDA (Compute Unified Device Architecture), da NVIDIA, é uma plataforma integrada software-hardware para desenvolvimento de aplicações de computação de uso geral utilizando os processadores gráficos (GPUs) da NVIDIA como co-processadores para processamento paralelo de longas cadeias de dados de elevada intensidade aritmética, casos em que há significativo ganho de desempenho com relação às CPUs. Essa plataforma funciona com todas as GPUs a partir da série G80 (Por exemplo: GeForce 8300, GeForce 8600GT, GeForce 8800GTX, GT260, GT280, GT295, etc. Ver lista completa no site da NVIDIA).

O software CUDA pode ser livremente baixado do site da NVIDIA, disponível para as plataformas Windows, OSX e Linux.

Na plataforma Windows, o software deve ser usado integrado ao MS Visual Studio 2005 (Obs: o MS Visual Studio 2008 não funciona bem com a CUDA). Infelizmente o software não funciona com a versão grátis do MSVS, o Visual Studio Express.

Nos sistemas Linux o software CUDA funciona bem se utilizado com terminais de texto, na linha-de-comando, mas alguns usuários ressentem-se da ausência de um ambiente gráfico de desenvolvimento. Os dois principais ambientes gráficos disponíveis são o ECLIPSE e o NetBeans. Apresentarei a seguir um guia passo-a-passo para a configuração do Netbeans 6.5.1 para o desenvolvimento de aplicações para a plataforma CUDA.

Supondo que o interessado já tem o software CUDA instalado na sua máquina, na distribuição Linux Ubuntu 8.10 (senão, veja como).

Instalação do Netbeans 6.5.1

1. Instalar o JDK (Java Development Kit) versão 6 ou superior (site da Sun Microsystems). No ubuntu basta usar o instalador Synaptic.

2. Instalar o Netbeans 6.5.1.

3. Rodar o Netbeans e configurá-lo como descrito a seguir (texto original).

Fazendo o editor reconhecer a extensão .cu

1. Navegue até

Menu->Ferramentas->Opções

2. Clique no botão “Miscelânea”;

3. Selecione a aba “Arquivos”;

4. Clique no botão “Novo…”;

5. Abrir-se-á uma janela com um campo intitulado “Extensão de arquivo:”;

6. Digite “cu” (sem as aspas) no espaço em branco e clique no botão “OK”;

7. Em seguida escolha a opção “Arquivos C (text/x-c)” (sem as aspas) na lista intitulada “Tipo de arquivo associado (MIME)”;

8. Clique no botão “OK”.

Fazendo o editor utilizar o compilador nvcc

1. Navegue até

Menu->Ferramentas->Opções

2. Clique no botão “C/C++”;

3. Seleciona a aba “Outro”;

4. Clique o botão “Editar” ao lado da lista “Extensões arquivo C:”;

5. Abrir-se-á uma janela intitulada “Lista de extensões”;

6. Digite “cu” (sem as aspas) no campo intitulado “Extensão” e clique no botão “Adicionar”;

7. Em seguida clique no botão “OK”.

8. Navegue até

Menu->Ferramentas->Opções

9. Clique no botão “C/C++”;

10. Selecione a aba “Ferramentas de construção”;

11. Clique no botão “Adicionar” da lista “Grupo de ferramentas”

Abrir-se-á uma janela intitulada “Adicionar nova coleção de ferramentas”

12. Clique no botão “Procurar” e navegue até a pasta onde o nvcc está instalado:

/usr/local/cuda/Bin

13. Selecione “GNU” na lista intitulada “Família do grupo de ferramentas”

14. Digite “nvcc” (sem as aspas) no campo intitulado “Nome do grupo de ferramentas”.

15. Clique no botão “OK”, fechando a janela “Adicionar nova coleção de ferramentas”.

16. Clique no botão “OK”, fechando a janela “Opções”.

Abrindo e configurando um projeto CUDA

1. Navegue até

Menu->Arquivo->Novo projeto

Abrir-se-á a janela intitulada “Novo Projeto”;

2. Selecione a opção “C/C++” da lista “Categorias:” e a opção “Projeto C/C++ a partir de código existente” na lista “Projetos”;

3. Clique o botão “Próximo>”;

4. A janela se alterará, aparecendo o campo intitulado “Ferramenta de construção” com a pergunta “Como você constrói o código?”;

5. Selecione a opção “Usando um makefile existente”;

6. Em seguida dê um clique no botão “Procurar…”;

7. Navegue até a pasta de um projeto do NVIDIA_CUDA_SDK. Por exemplo,

/home/seu-nome/NVIDIA_CUDA_SDK/projects/clock,

selecione o arquivo “Makefile” e clique no botão “Selecionar”, voltando à janela anterior;

8. Clique no botão “Próximo>”;

9. A janela se alterará, aparecendo o campo intitulado “Ações de construção”.

10. No campo “Diretório de trabalho:” deve estar o caminho para o diretório onde está o arquivo “Makefile” do projeto. Pode-se tanto digitar o caminho diretamente no campo apropriado quanto navegar até o diretório dando-se um clique no botão “Procurar…”.

11. No campo “Comando Construir:” deve estar o comando que invoca o compilador. O sistema inclui automaticamente a linha de comando “make -f Makefile“, que compila o programa no modo “release” usando o Makefile do projeto. Caso se deseje utilizar o emulador de GPU deve-se substituir a linha de comando por “make emu=1 -f Makefile“.

12. No campo “Comando Limpar:” deve estar o comando “make -f Makefile clean“.

13. No campo “Resultado da construção:” deve estar o caminho do arquivo executável a ser gerado pelo compilador. Pode-se digitar o caminho ou utilizar o botão “Procurar” para navegar até a pasta do programa-objeto, e então digitar o nome do arquivo executável no campo “File name:”, clicando no botão “Selecionar” em seguida;

14. Clique então no botão “Proximo >”;

15. A janela se alterará, aparecendo o campo intitulado “Arquivos de código-fonte”;

16. Abra a lista intitulada “Tipos de arquivo a ser adicionado ao projeto:” e selecione o penúltimo item, que deve conter uma lista semelhante a:

.cpp .cc .c++ .cxx .C .mm .c .i .m .cu .h .H .hpp .hxx .SUNWCCh .tcc .f .F .f90 .F90 .f95 .F95 .f03 .F03 .for .il .mod

Nota: observe que a extensão “.cu” faz parte da lista;

17. Clique então no botão “Proximo >”;

18. A janela se alterará, aparecendo o campo intitulado “Configuração da assistência a código”;

19. Selecione a opção “Configuração automática”;

20. Clique então no botão “Proximo >”;

21. A janela se alterará, aparecendo o campo intitulado “Nome e local do projeto”.

22. Deixe como estão os campos “Nome do projeto:”, “Localização do projeto:” e “Pasta do projeto:”;

23. Ative a seleção “Definir como projeto principal.”.

24. Clique então no botão “Finalizar”.

Seu projeto aparecerá então como uma árvore de diretórios na janela à esquerda do Netbeans;

25. Clique com o botão direito do mouse no nome do projeto (clock_1) e selecione a opção “Propriedades”, que é a mais de  baixo.

26. Abrir-se-á a janela intitulada “Propriedades do projeto -clock_1″;

27. Clique a opção “Construir” da janela “Categorias”, à esquerda;

28. Agora selecione “nvcc” na lista intitulada “Coleção de ferramentas”, do lado direito;

29. Abra a opção “Construir” da árvore de Categorias, clicando na seta à esquerda da palavra “Construir”;

30. Agora clique na palavra “Make” abaixo da palavra “Construir”, e ao lado direito aparecerão as opções de Diretório de trabalho, Comando construir, Comando limpar, e Resultado da construção, já vistos na configuração inicial do projeto. Você poderá, por exemplo, alterar a linha de comando de Construir para que possa ou gerar o código final, ou usar o emulador, ou usar o debug, etc., como convenha;

31. Clique agora a palavra “Executar” na lista de “Categorias”;

32. No campo “Executar diretório” deverá haver o caminho completo para o arquivo executável a ser gerado pelo Make.

33. No campo “Ambiente” deverão ser incluidas as variáveis PATH e LD_LIBRARY_PATH da seguinte forma:

a. Clique no botão “…” à direita da opção “Ambiente”. Abrir-se-á uma janela intitulada “Default – Ambiente”;

b. Clique uma vez no botão “Adicionar”. Aparecerá uma linha vazia na tabela com as colunas “Nome” e “Valor”;

c. Digite “PATH” (sem aspas) no campo “Nome” e “$PATH:/usr/local/cuda/lib” no campo “Valor”;

d. Clique novamente no botão “Adicionar” para acrescentar nova linha à tabela e preencha-a da seguinte forma:

e. Digite “LD_LIBRARY_PATH” (sem aspas) no campo “Nome” e “$LD_LIBRARY_PATH:/usr/local/cuda/lib” no campo “Valor” e clique no botão “OK”;

34. A opção “Construir primeiro” deve estar selecionada;

35. No campo “Tipo de console”, selecione a opção “Terminal externo”;

36. No campo “Tipo de terminal”, selecione a opção “Gnome Terminal”.

37. Clique no botão “OK”.

38. Pressione a tecla F6 para construir e executar o projeto “clock”;

39. Deve abrir-se uma janela de texto e aparecer as seguintes mensagens:

==============================================

Test PASSED

time = 810000

Press ENTER to exit…

==============================================

40. Ao se pressionar a tecla ENTER deve aparecer a seguinte mensagem:

[Pressione Enter para fechar a janela]

41. Pressione a tecla ENTER novamente e a janela se fechará.

Parabéns!!! Você acaba de configurar seu IDE Netbeans para compilar e executar programas CUDA.

Nota

Ao criar um novo projeto, siga a recomendação da NVIDIA: Copie o conteúdo do diretório “template” que está no diretório “projects” do NVIDIA_CUDA_SDK num novo diretório criado para o novo projeto. Em seguida troque os nomes dos arquivos e edite o conteúdo do “Makefile” para adequá-los ao novo projeto.

O que ainda pode ser feito

Configurar o sistema para gerar automaticamente o Makefile dos novos projetos

Parte ou todo esse roteiro não funcionou pra você? Deixe comentário!

Programando CUDA pelo Anjuta

O ambiente de desenvolvimento ANJUTA é mais poderoso, mais fácil de configurar e utilizar que o Netbeans.

1. Para abrir um projeto pré-existente no NVIDIA_CUDA_SDK, simplesmente abra o projeto como

Menu->Arquivo->Novo->5 Projeto a partir de código existente

Abrir-se-á a janela “Importar Projeto”;

2. Clique no botão “Frente”.

Abrir-se-á a janela “Projeto a importar”;

3. Digite um nome para o projeto no campo correspondente (por exemplo, “Fluidos”);

4. Navegue, através da lista na parte de baixo da mesma janela, até o diretório do projeto que deseja importar. No caso, o projeto:

../NVIDIA_CUDA_SDK/projects/fluidsGL

5. Clique no botão “Frente”

Abrir-se-á a janela “Confirmação”, contendo os dados do projeto;

6. Clique no botão “Aplicar”;

7. Abrir-se-á uma nova janela do Anjuta para o projeto, intitulada FluidsGL – Anjuta;

8. Na árvore de arquivos do lado esquerdo dessa janela estão todos os arquivos do projeto. Clique duas vezes no arquivo fluidsGL.cu para abrí-lo com o editor. Se o texto não estiver realçado, navegue até

Menu->Ver->Editor->Modo de realce

e escolha na lista ou o tipo “cpp”, para que o editor utilize o padrão de realce da linguagem C++ nos arquivos do projeto;

9. Para compilar o projeto, simplesmente abra o menu Compilar e escolha a opção “Compilar projeto”;

10. Para executar o código gerado, abra o menu Run e escolha a opção “Executar o programa”.

Abrir-se-á uma janela intitulada “Parâmetros do programa”;

11. Simplesmente navegue, clicando no botão “Abrir”, até o programa executável gerado pela compilação e selecione o arquivo executável. Por exemplo,

/home/luiz/NVIDIA_CUDA_SDK/bin/linux/release/fluidsGL

12. Deixe em branco o campo “Argumentos:”;

13. Clique no campo “Variáveis de ambiente”.

Abrir-se-á uma lista sob o rótulo “Variáveis de ambiente”;

14. Clique no botão “Novo” para criar uma nova entrada na lista;

15. Sob o rótulo “Nome” digite “PATH” (sem as aspas) e pressione a tecla TAB;

16. Sob o rótulo “Valor” digite “$PATH:/usr/local/cuda/lib” (sem as aspas) e clique com o botão esquerdo do mouse em algum ponto da janela;

17. Clique outra vez no botão “Novo” para criar uma nova entrada na lista;

18. Sob o rótulo “Nome” digite “LD_LIBRARY_PATH” (sem as aspas) e pressione a tecla TAB;

19. Sob o rótulo “Valor” digite “$LD_LIBRARY_PATH:/usr/local/cuda/lib” (sem as aspas) e  clique com o botão esquerdo do mouse em algum ponto da janela;

20. Clique no botão “Aplicar”;

21. Caso o programa não rode e reclame que não achou uma biblioteca, abra novamente a janela das variáveis de ambiente acima:

Menu->Run->Parâmetros do programa

e confira se elas estão presentes e com o valor correto (pode ocorrer que os valores não foram admitidos corretamente);

22. Pressione a tecla F3 para rodar o programa;

Aproveite o Anjuta! É um dos melhores IDEs do mundo Linux.

Parte ou todo esse conteúdo não funcionou pra você? Deixe comentário!