You are currently browsing the category archive for the ‘NVIDIA’ category.

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.

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…

Ao compilar o pacote de desenvolvimento do CUDA SDK 4.2, obtive o seguinte erro /usr/include/c++/4.7/ext/atomicity.h(51): error: identifier “__atomic_fetch_add” is undefined. Para resolver este contra-tempo, inserir em todos código cuda (.cu) a seguinte linha no início do código fonte.

#undef _GLIBCXX_ATOMIC_BUILTINS
#undef _GLIBCXX_USE_INT128

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!

Valeu Stage por emprestar o kinect até o natal… Pois comprei um para o meu bebê de 4 anos e temos que esperar o Papai-Noel chegar… Em breve novidades com este brinquedo super legal!!!

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!

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







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.

Após a conclusão da instalação do NVIDIA CUDA 4 conforme o post anterior, compartilho o finalização dos testes laboratoriais nas madrugadas e final de semana, onde utilizo a biblioteca openCV na plataforma openSUSE 11.4 utilizando a GPU.

Após o download dos fontes da biblioteca openCV, devemos fazer algumas pequenas alterações:

– Crie as pastas abaixo para manter a compatibilidade com o CUDA 3.2 e não perder muito cabelo:

/usr/local/cuda/NPP/SDK/common/lib64/
/usr/local/cuda/NPP/SDK/common/npp/include/

– Copie as bibliotecas do CUDA 4 SDK a seguir na pasta lib64:

libnpp.so (link simbólico)
libnpp.so.4 (link simbólico) 
libnpp.so.4.0.17

– Copie os arquivos .h do CUDA 4 SDK abaixo na pasta include:

nppcore.h  
nppdefs.h  
npp.h  
nppi.h  
npps.h  
nppversion.h

Agora um cmake para começar a brincadeira…

cmake \
        -DCMAKE_BUILD_TYPE=RELEASE \
        -DBUILD_LATEX_DOCS=OFF \
        -DBUILD_OCTAVE_SUPPORT=ON  \
        -DBUILD_PYTHON_SUPPORT=ON  \
        -DBUILD_SWIG_PYTHON_SUPPORT=ONF \
        -DBUILD_TESTS=ON \
        -DENABLE_OPENMP=OFF \
        -DENABLE_PROFILING=OFF \
        -DBUILD_PYTHON_SUPPORT=ON  \
        -DBUILD_NEW_PYTHON_SUPPORT=ON \
        -DCMAKE_INSTALL_PREFIX=%{_prefix} \
        -DLIB_INSTALL_DIR=%{_libdir} \
        -LIB_SUFFIX=64 \
        -DBUILD_EXAMPLES=ON \
        -DINSTALL_C_EXAMPLES=ON \
        -DINSTALL_OCTAVE_EXAMPLES=ON  \
        -DINSTALL_PYTHON_EXAMPLES=ON  \
        -DWITH_1394=ON \
        -DWITH_CUDA=ON \
        -DWITH_FFMPEG=ON \
        -DWITH_GSTREAMER=OFF \
        -DWITH_QT=ON \
        -DWITH_GTK=ON \
        -DWITH_JASPER=ON \
        -DWITH_JPEG=ON \
        -DWITH_PNG=ON \
        -DWITH_TIFF=ON \
        -DWITH_V4L=ON \
        -DWITH_XINE=ON \
        -DCUDA_NPP_LIBRARY_ROOT_DIR=/usr/local/cuda/NPP/SDK/ \
        -DENABLE_SSE=ON \
        -DENABLE_SSE2=ON \
        -DENABLE_SSE3=ON \
        -DENABLE_SSSE3=ON \
        -DENABLE_SSE41=ON \
        -DENABLE_SSE42=ON \
        .       

Para finalizar um video demonstrando um FaceFind COM UMA WEBCAM USB e o alto processamento utilizando a api NVIDIA CUDA 4 com openCV.

Arquivo

Statísticas

  • 572,969 Acessos

ATENÇÃO!

 °v° USE A FORÇA,
/(_)\ LEIA OS FONTES !
 ^ ^

openSUSE 11.4