Cómo instalar y utilizar OpenCL para efectuar cálculos

MetaQuotes | 26 marzo, 2014

OpenCL en el terminal de cliente MetaTrader 5

Ha pasado ya más de una año desde que se hizo posible escribir programas para OpenCL en MQL5, y ahora, al iniciar el terminal MetaTrader 5, en el Registro aparacen mensajes sobre dispositivos encontrados que pueden usar OpenCL, como se muestra en la imagen.

En este caso, el terminal MetaTrader 5 ha determinado que para iniciar los cálculos OpenCL directamente desde un programa MQL5 hay disponibles 4 métodos: dos tarjetas de video NVIDIA (OpenCL 1.1) y AMD (OpenCL 1.2), así como dos opciones de uso del procesador central Intel Core-i7 a elegir, dependiendo del driver instalado con tal propósito.

Si en nuestra computadora ya tenemos un dispositivo conveniente que pueda usar OpenCL versión 1.1 o superior, entonces puede saltarse tranquilamente la descripción y pasar directamente al apartado Comparación de rendimiento, para ver con sus propios ojos la ganancia de velocidad en las tareas que permite la computación paralela.

¡OpenCL es fascinante!

Sin embargo, ni mucho menos todos los usuarios han valorado como merecen las ventajas que brinda el uso de cálculos paralelos en sus asesores, indicadores y scripts, ya que desconocen las nuevas posibilidades o no tienen los conocimientos necesarios sobre ellas.

El asunto es que para iniciar cualquier programa MQL5 que use OpenCL, es necesario instalar el software adecuado. Por eso son muchos los que no han sabido iniciar el script del conjunto de Mandelbrot y muchos otros programas disponibles en el foro de MQL5.community.

En este artículo le mostraremos cómo instalar OpenCL en su ordenador personal, para que puede convencerse por sí mismo de las ventajes que posee el uso de los cálculos paralelos en MQL5. Aquí vamos a estudiar los detalles de la escritura de programas para OpenCL en MQL5 - ya existen dos artículos magníficos sobre este tema en la página web:

• OpenCL: El puente hacia mundos paralelos y
• OpenCL: De una programación simple a una más intuitiva.

Qué es OpenCL

OpenCL - es un estándar abierto de programación paralela, desarrollado por el consorcio Khronos Group en el año 2008. Este estándar permite crear aplicaciones que pueden ejecutarse paralelamente en procesadores gráficos (GPU) o centrales (CPU), distintos en su arquitectura y ubicados en un sistema heterogéneo.

En otras palabras, OpenCL permite implicar en los cálculos de una tarea a todos los núcleos del procesador central o toda la capacidad de computación de la unidad de procesamiento gráfico, cosa que, a fin de cuentas, reduce significativamente el tiempo de ejecución de un programa. Por eso, el uso de OpenCL es muy útil en las tareas relacionadas con computaciones muy laboriosas o que gastan muchos recursos.

Por ejemplo, si hablamos de MQL5, el aumento de la ganancia puede ser muy útil para ciertos scrips (indicadores o expertos) que lleven a cabo análisis históricos prolongados y complicados de varios símbolos y time frames (merece la pena matizar que el programa MQL5 que deba realizar una ejecución paralela deberá estar escrito de manera especial, utilizando OpenCL API).

Soporte técnico OpenCL

El soporte técnico OpenCL en MQL5 arranca desde la versión estándar 1.1, aparecida en el año 2010. Por eso, a la hora de usar la computación paralela, es necesario un software y un hardware relativamente nuevos, que correspondan a este estándar.

Además es importante destacar que, para usar OpenCL no es obligatorio en absoluto tener una tarjeta gráfica en un su ordenador personal, será suficiente con la unidad central de procesamiento. Esto significa que casi cualquier usuario tiene la posibilidad de usar OpenCL para acortar los plazos de tiempo en la ejecución de sus programas MQL5.

Como es natural, los procesadores centrales no llegan a la altura de sus rivales gráficos en términos de velocidad de computación distribuida, sin embargo, un buen procesador central de multinúcleo le será más que suficiente para obtener una mejora de velocidad significativa. Pero nos estamos desviando del tema, continuemos.

Como ya se ha dicho más arriba, para la computación paralela se pueden usar tanto tarjetas gráficas como procesadores centrales. En el mercado de fabricantes de este tipo de dispositivos, existen tres compañías líderes principales: Intel, AMD y NVidia. En el recuadro siguiente se muestra información sobre los dispositivos y los sistemas operativos compatibles con OpenCL 1.1 para cada uno de estos tres fabricantes:

Compruebe si tiene instalado en su PC aunque sea uno de los dos dispositivos (CPU o GPU) y un sistema operativo compatible con OpenCL 1.1. Si los tiene, entonces puede pasar al siguiente párrafo, en el que se explica el proceso de configuración de OpenCL, dependiendo del fabricante del software del aparato.

Configuración de OpenCL

Si en su PC tiene instalado el harware imprescindible y el software necesario, entonces para usar la computación paralela en MetaTrader 5 sólo hay que completar otro paso más:  configurar OpenCL para uno de sus dispositivos.

El pocedimiento de configuración de OpenCL puede diferenciarse, dependiendo del hardware que usted pretenda utilizar, es decir, una tarjeta gráfica o el procesador central. Si el terminal MetaTrader 5 reconoce la tarjeta gráfica compatible con OpenCL, entonces bastará con actualizar su driver hasta su última versión.

Sólo se le pedirá que instale un kit de desarrollo de software (SDK) si no tiene instalada una tarjeta gráfica adecuada en su computadora.

A no ser que quiera realizar experimentos, ya que las tarjetas gráficas para OpenCL disponen de ventajas indiscutibles.

Los siguentes párrafos describen el proceso de configuración de OpenCL, dependiendo de cada fabricante. Puede pasar directamente a las instrucciones de configuración que le interesen, pulsando en el enlace correspondiente:

• configuración de los procesadores de Intel;
• configuración de las tarjetas gráficas de AMD;
• configuración de los procesadores de AMD;
• configuración de las tarjetas gráficas de NVidia.
  

1. Intel

Para usar OpenCL con los procesadores Intel es necesario descargar e instalar "Intel SDK for OpenCL Applications". Para ello entraremos en la página del desarrollador, desde donde podremos hacerlo.

Dib. 1.1. Página de descarga de Intel SDK para OpenCL.

Aquí se muestra toda la información sobre OpenCL, así como una lista de los productos disponibles para descargar. Para descargar los productos disponibles, hay que pulsar el botón "Compare and Download Products" en la esquina superior derecha de la página.

Dib. 1.2. Información sobre los productos disponibles y las especificaciones para instalar.

Después de pulsar el botón, aparecerá una ventana en la que se mostrará información sobre los tipos de procesador y de sistemas operativos con los que son compatibles los productos indicados. Elegimos y descargamos el producto conveniente, pulsando el botón "Download" sobre su imagen.

Dib. 1.3. Enlaces para la descarga de SDK.

Aparecerá otra ventana con enlaces para realizar la descarga, así que elegimos y descargamos SDK con los bits necesarios. Esperamos varios minutos, cuando la descarga haya concluido, iniciamos el archivo obtenido. Confirmamos la instalación de los componentes de SDK y extraemos los archivos de configuración en una de las carpetas.

Dib. 1.4. Comienzo de la instalación de Intel SDK para OpenCL.

En la pantalla aparecerá la ventana de configuración "Intel SDK for OpenCL Applications" compatible con OpenCL 1.2. Pulsamos "Next" y seguimos las instrucciones de configuración.

Dib. 1.5. Aceptación de los términos de la licencia.

Aceptamos las condiciones de los términos de la licencia. Después, en la ventana aparecerán los componentes que van a ser instalados, pulsamos "Next" para continuar.

Dib. 1.6. Integración de SDK con Visual Studio.

Si tiene instalado en su PC "Microsoft Visual Studio" del año 2008 o versiones posteriores, entonces se le propondrá efectuar una integración para usar OpenCL también en su interior. Después sólo queda elegir para qué usuarios estarán accesibles los componentes instalados y la ruta para la configuración de SDK, tras lo cual pulsaremos "Install".

Dib. 1.7. Proceso de instalación.

Comenzará el proceso de instalación, que durará un par de minutos. Una vez instalado con éxito, veremos el resultado en la pantalla. Pulsamos "Finish" y terminamos la instalación.

Dib. 1.8. Finalización de la instalación.

2.1. Tarjetas gráficas y APU de AMD

Para instalar OpenCL en una tarjeta gráfica de AMD actualizamos su driver hasta su última versión. Para ello entramos en la página de descarga de drivers.

Dib. 2.1.1. Página de descarga del driver AMD.

Si conoce las caractrísticas de su tarjeta gráfica, entonces puede encontrar el driver rellenando el formulario en la parte izquierda de la página. Tras elegir las líneas adecuadas en la lista, pulsamos "Display Results" para buscar el driver conveniente.

Dib. 2.1.2. Descarga de AMD Catalyst.

El sistema ofrecerá unos cuantos drivers en la lista "Catalyst Software Suite", incluido el driver para OpenCL. Descargamos "Catalyst" e iniciamos el archivo obtenido.

Dib. 2.1.3. Página de descarga de la aplicación para la identificación del tipo de tarjeta gráfica y la versión del driver.

Asímismo, también se puede usar el sistema de búsqueda automática de drivers, pulsando sobre el enlace correspondiente en la esquina superior derecha de la página (dib. 2.1.1.). Se le propondrá descargar la aplicación "AMD Driver Autodetect" - así lo hacemos. Después iniciamos la aplicación descargada.

Dib. 2.1.4. Aplicación para la identificación y descarga del driver adecuado.

La aplicación realizará un análisis del sistema y le propondrá descargar el driver conveniente para la tarjeta gráfica. Lo descargamos e iniciamos el archivo obtenido. El programa de instalación le propondrá elegir la carpeta para la extracción de los archivos. Elegimos y pulsamos "Install".

Dib. 2.1.5. Programa de configuración AMD Catalyst.

Aparecerá una ventana con los términos de la licencia, aceptamos. Después elegimos el modo rápido de configuración "AMD Catalyst" y pulsamos siguiente.

Dib. 2.1.6. Proceso de instalación.

El proceso de instalación durará un par de minutos, una vez se haya completado con éxito, aparecerá una notificación en la pantalla.

Dib. 2.1.7. Finzalización de la instalación.

2.2. Procesadores de AMD

Para instalar OpenCL en un procesador de AMD, debemos descargar e instalar la última versión de "AMD APP SDK". Para ello entramos en la página siguiente, en el sitio oficial del desarrollador.

Dib. 2.2.1. Página de descarga de AMD APP SDK.

En esta página se puede encontrar alguna información sobre SDK, además, nos da una idea sobre qué es OpenCL. A nosotros nos interesa el enlace "Go to Downloads", debajo de la descripción, entramos en él.

Dib. 2.2.2. Recuadro de SDK disponibles para la descarga.

En la parte inferior de la página que se abrirá, podremos ver un recuadro con una lista de las últimas versiones de SDK para los diferentes sistemas operativos, ya sean de 32 o 64 bits, así como los enlaces para descargarlos. Elegimos la versión adecuada, pulsando el botón correspondiente. Aparecerá una página con los términos de la licencia -  los aceptamos y a continuación comenzará el proceso de descarga.

Tras iniciar el instalador descargado, se le propondrá extraer los archivos para la instalación y pasarlos a alguna carpeta. Después comenzará el proceso de instalación del ya conocido "AMD Catalyst", que contiene "AMD APP SDK" para su procesador central. Se puede ver el proceso de instalación del "Catalizador" en los dibujos 2.1.5 - 2.1.7, en el punto 2.1.

3. NVidia

Si tiene una tarjeta gráfica de NVidia, entonces, para instalar OpenCL también deberá actualizar el driver a su última versión. Para ello abrimos la página de descarga de drivers en la página del desarrollador.

Dib. 3.1. Página de descarga del driver de NVidia.

En la página hay un menú que le permitirá encontrar el driver que necesite, o bien de manera manual, o bien en el modo automático. En el modo manual, será necesario introducir el tipo de tarjeta gráfica, la serie, el tipo de sistema operativo y pulsar "Búsqueda". Después de ello, el sistema elegirá por sí mismo el driver adecuado para su tarjeta gráfica y le propondrá descargarlo.

Dib. 3.2. Descarga del driver elegido.

En el modo automático hay que pulsar en "Drivers gráficos", después se le propondrá realizar un escaneo de su sistema con ayuda de la aplicación java "GPU_Reader".

Dib. 3.3. Inicio de la aplicación para la identificación del tipo de tarjeta gráfica y la versión de driver.

Iniciamos la aplicación, pulsando "Run". Esperamos durante unos segundos, después aparecerá en la página información sobre su tarjeta gráfica, sobre la versión actual del driver instalado y la versión más reciente recomendada para la instalación del driver . Pulsamos "Download" y entraremos en la página de descarga, como se muestra en el dibujo 3.2.

Dib. 3.4. Resultado de la identificación automática del tipo de tarjeta gráfica y la versión del driver.

Pulsamos "Descargar ahora" y aceptamos los términos de la licencia, pulsando "Aceptar y descargar".

Dib. 3.5. Aceptación de los términos de licencia y descarga del driver.

De esta forma, obtendremos la última versión del driver para la tarjeta gráfica. Luego iniciamos el archivo obtenido. Se le propondrá extraer los archivos para la instalación del driver, en una de las carpetas. Extraemos los archivos y después comenzará el proceso de instalación. Pero primero deberemos aceptar de nuevo los términos de la licencia.

Dib. 3.6. Aceptación de los términos de la licencia en la primera etapa de la instalación.

Después elegimos el modo de instalación "Express" y pulsamos "Siguiente". Se le propondrá, además, instalar la utilidad "NVidia Experience" - pero no es obligatorio.

Dib. 3.7. Elección del modo de instalación.

A continuación comenzará directamente el proceso de instalación del driver, acompañado de un anuncio sobre los últimos desarrollos de NVidia - esperamos un par de minutos.

Dib. 3.8. Proceso de instalación.

Y ya está, el driver está instalado, sólo queda reiniciar el sistema y ya podrá usar OpenCL dentro del terminal de MetaTrader 5.

Dib. 3.9. Finalización de la instalación.

Comparación del rendimiento

Para demostrar las ventajas del uso de OpenCL в MQL5, se escribió el script OpenCL_Sample.mq5, que calcula los valores de las funciones de dos variables dentro de cierto conjunto y muestra el resultado en la ventana del gráfico con la ayuda de la etiqueta gráfica (OBJ_BITMAP_LABEL). Los cálculos se realizan de dos maneras, usando OpenCL o sin utilizarlo. Estos bloques están implementados en las funciones WithOpenCL() y WithoutOpenCL():

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//...
   Print("\nCálculos sin OpenCL:");
   WithoutOpenCL(values1,colors1,w,h,size,const_1,const_2);
//--- cálculos con OpenCL
   Print("\nCálculos con OpenCL:");
   WithOpenCL(values2,colors2,w,h,size,const_1,const_2);
//...
  }
//+------------------------------------------------------------------+
//| Realización de los cálculos sin utilización de OpenCL                   |
//+------------------------------------------------------------------+
void WithoutOpenCL(float &values[],uint &colors[],const uint w,const uint h,
                   const uint size,const uint const_1,const uint const_2)
  {
//--- almacenamos la hora de comienzo del cálculo
   uint x=GetTickCount();
//--- cálculo de los valores de función
   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);
//--- imprimimos la hora del cálculo de los valores de función
   Print("Cálculo de los valores de función = "+IntegerToString(GetTickCount()-x)+" мс");
//--- determinamos el valor mínimo y la diferencia entre 
//--- los valores mínimos y máximos de los puntos en el conjunto
   float min,dif;
   GetMinAndDifference(values,size,min,dif);
//--- guardamos la hora del comienzo de los cálculos
   x=GetTickCount();
//--- calcular los colores para marcar el conjunto
   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);
     }
//--- imprimimos la hora de la determinación de los colores para el marcado del conjunto
   Print("Determinación de los colores de marcado = "+IntegerToString(GetTickCount()-x)+" мс");
  }
//+------------------------------------------------------------------+
//| Realización de cálculos utilizando 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 para el uso de OpenCL
   int cl_ctx;
   int cl_prg;
   int cl_krn_1;
   int cl_krn_2;
   int cl_mem_1;
   int cl_mem_2;
//--- creando contexto para OpenCL (elección del aparato)
   if((cl_ctx=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE)
     {
      Print("OpenCL not found");
      return;
     }
//--- creando programa en base al código en la línea cl_src
   if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==INVALID_HANDLE)
     {
      CLContextFree(cl_ctx);
      Print("OpenCL program create failed");
      return;
     }
//--- creando kernel para el cálculo de los valores de la función de las dos 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 para el marcado de los puntos del conjunto en el plano
   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;
     }
//--- buffer OpenCL para la obtención de valores de función
   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;
     }
//--- buffer OpenCL para la obtención de los colores de los puntos
   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;
     }
//--- guardamos la hora del comienzo de los cálculos
   uint x=GetTickCount();
//--- la matriz establece los índices, desde los que comenzarán a realizarse los cálculos 
   uint offset[2]={0,0};
//--- la matriz establece los límites hasta los que se realizarán los cálculo
   uint work[2];
   work[0]=h;
   work[1]=w;
//--- cálculo de los valores de función
//--- transmitimos los valores al 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);
//--- iniciamos ejecución del kernel
   CLExecute(cl_krn_1,2,offset,work);
//--- leemos los valores obtenidos en la matriz
   CLBufferRead(cl_mem_1,values);
//--- imprimimos la hora del cálculo de los valores de función
   Print("Cálculo de los valores de función = "+IntegerToString(GetTickCount()-x)+" мс");
//--- determinamos el valor mínimo y la diferencia entre 
//--- los valores mínimos y máximos de los puntos en el conjunto
   float min,dif;
   GetMinAndDifference(values,size,min,dif);
//--- guardamos la hora del comienzo de los cálculos
   x=GetTickCount();
//--- establecemos los límites para los cálculos
   uint offset2[1]={0};
   uint work2[1];
   work2[0]=size;
//--- calcular los colores para marcar el conjunto
//--- transmitimos los valores al 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);
//--- iniciamos ejecución del kernel
   CLExecute(cl_krn_2,1,offset2,work2);
//--- leemos los valores obtenidos en la matriz
   CLBufferRead(cl_mem_2,colors);
//--- imprimimos la hora de la determinación de los colores para el marcado del conjunto
   Print("determinación de los colores para el marcado = "+IntegerToString(GetTickCount()-x)+" мс");
//--- borramos los objetos OpenCL
   CLBufferFree(cl_mem_1);
   CLBufferFree(cl_mem_2);
   CLKernelFree(cl_krn_1);
   CLKernelFree(cl_krn_2);
   CLProgramFree(cl_prg);
   CLContextFree(cl_ctx);
  }

Tras realizar el script, en la ventana del gráfico, durante varios segundos aparecerá un conjunto coloreado de valores de función. Cada uno de ellos corresponde a uno de los tonos del color seleccionado en los parámetros de entrada (rojo, verde o azul).

Resultado de la ejecución del script para el conjunto de puntos en el plano desde -22 hasta 22 con un salto de 0.1.

Además de la imagen en sí misma, en la revista "Expertos" se muestra la hora del cálculo de las funciones con cada uno de los métodos, lo que permite asegurarse de las ventajas y la polivalencia de uso de OpenCL en MQL5. Aumentamos el valor del salto y obtendremos los resultados del funcionamiento del script:

Cálculo de los valores de la función y su color de marcado con los dos métodos.

La duración total del cálculo de las funciones en la CPU con OpenCL se ha reducido en más de 5 veces, ¡y esto no es su límite, ni mucho menos! Es bien conocido que los cálculos en las tarjetas gráficas modernas que usan OpenCL se producen de manera mucho más rápida que en los procesadores. Dan buen testimonio de ello los resultados en la ejecución del script en los diferentes dispositivos con OpenCL, mostrados en el recuadro siguiente:

Como se puede ver, el uso de OpenCL en una tarjeta gráfica de AMD ha posibilitado una reducción de tiempo en los cálculos superior a 100 veces! No son menos significativos los resultados en la tarjeta GeForce GT 630 del año 2011, un poco más antigua - aquí la diferencia de tiempo es de 42 veces. Los procesadores de Intel y AMD cierran el recuadro, pero la aceleración alcanzada en ellos será muy, pero que muy útil a la hora de realizar cálculos de tareas complicadas.

Bueno, con esto el artículo llega a su fin. El recuadro de comparaciones demuestra la superioridad del uso de la computación paralela en las tareas de gestión masiva de datos. Lo único que hay que hacer es instalar el driver adecuado para su tarjeta gráfica o procesador.