Category Archive

Após os testes com o a biblioteca CUDA 4.1 RC 2 GPU conforme o post anterior, agora compilei a openCV também com a lib TBB e CUDA. Resultado: Performance computacional além da imaginação. Tudo isto em função da programação paralela. Escrito em C++.O TBB se encarrega na adaptação do software, ou seja determinando o número ideal de threads e tornando uma realidade a programação multinúcleo.

Deixo neste post, as alterações necessárias no código fonte da bibliotec openCV 2.3.1 para compilara com o gcc 4.6.2 no openSUSE 12.1 e com a biblioteca CUDA 4.1.

No arquivo  modules/gpu/src/imgproc.cpp:

Linha 762:

Trocar:

    ppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step),
   sqr.ptr<Npp32f>(), static_cast<int>(sqr.step), dst.ptr<Npp32f>(), 
    static_cast<int>(dst.step), sz, nppRect) );

Por:

    nppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step),
   sqr.ptr<Npp64f>(),   static_cast<int>(sqr.step), dst.ptr<Npp32f>(), 
    static_cast<int>(dst.step), sz, nppRect) );

No arquivo modules/gpu/src/graphcuts.cpp

linha 80

Trocar:

    nppSafeCall( nppiGraphcut_32s8u(terminals.ptr<Npp32s>(), leftTransp.ptr<Npp32s>(), 
 rightTransp.ptr<Npp32s>(), top.ptr<Npp32s>(), bottom.ptr<Npp32s>(), 
 static_cast<int>(terminals.step), static_cast<int>(leftTransp.step),
   sznpp, labels.ptr<Npp8u>(), static_cast<int>(labels.step), buf.ptr<Npp8u>()) );

Por:

    nppSafeCall( nppiGraphcut_32s8u(terminals.ptr<Npp32s>(), leftTransp.ptr<Npp32s>(),
   rightTransp.ptr<Npp32s>(), top.ptr<Npp32s>(), bottom.ptr<Npp32s>(), 
 static_cast<int>(terminals.step), static_cast<int>(leftTransp.step), 
 sznpp, labels.ptr<Npp8u>(), static_cast<int>(labels.step), pState) );

Inserir na linha 67
    NppiGraphcutState *pState;
    Npp8u *pDeviceMem;

Adicionar o linha 75 abaixo da funcao nppSafeCall
    cudaSafeCall( cudaMalloc((void **)& pDeviceMem, bufsz) );

Comentar a linha 78
    //if ((size_t)bufsz > buf.cols * buf.rows * buf.elemSize())
    //    buf.create(1, bufsz, CV_8U); Inserir na linha 80 após o comentário.

    nppSafeCall( nppiGraphcutInitAlloc(sznpp, &pState, pDeviceMem) );

No final do metodo cv::gpu::graphcut, linha 91 inserir

    nppSafeCall ( nppiGraphcutFree(pState));
    cudaSafeCall( cudaFree(pDeviceMem) );

No arquivo modules/gpu/src/element_operations.cpp 

Comente as linhas 297 ate a 304
    //    case CV_8UC4:
    //        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
    //            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
    //        break;
    //    case CV_16UC1:
    //        nppSafeCall( nppiAbsDiff_16u_C1R(src1.ptr<Npp32s>(), static_cast<int>(src1.step), src2.ptr<Npp32s>(), static_cast<int>(src2.step), 
    //            dst.ptr<Npp32s>(), static_cast<int>(dst.step), sz) );
    //        break;

No arquivo modules/gpu/src/matrix_reductions.cpp 

Inserir na linha 117
     int nBufferSize;
    nppiMeanStdDev8uC1RGetBufferHostSize (sz, &nBufferSize);
    Npp8u * pDeviceBuffer;
    cudaSafeCall( cudaMalloc((void **)& pDeviceBuffer, nBufferSize) );

Modificar a linha 124 

Trocar:
    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), sz, dbuf, (double*)dbuf + 1) );
Por:
    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),  sz, pDeviceBuffer, dbuf, (double*)dbuf + 1) );

Modificar a linha 126 

Trocar:
    cudaSafeCall( cudaDeviceSynchronize() );
Por:
    cudaSafeCall( cudaFree(pDeviceBuffer) ); 

A NVidia acaba de disponibilizar o seu pacote para desenvolvedores CUDA 4.1 RC2. Ou seja uma arquitetura de computação paralela da NVIDIA que possibilita aumentos significativos na performance de computação pelo aproveitamento da potência da GPU (unidade de processamento gráfico).

A computação está evoluindo de um “processamento central” na CPU para um “coprocessamento” na CPU e na GPU. Para permitir esse novo paradigma em computação, a NVIDIA inventou a arquitetura de computação paralela CUDA, que agora vem inclusa em GPUs GeForce, ION, Quadro e Tesla, representando uma base instalada significativa para os desenvolvedores de aplicativos. O download pode ser efetuado AQUI, já estou baixando e em breve novidades…

A seguir, disponibilizo passo-a-passodeixo de como utilizar a GPU aplicada aos recursos de visão computacional utilizando a tecnologia NVIDIA CUDA, uma arquitetura de computação paralela de propósito geral que tira proveito do mecanismo de computação paralela das unidades de processamento gráfico (GPUs) NVIDIA para resolver muitos problemas computacionais complexos em uma fração do tempo necessário em uma CPU.

Download:

O primeiro passo foi baixar o arsenal de pacotes do SDK da NVIDIA, ou seja o Developer Drivers for Linux (285.05.23), o CUDA ToolKit e para finalizar o GPU Computing SDK. Tudo isto esta disponível AQUI.

Sequência de instalação:

Após a instalação do drive com CUDA, execute o CUDA ToolKit , CUDA Tools SDK e para finalizar o GPU Computing SDK:

# ./cudatoolkit_4.1.21_linux_64_suse11.2.run

Crie as variáveis ambientais:

#! /bin/sh
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64
PATH=$PATH:/usr/local/cuda/bin
export PATH LD_LIBRARY_PATH

Execute o pacote GPU Computing SDK:

# ./gpucomputingsdk_4.1.21_linux.run

OBS1: Insira a linha a seguir no arquivo ~/NVIDIA_GPU_Computing_SDK/C/common/common.mk na linha 173

NVCCFLAGS   += --compiler-options -fno-strict-aliasing --compiler-options -fno-inline

OBS2: Durante a compilação no openSUSE 12.1, obtive o seguinte erro: “unsupported GNU version! gcc 4.6 and up are not supported!”

A solução foi ignorar o erro comentando as sequintes linha a seguir no arquivo /usr/local/cuda/include/host_config.h

//#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5)
//#error -- unsupported GNU version! gcc 4.6 and up are not supported!
//#endif /* __GNUC__> 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5) */

Pronto neste etapa o NVIDIA CUDA foi instalado com sucesso!