Como instalar e utilizar o OpenCL para realizar cálculos

25 março 2014, 10:08
MetaQuotes Software Corp.
0
7 723

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.

Entradas do Diário no terminal do MetaTrader 5 com relação aos dispositivos OpenCL encontrados

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)
Adicionalmente, o site oficial do desenvolvedor, o Khronos Group, oferece uma informação completa sobre o hardware e software necessários para cada versão do OpenCL.

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:



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

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.

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

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

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 Software Corp.
Artigo original: https://www.mql5.com/ru/articles/690

Arquivos anexados |
opencl_sample.mq5 (12.93 KB)
Rede em nuvem do MQL5: Você ainda está calculando? Rede em nuvem do MQL5: Você ainda está calculando?

Logo fará um ano e meio desde que a Rede em nuvem do MQL5 foi inaugurada. Esse evento inovador nos conduziu para uma era de negócios algorítmicos - agora com poucos cliques, negociadores podem ter centenas e milhares de núcleos de computação a sua disposição para a otimização de suas estratégias de negócios.

Indicador para o gráfico de Ponto e Figura Indicador para o gráfico de Ponto e Figura

Existem vários tipos de gráficos que fornecem informações sobre a situação do mercado atual. Muitos deles, como o Gráfico de Ponto e Figura, são o legado de um passado remoto. O artigo descreve um exemplo do gráfico de Ponto e Figura usando um indicador de tempo real.

Outra classe OOP do MQL5 Outra classe OOP do MQL5

Este artigo mostra como construir um Expert Advisor orientado a objeto desde o começo, desde conceber a ideia da negociação teórica até a programação de um MQL EA que torne esta ideia real no mundo empírico. Aprender fazendo é, na minha opinião, uma abordagem sólida para o sucesso, então, mostro em um exemplo prático para que você veja como pode organizar suas ideias para finalmente codificar seus robôs Forex. Meu objetivo é convidá-lo a aderir aos princípios de OO.

Criando EAs de rede neural usando o assistente do MQL5 e o gerador EA Hlaiman Criando EAs de rede neural usando o assistente do MQL5 e o gerador EA Hlaiman

O artigo descreve um método de criação automatizada de EAs de rede neural usando o assistente do MQL5 e o gerador EA Hlaiman. Ele mostra como você pode facilmente começar a trabalhar com redes neurais, sem ter que aprender todo o corpo de informações teóricas, e escrever o seu próprio código.