Arquivo da categoria: NVIDIA

openSUSE: cudaGetDeviceCount returned 999

Dicas NERD!

Se precisa executar os códigos exemplos cuda sem privilégio de root, e o comportamento é similar a retorno abaixo, deixo neste post como contornar o problema:

$ optirun ./deviceQuery
./deviceQuery Starting...
 CUDA Device Query (Runtime API) version (CUDART static linking)
cudaGetDeviceCount returned 999
-> unknown error
Result = FAIL

Basta executar o comando na linha de comando e pronto!

$ modprobe --force-modversion nvidia-uvm

Em seguida, execute o exemplo novamente.

$ optirun ./deviceQuery
./deviceQuery Starting...
 CUDA Device Query (Runtime API) version (CUDART static linking)
Detected 1 CUDA Capable device(s)
Device 0: "GeForce GTX 1660 Ti"
  CUDA Driver Version / Runtime Version          11.0 / 10.2
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 5945 MBytes (6233391104 bytes)
  (24) Multiprocessors, ( 64) CUDA Cores/MP:     1536 CUDA Cores
  GPU Max Clock rate:                            1590 MHz (1.59 GHz)
  Memory Clock rate:                             6001 Mhz
  Memory Bus Width:                              192-bit
  L2 Cache Size:                                 1572864 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  1024
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 3 copy engine(s)
  Run time limit on kernels:                     Yes
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      Yes
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 11.0, CUDA Runtime Version = 10.2, NumDevs = 1
Result = PASS

Bumblebee máximo desempenho com NVIDIA

Neste post, veremos como obter o máximo desempenho com a placa de Vídeo NVidia Optimus que otimiza o seu notebook de forma inteligente, oferecendo o desempenho gráfico impressionante que você precisa, quando você precisa, e sempre aumentando o tempo de vida da bateria para que você aproveite por mais tempo.

Primeiramente instale o openSUSE com o parametro do kernel brokenmodules=nouveau, assim tornando desnecessário colocar este módulo no kernel na blacklist. depois, para instalar o Bumblebee que explora os recursos da NVidia Optimus, primeiramente instale os seguintes pacotes no openSUSE 13.2:

  • bumblebee-3.2.1-16.1.x86_64
  • nvidia-bumblebee-343.36-1.1.x86_64
  • dkms-2.2.0.3-14.1.noarch
  • dkms-bbswitch-0.8-3.27.src.rpm
  • primus-20131226-16.1.x86_64
  • primus-32bit-20131226-3.1.3.x86_64
  • VirtualGL-devel-2.3.90-21.1.x86_64
  • VirtualGL-32bit-2.3.90-1.8.x86_64
  • VirtualGL-2.3.90-21.1.x86_64

Adicione o usuario nos grupos video e bumblebee:

# usermod -G video,bumblebee cabelo

Inicialmente o Bumblebee não esta em funcionamento,então os comando a seguir devolverão os seguintes resultados:

# cat /proc/acpi/bbswitch 
0000:01:00.0 ON

Testaremos o desempenho com o programa glxspheres com o comando a seguir:

$bglxspheres
Polygons in scene: 62464
Visual ID of window: 0x20
Context is Direct
OpenGL Renderer: Mesa DRI Intel(R) Haswell Mobile
59.977914 frames/sec - 66.935352 Mpixels/sec
60.040965 frames/sec - 67.005717 Mpixels/sec

nvidia.01

Aqui conseguimos um desempenho máximo de 60 frames/segundos, agora começaremos a brincadeira inciando o daemon Bumblebee:

# systemctl enable dkms
# systemctl enable bumblebeed
# systemctl status bumblebeed
bumblebeed.service - Bumblebee C Daemon
 Loaded: loaded (/usr/lib/systemd/system/bumblebeed.service; enabled)
 Active: active (running) since Ter 2015-02-24 21:34:38 BRT; 45min ago
 Main PID: 861 (bumblebeed)
 CGroup: /system.slice/bumblebeed.service
 └─861 /usr/sbin/bumblebeed
 # cat /proc/acpi/bbswitch 
0000:01:00.0 OFF
# optirun --status
Bumblebee status: Ready (3.2.1). X inactive. Discrete video card is off.

Agora com tudo fucionando executaremos o glxsphere novamente precedido do comando optirun:

# optirun glxspheres
Polygons in scene: 62464
Visual ID of window: 0x20
Context is Direct
OpenGL Renderer: GeForce GTX 860M/PCIe/SSE2
192.146589 frames/sec - 214.435593 Mpixels/sec
193.858314 frames/sec - 216.345879 Mpixels/sec

nvidia.02

Reparem que agora conseguimos obter 192 frames/segundos no lugar do suado 60 frames/segundos. Agora vamos turbinar a brincadeira com o comando primusrun:

$ vblank_mode=0 primusrun glxspheres
Context is Direct
OpenGL Renderer: GeForce GTX 860M/PCIe/SSE2
ATTENTION: default value of option vblank_mode overridden by environment.
ATTENTION: default value of option vblank_mode overridden by environment.
273.449995 frames/sec - 305.170194 Mpixels/sec
274.683783 frames/sec - 306.547102 Mpixels/sec
278.195957 frames/sec - 310.466688 Mpixels/sec
280.331172 frames/sec - 312.849588 Mpixels/sec

nvidia.03

Com este recurso, podemos selecionar quando usar o recurso máximo da placa NVidia ou poupar a bateria do Notebook.

GPU:CUDA 5 na plataforma openSUSE 12.3

cuda-logo

Agora o CUDA 5 é composto de um único instalador provendo o CUDA Toolkit, SDK código exemplos, e driver para os desenvolvedores. Ao instalar esta versão,  alguns contra-tempos eu me deparei em função do kernel 3.7 e/ou GCC 4.7, para facilitar o caminho de todos os desenvolvedores openSUSE, deixo esta dica de como obter sucesso na instalação. Primeiramente crie o link simbólico do aquivo version.h necessário para compilação do módulo.

$ cd /lib/modules/3.7.10-1.1-desktop/build/include/
$ ln -s generated/uapi/linux

Continuando, efetue o download do driver versão NVIDIA-Linux-x86_64-310.40.run no link http://www.nvidia.com.br/Download/index.aspx?lang=br ou instale a partir do repositório  com o comando a seguir:

# zypper ar -f ftp://download.nvidia.com/opensuse/12.3/ nvidia

Atenção: Os pacotes necessários ( requisitos obrigatórios ) para a instalação do driver são freeglut-devel, linux-glibc-devel e kernel-source.

Após a instalação do driver, efetue o download do pacote CUDA e execute a sua instalação com o parametro toolkit, sample e override:

# su
# ./cuda_5.0.35_linux_64_suse12.1-1.bin -toolkit -samples -override

Desabilitando a checagem co GCC

Altere a linha 80 do arquivo /usr/local/cuda-5.0/include/host_config.h conforme o exemplo abaixo:

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 7)

Agora crie um arquivo com o nome  /usr/local/cuda-5.0/include/__cuda_gcc47_fix.h e insira o seguinte conteúdo:

#undef _GLIBCXX_ATOMIC_BUILTINS
#undef _GLIBCXX_USE_INT128

Agora faremos uma pequena adaptação no compilador da nvidia, adicionando um parâmetro.

cd /usr/local/cuda-5.0/bin
mv nvcc nvcc.bin
echo '#!/bin/sh
$0.bin --pre-include __cuda_gcc47_fix.h $@' > nvcc
chmod +x nvcc

Agora se tudo estiver devidamente configurado e funcionando, basta muda para a pasta /usr/local/cuda-5.0/samples, compilar os exemplos e executá-lo:

cd /usr/local/cuda-5.0/samples
make
cd bin/linux/release/
./smokeParticles

cuda

Importante: Este documento tornará desnecessário quando o CUDA tornar compatível com o gcc 4.7 e opensuse 12.3.

Para os Suseiros, este post na Wiki…

Lançado CUDA 4.1! Instalando no openSUSE 12.1

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.32), 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.28_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.28_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!

openSUSE 12.1 64 bits, CUDA 4.1 RC2 com openCV e programação multi-nuclear.

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

Lançado CUDA 4.1 RC2! Instalando no openSUSE 12.1

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!

OpenCV no Android

Meu próximo desafio é portar o legado laboratorial da biblioteca openCV para a plataforma Android, pois além de prover a portabilidade, os novos modelos apresentam o Tegra da NVIDIA no qual é possível integrar com o NDK da Google. Então deixo aqui a minha receita de bolo.

Compilação principal.
$ export ANDROID_NDK=/dados/neti/programas64/android-ndk-r5c
$ export ANDROID_NDK_TOOLCHAIN_ROOT=/dados/neti/programas64/android-ndk-r5c/toolchains
$ cd android/
$ sh ./scripts/cmake_android.sh ou cmake_android_armeabi.sh
$ cd build ou cd build_armeabi/
$ make -j8
$ make install

Compilação do código exemplo hello word.

$ cd opencv/android/apps/HelloAndroid
$ sh ./cmake_android.sh ou cmake_android_armeabi.sh
$ cd ./build_armeabi
$ make
$ adb push HelloAndroid /data
$ adb shell chmod 777 /data/HelloAndroid
$ adb shell /data/HelloAndroid
$ adb pull /mnt/sdcard/HelloAndroid.png

 Compilação da biblioteca.

$ cd android-opencv/
$ sh ./cmake_android.sh
$ cd build
$ make -j8

OBS: Verificar nos scripts a presença do parâmetro -DARM_TARGET=armeabi







openCV, TBB e GPU (programação multinúcleo)

Após os testes com o a biblioteca openCV na GPU conforme o post anterior, agora compilei a openCV também com a lib TBB. Resultado: a aplicação que estava processando aproximadamente 120 FPS passou a processar mais de 170 FPS. 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.