Como instalar e utilizar o OpenCL para realizar cálculos
16 326
0
O OpenCL no terminal do cliente do MetaTrader 5
Já se passou mais de um ano desde que tornou-se possível escrever programas para o OpenCL no MQL5. Entradas de quaisquer dispositivos OpenCL encontrados agora podem ser vistas no Diário (Journal) no lançamento do terminal do MetaTrader 5, conforme mostrado abaixo.
Nesse caso, o terminal do MetaTrader 5 detectou 4 métodos disponíveis para executar o OpenCL diretamente de um programa do MQL5: uma placa de vídeo da NVIDIA (OpenCL 1.1) e uma da AMD (OpenCL 1.2), como também duas opções de utilização de CPU Intel Core-i7, dependendo do driver instalado. Se seu computador já tem um dispositivo adequado OpenCL versão 1.1 ou superior, você pode pular a parte da descrição seguramente e prosseguir diretamente para a Comparação de desempenho para poder ver por sua conta o ganho de desempenho para tarefas que permitem computação paralela.
O OpenCL é fascinante!
No entanto, nem tantos usuários têm tirado vantagem da utilização da computação paralela em seus Consultores Especialistas, indicadores ou scripts já que não estão cientes das novas possibilidades oferecidas e não têm o conhecimento necessário.
A questão é que a inicialização de qualquer programa do MQL5 que utilize o OpenCL exige um software apropriado para ser instalado. Essa é a razão pela qual muitos usuários simplesmente não puderam executar o script em conjunto Mandelbrot, assim como vários outros programas disponíveis no fórum MQL5.community.
Nesse artigo, mostraremos a você como instalar o OpenCL em seu computador para que você possa ver em primeira mão as vantagens de utilizar computação paralela no MQL5. Não consideraremos as particularidades da escrita de programas para o Open CL já que o site já apresenta dois grandes artigos que abrangem esse assunto:
O que é OpenCL?
OpenCL é o padrão aberto para programação paralela desenvolvida pelo consórcio Khronos Group em 2008. Esse padrão permite a você desenvolver aplicações que podem ser executados em paralelo em GPUs ou em CPUs com diferentes arquiteturas em um sistema heterogêneo.
Em outras palavras, o OpenCL torna possível o uso de todos os núcleos do CPU ou a enorme capacidade de computação de GPUs ao calcular uma tarefa, reduzindo assim o tempo de execução do programa. A utilização do OpenCL é, portanto, muito benéfica para lidar com tarefas associadas com computações trabalhosas e consumidoras de recursos.
Por exemplo, falando no MQL5, o ganho de desempenho pode ser muito recompensador ao lidar com certo script (indicador ou Consultor Especialista) que realiza uma complexa e extensa análise de dados do histórico através de vários símbolos e períodos (deve-se notar aqui que um programa do MQL5 que é destinado a usar execução paralela deve ser escrito de uma forma especial utilizando o OpenCL API).
Suporte OpenCL
O suporte para o OpenCL no MQL5 é fornecido desde a versão 1.1 lançada em Junho de 2010. Então, a fim de utilizar computação paralela, você deve ter um software e hardware relativamente apropriados para o padrão.
Dito isto, deve-se notar que para começar a utilizar o OpenCL não importa realmente se você tem ou não uma placa de vídeo em seu PC - um CPU resolve. Isso significa que o OpenCL está disponível virtualmente para cada usuário que desejar reduzir o tempo de execução em seus programas do MQL5.
Os CPUs estão definitivamente muito atrás de seus rivais gráficos em termos de velocidade de computação distribuída. No entanto, uma boa CPU multi-núcleo deve se sair bem na obtenção de um aumento significativo de velocidade. Mas vamos voltar para o assunto de nossa discussão.
Como já mencionado anteriormente, você pode utilizar tanto placas de vídeo quanto CPUs para computação paralela. Existem três grandes fabricantes de dispositivos interessantes no mercado: Intel, AMD e NVidia. A tabela seguinte oferece informações sobre dispositivos e sistemas operacionais que dão suporte ao OpenCL 1.1 para cada um dos três fabricantes:
| Fabricante | Dispositivos | Sistemas operacionais |
|---|---|---|
| Intel | CPUs: Core i3, i5, i7 - para PCs; Xeon - para servidores; Xeon Phi - para coprocessadores (leia mais). |
Windows 7, 8; openSUSE; Red Hat. |
| AMD | Placas de vídeo: AMD Radeon HD Graphics da série 6400 e superior; ATI Radeon HD Graphics da série 5400 e superior; ATI FirePro Graphics A300 séries S, W, V ; ATI Mobility Radeon HD da série 5400 e superior; ATI FirePro M7820 M5800 (leia mais). CPUs baseados na arquitetura K8 e superior: Opteron, Athlon 64, Athlon 64 FX, Athlon 64 X2, Sempron, Turion 64, Turion 64 X2, Phenom, Phenom II (leia mais). APU (CPU híbrido/processador da GPU): CPU das séries A, C, E, E2, G, R. |
Windows Vista SP2, 7, 8; openSUSE 11.x; Ubuntu 11.04; Red Hat 6.x. |
| NVidia | GPUs (com arquitetura CUDA): Tesla, Quadro, GeForce (leia mais). |
Windows XP, Vista, 7, 8 Linux and Mac OS (leia mais) |
Certifique-se que você tenha pelo menos um dispositivo (CPU ou GPU) disponível em seu computador e verifique se esse dispositivo, assim como o sistema operacional instalado, suporta o OpenCL 1.1. Se esses requerimentos forem alcançados, você pode prosseguir seguramente para a próxima seção que descreve como configurar o OpenCL, dependendo do fabricante do hardware.
Configurando o OpenCL
Se você tem o hardware e software necessários instalados em seu computador, tudo o que precisa fazer para começar a utilizar a computação paralela no MetaTrader 5 é configurar o OpenCL para um de seus dispositivos.
O procedimento de configuração do OpenCL varia dependendo do hardware que você pretende utilizar - GPU ou CPU. Se o terminal do MetaTrader 5 localizou uma placa de vídeo que suporta o OpenCL, você precisa apenas atualizar seus drivers para a versão mais recente.
Será necessário instalar um SDK para o CPU somente se o computador não tiver a placa de vídeo apropriada.
Importante: Se você já tem uma placa de vídeo com suporte para o OpenCL instalada, você não precisa instalar uma versão do software para emulação do OpenCL na CPU!
A não ser que seja necessário para experimentos já que placas de vídeo para o OpenCL oferecem vantagens indiscutíveis.
Os parágrafos seguintes descrevem o procedimento de configuração do OpenCL, dependendo do fabricante. Você pode ir para as instruções de configuração relevantes usando o link correspondente:
- Configuração para CPUs da Intel;
- Configuração para GPUs da AMD;
- Configuração para CPUs da AMD;
- Configuração para GPUs da NVidia.
1. Intel
Para poder utilizar o OpenCL nas CPUs da Intel, você precisa baixar e instalar o Intel SDK para aplicações OpenCL. Para fazê-lo, visite a página de transferência do desenvolvedor oficial.
Fig. 1,1. A página de transferência do Intel SDK para OpenCL
Aqui, você pode encontrar informações gerais sobre o OpenCL, assim como uma lista de produtos disponíveis para transferência. Para baixar os produtos disponíveis, clique no botão Compare e baixe produtos no canto superior direito da página.
Fig. 1,2. Informações sobre produtos disponíveis e requerimentos de instalação.
Após clicar, você verá uma janela com informações sobre os requerimentos do produto assim como tipos de processador suportados e sistemas operacionais. Selecione e baixe um produto adequado clicando no botão Download acima do ícone do produto.
Fig. 1,3. Links de transferência do SDK
Outra janela aparecerá com os links de transferência. Selecione e baixe o SDK 32-bits ou 64-bits. Aguarde por alguns minutos e execute o arquivo obtido quando a transferência terminar. Confirme a instalação dos componentes do SDK e extraia os arquivos em uma das pastas.
Fig. 1,4. Iniciando a instalação do Intel SDK para o OpenCL.
Você verá a janela de instalação dizendo Intel SDK para aplicações OpenCL com suporte para o OpenCL 1.2. Clique em Próximo e siga as instruções de instalação.
Fig. 1,5. Aceitação do contrato de licença do usuário final.
Aceite os termos e condições do contrato de licença. Seguindo isso, os componentes a serem instalados serão exibidos na janela - clique em Próximo para continuar.
Fig. 1,6. Integração do SDK com o Visual Studio.
Se o software Microsoft Visual Studio 2008 (ou versões posteriores) já estiver disponível em seu computador, você será notificado para integrá-lo para fins do OpenCL. Depois você só precisará selecionar usuários os quais serão capazes de acessar os componentes instalados, especificar o local da instalação do SDK e clicar em Instalar.
Fig. 1,7. Instalação.
A instalação levará alguns minutos. Uma vez que ela tiver sido concluída com sucesso, você verá o resultado na tela. Clique em Finalizar para encerrar o processo de instalação.
Fig. 1,8. Finalizando a instalação.
2,1. Placas de vídeo AMD e APU
Para instalar o OpenCL para uma placa de vídeo AMD, vamos atualizar seu driver para a versão disponível mais recente. Isso pode ser feito pela página de transferência do driver.
Fig. 2.1.1. Página de transferência do driver da AMD
Se você souber as especificações de sua placa de vídeo, o driver pode ser facilmente localizado preenchendo um formulário no lado esquerdo da página. Uma vez que você tenha selecionado as opções necessárias em todos os campos do formulário, clique em Exibir Resultados para encontrar o driver apropriado.
Fig. 2.1.2. Transferência do AMD Catalyst.
O sistema oferecerá alguns drivers na Catalyst Software Suite, incluindo o driver do OpenCL. Baixe o Catalyst e execute o arquivo obtido.
Fig. 2.1.3. Página de transferência da aplicação para identificação do tipo de placa de vídeo e versão do driver.
Você também pode utilizar o sistema de detecção automática de driver clicando no link correspondente no topo superior direito da página (Fig. 2..1.1). Você será notificado para baixar a aplicação AMD Driver Autodetect - faça isso e então a execute.
Fig. 2.1.4. Aplicação para detecção e transferência do driver apropriado.
A aplicação analisará o sistema e oferecerá a você baixar o driver da placa de vídeo apropriado. Baixe-o e execute o arquivo obtido. O gerenciador de instalação pedirá a você que selecione a pasta para descompactar os arquivos - selecione e clique em Instalar.
Fig. 2.1.5. Gerenciador de instalação AMD Catalyst.
O contrato de licença do usuário final aparecerá em uma janela em um menu suspenso. Precisamos aceitar seus termos e condições. Em seguida, selecionamos a instalação expressa, especificamos o local da instalação do AMD Catalyst e clicamos em Próximo.
Fig. 2.1.6. Instalação.
A instalação levará alguns minutos. Uma vez que ela tiver sido concluída, você verá a mensagem relevante na tela.
Fig. 2.1.7. Finalizando a instalação.
2,2. CPUs AMD
Para instalar o OpenCL para um CPU AMD, precisamos baixar e instalar a versão mais atual do AMD APP SDK. Com essa finalidade, vá para a seguinte página no site oficial do desenvolvedor.
Fig. 2.2.1. Página de transferência do AMD APP SDK.
Essa página oferece algumas informações sobre o SDK como dar uma ideia do OpenCL. O que precisamos aqui é encontrar e clicar no link Go to Downloads abaixo da descrição.
Fig. 2.2.2. Tabela das SDKs disponíveis para transferência.
No final da página, você verá uma tabela com uma lista das versões do SDK mais recentes para vários sistemas operacionais, tanto em 32-bits quanto em 64-bits, assim como os links de transferência. Selecione a versão necessária clicando no link relevante. Você será direcionado para a página com o contrato de licença do usuário final. Aceite-o para iniciar a transferência.
Após executar o instalador baixado, você será notificado para extrair os arquivos de instalação para alguma pasta. Isso será seguido pela instalação do AMD Catalyst acima descrito contendo o AMD APP SDK para sua CPU. O procedimento de instalação do Catalyst é exibido na Fig. 2.1.5 - 2.1.7 da seção 2.1 acima.
3. NVidia
Se você tem uma placa de vídeo NVidia, você precisa atualizar seu driver para a versão mais atual para poder instalar o OpenCL. Você pode baixá-lo da página de transferência do driver no site do desenvolvedor.
Fig. 3,1. Página de transferência do driver da NVidia.
Essa página oferece opções tanto de localizar o driver necessário manualmente quanto automaticamente. Utilizando a opção manual, você precisa selecionar o tipo de produto, série, sistema operacional e clicar em Buscar. O sistema encontrará o driver mais recente adequado para sua placa de vídeo e notificá-lo para baixá-lo.
Fig. 3,2. Transferência do driver selecionado.
Se você escolher a opção 2, você precisa clicar em Drivers Gráficos pelo qual lhe será solicitado uma varredura de seu sistema utilizando a aplicação Java GPU_Reader.
Fig. 3,3. Executando a aplicação para identificar o tipo de placa de vídeo e a versão do driver.
Execute a aplicação clicando em Executar. Aguarde por alguns segundos para poder ver as informações da placa de vídeo, a versão atual do driver instalado e a versão do driver mais recente recomendada. Clique em Baixar para ser direcionado para a página de transferência mostrada na Fig. 3.2.
Fig. 3,4. Resultados da identificação automática do tipo de placa de vídeo e da versão do driver.
Clique em Baixar Agora e aceite o contrato de licença do software NVidia clicando no botão Concordar e Baixar.
Fig. 3,5. Aceitação do contrato de licença e transferência do driver.
Assim, obtemos a versão mais recente do driver para a placa de vídeo. Depois executamos o arquivo obtido - será pedido a você que extraia os arquivos de instalação do driver em uma das pastas. A instalação começará após a descompactação dos arquivos. Primeiro, você precisa aceitar os termos e condições do contrato de licença do software NVidia mais uma vez.
Fig. 3,6. Aceitação do contrato de licença no primeiro estágio da instalação.
Depois selecione a opção de instalação Expressa e clique em Próximo. Adicionalmente, lhe será oferecido instalar o programa suplementar NVidia Experience o qual é opcional.
Fig. 3,7. Selecionando a opção de instalação.
A instalação do driver começará imediatamente após isso, acompanhada com a propaganda dos últimos desenvolvimentos da NVidia.
Fig. 3,8. Instalação.
É isso aí. O driver foi instalado e precisamos apenas de reiniciar o sistema para podermos utilizar o OpenCL no terminal do MetaTrader 5.
Fig. 3,9. Finalizando a instalação.
Comparação de desempenho
O OpenCL_Sample.mq5 foi escrito para demonstrar as vantagens da utilização do OpenCL no MQL5. Ele calcula valores da função de duas variáveis em um conjunto e exibe resultados na janela do gráfico utilizando uma etiqueta gráfica (OBJ_BITMAP_LABEL). Os cálculos são realizados de duas formas - utilizando e não utilizando o OpenCL. Esses blocos são implementados no formulário das funções WithOpenCL() e WithoutOpenCL(), respectivamente:
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //... Print("\nCalculations without OpenCL:"); WithoutOpenCL(values1,colors1,w,h,size,const_1,const_2); //--- calculations with OpenCL Print("\nCalculations with OpenCL:"); WithOpenCL(values2,colors2,w,h,size,const_1,const_2); //... } //+------------------------------------------------------------------+ //| Calculations without using OpenCL | //+------------------------------------------------------------------+ void WithoutOpenCL(float &values[],uint &colors[],const uint w,const uint h, const uint size,const uint const_1,const uint const_2) { //--- store the calculation start time uint x=GetTickCount(); //--- calculation of function values for(uint i=0;i<h;i++) for(uint j=0;j<w;j++) values[i*w+j]=Func(InpXStart+i*InpXStep,InpYStart+j*InpYStep); //--- print the function calculation time Print("Calculation of function values = "+IntegerToString(GetTickCount()-x)+" ms"); //--- determine the minimum value and the difference between //--- the minimum and maximum values of points in the set float min,dif; GetMinAndDifference(values,size,min,dif); //--- store the calculation start time x=GetTickCount(); //--- calculate paint colors for the set uint a; for(uint i=0;i<size;i++) { a=(uint)MathRound(255*(values[i]-min)/dif); colors[i]=const_1*(a/16)+const_2*(a%16); } //--- print the paint color calculation time Print("Calculation of paint colors = "+IntegerToString(GetTickCount()-x)+" ms"); } //+------------------------------------------------------------------+ //| Calculations using OpenCL | //+------------------------------------------------------------------+ void WithOpenCL(float &values[],uint &colors[],const uint w,const uint h, const uint size,const uint const_1,const uint const_2) { //--- variables for using OpenCL int cl_ctx; int cl_prg; int cl_krn_1; int cl_krn_2; int cl_mem_1; int cl_mem_2; //--- create context for OpenCL (selection of device) if((cl_ctx=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE) { Print("OpenCL not found"); return; } //--- create a program based on the code in the cl_src line if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==INVALID_HANDLE) { CLContextFree(cl_ctx); Print("OpenCL program create failed"); return; } //--- create a kernel for calculation of values of the function of two variables if((cl_krn_1=CLKernelCreate(cl_prg,"Func"))==INVALID_HANDLE) { CLProgramFree(cl_prg); CLContextFree(cl_ctx); Print("OpenCL kernel_1 create failed"); return; } //--- kernel for painting points of the set in the plane if((cl_krn_2=CLKernelCreate(cl_prg,"Grad"))==INVALID_HANDLE) { CLKernelFree(cl_krn_1); CLProgramFree(cl_prg); CLContextFree(cl_ctx); Print("OpenCL kernel_2 create failed"); return; } //--- OpenCL buffer for function values if((cl_mem_1=CLBufferCreate(cl_ctx,size*sizeof(float),CL_MEM_READ_WRITE))==INVALID_HANDLE) { CLKernelFree(cl_krn_2); CLKernelFree(cl_krn_1); CLProgramFree(cl_prg); CLContextFree(cl_ctx); Print("OpenCL buffer create failed"); return; } //--- OpenCL buffer for point colors if((cl_mem_2=CLBufferCreate(cl_ctx,size*sizeof(uint),CL_MEM_READ_WRITE))==INVALID_HANDLE) { CLBufferFree(cl_mem_1); CLKernelFree(cl_krn_2); CLKernelFree(cl_krn_1); CLProgramFree(cl_prg); CLContextFree(cl_ctx); Print("OpenCL buffer create failed"); return; } //--- store the calculation start time uint x=GetTickCount(); //--- array sets indices at which the calculation will start uint offset[2]={0,0}; //--- array sets limits up to which the calculation will be performed uint work[2]; work[0]=h; work[1]=w; //--- calculation of function values //--- pass the values to the kernel CLSetKernelArg(cl_krn_1,0,InpXStart); CLSetKernelArg(cl_krn_1,1,InpYStart); CLSetKernelArg(cl_krn_1,2,InpXStep); CLSetKernelArg(cl_krn_1,3,InpYStep); CLSetKernelArgMem(cl_krn_1,4,cl_mem_1); //--- start the execution of the kernel CLExecute(cl_krn_1,2,offset,work); //--- read the obtained values to the array CLBufferRead(cl_mem_1,values); //--- print the function calculation time Print("Calculation of function values = "+IntegerToString(GetTickCount()-x)+" ms"); //--- determine the minimum value and the difference between //--- the minimum and maximum values of points in the set float min,dif; GetMinAndDifference(values,size,min,dif); //--- store the calculation start time x=GetTickCount(); //--- set the calculation limits uint offset2[1]={0}; uint work2[1]; work2[0]=size; //--- calculation of paint colors for the set //--- pass the values to the kernel CLSetKernelArg(cl_krn_2,0,min); CLSetKernelArg(cl_krn_2,1,dif); CLSetKernelArg(cl_krn_2,2,const_1); CLSetKernelArg(cl_krn_2,3,const_2); CLSetKernelArgMem(cl_krn_2,4,cl_mem_1); CLSetKernelArgMem(cl_krn_2,5,cl_mem_2); //--- start the execution of the kernel CLExecute(cl_krn_2,1,offset2,work2); //--- read the obtained values to the array CLBufferRead(cl_mem_2,colors); //--- print the paint color calculation time Print("Calculation of paint colors = "+IntegerToString(GetTickCount()-x)+" ms"); //--- delete OpenCL objects CLBufferFree(cl_mem_1); CLBufferFree(cl_mem_2); CLKernelFree(cl_krn_1); CLKernelFree(cl_krn_2); CLProgramFree(cl_prg); CLContextFree(cl_ctx); }
Após executar o script, por alguns segundos você poderá ver o conjunto pintado de valores de função na janela do gráfico. Cada um deles corresponde a um dos tons da cor selecionada nos parâmetros de entrada (vermelho, verde ou azul).
Resultados de execução de scripts para o conjunto de pontos no plano de -22 a 22 no passo 0.1.
Além da própria imagem, o tempo de cálculo da função para ambos métodos é exibido no Diário "Consultor Especialista" de forma que você possa ver claramente as vantagens e o valor prático da utilização do OpenCL no MQL5. Aumente o valor do passo e obtenha os resultados de execução do script:
Resultados do cálculo da função e valores da cor de pintura utilizando dois métodos.
O tempo total do cálculo da função no CPU utilizando o OpenCL mostrou-se ser mais de 5 vezes menor e isso está longe de ser o limite! É muito conhecido que cálculos em GPUs avançadas com suporte para OpenCL são muito mais rápidos que em CPUs. Você pode encontrar um prova clara desse fato nos resultados da execução do script em dispositivos OpenCL diferentes, conforme mostrado na tabela abaixo:
| Dispositivo OpenCL |
Tempo de execução sem utilizar o OpenCL, ms |
Tempo de execução utilizando o OpenCL, ms |
Ganho de desempenho |
|---|---|---|---|
| AMD Radeon HD 7970 | 20,361 ms |
171 ms |
119.07 vezes |
| NVidia GeForce GT 630 |
24,742 ms |
578 ms |
42.8 vezes |
| Intel Core i5 430M |
27,222 ms |
5,428 ms |
5.01 vezes |
| AMD Athlon X2 Dual-Core QL-65 |
45,723 ms |
9,516 ms | 4.8 vezes |
Como pode ser visto, a utilização do OpenCL nas placas de vídeo de primeira linha da AMD resultou em uma redução para 1 centésimo do tempo de cálculo! Resultados significantes já foram obtidos na ligeiramente antiga GeForce GT 630 de 2011, com uma redução de 1/42 do tempo. As CPUs da Intel e da AMD vieram por último. No entanto, o ganho de desempenho atingido nelas será também muito benéfico ao lidarmos com cálculos complexos.
Isso é tudo. A tabela de comparações demonstra uma clara vantagem da utilização de computação paralela no processamento de dados em massa. Tudo o que você deve fazer é instalar o driver apropriado para a sua placa de vídeo ou CPU.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/690
Outra classe OOP do MQL5
Rede em nuvem do MQL5: Você ainda está calculando?
Criando EAs de rede neural usando o assistente do MQL5 e o gerador EA Hlaiman
Indicador para o gráfico de Ponto e Figura
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso