GPUBrasil

Artigo publicado na “Viva o Linux” por Alessandro de Oliveira Faria (A.K.A CABELO) sobre a tecnologia CUDA da NVidia.

Nesse artigo ele faz uma introdução sobre a tecnologia CUDA e o seu potencial em acelerar cálculos computacionais através da paralelização. Na segunda parte do artigo, é apresentado um tutorial de instalação do CUDA e como compilar e executar os exemplos que acompanham o SDK.

Link para o artigo: “CUDA: Programe a sua NVIDIA“.

A linguagem MUDA facilita a utilização da unidade de processamento vetorial normalmente dedicada a multimedia nas CPUs para cálculos vetoriais de uso-geral.

A AMD liberou a versão 2.0 do seu SDK para a linguagem OpenCL, que gera código tanto para as CPUs x86 (Intel ou AMD) quanto para as GPUs ATI. Um benchmark comparativo entre uma implementação OpenMP e uma implementação OpenCL, feito por Jack Pien, mostra que o SDK da AMD produz bons resultados mesmo com um cluster de CPUs INTeL. Quem não tem GPUs no cluster pode compilar o código e desenvolver seus algoritmos, e quando acrescentar GPUs não tem que reescrever tudo de novo.

Aqui vai mais uma dica para o pessoal que acompanha o nosso blog. Existe um programinha bastante útil para verificar as especificações de sua GPU, como o “fill rate”, o número de shaders, a memória, os clocks, etc, chamado GPU-Z (o link para donwload está no final do post).

Abaixo está uma captura de tela do programa para que vocês tenham uma idéia das informações que o programa irá fornecer.

Esse programa costuma ser utilizado por “overclockers” de GPU para demonstrar o funcionamento de suas placas de vídeo com uma velocidade de clock mais elevado.

Além do GPU-Z também existe uma versão para a CPU chamado de CPU-Z.

Baixe o GPU-Z aqui.

Baixe o CPU-Z aqui.

Freqüentemente precisamos medir o tempo de execução de um programa, especialmente quando queremos mostrar que um programa em GPU é mais rápido que um em CPU. A maioria das funções que a linguagem C oferece não servem a esse propósito, já que medem o tempo em segundos, e um programa para GPU raramente completa um segundo de execução. As bibliotecas CUDA oferecem um recurso simples para fazer essa medição, em unidades de milissegundos. Eis um exemplo de código:

# 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));

// 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!

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!