Introdução ao i.MX6Q / D (GC2000) Vivante OpenCL Embedded Profile

OpenCL Embedded
Este post faz parte da série OpenCL Embedded Profile. Leia também os outros posts da série:

O objetivo deste post não é fazer de você um novo expert em OpenCL, mas te fornecer os conhecimentos básicos para que possa aproveitar o suporte a GPGPU dos processadores i.MX6 da nova NXP e poder ter o seu código (ou parte dele) acelerada por sua GPU (Graphics Processing Unit).

 

 

O que é GPGPU e OpenCL?

 

GPGPU

 

  • GSGPU significa "Unidade de Processamento Gráfica de Uso Geral" (General Purpose Graphics Processing Unit);
  • Os algoritmos adequados para aplicação utilizando a GPGPU são aqueles que apresentam duas propriedades: que possuem dados sendo executados em paralelo e intenso throughput;
  • Por execução dos dados em paralelo entenda pela capacidade do processador poder executar a operação em diferentes elementos de dados (de hardware) simultaneamente;
  • Intenso throughput: significa que o algoritmo vai processar muitos elementos de dados ao mesmo tempo, de modo que haverá tanto dado que é uma ótima solução operar em paralelo;
  • Aplicações baseadas em pixel, tais como visão computacional e de vídeo e processamento de imagem são muito bem adaptadas à tecnologia GPGPU, e por esta razão, muitos dos pacotes de software comerciais nessas áreas agora incluem aceleração GPGPU.

 

OpenCL

 

  • Open Computing Language (OpenCL) é um framework para escrever cógidos que executam em plataformas heterogêneas que consistem de unidades centrais de processamento (CPUs), unidades de processamento gráfico (GPUs), processadores de sinais digitais (DSPs), field-programmable gate arrays (FPGAs) e outros processadores;
  • OpenCL inclui uma linguagem (com base no C99) para escrever kernels (funções que executam em dispositivos OpenCL), além de interfaces de programação de aplicativos (APIs) que são usados para definir e, em seguida, controlar as plataformas;
  • OpenCL fornece computação paralela utilizando paralelismo baseada em tarefas e-ou base de dados;
  • OpenCL é um padrão aberto mantido pelo consórcio Khronos Group, um consórcio de tecnologia sem fins lucrativos;
  • Grandes empresas como Apple, Intel, Qualcomm, a Advanced Micro Devices (AMD), Nvidia, Altera, Samsung, Vivante e ARM Holdings já o adotaram.

 

Há uma série de tutoriais OpenCL na web explicando todos os seus conceitos e capacidades. Abaixo, separei pra vocês os mais importantes.

 

 

Introdução ao OpenCL

 

Para visualizar a arquitetura heterogênea em termos de API e restringir o uso de memória para execução paralela, o OpenCL define múltiplas camadas em cascata de definições de hardware virtual. O mecanismo de execução básico, aquele que faz com que os kernels rodem, é chamado um elemento de processamento (Processing Element - PE). Um grupo de elementos de processamento é chamado de Unidade Computacional (Compute Unit- CU). Finalmente, um grupo de Unidades Computacionais é chamado de Dispositivo de Computação (Compute Device).

 

Um sistema Host poderia interagir com várias Unidades Computacionais em um sistema (por exemplo, um GPGPU e um DSP), mas o compartilhamento de dados e sincronização é grosseiramente definidos a este nível. Veja a figura abaixo.

 

opencl

  

Cada item que um kernel roda é chamado de Item de Trabalho (work-item). Um exemplo simples disso é determinar a cor de um único pixel (item de trabalho) em uma imagem de saída. Itens de trabalho são agrupados em Grupos de Trabalho (work groups), que são, cada um deles, executados em paralelo para acelerar o desempenho de cálculo matemático. O quão grande work-group é depende do algoritmo que está sendo executado no momento e as dimensões dos dados a serem processados (por exemplo, um item de trabalho por pixel para um bloco de pixels de um filtro implementado em software).

 

Veja a imagem abaixo que ilustra a relação entre item de trabalho (work-item) e grupo de trabalho (work-group).

 

opencl

 

OpenCL é executado em um modelo de programação que podemos chamar de modelo de "dados em paralelo", onde os kernels executam uma vez para cada item em um espaço de index (space index). A dimensionalidade dos dados a serem processados (por exemplo, 1, 2, ou 3 matrizes de dimensão) é chamado NDRange ou gama N-dimensional.

 

 

Características do I.MX6Q / D GPU (GC2000) OpenCL EP

 

  • GPGPU Vivante GC2000 capaz de executar OpenCL 1.1 Embedded Profile (EP);
  • Possui OpenCL embedded profile, ou seja, tem suporte a imagens 3D, consegue operar com inteiros de 64 bits ou números de ponto flutuante de precisão dupla;
  • Núcleos 4xSIMD (VEC-4) unidades de shader;
  • Até 512 registradores de uso geral, cada um com 128 bits para cada um dos núcleos;
  • Número máximo de instruções por kernels de 512;
  • Taxa de transferência de apenas 1-ciclo para instruções de shader;
  • Memória cache L1 de 4KB;
  • 168 registradores para sombreamento de vértice (vertex shader) e 64 registradores especiais para shader de fragmento;
  • Pipeline/core de inteiros;
  • No OpenCL embedded profile, os requisitos para samplers são reduzidos, com o número de samplers diminuindo de 16 (FP - perfil completo) para 8 (PE), e com a precisão matemática (ULP) está dentro da especificação IEEE-754 para algumas funções;
  • Por último, em OpenCL EP o tamanho mínimo da imagem é reduzido para 2048 (de 8192 em Ponto Flutuante) e os requisitos de memória local são reduzidos para 1 KB (de 32KB em Ponto Flutuante).

 

opencl

 

opencl

 

Cada um dos núcleos de shader (sombreamento) funciona como uma Unidade de Controle (CU). Os núcleos são Vec4 ISA nativos, assim, a largura de vector preferida para todas as primitivas é 4.

 

opencl

opencl

 

 

Otimização de código para rodar no i.MX6Q/D OpenCL EP

 

Entrada dos vetores matemáticos tem que ser múltiplos de quatro por conta do SIMD

 

  • Como mencionado anteriormente, a GC2000 do i.MX 6Q tem uma engine SIMD vec4 ponto flutuante, então o vetor matemático preferido pelo i.MX é composto de 4 entradas (ou múltiplos de 4) para taxa de throughtput matemático máximo.

 

Use registros de 32 bits para os cálculos matemáticos

 

  • Tanto o cálculo matemático em inteiros e em ponto flutuante é nativo em 32 bits. Primitivas de 8 e 16-bits também deverão usar registradores de 32 bits, portanto, não há ganho computacional (em termos de performance matemática) em ir com tamanhos inferiores a 32 bits.

 

Use ponto flutuante ao invés de inteiros

 

  • Pipeline de 1x32 em Inteiro (suporta 32 bits inteiros em hardware, 8-bit /16-bit em software);
  • Pipeline de 4x32 em Ponto Flutuante (suporta 16 bits e 32 bits em ponto Flutuante em hardware 32 bits em hardware).

 

Para maximizar a eficiência computacional do OpenCL, é melhor converter formatos de números inteiros para ponto flutuante para utilizar as quatro unidades de matemática de ponto flutuante paralelas.

 

Use inteiros de 16-bits para divisão e inteiros de 32-bits para outras operações matemáticas

 

  • Para matemática com números inteiros (excluindo a opração de divisão), há um somador de 32 bits e um multiplicador de números inteiros de 32-bits por núcleo. Se formatos inteiros forem necessários, use inteiros de 32 bits para adição, multiplicação, para mascaramento de bits, e senóides;
  • Tente minimizar, diminuir ao máximo e até não usar inteiros de 8 bits ou 16 bits, uma vez que eles serão calculados em software e a unidade lógica aritmética de inteiros de 32-bits não será utilizada;
  • Divisão de inteiros: o hardware do IMX.6Q suporta apenas divisão de inteiros de 16 bits, e divisão com inteiros de 8-bits e 32-bits são feitos por software;
  • É melhor usar a divisão de 16 bits, se possível, porque utiliza elementos de hardware. Haverá uma penalidade de desempenho se a divisão de 32 bits for utilizada.

 

Use o modo Rodada Zero

 

  • A Computação em Ponto Flutuante suporta apenas "round-to-zero", ou seja, arredodamento para zero (o arredonamento para o par mais próximo não é necessário para o Embedded Profile, se o round-to-zero é suportado).

 

Acessos de dados devem ser de 16B

 

  • Essa dica é para que se faça o uso mais eficiente da Memória Cache L1 do GPGPU;
  • Tamanho do grupo de trabalho deve ser um múltiplo do tamanho de uma thread;
  • Tamanho do grupo de trabalho deve ser um múltiplo inteiro do tamanho do grupo de trabalho preferido, interno a GPU (16 para o GC2000) para o uso ótimo do hardware utilizado.

 

Mantenha o tamanho do trabalho global em 64 K (valor máximo) por dimensão

 

  • Como os IDs globais são 16 bits, é necessário manter o tamanho do trabalho global dentro de 64K (65.536 ou 216) por dimensão.

 

Branching Condicional deve ser evitado, se isso for possível

 

  • Penalidades por decisões erradas de Branch dependem da porcentagem de itens de trabalho (work itens) que vão para cada um dos lados da decisão do branch.

 

 

Este post é longo o suficiente para ser apenas uma introdução acerca do tema i.MX6Q/D OpenCL Embedded Profile. Para mais informações, incluindo um aplicativo de exemplo, dê uma olhada neste excelente paper fornecido pela NXP, disponível neste link

 

EOF!

 

Originalmente publicado no blog Computer Vision on i.MX Processors em inglês neste link e traduzido por Thiago Lima com autorização do Autor André Silva.

Outros artigos da série

Como fazer um Hello World com o OpenCL Embedded Profile (GC2000) >>
Este post faz da série OpenCL Embedded Profile. Leia também os outros posts da série:
NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Andre Silva
Mestre em Engenharia Elétrica (USP São Carlos). Engenheiro de Aplicações na NXP Semiconductors liderando o time de Compute and Graphics do GTEC (Graphics Technology Engineering Center). Especialista na família de processadores multimídia i.MX e tem como hobby Visão computacional e Robótica.

17
Deixe um comentário

avatar
 
4 Comment threads
13 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
4 Comment authors
Andre SilvaAndre SilvaCleiton BuenoCaio Pereira Recent comment authors
  Notificações  
recentes antigos mais votados
Notificar
Cleiton Bueno
Visitante

Uso do CPU ao executar o exemplo Qt5_CinematicExperience, o resultado acontece com outros também: PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 1138 root 20 0 179264 44436 15912 S 60.1 8.8 13:06.86 Qt5_CinematicExperience -platform eglfs Resumo do qtbase5.6 realizando compilação-cruzada para i.MX6(Toradex Colibri) usando branch Krogoth, adicionando linuxfb e gles2, removendo x11 e wayland: Saida config.summary: ... QPA backends: DirectFB ............. yes EGLFS ................ yes EGLFS i.MX6 ........ yes EGLFS i.MX6 Wayland. no EGLFS EGLDevice .... no EGLFS GBM .......... no EGLFS Mali ......... no EGLFS Raspberry Pi . no EGLFS X11 .......... no LinuxFB… Leia mais »

Caio Pereira
Visitante
Caio Pereira

@disqus_t1mUEGxiCY:disqus , 6 meses depois conversando com o @cleitonbueno:disqus, ele me mostrou que o Qtquick2 não é renderizado pela GPU quando é utilizado EGLFS.
http://doc.qt.io/qt-5/embedded-linux.html#eglfs - Seção 4

Tks Cleiton Bueno.

Andre Silva
Visitante
Andre Silva

Ola Caio,

valeu pela informacao. QT ainda é um tanto quanto estranho pra mim tambem.

abraços,
Andre

Cleiton Bueno
Visitante

Parabéns pelo artigo André, é uma área e um assunto que acho muito interessante.

Abraço.

Caio Pereira
Visitante
Caio Pereira

Muito legal o post Andre, eu estava precisando algo um pouco mais simples. Estou trabalhando com linux, Qt e IMX6, mas o consumo de memória e processamento está muito alto. Como saber se o Qt está usufruindo dos recursos da GPU? Tem alguma referência da NXP sobre esse assunto?!
Muito obrigado!

Abraços

Andre Silva
Visitante
Andre Silva

Ola Caio que bom que gostou do Post !

Voce esta utilizando BSP e drivers fornecido pela antiga Freescale (NXP) ? Voce pode testar baixando o nosso BSP (yocto) e compilando uma imagem do QT5 (ou utilizando um pre-build ja pronto).

abraços,

Andre

Caio Pereira
Visitante
Caio Pereira

Olá Andre, sim já estou usando yocto (1.7 e 1.8), testei as imagens prontas, mas estou fazendo a minha Imagem (sem X11/Wayland).

Andre Silva
Visitante
Andre Silva

Caio,

vou precisar checar essa informacao, normalmente a aceleracao da GPU ja esta ativada quando utilizada a imagem QT5.

abraços,
Andre

Caio Pereira
Visitante
Caio Pereira

passei os parâmetros no qtbase_%.bbappend gles2 egl , mas enfim, qualquer informação sobre como eu visualizar desempenho/informação da GPU é muito bem vindo!

Obrigado!

Andre Silva
Visitante
Andre Silva

Caio, voce rodou a mesma aplicacao no PC e verificou se ocorre o mesmo problema la ? Acabei de verificar aqui e nao ha nenhum problema conhecido relacionado com isso. Voce esta testando alguma aplicacao pessoal ou os demos da QT5 que acompanham na imagem ? Aqui nesse link: https://community.freescale.com/docs/DOC-102484 o autor reporta consumo de CPU de 5% no demo da QT5.

abracos,
Andre

Caio Pereira
Visitante
Caio Pereira

No PC está tudo ok.
Estou testando o cinematic experience e minha aplicação.
Na minha melhor compilação (Yocto 1.8) cinematic experience chega a 52% de cpu. (IMX6 Solo)

Vou checar com o pessoal do forum. Obrigado pela ajuda!

Cleiton Bueno
Visitante

Caio, mesmo executando com -platform eglfs o consumo fica nesse patamar?

Caio Pereira
Visitante
Caio Pereira

Cleiton, exato todos os testes estão sendo realizados passando -platform eglfs. Você já chegou a testar no IMX6?

Cleiton Bueno
Visitante

Ok, você gerou com o Yocto Projecto correto? No caso você esta sem server-x né? Ou você gerou com core-image-sato ou algo como o Wayland coisa assim?

Caio Pereira
Visitante
Caio Pereira

Gerei no Yocto 1.7 e 1.8. Sim, estou sem X11 e sem Wayland.
1 compilação foi uma distro que criei baseado na poky e outras duas compilação foram imagens da toradex baseada no angstrom. Não utilizei core-image-sato não.

Caio Pereira
Visitante
Caio Pereira

Sim, todos os testes que realizei foram com o parâmetro -platform eglfs
USER PID %CPU %MEM VSZ RSS TTY STAT START
root 439 54.1 18.1 175748 45536 ttymxc0 Sl 13:42 0:50 ./Qt5_CinematicExperience -platform eglfs -plugin tslib:/dev/input/event1

Caio Pereira
Visitante
Caio Pereira

Andre, este documento está em uma área que não tenho acesso (mesmo com cadastro no community). Abs