La batalla por la velocidad: QLUA vs MQL5 - ¿Por qué MQL5 es de 50 a 600 veces más rápido?

19 septiembre 2019, 13:05
MetaQuotes
0
749

Para comparar los lenguajes MQL5 y QLUA, hemos diseñado varias pruebas que miden la velocidad de ejecución de las operaciones básicas. En dichos tests, hemos utilizado una computadora con Windows 7 Professional 64 bit, MetaTrader 5 build 1340 y QUIK de versión 7.2.0.45.

Los resultados se muestran en un recuadro, donde los valores se representan en milisegundos (cuanto menor sea el tiempo, mejor será el resultado)

#
Nombre del script de prueba
MQL5, ms
 QLUA, ms
Ventaja de MQL5
1
 TestFloat 3 969 273 391 69 veces
2
 TestArrays 375 230 768 615 veces
3
 TestFibo 1 125 61 110 55 veces
4
 TestPiCalculated 2 328
183 812
 79 veces
5
 TestQuickSort 2 031
211 279
104 veces
 6  TestAckermann  828  64 541  78 veces

Las comparaciones muestran que MQL5 es de 50 a 600 veces más rápido que QLUA en las operaciones básicas de cualquier lenguaje de programación. Esto se logra gracias a que MQL5 es un lenguaje compilable rigurosamente tipado en 32/64 bits, en oposición a la interpretación dinámica de QLUA.

¿Y qué es lo que ofrece al tráder? La posibilidad de calcular a una velocidad máxima enormes matrices de datos (en MetaTrader 5 son prácticamente ilimitadas) y tomar decisiones a una mayor velocidad.

Y esto solo se refiere a la funcionalidad básica. Pero, tras las fachadas de los lenguajes, se ocultan sus API. Y no todos las tienen sencillas. Al tratarse de un lenguaje aplicado para una plataforma comercial, MQL5 contiene cientos de funciones especializadas de acceso/procesamiento de información de mercado e interacción con todos los componentes del terminal.

Lo importante es que MQL5 no se subordina al sistema existente, sino que constituye por sí mismo un eslabón principal de la plataforma. Todos los procesos en el terminal comercial se construyen para satisfacer las necesidades de los desarrolladores de robots comerciales. Esto proporciona una velocidad de acceso máxima a los datos internos de la plataforma, así como un canal para las operaciones comerciales.


TestFloat - Velocidad de ejecución de operaciones con números reales

Código en MQL5

//+------------------------------------------------------------------+
//|                                                    TestFloat.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//---
#define MAX_SIZE 35000
//---
double f0=0;
double f1=123.456789;
double f2=98765.12345678998765432;
double f3=12345678943.98;
//---
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
int OnStart()
  {
   uint tick_count,res;
//--- test
   tick_count=GetTickCount();
   TestFloat();
   res=GetTickCount()-tick_count;
   Print("Test float time=",res," ms");
   Print("Result=",f0);
//--- retorna el tiempo invertido en la ejecución del test, en milisegundos
   return((int)res);
  }
//+------------------------------------------------------------------+
//| Función de simulación                                            |
//+------------------------------------------------------------------+
void TestFloat()
  {
   for(int i=0;i<MAX_SIZE;i++)
      for(int j=0;j<MAX_SIZE;j++)
        {
         f0=f0+(f1/(i+1))-f2+(f3*i);
        }
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestFloat
f0=0.0  
f1=123.456789
f2=98765.12345678998765432
f3=12345678943.98
MAX_SIZE=35000
function Start()
   local t=os.clock()
   TestFloat()
   local res=(os.clock()-t)*1000
   -- introducimos aquí los resultados de la ejecución
   check=f0
   message("TestFloat time=" ..res.." ms\n  check="..tostring(check));
end

function TestFloat()
    -- iteramos en el ciclo hasta un valor 1 unidad menor que MAX_SIZE
        MAX_SIZE=MAX_SIZE-1
        for i=0, MAX_SIZE do
        for j=0, MAX_SIZE do
            f0=f0+(f1/(i+1))-f2+(f3*i);
        end
    end
end
-- iniciamos el script
Start()

TestArrays - Simulación del tiempo de acceso a los elementos de la matriz

Código en MQL5

//+------------------------------------------------------------------+
//|                                                   TestArrays.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//---
#define MAX_SIZE 32000
//---
int x[MAX_SIZE],y[MAX_SIZE];
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
int OnStart()
  {
   int  i,k;
   uint tick_count,res;
//--- test
   tick_count=GetTickCount();
   for(i=0;i<MAX_SIZE;i++)
      x[i]=i+1;

   for(k=0;k<MAX_SIZE;k++)
      for(i=MAX_SIZE-1; i>=0; i--)
         y[i]+=x[i];
   long check=0;
   for(i=0;i<MAX_SIZE;i++)
     {
      check+=y[i];
     }          
   res=GetTickCount()-tick_count;
   Print("TestArrays time=",res," ms");
      Print("check=",check);
//--- retorna el tiempo invertido en la ejecución del test, en milisegundos
   return((int)res);
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestArrays
function Start()
        MAX_SIZE=32000
    x={}
    y={}
    local start=os.clock()
    for i=1,MAX_SIZE,1 do
      x[i]=i
      y[i]=0
    end  
    y[MAX_SIZE]=0
    for k=1,MAX_SIZE,1 do
        for i=MAX_SIZE, 1,-1 do         
            y[i]=y[i]+x[i]
        end
    end
    local res=(os.clock()-start)*1000
    -- número de control
    local check=0
    for k=1,MAX_SIZE,1 do
        check=check+y[k]
    end
    message("Time = "..res.." ms\n  check=".. check)
end
-- iniciamos el script
Start()


TestFibo - cálculo de la secuencia de la serie de Fibonacci

Código en MQL5

//+------------------------------------------------------------------+
//|                                                     TestFibo.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//---
#define MAX_SIZE 40
long fib[MAX_SIZE];
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   int  i;
   uint res;
//--- test
   res=GetTickCount();
   for(i=0;i<MAX_SIZE;i++)
      fib[i]=TestFibo(i);
   res=GetTickCount()-res;
   Print("TestFibo time=",res," ms");
   Print("Fibo[39]=",fib[39]);
  }
//+------------------------------------------------------------------+
//| Función de simulación                                            |
//+------------------------------------------------------------------+
long TestFibo(long n)
  {
   if(n<2) return(1);
//---
   return(TestFibo(n-2)+TestFibo(n-1));
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestFibo
MAX_SIZE=40
fib={}
function Start()
   start=os.clock()
   for i=0,MAX_SIZE-1 do
     fib[i]=TestFibo(i)
   end
   res=(os.clock()-start)*1000
   message("TestFibo time="..res.." ms\n Fibo[39]="..fib[39])
end

function TestFibo(n)
   if n<2 then
      return(1)
   else
      return(TestFibo(n-2)+TestFibo(n-1))
   end
end
-- iniciamos el script
Start()



TestPiCalculated -  Cálculo de 22 000 dígitos del número Pi

Código en MQL5

//+------------------------------------------------------------------+
//|                                             TestPiCalculated.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//---
#define MAX_SIZE 22000
//--- en esta línea ubicamos el valor del número PI
string str;
int    a[(MAX_SIZE/4+1)*14];
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
int OnStart()
  {
   uint tick_count,res;
//--- test
   tick_count=GetTickCount();
   PiCalculate(MAX_SIZE);
   res=GetTickCount()-tick_count;
   Print("TestPiCalculated time=",res," ms");
   Print("Pi=",StringSubstr(str,0,16));
//--- retorna el tiempo invertido en la ejecución del test, en milisegundos
   return((int)res);
  }
//+------------------------------------------------------------------+
//| Función de simulación                                            |
//+------------------------------------------------------------------+
void PiCalculate(const int digits)
  {
   int d = 0,e,b,g,r;
   int c = (digits/4+1)*14;
   int f = 10000;
//---
   for(int i=0;i<c;i++)
      a[i]=20000000;
//---
   while((b=c-=14)>0)
     {
      d=e=d%f;
      while(--b>0)
        {
         d = d * b + a[b];
         g = (b << 1) - 1;
         a[b]=(d%g)*f;
         d/=g;
        }
      r=e+d/f;
      if(r<1000)
        {
         if(r>99)
            str+="0";
         else
           {
            if(r>9)
               str+="00";
            else
               str+="000";
           }
        }
      str+=IntegerToString(r);
     }
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestPiCalculated
-- cuántos dígitos del número Pi vamos a calcular
MAX_SIZE=22000
-- en esta línea ubicamos el valor del número PI
str=""
a={}
function OnStart()
        start=os.clock()
        PiCalculate(MAX_SIZE)
        -- tiempo de cálculo del número Pi en milisegundos
        res=(os.clock()-start)*1000
        message("TestPiCalculated time=" .. res .." ms\n\n Pi="..string.sub(str,1,16)) -- mostramos 16 dígitos
end
function PiCalculate(digits)
        d = 0
        c = (math.floor(digits/4)+1)*14  -- math.floor() -división entera basada en el ejemplo de la guía LUA
        f = 10000

        for i=0,c do
                a[i]=20000000
        end
        c=c-14
        b=c
        while b>0 do
                e=d%f
                d=e
                while b-1>0 do
                        b=b-1
                        d = d * b + a[b]
                        g = (b * 2) - 1
                        a[b]=(d%g)*f  
            d=math.floor(d/g)  -- math.floor(d/g) -división entera basada en el ejemplo de la guía LUA
        end
        r=e+math.floor(d/f)  -- math.floor(d/f) - división entera basada en el ejemplo de la guía LUA
                if r<1000 then
                        if(r>99) then 
                                str=str .. "0"
                        else
                                if(r > 9) then
                                        str=str .. "00"
                                else
                                        str=str .. "000"
                                end
                        end
                end
                str=str .. string.format("%d",r)
                c=c-14
                b=c
        end
end
-- iniciamos el script
OnStart()


Simulación del tiempo de clasificación rápida de la matriz

Código en MQL5

//+------------------------------------------------------------------+
//|                                                TestQuickSort.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//--- clasificaremos una matriz con un tamaño de 16 millones de elementos
#define MAX_SIZE 16000000
//---
int array[MAX_SIZE];
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   uint tick_count,res;
   for(int i=0;i<MAX_SIZE;i++)
      array[i]=i%100;
   tick_count=GetTickCount();
   QuickSort(array,0,MAX_SIZE-1);
   res=GetTickCount()-tick_count;
   Print("TestQuickSort time=",res," ms");

   for(int i=1;i<MAX_SIZE;i++)
      if(array[i]<array[i-1])
        {
        Print("Array not sorted");
        break;
        }
  }
//+------------------------------------------------------------------+
//| Función de clasificación rápida                                  |
//+------------------------------------------------------------------+
void QuickSort(int &arr[],int left,int right)
  {
   int i=left;
   int j=right;
   int center=arr[(i+j)/2];
   int x;
//---
   while(i<=j)
     {
      while(arr[i]<center && i<right) i++;
      while(arr[j]>center && j>left) j--;
      if(i<=j)
        {
         x=arr[i];
         arr[i]=arr[j];
         arr[j]=x;
         i++;
         j--;
        }
     }
   if(left<j) QuickSort(arr,left,j);
   if(right>i) QuickSort(arr,i,right);
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestQuickSort
-- clasificaremos una matriz con un tamaño de 16 millones de elementos
MAX_SIZE=16000000
array={}
function Start()
    for i=0,MAX_SIZE-1 do
        array[i]=i%100
    end
    start=os.clock()
    QuickSort(array,0,MAX_SIZE-1)
    res=(os.clock()-t)*1000
    message("TestQuickSort time=" .. res .. " ms")
    for i=1,MAX_SIZE-1 do
        if array[i]<array[i-1] then
            message("Array not sorted");
            break;
        end
    end
end

function QuickSort(arr,left,right)
    i=left
    j=right
    center=arr[math.floor((i+j)/2)]
    while i<=j do
        while(arr[i]<center and i<right) do
            i=i+1
        end
        while(arr[j]>center and j>left) do
            j=j-1
        end
        if i<=j then
            x=arr[i]
            arr[i]=arr[j]
            arr[j]=x
            i=i+1
            j=j-1
        end
    end
    if left<j then 
        QuickSort(arr,left,j)
    end
    if right>i then 
        QuickSort(arr,i,right)
    end
end
-- iniciamos el script
Start()


TestAckermann - simulación de la recursión en las funciones

Código en MQL5

//+------------------------------------------------------------------+
//|                                                TestAckermann.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2016, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
//--- número de pasadas en la función de Ackermann en el ciclo
#define MAX_SIZE 120000
//+------------------------------------------------------------------+
//| Función OnStart                                                  |
//+------------------------------------------------------------------+
void  OnStart()
  {
//--- número de control
   uint check=0;
//--- tiempo de ejecución en milisegundos
   uint res=0;
//--- test
   res=GetTickCount();
   for(int i=0;i<MAX_SIZE;i++)
      check+=Ackermann(1+i%3,1+i%5);
   res=GetTickCount()-res;
   Print("TestAckermann time=",res," ms");
   Print("check=",check);
//---
  }
//+------------------------------------------------------------------+
//| Función de simulación                                            |
//+------------------------------------------------------------------+
int Ackermann(int m,int n)
  {
   if(m==0) return(n+1);
   if(n==0) return(Ackermann(m-1,1));
//---
   return(Ackermann(m-1,Ackermann(m,(n-1))));
  }
//+------------------------------------------------------------------+

Código en LUA

-- TestAckermann
MAX_SIZE=120000
function Start()        
    local check=0 -- número de control
    local start=os.clock()
        for i=1,MAX_SIZE do
             check=check+Ackermann(1+i%3,1+i%5);                                                
        end 
    local finish=os.clock()
    local time=(finish-start)*1000
    message("TestAckermann time=".. time.." ms\n\n check="..check)
end

function Ackermann(m,n)
        if(m==0) then return(n+1) end
        if(n==0) then return(Ackermann(m-1,1)) end
        return(Ackermann(m-1,Ackermann(m,(n-1))))
end
-- iniciamos el script
Start()



Podrá descargar el directorio completo de scripts y comprobar los resultados por sí mismo.

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/4310

Archivos adjuntos |
TestAckermann.mq5 (1.47 KB)
TestArrays.mq5 (2.63 KB)
TestFloat.mq5 (1.53 KB)
TestQuickSort.mq5 (1.89 KB)
Scripts.zip (7.29 KB)
Estudio de las figuras técnicas de Merrill Estudio de las figuras técnicas de Merrill

En el presente artículo, vamos a analizar el modelo de las figuras técnicas de Merrill, e intentaremos averiguar hasta qué punto estos patrones técnicos son útiles hoy en día. Para este propósito, crearemos una herramienta para testearlos y aplicaremos este modelo a diferentes tipos de datos, a saber: precio de cierre, sus máximos y mínimos, indicadores del tipo oscilatorio.

Gestión de la optimización (Parte 2): Creando los objetos clave y la lógica de la aplicación Gestión de la optimización (Parte 2): Creando los objetos clave y la lógica de la aplicación

Es la continuación del artículo anterior que describe la creación de la interfaz gráfica para gestionar la optimización. Aquí, vamos a considerar la lógica del funcionamiento de la extensión creada. Vamos a crear un envoltorio para el terminal MetaTrader 5 con el fin de iniciarlo como un proceso controlado usando C#. Además, vamos a analizar el trabajo con los archivos de configuración y archivos de los ajustes. La lógica del programa será dividida en dos partes: en la primera estarán descritos los métodos que se invocan después de pulsar algún botón, la segunda parte se encargará del inicio y de la gestión de la optimización.

Arrancando el beneficio hasta el último pips Arrancando el beneficio hasta el último pips

En el presente artículo, he intentado combinar la teoría con la práctica en el campo de la negociación algorítmica. La mayoría de las discusiones sobre la creación de Sistemas Comerciales está asociada al uso de las barras históricas de precio y varios indicadores aplicados a ellas. Es un tema tan discutido que no vamos a tocarlo. Las barras representan una entidad completamente artificial, por tanto, usaremos algo más próximo a la protoinformación— los ticks.

Biblioteca para el desarrollo rápido y sencillo de programas para MetaTrader (Parte XIV): El objeto "Símbolo" Biblioteca para el desarrollo rápido y sencillo de programas para MetaTrader (Parte XIV): El objeto "Símbolo"

En este artículo vamos a crear un objeto de símbolo que será el objeto básico para crear la colección de símbolos. Con su ayuda, podremos obtener los datos de los símbolos necesarios para su posterior análisis y comparación.