Frage an #define-Experten - Seite 8

Neuer Kommentar
  
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();
  }

Trotzdem gewinnt der beste Code manchmal, aber sehr selten, d.h. der Link ist kostenlos

 
Alexandr Andreev:

) nun, so funktioniert das nicht)


So funktioniert es in C++
In mql ist es, glaube ich, das Gleiche, aber mit zusätzlichen Wrappern von MQ


Forum für Handel, automatisierte Handelssysteme und Strategietests

FAQ von Anfängern MQL5 MT5 MetaTrader 5

Roman, 2019.12.11 14:02

Sie müssen nicht darüber nachdenken, warum sollte ich... Der Compiler erledigt das ganz von selbst. ))
C# ist nicht C

Schauen Sie sich das Video über __inline an.
Dort wird erklärt, wie Funktionen im Speicher für diejenigen funktionieren, die keinen Unterschied machen.


 
Roman:

So funktioniert es in C++
In mql denke ich das Gleiche, aber mit zusätzlichen Wrappern von MQ

Nun, jetzt wieder lesen Sie diesen Thread und eine Menge von Aussagen und Test-Beispiele -, dass es einige Unterschiede. Und wir haben sie gefunden)))

 
Alexandr Andreev:

Nun, jetzt wieder lesen Sie diesen Thread und eine Reihe von Aussagen und Beispiele für Tests -, dass es einen Unterschied gibt. Und sie haben))))

Nein )) Ich habe keine Lust, es noch einmal zu lesen.
Mir ist klar, dass es da einen Unterschied gibt.

 
Roman:

Nein )) Ich habe keine Lust, es noch einmal zu lesen.
Mir ist klar, dass es da einen Unterschied gibt.

)))) eine weitere 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();}

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

Der obere Weg ist um fast 15% schneller, was sehr bedeutsam ist (wenn das alles so offensichtlich ist, erklären Sie es mir).


 
Alexandr Andreev:

)))) eine weitere IMHO

Der obere Weg ist um fast 20 % schneller, aber da alles so offensichtlich ist, erklären Sie es mir)


Die zu vergleichenden Schleifen sind hinsichtlich des Codes im Hauptteil nicht identisch.
Die erste Schleife hat einen Code im Körper, der Körper der zweiten Schleife hat einen anderen Code.
Natürlich unterschiedliche Code-Anweisungen, natürlich unterschiedliche Ausführungszeiten.
Machen Sie den gleichen Code im Schleifenkörper und ändern Sie nur die Schleifenbedingung ArraySize und die Variable size.
Wir testen diesen Teil, nicht den Körper.

 
Roman:

Die verglichenen Schleifen sind nicht derselbe Code im Körper.
Die erste Schleife hat einen Code in ihrem Körper und der Körper der zweiten Schleife hat einen anderen Code.
Natürlich sind die verschiedenen Code-Anweisungen und die Ausführungszeit unterschiedlich.
Machen Sie den gleichen Code im Schleifenkörper und ändern Sie nur die Schleifenbedingung ArraySize und die Variable size.
Wir testen diesen Teil, nicht den Körper.

Ihr Test ist nicht ganz korrekt, da er vom Startfall abhängt, führen Sie ihn erneut durch. In beiden Fällen handelt es sich um einen Inkrement und eine Division. Nun, plus es gibt ein paar zusätzliche Dutzend~ Milliarden ArraySize-Aufrufe oben.

Übrigens sollten wir in den Textkörper schreiben, was wir testen wollen. Denn es ist der Körper, der wiederholt wird. Wir versuchen, es in loop.... einzubinden, um ein Ergebnis zu erhalten d.h. es war ursprünglich notwendig,ArraySize aus dem Body aufzurufen

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

Ihr Test ist nicht ganz korrekt, da er vom Startfall abhängt, führen Sie ihn erneut durch. Hier haben beide Fälle ein Inkrement und eine Division. Nun, plus es gibt ein paar Dutzend~ Milliarden von ArraySize Aufrufen auf sie.

Übrigens sollten wir in den Textkörper schreiben, was wir testen wollen. Denn es ist der Körper, der wiederholt wird. Wir versuchen, es in loop.... einzubinden, um ein Ergebnis zu erhalten d.h. es war ursprünglich notwendig,ArraySize aus dem Body aufzurufen

Bei jeder Iteration enthält die Bedingung der Schleife bereits eine Überprüfung der Bedingung i<ArraySize() oder i<size
, d.h. bei jeder Iteration wird entweder eine Funktion oder eine Variable aufgerufen.
Warum sollten wir das zu prüfende Objekt in den Körper stecken?

Die Logik selbst veranlasst uns zu entscheiden, was schneller zu erledigen ist. Zu einer Funktion oder zu einer Variablen.
Es ist mir egal, wie der Compiler es nennt. Ich verlasse mich nicht auf den Compiler, ich benutze nur meinen gesunden Menschenverstand, um herauszufinden, was vom Standpunkt der Referenz aus gesehen schneller zu handhaben ist.

 
Roman:

Bei jeder Iteration wird in der Schleifenbedingung ohnehin die Bedingung i<ArraySize() oder i<size
geprüft, was bedeutet, dass bei jeder Iteration entweder eine Funktion oder eine Variable aufgerufen wird.
Warum sollten wir das zu prüfende Objekt in den Körper stecken?

Denn wir sind die Glücklichen, die diese Funktion haben, und die Funktion kann jede andere sein. Und es wird genau im Körper platziert. Ich habe sie nur vervielfältigt, um ihre Wirkung zu verstärken und verschiedene Arrays anzusprechen.

Es ist jedoch falsch, komplexere Aufgaben hinzuzufügen, deren Berechnungsfehler den untersuchten Effekt überschatten könnten. Übrigens ist es auch möglich, dass die Assemblierung in μl nicht konstant ist, d.h. beim erneuten Kompilieren kann man leicht unterschiedliche Daten erhalten (obwohl dies nicht exakt ist, aber es ist eine Art von Schutz gegen Hacking) So kann alles auf Ihrem Code für Sie getestet werden. Schauen Sie, ob sich die Ergebnisse ändern.

Mcl versucht einfach, den Code wie im Video gezeigt zu ersetzen. Nun, dort ist es ein wenig anders. Aber ganz allgemein gesprochen.

Und diese Anweisungen für Funktionen, die nicht wissen, welchen Wert sie erhalten werden - das ist, wie js und php und andere ähnliche Sprachen arbeiten, auch µl arbeitet auf diese Weise, aber nur im Debug-Modus

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

Bei jeder Iteration wird in der Schleifenbedingung ohnehin die Bedingung i<ArraySize() oder i<size
geprüft, was bedeutet, dass bei jeder Iteration entweder auf eine Funktion oder eine Variable zugegriffen wird.
Warum sollten wir das zu prüfende Objekt in den Körper stecken?

Die Logik selbst fordert uns auf, zu entscheiden, was schneller zu erledigen ist. Zu einer Funktion oder zu einer Variablen.
Es ist mir egal, wie der Compiler sie dort einbindet. Ich verlasse mich nicht auf den Compiler, ich verlasse mich auf meinen gesunden Menschenverstand und finde heraus, was vom Standpunkt der Referenz schneller zu handhaben ist.

Das klappt nicht immer.

Forum zum Thema Handel, automatisierte Handelssysteme und Testen von Handelsstrategien

Frage an #define-Experten

Roman, 2020.11.02 19:44

Ich habe meinen Beitrag geändert.
Es ist genau umgekehrt, d.h. ArraySize ist jetzt schneller als cnt.
Vorher war es genau umgekehrt. Vielleicht wirkt sich das Inkrement cnt-- aus, der Schleifenkörper ist anders und wahrscheinlich muss etwas anderes für die Last erfunden werden.

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
Neuer Kommentar