domanda per gli esperti di #define - pagina 8

Nuovo commento
  
void OnStart()
  {
   int mas[];
   int mas1[300];
   int mas2[300];
   int mas3[300];
   int mas4[300];
   int mas5[300];
   int mas6[300];
   int z=300;
   int size=100000000;
   ArrayResize(mas,size);
   ulong r=0;
   ulong r1=0;
   ulong r2=0;
   int random;
   ulong max=100; 
   int t=0;
   int tr=0; 
   MathSrand(10);
    int num_steps=ArraySize(mas);
    double x, pi, sum=0.0;
    double step = 1.0/(double)num_steps;
    
     int v=size;
    ulong t1 = GetMicrosecondCount();
     
    
  // for(ulong z=0; z<max; z++)
     {
      for(ulong i=0; i<ArraySize(mas); i++)
        { 
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2=r2/10;
        }

     }  
   ulong t2=GetMicrosecondCount();
   //for(ulong z=0; z<max; z++)
     {
      for(ulong i=0; i<v; i++)
        { 
        r1+=v;
        r1=r1/10;
        }
     }
   
   int pi2 = sum*step;
   ulong t3=GetMicrosecondCount();
   Print(t2-t1,"  ",t3-t2," ",r," ",r1," ",r2," ",pi," ",pi2);
// Templ();
  }

Anche così, il codice superiore a volte vince, ma molto raramente, cioè il link è libero

 
Alexandr Andreev:

) beh non è così che funziona)


Questo è il modo in cui funziona in C++
Penso che sia lo stesso in mql ma con dei wrapper aggiuntivi da MQ


Forum sul trading, sistemi di trading automatico e test di strategia

FAQ da principianti MQL5 MT5 MetaTrader 5

Romano, 2019.12.11 14:02

Non c'è bisogno di pensarci su, perché dovrei... Il compilatore farà tutto da solo. ))
C# non è C

Date un'occhiata al video su __inline.
Lì si spiega come funzionano le funzioni nella memoria per coloro che non fanno alcuna differenza.


 
Roman:

Questo è come funziona in C++
In mql penso che sia lo stesso, ma con dei wrapper aggiuntivi da MQ

Beh, ora rileggere questo thread e un sacco di dichiarazioni ed esempi di test - che c'è qualche differenza. E l'abbiamo trovato)))

 
Alexandr Andreev:

Bene ora rileggere questo thread e un mucchio di dichiarazioni ed esempi di test - che c'è una differenza. E hanno fatto))))

No )) Non ho alcun desiderio di rileggerlo.
Per me è ovvio che c'è una differenza.

 
Roman:

No )) Non ho alcun desiderio di rileggerlo.
Per me è ovvio che c'è una differenza.

)))) un altro IMHO.

 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   int mas[];
   int mas1[300];
   int mas2[300];
   int mas3[300];
   int mas4[300];
   int mas5[300];
   int mas6[300];
   int z=300;
   int size=1000000000;
   ArrayResize(mas,size);
   ulong r=0;
   ulong r1=0;
   ulong r2=0;
   int random;
   ulong max=100; 
   int t=0;
   int tr=0; 
   MathSrand(10);
    int num_steps=ArraySize(mas);
    double x, pi, sum=0.0;
    double step = 1.0/(double)num_steps;
    
     int v=size;
    ulong t1 = GetMicrosecondCount();
     
    
  // for(ulong z=0; z<max; z++)
     {
      for(int i=0; i<ArraySize(mas); i++)
        { 
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1);
        r2+=ArraySize(mas2);
        r2+=ArraySize(mas3);
        r2+=ArraySize(mas4);
        r2+=ArraySize(mas5);
        r2+=ArraySize(mas6);
        r2+=ArraySize(mas1); 
        r2++;
        r2=r2/100;
        }

     }  
   ulong t2=GetMicrosecondCount();
   //for(ulong z=0; z<max; z++)
   int sizem=ArraySize(mas);
     {
      for(int i=0; i<sizem; i++)
        { 
        r1++;
        r1=r1/100;
        r1++;
        
        }
     }
    
   ulong t3=GetMicrosecondCount();
   Print(t2-t1,"  ",t3-t2," ",r2," ",r1);
// Templ();
  }

//+------------------------------------------------------------------+
//|                                           
  
void Funk(ulong &a){a++;}
void FunkRand(ulong &a){a+=rand();}

//+------------------------------------------------------------------+

La via superiore è più veloce di quasi il 15% questo è molto significativo, beh se tutto è così ovvio spiegatemelo)


 
Alexandr Andreev:

)))) un altro IMHO

Il modo migliore è più veloce di quasi il 20%, beh, visto che è tutto così ovvio spiegamelo)


I cicli confrontati non sono gli stessi in termini di codice nel corpo.
Il primo ciclo ha un codice nel corpo, il corpo del secondo ciclo ha un altro codice.
Naturalmente istruzioni di codice diverse, naturalmente tempi di esecuzione diversi.
Fate lo stesso codice nel corpo del ciclo e cambiate solo la condizione del ciclo ArraySize e la variabile size.
Stiamo testando questa parte, non il corpo.

 
Roman:

I cicli che vengono confrontati non sono lo stesso codice nel corpo.
Il primo ciclo ha un codice nel suo corpo e il corpo del secondo ciclo ha un altro codice.
Naturalmente, le istruzioni del codice e il tempo di esecuzione sono diversi.
Fate lo stesso codice nel corpo del ciclo e cambiate solo la condizione del ciclo ArraySize e la variabile size.
Stiamo testando questa parte, non il corpo.

Il tuo test è più scorretto perché dipende dal caso di lancio, eseguilo di nuovo. Qui in entrambi i casi c'è un incremento e una divisione. Beh, in più ci sono un paio di decine~ miliardi di chiamate ArraySize in più.

A proposito, è nel corpo che dovremmo scrivere ciò che stiamo testando. Perché è il corpo che viene ripetuto. Stiamo cercando di avvolgerlo in loop.... per ottenere un risultato cioè in origine era necessariochiamare ArraySize dal corpo

Документация по MQL5: Операции с массивами / ArraySize
Документация по MQL5: Операции с массивами / ArraySize
  • www.mql5.com
"Нулевое измерение = Размер массива / (Первое измерение * Второе измерение * Третье измерение)"
 
Alexandr Andreev:

Il tuo test è più scorretto perché dipende dal caso di lancio, eseguilo di nuovo. Qui entrambi i casi hanno un incremento e una divisione. Beh, in più ci sono un paio di decine~ miliardi di chiamate ArraySize sopra.

A proposito, è nel corpo che dovremmo scrivere ciò che stiamo testando. Perché è il corpo che viene ripetuto. Stiamo cercando di avvolgerlo in loop.... per ottenere un risultato cioè inizialmente era necessariochiamare ArraySize dal corpo

Ad ogni iterazione, la condizione del ciclo contiene già un controllo della condizione i<ArraySize() o i<size
, cioè ad ogni iterazione viene chiamata una funzione o una variabile.
Perché dovremmo mettere l'oggetto da testare nel corpo?

La logica stessa ci spinge a decidere quale sarà più veloce da gestire. A una funzione o a una variabile.
Non mi interessa come lo chiama il compilatore. Non mi sto affidando al compilatore, sto solo usando il mio buon senso per capire cosa è più veloce da gestire dal punto di vista dei riferimenti.

 
Roman:

Ad ogni iterazione, nella condizione del ciclo, la condizione i<ArraySize() o i<size
è comunque controllata, il che significa che ad ogni iterazione si accede ad una funzione o ad una variabile.
Perché dovremmo mettere l'oggetto da testare nel corpo?

Perché noi siamo i fortunati che hanno questa funzione e la funzione può essere qualsiasi altra. Ed è collocato esattamente nel corpo. L'ho solo duplicato nel tentativo di migliorarne l'effetto rivolgendosi a diverse matrici.

Ma è sbagliato aggiungere compiti più complicati, il cui errore di calcolo può mettere in ombra l'effetto studiato. Tra l'altro è anche possibile che l'assemblaggio non sia costante in μl. cioè quando si ricompila può ottenere dati leggermente diversi (anche se questo non è esatto, ma è un po' usato come protezione contro l'hacking) Quindi tutto può essere testato sul tuo codice per te. Vedi se i risultati cambiano.

Mcl cerca semplicemente di sostituire il codice come indicato nel video. Beh, lì è un po' diverso. Ma in termini generali.

E quelle istruzioni di funzioni che non sanno quale valore otterranno - questo è il modo in cui lavorano js e php e altri linguaggi simili, anche µl funziona così ma solo in modalità debug

Документация по MQL5: Константы, перечисления и структуры / Состояние окружения / Информация о запущенной MQL5-программе
Документация по MQL5: Константы, перечисления и структуры / Состояние окружения / Информация о запущенной MQL5-программе
  • www.mql5.com
Информация о запущенной MQL5-программе - Состояние окружения - Константы, перечисления и структуры - Справочник MQL5 - Справочник по языку алгоритмического/автоматического трейдинга для MetaTrader 5
 
Roman:

Ad ogni iterazione, nella condizione del ciclo, la condizione i<ArraySize() o i<size
è comunque controllata, il che significa che ad ogni iterazione si accede ad una funzione o ad una variabile.
Perché dovremmo mettere l'oggetto da testare nel corpo?

La logica stessa ci spinge a decidere quale sarà più veloce da gestire. A una funzione o a una variabile.
Non mi interessa come lo chiama il compilatore. Non mi affido al compilatore, mi affido al buon senso e capisco cosa è più veloce da gestire dal punto di vista dei riferimenti.

Non funziona sempre.

Forum sul trading, sistemi di trading automatico e test di strategie di trading

Domanda per gli esperti di #define

Romano, 2020.11.02 19:44

Ho cambiato il mio post.
È il contrario, cioè ArraySize è più veloce di cnt.
Prima era viceversa. Forse l'incremento cnt influisce, il corpo del ciclo è diverso e probabilmente bisogna inventare qualcos'altro per il carico.

void OnStart()
{
   int arr[];
   int sz = ArrayResize(arr, 100000000);  
   
   ulong t = GetMicrosecondCount();
   
   for(int i=0; i < ArraySize(arr); i++) 
   {
      ArrayResize(arr, sz--); //какая то нагрузка
   }   
   
   t = GetMicrosecondCount() - t;
   
   PrintFormat("Total time: %.3f ms", t / 1000.0);
}
2020.11.02 21:33:22.863 TestScript (USDJPY,M1)  Total time: 451.200 ms


void OnStart()
{
   int arr[];
   int sz = ArrayResize(arr, 100000000);  
   int cnt = ArraySize(arr);
   
   ulong t = GetMicrosecondCount();
   
   for(int i=0; i < cnt; i++) 
   {
      ArrayResize(arr, sz--);
      cnt--;
   }
      
   t = GetMicrosecondCount() - t;
   
   PrintFormat("Total time: %.3f ms", t / 1000.0);
}
2020.11.02 21:56:26.591 TestScript (USDJPY,M1)  Total time: 531.872 ms

123456789101112
Nuovo commento
Motivazione: