Hier sehen Sie, was Sie mit OpenCL direkt in MetaTrader 5 ohne DLLs machen können - Seite 5

Neuer Kommentar
 
Renat Fatkhullin:

Vor diesem Hintergrund scheint AMD nicht nur wegen der offensichtlich schnelleren mathematischen Berechnungen im Vorteil zu sein (Mining-Farmen werden in der Regel auf AMD aufgebaut), sondern auch wegen seiner Strategie der offenen Standards (sie haben sich geöffnet und werben viel für die Öffentlichkeit). Die Einführung von OpenCL 2.0 in AMD-Karten hat diese Spezifikation sehr nahe an die CUDA-Fähigkeiten herangebracht, so dass es keinen Grund mehr gibt, die Grundlagen für CUDA zu schaffen.

Das sind nützliche Informationen, während ich vor etwa 7 Jahren mit CUDA herumspielte und dachte, dass es immer noch das Spiel beherrscht.

Meine Frage ist: Wie sieht es heutzutage mit OpenCL-Debuggern aus? Ich beziehe mich nicht auf das MT5-Terminal, sondern auf das MT5-Terminal im Allgemeinen. Bisher habe ich nur einen Debugger von Intel als Plugin für Visual Studio und einen eigenständigen Debugger (depricated) von der gleichen Firma gesehen. Aber es scheint, dass Intels Prozessoren und eingebettete Grafiken für diesen Zweck bestimmt sind. Ich verstehe nicht gut, wie man parallelen Code überhaupt debuggen kann - für mich ist es bisher nur eine Blackbox.

 

Sie können mit CUDA nur für sich selbst oder für bestimmte Bereiche arbeiten, in denen Sie die ausdrückliche Anwesenheit von Nvidia-Karten verlangen können.

Ja, CUDA hatte früher mehr Funktionen. Mit der AMD-Hardware, die mit OpenCL 2.0 und der neuen Version von OpenCL 2.1 auf den Markt kommt, gibt es jedoch keinen Grund mehr, sich an einen Hersteller zu binden. Vor allem dann, wenn dieser Anbieter auch noch die Funktionalität unterschlägt.

Was die maximale Abdeckung angeht, gibt es nur eine Wahl - OpenCL, das auch auf normalen Prozessoren gut funktioniert. Das heißt, Sie müssen nicht die unbedingte Anwesenheit der GPU verlangen oder zwei Versionen von Code für die GPU und die CPU schreiben. Einmal geschrieben, funktioniert der OpenCL-Code auf verschiedenen Konfigurationen.

CUDA/OpenCL kann nur in speziellen Debuggern debuggt werden. Hier kann es kein Wunder geben.

 
Renat Fatkhullin:

im Beispiel

if((cl_ctx=CLContextCreate())==INVALID_HANDLE)

Bei Konfigurationen mit einem CPU-verfügbaren Gerät wird "OpenCL nicht gefunden" angezeigt.

Ansonsten.

if((cl_ctx=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE)

Werke

*Das Problem ist die Standardgeräteauswahl

 

Können wir das alles in einer schönen Form haben, ohne die ganzen Anführungszeichen? Das ist unangenehm für die Wahrnehmung und die Gestaltung.

Und für neuronale Netze sollten wir Standardklassen haben, und es ist möglich, opcl instantly) wie wellslab zu verwenden

"#define HL1Count "             + (string)hl1NeuronCount + "                     \r\n"
          "#define HL2Count "             + (string)hl2NeuronCount + "                     \r\n"
          //------------------------------------------------------------------------------------
          "#define NeuronSensitivity  "   + (string)NeuronSensitivity_P + "                \r\n"
          //------------------------------------------------------------------------------------
          "#define sampleCount "          + (string)sampleCount + "                        \r\n"
          //------------------------------------------------------------------------------------
          "#define signalCount "          + (string)signalCount + "                        \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrSaSize "         + (string)(sizeof(ArrSample) / sizeof(float)) + "\r\n"
          "typedef struct{float C[StrArrSaSize];} ArrSa;                                   \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrWeSize "         + (string)(sizeof(ArrWe) / sizeof(float)) + "    \r\n"
          "typedef struct{float C[StrArrWeSize];} ArrWe;                                   \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrCrSize "         + (string)(sizeof(ArrCr) / sizeof(float)) + "    \r\n"
          "typedef struct{float C[StrArrCrSize];}ArrCr;                                    \r\n"
          //------------------------------------------------------------------------------------
          "#define Spread "               + (string)(Spread_P * Point()) + "               \r\n"
          //------------------------------------------------------------------------------------
          "#define Point "                + (string)Point() + "                            \r\n"
          "#define SL "                   + (string)(StopLoss_P * Point()) + "             \r\n"
          "#define TP "                   + (string)(TakeProfit_P * Point()) + "           \r\n"
          //------------------------------------------------------------------------------------
          "                                                                                \r\n"
          "__kernel void Work(__global ArrSa *Sample,                                      \r\n"
          "                   __global ArrWe *Weights,                                     \r\n"
          "                   __global ArrCr *Result)                                      \r\n"
          "{                                                                               \r\n"
          "  int thread       = get_global_id(0);                                          \r\n"
          "                                                                                \r\n"
          "  //------------------Переменные нейронной сети---------------------------------\r\n"
 
Maxim Dmitrievsky:

Können wir das alles in einer schönen Form haben, ohne die ganzen Anführungszeichen? Das ist unangenehm für die Wahrnehmung und die Gestaltung.

Und für neuronale Netze sollten wir Standardklassen haben, und es ist möglich, opcl instantly) wie wellslab zu verwenden

Und warum nicht? Sehen Sie, es gibt keine einzige spezifische Funktion, die MQL nicht kennt. Ich habe MQL verwendet, um diese Funktion für OCL zu schreiben und zu debuggen, und dann habe ich das Ganze gehärtet. Sie können sogar einen Code-Konverter in OCL erstellen, aber ich sehe keinen besonderen Grund, dies für mich selbst zu tun. Vielleicht wird MQ es tun, aber ich bezweifle es.
 
Renat Fatkhullin:

Dies ist eine Demonstration nicht nur der GPU-Berechnungen im MQL5-Code, sondern auch der grafischen Möglichkeiten des Terminals:

Der vollständige Quellcode in Form eines Skripts ist beigefügt. Der Fehler bei OpenCL 1.2 wurde behoben.

Ich weiß auch, wie man stickt. Und auf einer Schreibmaschine... (c) Wozu dient dieses Handelsterminal?
 
Werden die Agenten in der Cloud arbeiten?
 
GKS:
Werden die Agenten in der Cloud arbeiten?
Nein
 

Es gibt ein großes Problem mit OCL und generell mit allen Möglichkeiten der Parallelisierung - nur sehr wenige Algorithmen können effektiv parallelisiert werden. Warum in den Beispielen des parallelen Rechnens so beliebt sind Simulation von Wellen, Kugel fallen auf eine Pyramide mit ihrer Zerstörung, dh alles, was in kleine Stücke gebrochen werden kann und berechnet auf Ihrem eigenen Prozessor.

Für fora/bear sind dies natürlich neuronale Netze, verschiedene Fourier-Transformationen, Wavelets, Filter usw., die alle vollkommen parallel sind. Es gibt jedoch lineare Algorithmen, die überhaupt nicht parallelisiert werden können. Dies ist in der Regel der Fall, wenn das Ergebnis des nächsten Algorithmus-Schrittes auf dem Ergebnis des vorherigen Schrittes basiert.

Ich habe dies für diejenigen geschrieben, die denken, dass ich zwei coole Grafikkarten kaufen werde und alles wird in meinem Testgerät gut funktionieren.

123456789101112...18
Neuer Kommentar