Errores, fallos, preguntas - página 2878

Nuevo comentario
 
Igor Makanu:

qué variante de conversión funcionará más rápido durante la optimización

Esto sólo se llamará una vez por pase. Por lo tanto, no hay ninguna diferencia.

 
fxsaber:

Esto sólo se llamará una vez para todo el pasaje. Así que no hay diferencia.

así que sí... Pero voy a ejecutarlo durante un par de días para optimizarlo, quiero medir el rendimiento de alguna manera ..... aunque sospecho que la variante 1 será más eficiente, no habrá 100500 veces de copia en arrays

 
Igor Makanu:

sí... Pero voy a hacer funcionar el ordenador durante un par de días para optimizarlo, quiero medir el rendimiento de alguna manera ..... aunque sospecho que la opción 1 será más eficiente, no habrá 100500 veces de copia a arrays

Así que la variante 2 es probablemente más rápida, pero como has señalado arriba, no importa.
 
TheXpert:
La unión no es copiar a arrays, es una interpretación diferente del mismo espacio de memoria. por lo que la segunda opción es probablemente más rápida, pero como se señaló anteriormente, no importa.
La Unión no es tan rápida como parece. Desgraciadamente.
Yo apuesto por el primero.
 
Igor Makanu:

sí... Pero voy a hacer funcionar el ordenador durante un par de días para optimizarlo, quiero medir el rendimiento de alguna manera ..... aunque sospecho que la opción 1 será más eficiente, no habrá 100500 veces de copia a arrays

hay una antigua forma de medir la velocidad

al estilo de

for (int i=0; i< 1000000; i++){nuestro código1}....
for (int i=0; i< 1000000; i++) {nuestro código2}....

 
Nikolai Semko:
La Unión no es tan rápida como parece. Apuesto por la primera.

Yo también apuesto por el primero! Los operadores binarios son varias veces más rápidos que el operador if, aunque el segundo no lo tiene.

 

revisado:

#define    SpeedTest(count_x10,msg,EX)        {ulong mss=GetMicrosecondCount(); ulong count=(ulong)pow(10,count_x10);for(ulong _i=0;_i<count&&!_StopFlag;_i++){EX;} \
                                              printf("%s: loops=%llu ms=%llu",msg,count,GetMicrosecondCount()-mss);}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   ulong sum = 0;
   SpeedTest(10, "tst 1 : ",
   {
      ushort in01A = (ushort)rand();
      ushort in01B = (ushort)rand();
      ushort in02A = (ushort)rand();
      ushort in02B = (ushort)rand();
      ushort in03A = (ushort)rand();
      ushort in03B = (ushort)rand();
      ushort in04A = (ushort)rand();
      ushort in04B = (ushort)rand();
      ushort in05A = (ushort)rand();
      ushort in05B = (ushort)rand();
      uint param[5];
      param[0] = (uint)in01A << (sizeof(ushort) * 8) | in01B;
      param[1] = (uint)in02A << (sizeof(ushort) * 8) | in02B;
      param[2] = (uint)in03A << (sizeof(ushort) * 8) | in03B;
      param[3] = (uint)in04A << (sizeof(ushort) * 8) | in04B;
      param[4] = (uint)in05A << (sizeof(ushort) * 8) | in05B;
      for(int i = 0; i < 5; i++) sum += param[i];
   });
//--   
   sum = 0;
   union ushortTouint
   {
      uint param[5];
      ushort in[10];
   }U;
   SpeedTest(10, "tst 2 : ",
   {
      ushort in00 = (ushort)rand();
      ushort in01 = (ushort)rand();
      ushort in02 = (ushort)rand();
      ushort in03 = (ushort)rand();
      ushort in04 = (ushort)rand();
      ushort in05 = (ushort)rand();
      ushort in06 = (ushort)rand();
      ushort in07 = (ushort)rand();
      ushort in08 = (ushort)rand();
      ushort in09 = (ushort)rand();
      ushortTouint u;
      u.in[0] = in00;
      u.in[1] = in01;
      u.in[2] = in02;
      u.in[3] = in03;
      u.in[4] = in04;
      u.in[5] = in05;
      u.in[6] = in06;
      u.in[7] = in07;
      u.in[8] = in08;
      u.in[9] = in09;
      for(int i = 0; i < 5; i++) sum += u.param[i];
   });

}

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : loops=10000000000 ms=10862287

la diferencia no es significativa, es muy probable que si cambiamos las pruebas en el orden inverso, los resultados sean los contrarios

no crítico

 
Igor Makanu:

no hay una diferencia significativa, es muy probable que si se intercambian las pruebas, los resultados sean los opuestos

Es muy probable que el compilador haya generado el mismo código para ambos casos. En este caso, sólo hay que elegir el que subjetivamente te guste más

 
Igor Makanu:

revisado:

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : loops=10000000000 ms=10862287

la diferencia no es significativa, es muy probable que si cambiamos las pruebas en el orden inverso, los resultados sean los contrarios

no es crítico

El script aquí demuestra que el tiempo de creación de números aleatorios puede ser no uniforme y depende del volumen de variables creadas))

Y el código que necesitamos en este número de repeticiones me lleva 0 ms.

Todavía no hay respuesta.

o el optimizador de código está recortando algo innecesario
 
Alexandr Andreev:

Parece que hay un script que demuestra que los tiempos de generación de números aleatorios pueden ser desiguales

no rand() es una función normal, siempre funciona igual

Pero al probar la velocidad, si se inicializa con constantes, las pruebas se "acelerarán" durante la ejecución - la optimización del código en MQL durante el tiempo de ejecución es buena

en general, se comprobó muchas veces

Alexandr Andreev:

y mucho depende del tamaño de las variables creadas)))

Por supuesto, la asignación de memoria consume mucho tiempo, lo he comprobado, estoy probando tanto objetos creados dinámicamente ( nuevo puntero ) como sólo objetos de ámbito local, la prueba se extiende 100500 veces por nuevo + borrado

la pregunta era, porque en el probador en el ámbito global de la memoria se asigna a las variables una vez y no cada pase - pero necesito arrays uint, así que he probado con este script, no como lo escribí la primera vez

Alexandr Andreev:

Y el código que necesitamos en este número de repeticiones me lleva 0 ms

todavía no hay respuesta

O bien el optimizador de código está cortando algo innecesario.

¿usaste mi guión? - o no has esperado al final del test y has interrumpido o has desbordado ulong - el primer parámetro de la macro es 10^ count



Andrei Trukhanovich:

es muy probable que el compilador haya generado el mismo código para ambos casos. en este caso, simplemente elige el que subjetivamente te guste más.

Sí, quizás sí

eso es lo que preguntaba - he leído muchas veces que los procesadores modernos pueden ejecutar más de una operación elemental por reloj optimizando el pipeline de instrucciones .... un montón de bla-bla-bla... y la cuestión es que las instrucciones aritméticas son ejecutadas por el procesador en un número imprevisible de ciclos de reloj

En cuanto a las operaciones de bifurcación y asignación de memoria, están muy mal optimizadas por el procesador, así que no busques la optimización en la simplificación de la aritmética, intenta escribir un código lo más lineal posible con la mínima bifurcación, y es mejor que las variables se declaren y se les asignen valores justo antes de los cálculos, eso permite que la predicción del pipeline de instrucciones y el muestreo de la caché optimicen este código


Es decir, el muestreo de los valores de los elementos de la matriz (direccionamiento) probablemente no será crucial para la velocidad - pensé que habría una ventaja de desplazamiento frente a la unión, resulta que no hay ninguna diferencia

1...287128722873287428752876287728782879288028812882288328842885...3187
Nuevo comentario