Fehler, Irrtümer, Fragen - Seite 1573

[Alexey Navoykov]

Anton Zverev:

Ein 100Kb-Quellcode-Projekt wird in weniger als einer Sekunde auf 1325 build kompiliert. Solides OOP, viele virtuelle Funktionen und Überladungen, Templates, Zeiger, Const-Modifier (wo immer möglich). Keine DLL und OpenCL.

Ich würde gerne den Grund für Ihre Verzögerungen herausfinden. Vielleicht ist es eine Konstante, die dem Compiler hilft, schnell zu optimieren. Ich habe noch nie Verzögerungen erlebt. Bitte stellen Sie mir den Quellcode von kodobase zur Verfügung, der das System verlangsamt.

Nun, 100 Kb sind zu viel, nicht wahr? Ich habe fast 1 Mbyte. Alles, was Sie haben, ist hier vorhanden, plus eine Menge Makros. Außer dass const nicht überall gesetzt ist, aber das ist kein Grund für solche verrückten Lags, zumal in Build 1159 alles fast sofort kompiliert wurde.

Ich kann nicht in Build 1325 testen, weil das Projekt überhaupt nicht kompiliert und eine ganze Reihe von Fehlern auftaucht, und das alles abends. Genosse A100 hat auch eine ganze Reihe von Fehlern im neuen Build gemeldet. Ich habe keine Lust, meine Zeit mit dem Herumstochern in diesen Fehlern zu verschwenden, ich werde warten, bis sie den funktionierenden Build veröffentlichen.

Deshalb habe ich Ihnen von den Verzögerungen bei Build 1241 erzählt. Wenn Sie die Möglichkeit haben, es zu testen, versuchen Sie, es mit dem neuesten Build zu vergleichen. Aber ich bezweifle, dass das neue Build die Geschwindigkeit deutlich erhöhen kann. Ganz im Gegenteil, den MT-Entwicklern ist die Kompiliergeschwindigkeit völlig egal, sie wollen nur zusätzliche Nanosekunden aus der Laufzeit herausquetschen, um Marketingaussagen zu machen, dass die Geschwindigkeit von MQL-Programmen mit der von C++ vergleichbar ist (allerdings nur bei einigen abstrakten Beispielen).Soweit ich weiß, geht es ihnen nicht um die Effizienz der Optimierung, d. h. darum, ob das Spiel die Kosten wert ist.

Ich werde versuchen, in der Codebasis nach Quellcode zu suchen, aber nicht unbedingt, dass ich ein ähnliches Projekt finde. Es muss ein großes Projekt sein, während dort meist kleine Projekte offen zugänglich sind.

[Alexey Navoykov]

Renat Fatkhullin:

Er hat wahrscheinlich riesige Funktionen in Form von Textspulen.

Der Optimierer muss solche Codefragmente in vielen Durchgängen immer wieder verbessern. Es genügt, die Größe der Funktionen zu reduzieren, damit der Optimierer die Geschwindigkeit drastisch erhöhen kann.

Nun, Sie müssen auf die neuesten Builds umsteigen, da wir sowohl die Qualität als auch die Geschwindigkeit der Builds ständig verbessern.

Keine riesigen Funktionen. Höchstens 150 Zeilen (oder gilt das als gigantisch?). Und wenn man so darüber nachdenkt, was hat die Größe einer Funktion damit zu tun, dass der Compiler einen Haufen kleiner Funktionen ausprobiert? Angenommen, er geht die große Funktion 10 Mal durch.Also zerlege ich sie in 5 kleine Funktionen und gehe jede davon 2 mal durch. Wir erhalten das gleiche Ergebnis. Also ist die gesamte Codemenge wichtig, richtig? Aber selbst wenn das Ergebnis ein wenig schneller wird, wenn man große Funktionen zerlegt, was soll's? Wir reden hier über eine 10 (!) mal langsamere Kompilierung.

Es ist klar, dass Sie die Ausführung des Programms so weit wie möglich beschleunigen wollen, also machen Sie viele Durchläufe, um etwas zu verbessern. Und je komplizierter Sie die Sprache machen, desto länger werden diese Durchläufe sein, was die Zeit des Programmierers verbraucht. Und natürlich stellt sich die Frage nach der Effizienz all dessen: Um wie viel schneller wird das Programm durch Ihre Optimierung im Vergleich zur Leerlaufzeit des Programmierers, der auf den Abschluss der Optimierung wartet?

Natürlich kann man versuchen, einige Kompromisse zu finden, aber es ist viel effizienter, verschiedene Kompiliermodi zu erstellen, wie ich oben geschrieben habe. Die Programmversion mit all den Optimierungen wird erst ganz am Ende benötigt - 99% der Zeit der Programmierer wird mit dem Schreiben und Debuggen des Codes verbracht, wenn sie Ihre Optimierungen überhaupt nicht brauchen.

[Vasiliy Sokolov]

Alexey Navoykov:

Wie lange wird es noch dauern, dass nach jedem Build-Update die Codes nicht mehr kompiliert werden! Und wenn sie doch kompiliert werden, funktionieren sie nicht mehr so wie vorher (was noch schlimmer ist). Wer braucht schon eine solche Programmiersprache?

...

Ich weiß nicht, was Sie meinen. Ich habe mehrere sehr komplexe Projekte in MQL mit mehr als 20 000 000 Codezeilen. Die neuen Builds können im Handumdrehen erstellt werden. Während der gesamten Zeit gab es nur zwei Probleme. Einmal wegen meines Fehlers und das andere Mal wegen eines Fehlers des Entwicklers.

[Vasiliy Sokolov]

Alexey Navoykov:

Maximal 150 Zeilen

Dies ist eine sehr große und falsche Funktion.

[Alexey Navoykov]

Vasiliy Sokolov:
Ich weiß nicht, was Sie meinen. Ich habe mehrere sehr komplexe Projekte in MQL mit einem Codeumfang von über 20 000 000 Zeilen. Die neuen Builds werden im Handumdrehen erstellt. Während der gesamten Zeit gab es nur zwei Probleme. Einmal wegen meines Fehlers und das andere Mal wegen eines Fehlers des Entwicklers.

Nun, dann haben Sie Glück. Ihr Code enthält keines der Konstrukte, die in meinem Code vorkommen. Was ist daran so seltsam?

Blättern Sie ein paar Seiten weiter und Sie werden feststellen, dass er auch in der neuen Version viele Fehler gefunden hat, von denen einige schwer zu finden sind. Glauben Sie, dass er absichtlich danach gesucht hat?

[Renat Fatkhullin]

Alexey Navoykov:

Nun, dann haben Sie Glück. Ihr Code enthält keines der Konstrukte, die in meinem Code vorkommen. Was ist daran so seltsam?

Blättern Sie ein paar Seiten weiter oben, der Mann dort hat auch eine Reihe von Fehlern in der neuen Version gefunden, von denen einige schwer zu finden sind. Glauben Sie, dass er absichtlich nach ihnen gesucht hat?

Zeigen Sie bitte ein Beispiel für eine wiederholbare Bremse.

Leider haben Sie bisher nur unbegründete Behauptungen aufgestellt, einschließlich direkter Angriffe auf die Entwickler.

Sie liegen falsch, was den Umfang der Funktionen und den Gesamtumfang des Programms angeht. Die Größe der einzelnen Funktionen wirkt sich direkt und nichtlinear auf die Optimierung jeder einzelnen Funktion aus, sowohl durch die Vergrößerung des Syntaxbaums als auch durch die Optimierung in mehreren Durchgängen. Kleinere Funktionen werden im laufenden Betrieb optimiert.

[Vasiliy Sokolov]

Alexey Navoykov:

Nun, dann haben Sie Glück. Ihr Code enthält keines der Konstrukte, die in meinem Code vorkommen. Was ist daran so seltsam?

Blättern Sie durch die Seiten oben, der Mann dort hat auch eine Reihe von Fehlern in der neuen Version entdeckt, von denen einige schwer zu finden sind. Glauben Sie, dass er absichtlich danach gesucht hat?

1) Ich frage mich, welche Konstrukte Sie verwendet haben, die in meinem Code nicht enthalten sind. Der Umfang meines Codes beträgt mehrere tausend Zeilen, und Ihre Konstrukte existieren nicht? Es muss doch etwas Einzigartiges sein?

2) Tatsächlich gab es einen internen Compiler-Fehler im vorherigen Build, der auftritt, wenn Klassen miteinander verknüpft werden. Es war ein Fehler der Entwickler, aber sie haben ihn behoben. Ich kann mich an keine anderen Fehler erinnern.

[A100]

Vasiliy Sokolov:

2) Der vorherige Build hatte tatsächlich einen internen Compilerfehler, der auftritt, wenn Klassen miteinander verknüpft werden. Dies ist ein Fehler im Entwicklungsteam, der aber behoben wurde. Ich kann mich an keine anderen Fehler erinnern.

https://www.mql5.com/ru/forum/1111/page1591#comment_2463820

Und wo bleibt die gegenseitige Verknüpfung der Klassen untereinander?

Ich habe es hier noch weiter vereinfacht, um Ihnen die Suche nach gegenseitigen Verweisen zu erleichtern und zu verstehen, welche Konstrukte Sie nicht verwenden

[Vasiliy Sokolov]

A100:

https://www.mql5.com/ru/forum/1111/page1591#comment_2463820

Und wo ist hier der gegenseitige Bezug der Klassen zueinander?

Hier noch weiter vereinfacht, um Ihnen die Suche nach wechselseitigen Verweisen zu erleichtern und zu verstehen, welche Konstrukte Sie nicht verwenden

Sie betreiben Reverse-Engineering. Die Arbeit ist nützlich, um den Compiler zu verbessern, aber in Bezug auf die praktische Programmierung ist nicht anwendbar. Ich kenne keinen einzigen Programmierer, der den von Ihnen zitierten Code in der Praxis verwenden würde:

//+------------------------------------------------------------------+
//|                                                      Test116.mq5 |
//|                                                                  |
//+------------------------------------------------------------------+
bool is( const string type, bool )
{
        return ( type == "1" || type == "2" || type == "3" || type == NULL );
}
bool _is( string type ) { return is( type, false ); }
//+------------------------------------------------------------------+
template<typename T>
bool __is( T ) { return _is( typename( T )); }
//+------------------------------------------------------------------+
#define  IS( T )         __is( T(0))
//+------------------------------------------------------------------+
template<typename T>
int sh( T t )
{
        T tt = 0x1;
        for ( int i = 0; i < 4; i++, tt <<= 1 )
                if ( (t & tt) == tt )
                        return i;
        return -1;
}
//+------------------------------------------------------------------+
class D { public:
template<typename T1, typename T2>                                     
                        T2                              g( T1 t1, T2, int sh = -1 ); 
};                                                                     
template<typename T1, typename T2>                                     
T2 D::g( T1 t1, T2, int sh )
{                                                                      
        sh = sh( t1 );                                   
        T2 t2 = T2(t1) >> 1;
        return (sh( t1 ) & sh) == sh( t1 ) && IS( T2 ) ? 1 : 0;
}                                                                      
//+------------------------------------------------------------------+
class M : public D {
        virtual void f1() { g( 0, 0 ); }
};
//+------------------------------------------------------------------+
class A {};
void g( A* ) export {}
class B { public:
        void h() { A a; g( &a ); }
};
class C { public:
        void f() {}
};
void OnStart()
{
        C c;
        c.f();
}
//+------------------------------------------------------------------+

[Alexey Navoykov]

Renat Fatkhullin:

Zeigen Sie bitte ein Beispiel für eine reproduzierbare Bremse.

Leider haben Sie bisher nur unbegründete Behauptungen aufgestellt, einschließlich direkter Angriffe auf die Entwickler...

Ich habe Ihnen gesagt, dass dies ein großes Projekt ist, die Gesamtgröße des gesamten Quellcodes beträgt etwa 1 Mb. Wie können Sie die Bremsen demonstrieren? Senden Sie den gesamten Code oder was? Sie verstehen, dass dies unmöglich ist. Und Kompilierung von einzelnen Stücken, natürlich geht viel schneller.

Und was meinen Sie mit "unbewiesenen Behauptungen"? Dass Ihr optimierender Compiler viel langsamer ist? Und dass Sie sich nicht viel darum scheren? Was ist hier unbewiesen?

Hier ist ein Link zu einer Diskussion vom Oktober letzten Jahres, als Sie gerade diese globale Optimierung eingeführt haben: https://www.mql5.com/ru/forum/1111/page1424#comment_1981722

Der Mann schreibt:

Ein anderer Code - beachten Sie die Zeit - er muss um den Faktor 20 gestiegen sein

Und dann antworten Sie:

Dies ist ein neuer optimierender Compiler für MQL5 (er ist in MQL4 nicht vorhanden).

Sie müssen für besseren Zielcode mit längerer Kompilierungszeit bezahlen.

Und dann gibt es noch einige andere Leute, mich eingeschlossen, die sich ebenfalls über die langsame Kompilierung beschwert haben. Aber Ihre Antworten scheinen darauf hinzudeuten, dass Sie sich nur für "bessere Qualität des Zielcodes" und einen mythischen "2- bis 10-fachen Geschwindigkeitsschub" interessieren, obwohl ich solche Geschwindigkeitsschübe in echten Arbeitsprojekten nicht gesehen habe.

Wie ich oben sagte, konnte ich es nicht mit dem neuesten Build (vom 22. April) testen, da ich einige Fehler beim Kompilieren hatte. Aber ich nehme an, dass die Kompiliergeschwindigkeit dort gleich langsam ist, da Sie nie eine Beschleunigung des Compilers im neuen Build angekündigt haben.