Aventuras de um Garoto Digital do Século 21

CUDA - A aposta da Nvidia para Computação de Alto Desempenho

2011-05-10T17:34:00.000-03:00

Olá, leitores!

Seguindo a série sobre Supercomputação, vou falar um pouco sobre a tecnologia que tenho estudado nesse tema, a Computing Unified Device Architecture - CUDA.

A arquitetura CUDA permite usar as placas de vídeo da Nvidia como processadores paralelos de uso geral. É uma tecnologia proprietária, mas em constante desenvolvimento e com uma já grande comunidade de usuários e muitos trabalhos publicados. A primeira versão foi lançada ao público em 2006, simultaneamente ao lançamento dos novos chips da família G80. A primeira placa a suportar a CUDA foi a GeForce 8800 GT.

O objetivo desta tecnologia é permitir o uso do poder de processamento de sua placa de vídeo para cálculos de computação geral. Esta técnica nasceu com o nome de GPGPU. Mais informações sobre o GPGPU no post anterior. Ela também visa a facilitar a programação, dispensando um conhecimento profundo da arquitetura de hardware da placa, permitindo ao programador concentrar-se apenas na programação.

Hoje, já está em sua versão 4.0, com suporte para as placas mais novas e também às mais antigas. O desenvolvimento do framework acompanha o desenvolvimento das novas arquiteturas de hardware; novas funções são adicionadas sempre que a arquitetura do hardware evolui.

Então você quer programar em CUDA? Vamos ver o que você vai precisar:

Certifique-se que sua placa está com os drivers atualizados e suporta a tecnologia. Você pode conferir neste link: http://www.nvidia.com.br/Download/index.aspx?lang=br
Faça o download do toolkit, de acordo com o sistema operacional que você usa: http://developer.nvidia.com/cuda-toolkit-32-downloads.
Faça o download do SDK (Software Development Kit). O SDK contém exemplos documentados com os códigos fonte, incluindo um template que você pode usar para começar o seu programa. Ele está na mesma página do toolkit.
Caso você tenha problemas na instalação do toolkit e do SDK no Ubuntu, segue um ótimo roteiro para instalá-lo corretamente: http://gpubrasil.com/2010/05/12/instalacao-do-cuda-3-0-no-ubuntu-10-04/. Esse roteiro pode ser usado para a versão 3.2 normalmente. Ainda não testei no Ubuntu 11.04, mas sei que também funciona com o 10.10.

Com os drivers e ferramentas instalados, você já tem tudo o que precisa para começar a se divertir com sua placa! ;-)

Agora, fica muito mais fácil programar quando você usa um Ambiente de Desenvolvimento Integrado (IDE). Para programar em CUDA, utilizando C/C++ você pode usar facilmente qualquer uma das IDE's conhecidas. Neste post, vou mostrar como configurar o Eclipse no Ubuntu. Por quê? Porque é o que eu uso! ;-) Nada contra o Windows, é que ainda não programei para ele. Mas para usar o Eclipse para Windows, deve ser bem parecido.

O Eclipse tem me ajudado bastante e já estou bem acostumado com ele. Tem bons recursos como refactoring, completa o código, busca de headers, gerenciamento de versões e outras funcionalidades por meio de sua vasta biblioteca de plugins. Eu recomendo! Para configurá-lo siga estes passos:

Faça o download do Eclipse Classic, de acordo com o seu SO: http://www.eclipse.org/downloads/
Após instalá-lo, você terá o ambiente de desenvolvimento padrão para Java. Para programar em C/C++ precisamos instalar o plugin CDT (C/C++ Development Tools). Para isso, faça o seguinte:

Abra o Eclipse e clique em Help > Install new software...
No diálogo que se abre, escolha "All available sites" na primeira caixa de texto.
Embaixo, vai aparecer uma árvore com várias opções. Procure por "Programming Languages" e clique no sinal de + para estender as opções.
Marque a caixa com a opção "Eclipse C/C++ Development Tools".
Clique em Next
Se aparecer um termo de serviço, aceite (depois de ler, né? XD) e continue. O Eclipse fará o download dos componentes e irá instalar o ambiente para C/C++.
Quando ele terminar a instalação, irá pedir para reiniciar. Após o reinício, você já pode começar a programar em C/C++!

Muito bom. Agora que já temos o ambiente pronto, vamos começar um novo projeto e configurá-lo para usar o template do CUDA como base:

Abra o Eclipse e clique em File > New > Project... (Se você ver a opção C++ Project, pode clicar nela e pular a próxima etapa)
Na caixa do wizard, procure a opção C/C++ e expanda clicando no sinal de +. Escolha C ou C++ Project. Clique em Next.

Na próxima etapa, coloque o nome do projeto, e desmarque a caixa "Use default location". Clique no botão "Browse..." e navegue até a pasta onde você instalou o SDK do CUDA (você se lembra onde, né?). Na pasta raiz do SDK, navegue até a pasta C/src. Nesta pasta, ficam os códigos fonte dos exemplos e o template. Crie uma pasta para o seu projeto. Na seção "Project Type" escolha Executable > Empty Project. Na seção "Toolchains" escolha Linux GCC.

Na próxima caixa, clique no botão "Advanced Settings" para abrir as propriedades do projeto. No lado esquerdo, clique em "C/C++ Build". No lado direito, mude a opção "Cofiguration" para [All Configurations]. Desmarque a opção "Generate Makefiles automatically". Clique na aba "Behaviour" e apague a palavra "all" que está na caixa de texto ao lado da opção "Build(incremental build)".

Volte no lado esquerdo e expanda a opção "C/C++ General" clicando no nosso velho conhecido sinal de +. Clique na opção "Paths and Symbols". Na aba "Includes", escolha "C sources" e clique no botão "Add..." e depois em "File System...". Navegue até a pasta C/common/inc que fica dentro da pasta do SDK. Faça o mesmo para a opção "C++ sources", caso você queira programar em C++. Em seguida, clique na aba "Library Paths". Clique no botão "Add..." e adicione a pasta /usr/local/cuda/lib ou /usr/local/cuda/lib64 de acordo com a arquitetura de seu SO (considerando que você instalou a toolkit no diretório padrão. Caso tenha instalado em outro diretório, basta informá-lo de acordo com sua escolha). Clique em "OK", depois em "Finish".
O Eclipse irá perguntar se você quer mudar para a perspectiva de C/C++, caso seja a primeira vez que você começou um projeto C/C++. Responda "Yes". Do lado esquerdo, você verá o "Project Explorer", com os nomes dos seus projetos. Clique com o botão direito do mouse no projeto que acabamos de começar (filosófico isso...) e clique em "Import...". Na caixa que aparece, expanda o item "General" e clique em "File System". Clique em "Next". Na próxima caixa, clique no botão "Browse" e navegue para a pasta do SDK/C/src/template. Marque a caixa de seleção que aparece no lado esquerdo, junto ao nome da pasta template. Isso irá marcar todos os arquivos da pasta. Nós vamos precisar deles. Clique em "Finish".
No "Project Explorer", clique no sinal de + ao lado do nome do seu projeto. Isso irá expandir e mostrar os arquivos que o compõem. Dê um duplo-clique no arquivo chamado "Makefile" para abri-lo. Procure a variável EXECUTABLE e mude o seu valor para um nome qualquer. Este será o nome do executável que será compilado.

Clique no menu Project > Build project. Repare no console se não ocorrerão erros. Caso a compilação seja bem sucedida, temos que informar ao Eclipse onde está o nosso executável. Clique agora no menu Run > Run Configurations... Nessa caixa, no lado esquerdo, clique em "C/C++ Application" e em seguida, no ícone "New launch configuration", acima da seção. Ele se parece com uma folha em branco com um sinalzinho de +. Deverá aparecer um item com o nome do seu projeto. Agora clique no botão "Browse". Navegue até a pasta do SDK/C/bin/linux/release e procure o executável com o nome que você escolheu. Clique em "Apply" e depois em "Run". Se tudo correr bem, o programa teste será executado no console do Eclipse, mostrando o tempo de execução.

Com isso, estamos prontos para começar a programar. Let's code!

No próximo post, vou falar mais das características e de como a CUDA funciona, para termos uma base de conhecimentos. Lembrando que computação paralela requer alguns cuidados, então é fundamental termos alguns conceitos bem definidos para que o nosso código funcione corretamente. Caso surja alguma dúvida, não se acanhe e use os comentários. Se você já usa o CUDA em outros ambientes de desenvolvimento e outros SO's e quiser compartilhar seu conhecimento, seu comentário (e links!) será bem-vindo. Até o próximo post!

Surgimento e Panorama da Supercomputação em GPU

2011-04-27T15:49:00.000-03:00

Olá leitores!

Para inaugurar o blog, vamos conversar um pouco sobre essa nova tendência, a da Computação de Alto Desempenho utilizando GPU. Ou, GPU Computing, para simplificar.

GPU Computing começou com uma turma meio perturbada, que teve a ideia de usar o paralelismo dos fragment processors das placas de vídeo para cálculos gerais. Daí a sigla da época era GPGPU, inglês para Computação de Propósito Geral utilizando Unidades de Processamento Gráfico (General Purpose computation on Graphics Processing Units). Isso foi por volta de 2002, quando os processadores gráficos tinham evoluído de simples processadores de vídeo com algumas funções matemáticas especiais para computação gráfica, para poderosos processadores vetoriais, capazes de processar milhões de pixels, texels, voxels e mais um punhado de coisinhas terminadas em xel. A turminha da computação gráfica já tinha desenvolvido efeitos bem bonitos usando linguagens bem específicas, com Cg (C for graphics), GLSL (OpenGL Shader Language).

Os shader programs são pequenos trechos de código que são replicados e executados simultaneamente em vários elementos de uma textura ou vértices de um polígono. Através dos shaders, os programadores gráficos conseguem fazer aqueles brilhos, explosões, sombras e outras coisinhas legais que gostamos de ver nos nossos jogos! Então, alguém um dia pensou "Ei, se é possíver fazer uma operação numa textura inteira, por que não fazer umas continhas?". Se pensarmos em uma imagem como uma matriz de pixels, onde cada pixel é um valor de cor, é possível imaginar que daria para usar esta estrutura para armazenar outro tipo de dados. As placas de vídeo da época já eram capazes de trabalhar com texturas com números de ponto flutuante de 32 bits (o nosso velho float). Então, foi exatamente isso que essa turminha fez! Em vez de cores, eles armazenaram números. E em vez de aplicarem efeitos gráficos, eles trabalharam com várias texturas, fazendo multiplicações, somas, transposições e voilá! Conseguiram fazer essas operações 20 vezes mais rápidos que nos métodos tradicionais. Resumindo, o GPGPU consistia em "enganar" a placa de vídeo e fazê-la mastigar números, em vez de compor texturas. Um verdadeiro trabalho de um ninja dos códigos!

Mas isso dava muito... trabalho! As texturas de ponto flutuante são normalizadas entre 0 e 1, ou -1 e 1. Ou seja, você tem que transformar seus dados para esta faixa, calculá-los e depois transformá-los de volta. E nesse processo, um pouco da precisão numérica era sacrificada. Mas rodar um processo 20 vezes mais rápido é bem incentivador. Rodar aquela simulação de duas semanas em algumas horas? Tô dentro! Começaram a surgir várias pesquisas implementando métodos matemáticos nas placas de vídeo.

Isso chamou a atenção da indústria. Ora, se eu já ganho um punhado de dinheiro vendendo placas para jogadores, se eu vender mais um punhado de placas para pesquisadores, vou ganhar outro punhado de dinheiro! Ei! Esse povo tem mais dinheiro, então eu posso cobrar mais caro! XD

Bem... mais ou menos. Os pesquisadores querem precisão e facilidade de uso. A maioria dos interessados são físicos, químicos, matemáticos que estão interessados em fazer simulações e não em ficar escrevendo código difícil! Então, as fabricantes se movimentaram e lançaram ferramentas para facilitar o uso de suas placas de vídeo para computação geral.

Hoje, programar a sua placa de vídeo está muito mais fácil as duas maiores fabricantes já oferecem um amplo conjunto de ferramentas para fazê-lo. Destacam-se a tecnologia CUDA, da Nvidia e a OpenCL, um padrão aberto mantido por um consórcio. A gigante Microsoft também quer entrar na brincadeira e lançou o DirectCompute, que permite usar a biblioteca gráfica deles, o famoso DirectX, para computação geral. Também já foram publicados milhares de artigos e muitos softwares famosos, como Matlab, estão usando esta tecnologia para melhorar sua performance. As indústrias de jogos também estão usando esse negocinho para fazer efeitos de física melhores.

Para quem quiser saber mais, dá uma passadinha no site da Nvidia e procure por CUDA, ou no site do grupo Khronos, que mantém o OpenCL. Ou aqui, no GPUBrasil, que é um grupo de estudos com essa tecnologia.

Acho que tá bom por agora, não é? No próximo post, falarei mais sobre a linguagem CUDA, que é a que eu tenho estudado mais e falarei como instalar os kits de desenvolvimento e configurar o Eclipse para programar. Vejo vocês lá!

Saudações, aventureiros da Nave Digital

2011-04-27T14:42:00.000-03:00

Olá, leitores!

Desde que comecei a estudar essa máquina fascinante, chamada computador, lá nos meados da longínqua década de 90 (putz, já é no século passado!), eu descobri muita coisa interessante. E cada dia, descubro coisas novas... E como sei que de vez em quando dá um trampo do cão conseguir informações resolvi criar este blog, que vai servir como um diário de bordo das coisinhas legais com as quais eu estiver brincando.

O meu objetivo vai ser centralizar e divulgar o que eu for aprendendo e com a contribuição de vocês, nobres leitores, aprender muito mais. E, claro, colaborar para difundir esse conhecimento!

Sobre mim, sou adepto da filosofia do Open Source, então, o que eu for produzindo, vou compartilhar sob essa filosofia. Também sou um cientista, portanto, gosto de chafurdar nas pesquisas para conhecer o que o povo anda criando por aí... E sobretudo, um gamer assumido, então tenha certeza que você vai ouvir muito sobre jogos aqui!

Bom espero que gostem e achem algo útil por aqui. Logo, logo vou fazer a primeira postagem mais técnica sobre as coisinhas com as quais eu tenho me divertido! T+!