MetaTrader 5 herunterladen

Wie Sie OpenCl öffnen und für Kalkulationen verwenden.

27 Juni 2016, 13:54
MetaQuotes Software Corp.
0
1 110

OpenCL im MetaTrader-5-Terminal

Es ist nun schon seit mehr als einem Jahr möglich, in MQL 5 Programme für OpenCL zu schreiben. Einträge für verschiedene OpenCL-Geräte können nun im MetaTrader-5-Journal eingesehen werden (siehe unten).

Gefundene Journaleinträge im MetaTrader-5-Terminal betreffend OpenCL-Geräte

Im vorliegenden Fall hat das MetaTrader-5-Terminal vier mögliche Methode entdeckt, um OpenCL direkt mit einem MQL5-Programm auszuführen: eine Grafikkarte von NVIDIA (OpenCL1.1) oder eine von AMD (OpenCL 1.2) sowie zwei Intel Core-i7 CPUs, abhängig von den jeweils installierten Treibern. Für den Fall, dass Ihr Computer bereits über eine OpenCL-Version verfügt (1.1 oder höher), können Sie ruhigen Gewissens den Beschreibungsteil überspringen und direkt zu Performancevergleich springen, um mit eigenen Augen zu sehen, welchen unglaublichen Einfluss die Verwendung von Parallelrechnern haben kann.

OpenCL ist einfach nur faszinierend!

Allerdings haben noch nicht sehr viele Benutzer den wahren Wert von paralleler Datenverarbeitung bezüglich Expert Advisors, Indikatoren oder Skripten erkannt, da sie sich einfach nicht der Möglichkeiten bewusst sind und/oder nicht über die entsprechenden Kenntnisse verfügen.

Das Problem ist, dass das Ausführen von MQL5-Programmen, die OpenCL benutzen, einer gewissen Software bedarf. Dies ist der Grund dafür, dass viele Benutzer nicht in der Lage waren, das Mandelbrot-Set-Skript auszuführen - genauso wie viele andere Programme, die im MQL5.community-Forum zur Verfügung stehen.

In diesem Artikel möchte ich Ihnen sehr gerne zeigen, wie Sie OpenCL auf Ihrem Computer installieren, damit Sie aus erster Hand die Vorteile paralleler Datenverarbeitung erleben können. Wir werden dabei nicht auf das Schreiben spezifischer OpenCL-Programme eingehen, da die Webseite bereits zwei größere Artikel zu diesem Thema parat hat:

Was ist OpenCL?

OpenCL ist der offene Standard, was das Parallel Computing betrifft. Es wurde 2008 von der sogenannten Khronos Group entwickelt. Dieser Standard erlaubt es Ihnen, Applikationen zu entwickeln, die auf mehreren „parallel geschalteten“ GPUs oder CPUs unterschiedlicher Architektur in einem heterogenen System ausgeführt werden können.

Mit anderen Worten: OpenCL erlaubt es Ihnen, alle Ihre CPU-Kerne oder alle Ihre GPUs dazu zu verwenden, Berechnungen anzustellen, wodurch die Ausführungszeit effektiv reduziert wird. Die Verwendung von OpenCL ist daher außerordentlich nützlich, wenn Sie es mit Aufgaben zu tun haben, die sehr viele Ressourcen erfordern.

Wenn wir beispielsweise über MQL5 reden, kann der Perfomancegewinn beträchtlich sein, wenn ein bestimmtes Skript (Indikator oder EA) abgearbeitet wird, das eine komplexe Analyse historischer Daten entsprechend mehrerer Symbole und Zeitrahmen durchführt (hierbei Sie nur kurz erwähnt, dass ein jedes MQL5-Programm, das Parallel Computing verwenden soll, in einer ganz speziellen Weise geschrieben sein muss - indem OpenCL API verwendet wird).

Unterstützung von OpenCL

Der MQL5-Support für OpenCL begann im Juni 2010 mit der Version 1.1. Um also parallele Berechnungen durchzuführen, benötigen Sie relativ neue Soft- und Hardwarekomponenten.

Gleichsam sollte an dieser Stelle erwähnt werden, dass es zum Starten von OpenCL nicht wirklich bedeutsam ist, ob sich an Ihrem PC eine Grafikkarte befindet oder nicht - eine CPU wird genügen. Das heißt, das OpenCL theoretisch für jeden Nutzer zugänglich ist, der die Durchführungs- bzw. Berechnungszeiten seiner MQL5-Programme verringern will.

CPUs liegen definitiv meilenweit hinter ihren grafischen Pendants, wenn es um die Verteilung von Rechengeschwindigkeit geht. Dennoch kann eine solide Multikern-CPU immer noch eine beachtliche Geschwindigkeit erreichen. Aber kehren wir zum Thema zurück.

Wie bereits gesagt: Sie können entweder GPUs oder CPUs für Parallelberechnungen verwenden. Es gibt hierbei lediglich drei Hersteller, die aufgrund ihres Marktführerstatus einer Erwähnung wert erscheinen: Intel, AMD und Nvidia. Die folgende Tabelle enthält Informationen über die Geräte und Betriebssysteme eines jeden dieser Hersteller, die OpenCL 1.2 unterstützen:

Hersteller Geräte Betriebssysteme
Intel CPUs:

Core i3, i5, i7 - für PCs;
Xeon - für Server;
Xeon Phi - für Koprozessoren (mehr dazu hier).
Windows 7, 8;
openSUSE;
Red Hat.
AMD Grafikkarten:

AMD Radeon HD Grafikkarten der Serie 6400 und höher;
ATI Radeon HD Grafikkarten der Serie 5400 und höher;
ATI FirePro Grafikkarten der Serien A300, S, W, V;
ATI Mobility Radeon HD Karten der Serie 5400 und höher;
ATI FirePro M7820 M5800 (mehr dazu hier).

Mindestens auf K8-Architektur basierende CPUs:

Opteron, Athlon 64, Athlon 64 FX, Athlon 64 X2, Sempron, Turion 64, Turion 64 X2, Phenom, Phenom II (mehr dazu hier).

APU (hybrider CPU/GPU-Prozessor):

CPU-Serien A, C, E, E2, G, R.
Windows Vista SP2, 7, 8;
openSUSE 11.x;
Ubuntu 11.04;
Red Hat 6.x.
Nvidia GPUs (mit einer CUDA-Architektur):

Tesla, Quadro, GeForce (mehr dazu hier).
Windows XP, Vista, 7, 8
Linux und Mac OS
(mehr dazu hier)
Außerdem verfügt die offizielle Entwicklerwebseite von Khronos Group über eine vollständige Liste der für OpenCl benötigten Hard- und Softwarekomponenten.

Stellen Sie bitte sicher, dass Ihr Rechner mindestens ein Gerät (CPU oder GPU) aufweist, und überprüfen Sie bitte, ob dieses Gerät wie auch Ihr Betriebssystem die OpenCL-Version 1.1 unterstützen. Falls dies der Fall sein sollte, können Sie problemlos zum nächsten Abschnitt übergehen, der Ihnen zeigen wird, wie Sie OpenCL entsprechend der Hardwarekomponenten Ihres Herstellers konfigurieren.

OpenCL einrichten und konfigurieren

Wenn Sie die benötigte Software auf Ihrem Rechner installiert haben, müssen Sie OpenCL lediglich auf einem Ihrer Geräte einrichten, um Parallelkalkulationen in MetaTrader 5 benutzen zu können.

Der OpenCL-Installationsvorgang variiert dabei, und zwar abhängig davon, welche Hardwarekomponente Sie benutzen - eine GPU oder eine CPU. Falls das MetaTrader-5-Terminal eine Grafikkarte findet, die OpenCL unterstützt, müssen Sie nur die Treiber auf die aktuellste Version aktualisieren.

Sie werden hierfür ein Software-Development-Kit (SDK) für Ihre CPU herunterladen müssen, falls Ihr Rechner nicht über eine geeignete Grafikkarte verfügt.

Wichtig: Wenn Sie bereits über eine Grafikkarte verfügen, die OpenCL unterstützt, so müssen Sie keine Software zur OpenCL-CPU-Emulation installieren.

Außer natürlich Sie planen das eine oder andere Experiment. Sie sollten nämlich wissen, dass sich Im Normalfall Grafikkarten wesentlich besser für OpenCL eignen.

Die folgenden Paragraphen beschreiben die Installationsprozedur, abhängig vom jeweiligen Hersteller. Mithilfe folgender Links gelangen Sie zu den entsprechenden Installationsanweisungen:


1. Intel

Um OpenCL in Kombination mit Intel Prozessoren benutzen zu können, müssen Sie sich Intel SDK for OpenCL Applications herunterladen und installieren. Begeben Sie sich dazu auf die offzielle Webpräsenz der Entwickler.

Abb. 1.1 Downloadseite zum Herunterladen von Intel SDK für OpenCL

Abb. 1.1 Downloadseite zum Herunterladen von Intel SDK für OpenCL

Hier finden Sie alle Informationen bezüglich OpenCL sowie eine Liste sämtlicher zur Verfügung stehender Produkte. Um diese Produkte herunterzuladen, klicken Sie bitte auf den Button Produkte vergleichen und herunterladen, der sich in der oberen, rechten Ecke befindet.

Abb. 1.2 Informationen zu den verfügbaren Produkten und Installationsbedingungen.

Abb. 1.2 Informationen zu den verfügbaren Produkten und Installationsbedingungen.

Nach einem Klick werden Sie ein Fenster mit Informationen über die Voraussetzungen des Produkts (Prozessortyp, Betriebssystem) zu Gesicht bekommen. Wählen Sie das Produkt aus, das Ihnen am geeignetsten erscheint, und klicken Sie auf den Download-Button über dem Produkticon.

Abb. 1.3 SDK-Downloadlinks

Abb. 1.3 SDK-Downloadlinks

Nun wird ein anderes Fenster mit verschiedenen Downloadlinks erscheinen. Wählen Sie entweder die 32- oder die 64-Bit-Version von SDK aus. Warten Sie einige Minuten, bis der Download abgeschlossen ist, und führen Sie dann die heruntergeladene Datei aus. Bestätigen Sie die Installation der SDK-Komponenten und extrahieren Sie Dateien in einen der Ordner.

Abb. 1.4 Starten der Installation von Intel SDK für OpenCL.

Abb. 1.4 Starten der Installation von Intel SDK für OpenCL.

Sie Sehen nun das Installationsfenster mit dem Hinweis: Intel SDK für OpenCL Applikationen mit OpenCL 1.2-Unterstützung. Gehen Sie auf Weiter und folgen Sie den Installationsanweisungen.

Abb. 1.5 Akzeptieren der Endbenutzerlizenzvereinbarung.

Abb. 1.5 Akzeptieren der Endbenutzerlizenzvereinbarung.

Akzeptieren Sie die Endbenutzerlizenzvereinbarung. Nun sehen Sie die Komponenten, die installiert werden sollen. Gehen Sie hier bitte auf Weiter, um fortzufahren.

Abb. 1.6 Integration von SDK & Visual Studio.

Abb. 1.6 Integration von SDK & Visual Studio.

Falls sich Microsoft Visual Studio 2008 (oder eine spätere Version) bereits auf Ihrem PC befinden sollte, werden Sie aufgefordert, diese zu integrieren. Dann müssen Sie lediglich alle Benutzer auswählen, die Zugriff auf die installierten Komponenten haben sollen, den SDK-Installationsordner spezifizieren und auf Installieren klicken.

Abb. 1.7 Installation.

Abb. 1.7 Installation.

Die Installation wird möglicherweise einige Minuten in Anspruch nehmen. Sobald der Installationsvorgang abgeschlossen ist, können Sie die Ergebnisse auf Ihrem Bildschirm betrachten. Gehen Sie auf Beenden, um den Installationsprozess endgültig abzuschließen.

Abb. 1.8 Beenden der Installation.

Abb. 1.8 Beenden der Installation.

2.1 AMD-Grafikkarten und APU

Um OpenCL für AMD-Grafikkarten zu installieren, müssen wir zunächst die Treiber auf den neusten Stand bringen. Hierzu bedienen wir uns der Treiber der Downloadseite.

Abb. 2.1.1 Downloadseite für AMD-Treiber.

Abb. 2.1.1 Downloadseite für AMD-Treiber.

Falls Sie die Spezifikationen Ihrer Grafikkarte kennen, können Sie den Treiber kinderleicht mittels dem Formular auf der linken Seite der Webseite ermitteln. Sobald Sie die notwendigen Felder ausgefüllt haben, klicken Sie bitte auf Resultate anzeigen, um den entsprechenden Treiber zu finden.

Abb. 2.1.2 AMD-Catalyst-Download.

Abb. 2.1.2 AMD-Catalyst-Download.

Das System wird Ihnen via Catalyst Software Suite einige Treiber anbieten - einschließlich des gesuchten OpenCL-Treibers. Laden Sie sich Catalyst herunter und führen Sie die Datei aus.

Abb. 2.1.3 Seite zum Herunterladen von Applikationen, die zur Identifikation von Grafikartentypen und Treiberversionen dienen.

Abb. 2.1.3 Seite zum Herunterladen von Applikationen, die zur Identifikation von Grafikartentypen und Treiberversionen dienen.

Sie können sich auch des automatischen Treiberbestimmungstools bedienen, indem Sie auf den entsprechende Link in der rechten, oberen Ecke der Seite klicken (Abb. 2.1.1). Sie werden daraufhin aufgefordert das Programm AMD Driver Autodetect auf Ihrem Rechner zu installieren. Stimmen Sie zu und starten Sie es.

Abb. 2.1.4 Applikation zum Finden und Herunterladen eines geeigneten Treibers.

Abb. 2.1.4 Applikation zum Finden und Herunterladen eines geeigneten Treibers.

Die Applikation wird das System analysieren und Ihnen anbieten, die entsprechenden Grafikkartentreiber herunterzuladen. Laden Sie diese herunter und führen Sie die erhaltene Datei aus. Der Installationsassistent wird Sie dann darum bitten, den Ordner zu spezifizieren, in dem die Daten entpackt werden sollen - wählen Sie ihn aus und klicken Sie auf Installieren.

Abb. 2.1.5 Installationsassistent für AMD Catalyst.

Abb. 2.1.5 Installationsassistent für AMD Catalyst.

Nun erscheint der Endbenutzerlizenzvertrag (EULA) in einem neuen Fenster. Um fortzufahren, müssen Sie den Bedingungen des Vertrags zustimmen. Nun wählen wir Schnellinstallation, geben den Installationspfad für AMD Catalyst an und gehen auf Weiter.

Abb. 2.1.6 Installation.

Abb. 2.1.6 Installation.

Die Installation wird möglicherweise einige Minuten in Anspruch nehmen. Sie werden auf Ihrem Bildschirm mit einer entsprechenden Nachricht informiert, sobald die Installation abgeschlossen ist.

Abb. 2.1.7 Beenden der Installation.

Abb. 2.1.7 Beenden der Installation.

2.2 AMD-CPUs

Um OpenCL für eine AMD-CPU zu installieren, müssen wir zunächst die aktuellste Version des Softwarekits AMD APP SDK installieren. Hierfür gehen wir auf die folgende Seite der offiziellen Entwicklerwebseite.

Abb. 2.2.1 Downloadseite für AMD APP SDK.

Abb. 2.2.1 Downloadseite für AMD APP SDK.

Diese Seite liefert uns einige Informationen über SDK und einen Einblick in OpenCL. Alles, was wir von hier benötigen, ist der Link Zu den Downloads unter der Beschreibung.

Abb. 2.2.2 Verzeichnis aller SDKs, die heruntergeladen werden können.

Abb. 2.2.2 Verzeichnis aller SDKs, die heruntergeladen werden können.

Ganz am Ende der Seite werden Sie eine Tabelle vorfinden, die eine Liste aller verfügbaren SDK-Versionen (für verschiedene Systeme sowie 32/64-Bit) samt ihrer Downloadlinks enthält. Wählen Sie die benötigte Version aus und klicken Sie auf den entsprechenden Link. Sie werden nun zur Seite mit der Endbenutzerlizenzvereinbarung geleitet. Akzeptieren Sie diese, um schließlich den Download zu starten.

Nachdem Sie den Downloadassistenten gestartet haben, werden Sie aufgefordert, die Dateien in einen zu spezifizierenden Ordner zu extrahieren. Hieran anknüpfend erfolgt die Installation oben bereits erwähnter Komponenten: AMD Catalyst samt AMD APP SDK. Der Catalyst-Installationsprozess wird in Abb. 2.1.5-2.1.7 in Abschnitt 2.1 weiter oben dargestellt.

3. Nvidia

Sollten Sie über eine Nvidia-Grafikkarte verfügen, müssen Sie wahrscheinlich deren Treiber auf den aktuellsten Stand bringen, um OpenCL zu installieren. Diese können auf der Treiber-Downloadseite des Herstellers heruntergeladen werden.

Abb. 3.1 Seite zum Herunterladen von Nvidia-Treibern.

Abb. 3.1 Seite zum Herunterladen von Nvidia-Treibern.

Diese Seite hilft Ihnen dabei, alle erforderlichen Treiber zu finden - sei es automatisch oder manuell. Für eine manuelle Suche müssen Sie auf Suche klicken, nachdem Sie die folgenden Elemente spezifiziert haben: Produkttyp, Serie und Betriebssystem. Das System wird daraufhin die aktuellsten Treiber für Ihre Grafikkarte heraussuchen und Sie auffordern, diese herunterzuladen.

Abb. 3.2 Download der ausgewählten Treiber.

Abb. 3.2 Download der ausgewählten Treiber.

Falls Sie sich für Option Nummer 2 entscheiden sollten, müssen Sie auf Grafiktreiber klicken, woraufhinSie aufgefordert werden, einem Scan Ihres Systems durch die JavaApplikation GPU_reader zuzustimmen.

Abb. 3.3 Ausführen der Applikation, um den Grafikartentyp und die Treiberversion zu identifizieren.

Abb. 3.3 Ausführen der Applikation, um den Grafikartentyp und die Treiberversion zu identifizieren.

Starten Sie die Applikation mit einem Klick auf Ausführen. Warten Sie einige Sekunden, damit Ihnen die Grafikkarteninformationen, die aktuelle Version Ihrer installierten Treiber sowie schließlich die aktuellste, empfohlene Treiberversion angezeigt werden können. Gehen Sie auf Download, um auf die in Abb. 3.2 abgebildete Downloadseite zu gelangen.

Abb. 3.4 Resultate der automatisierten Identifikation des Grafikkartentyps und der Treiberversion.

Abb. 3.4 Resultate der automatisierten Identifikation des Grafikkartentyps und der Treiberversion.

Klicken Sie auf Jetzt Herunterladen und akzeptieren Sie die Softwarelizenzvereinbarung von Nvidia, indem Sie auf den Button Zustimmen und Herunterladen klicken.

Abb. 3.5 Akzeptieren der Lizenzvereinbarung und Herunterladen der Treiber.

Abb. 3.5 Akzeptieren der Lizenzvereinbarung und Herunterladen der Treiber.

Wir erhalten somit die aktuellste Treiberversion unserer Grafikkarte. Wir führen daraufhin die erhalten Datei aus. Hierbei werden Sie darum gebeten, einen Ordner zu spezifizieren, in den die Treiberinstallationsdateien extrahiert werden sollen. Sobald die Dateien vollständig entpackt sind, wird die Installation umgehend beginnen. Zunächst müssen Sie erneut die Geschäftsbedingungen und Lizenzvereinbarung von Nvidia akzeptieren.

Abb. 3.6 Akzeptieren der Lizenzvereinbarung während der ersten Phase der Installation.

Abb. 3.6 Akzeptieren der Lizenzvereinbarung während der ersten Phase der Installation.

Wählen Sie Expressinstallation und klicken Sie auf Weiter. Nun erhalten Sie die Chance, optional das zusätzliche Add-in-Programm Nvidia Experience zu installieren.

Abb. 3.7 Auswahl der Installationseinstellungen.

Abb. 3.7 Auswahl der Installationseinstellungen.

Die Installation der Treiber, die von verschiedene Werbeeinblendungen von Nvidia begleitet wird, wird unmittelbar im Anschluss daran beginnen.

Abb. 3.8 Installation.

Abb. 3.8 Installation.

Das war's. Der Treiber wurde installiert und wir müssen nun nichts weiter tun, als das System neu zu starten, um OpenCL im MetaTrader-5-Terminal verwenden zu können.

Abb. 3.9 Beenden der Installation.

Abb. 3.9 Beenden der Installation.

Performancevergleich

Die Datei OpenCL_Sample.mq5 eignet sich perfekt dafür, um all die Vorteile zu veranschaulichen, die es mit sich bringt, wenn man OpenCL in MQL5 ausführt. Sie kalkuliert die Werte der Funktion zweier Variablen eines Sets und zeigt die Resultate im Chart-Fenster mithilfe eines grafischen Labels (OBJ_BITMAP_LABEL) an. Die Kalkulationen werden dabei entweder unter der oder ohne die Verwendung von OpenCL durchgeführt. Diese Blöcke werden in Form der beiden Funktionen WithOpenCL() bzw. WithoutOpenCL() implementiert.

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//...
   Print("\nCalculations without OpenCL:");
   WithoutOpenCL(values1,colors1,w,h,size,const_1,const_2);
//--- calculations with OpenCL
   Print("\nCalculations with OpenCL:");
   WithOpenCL(values2,colors2,w,h,size,const_1,const_2);
//...
  }
//+------------------------------------------------------------------+
//| Calculations without using  OpenCL                               |
//+------------------------------------------------------------------+
void WithoutOpenCL(float &values[],uint &colors[],const uint w,const uint h,
                   const uint size,const uint const_1,const uint const_2)
  {
//--- store the calculation start time
   uint x=GetTickCount();
//--- calculation of function values
   for(uint i=0;i<h;i++)
      for(uint j=0;j<w;j++)
         values[i*w+j]=Func(InpXStart+i*InpXStep,InpYStart+j*InpYStep);
//--- print the function calculation time
   Print("Calculation of function values = "+IntegerToString(GetTickCount()-x)+" ms");
//--- determine the minimum value and the difference between 
//--- the minimum and maximum values of points in the set
   float min,dif;
   GetMinAndDifference(values,size,min,dif);
//--- store the calculation start time
   x=GetTickCount();
//--- calculate paint colors for the set
   uint a;
   for(uint i=0;i<size;i++)
     {
      a=(uint)MathRound(255*(values[i]-min)/dif);
      colors[i]=const_1*(a/16)+const_2*(a%16);
     }
//--- print the paint color calculation time
   Print("Calculation of paint colors = "+IntegerToString(GetTickCount()-x)+" ms");
  }
//+------------------------------------------------------------------+
//| Calculations using OpenCL                                        |
//+------------------------------------------------------------------+
void WithOpenCL(float &values[],uint &colors[],const uint w,const uint h,
                const uint size,const uint const_1,const uint const_2)
  {
//--- variables for using OpenCL
   int cl_ctx;
   int cl_prg;
   int cl_krn_1;
   int cl_krn_2;
   int cl_mem_1;
   int cl_mem_2;
//--- create context for OpenCL (selection of device)
   if((cl_ctx=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE)
     {
      Print("OpenCL not found");
      return;
     }
//--- create a program based on the code in the cl_src line
   if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==INVALID_HANDLE)
     {
      CLContextFree(cl_ctx);
      Print("OpenCL program create failed");
      return;
     }
//--- create a kernel for calculation of values of the function of two variables
   if((cl_krn_1=CLKernelCreate(cl_prg,"Func"))==INVALID_HANDLE)
     {
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL kernel_1 create failed");
      return;
     }
//--- kernel for painting points of the set in the plane
   if((cl_krn_2=CLKernelCreate(cl_prg,"Grad"))==INVALID_HANDLE)
     {
      CLKernelFree(cl_krn_1);
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL kernel_2 create failed");
      return;
     }
//--- OpenCL buffer for function values
   if((cl_mem_1=CLBufferCreate(cl_ctx,size*sizeof(float),CL_MEM_READ_WRITE))==INVALID_HANDLE)
     {
      CLKernelFree(cl_krn_2);
      CLKernelFree(cl_krn_1);
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL buffer create failed");
      return;
     }
//--- OpenCL buffer for point colors
   if((cl_mem_2=CLBufferCreate(cl_ctx,size*sizeof(uint),CL_MEM_READ_WRITE))==INVALID_HANDLE)
     {
      CLBufferFree(cl_mem_1);
      CLKernelFree(cl_krn_2);
      CLKernelFree(cl_krn_1);
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL buffer create failed");
      return;
     }
//--- store the calculation start time
   uint x=GetTickCount();
//--- array sets indices at which the calculation will start 
   uint offset[2]={0,0};
//--- array sets limits up to which the calculation will be performed
   uint work[2];
   work[0]=h;
   work[1]=w;
//--- calculation of function values
//--- pass the values to the kernel
   CLSetKernelArg(cl_krn_1,0,InpXStart);
   CLSetKernelArg(cl_krn_1,1,InpYStart);
   CLSetKernelArg(cl_krn_1,2,InpXStep);
   CLSetKernelArg(cl_krn_1,3,InpYStep);
   CLSetKernelArgMem(cl_krn_1,4,cl_mem_1);
//--- start the execution of the kernel
   CLExecute(cl_krn_1,2,offset,work);
//--- read the obtained values to the array
   CLBufferRead(cl_mem_1,values);
//--- print the function calculation time
   Print("Calculation of function values = "+IntegerToString(GetTickCount()-x)+" ms");
//--- determine the minimum value and the difference between 
//--- the minimum and maximum values of points in the set
   float min,dif;
   GetMinAndDifference(values,size,min,dif);
//--- store the calculation start time
   x=GetTickCount();
//--- set the calculation limits
   uint offset2[1]={0};
   uint work2[1];
   work2[0]=size;
//--- calculation of paint colors for the set
//--- pass the values to the kernel
   CLSetKernelArg(cl_krn_2,0,min);
   CLSetKernelArg(cl_krn_2,1,dif);
   CLSetKernelArg(cl_krn_2,2,const_1);
   CLSetKernelArg(cl_krn_2,3,const_2);
   CLSetKernelArgMem(cl_krn_2,4,cl_mem_1);
   CLSetKernelArgMem(cl_krn_2,5,cl_mem_2);
//--- start the execution of the kernel
   CLExecute(cl_krn_2,1,offset2,work2);
//--- read the obtained values to the array
   CLBufferRead(cl_mem_2,colors);
//--- print the paint color calculation time
   Print("Calculation of paint colors = "+IntegerToString(GetTickCount()-x)+" ms");
//--- delete OpenCL objects
   CLBufferFree(cl_mem_1);
   CLBufferFree(cl_mem_2);
   CLKernelFree(cl_krn_1);
   CLKernelFree(cl_krn_2);
   CLProgramFree(cl_prg);
   CLContextFree(cl_ctx);
  }

Nachdem das Skript ausgeführt worden ist, können Sie für einige Sekunden das farbig markierte Set von Funktionswerten im Chart-Fenster erkennen. Jedes von ihnen korrespondiert mit einem Farbton, der in den Eingabeparametern ausgewählt wird.

Die Resultate der Skriptausführung einer Menge von Punkte in der Ebene von -22 bis 22 (in 0.1er Schritten).

Die Resultate der Skriptausführung einer Menge von Punkte in der Ebene von -22 bis 22 (in 0.1er Schritten).

Neben dem Bild selbst wird im „Expert Advisors“-Journal ferner die Zeit dargestellt, die benötigt wird, um die Funktionen für beide Methoden zu berechnen - definitiv einer der wichtigsten Vorteile, die die Verwendung von OpenCL via MQL5 mit sich bringt. Erhöhen Sie die Schrittweite und lassen Sie sich die Resultate der Skriptausführung anzeigen:

Resultate der Funktionsberechnung und des Druckens von Farbwerten unter Verwendung zweier Methoden.

Resultate der Funktionsberechnung und des Druckens von Farbwerten unter Verwendung zweier Methoden.

Insgesamt hat die Funktionsberechnung mit OpenCL durch die CPU mehr als fünfmal so viel Zeit in Anspruch genommen...und dabei haben wir noch nicht einmal das Limit erreicht! Es ist allseits bekannt, dass fortgeschrittene GPU-Kalkulationen via OpenCL wesentlich schneller als CPU-Berechnungen von statten gehen. Dies lässt sich relativ leicht beweisen, indem Sie sich die Resultate der Skriptausführungen auf verschiedenen OpenCL-Geräten zu Gemüte führen. Betrachte Sie hierzu nachstehende Tabelle:

OpenCL-Gerät
Durchführungsdauer ohne OpenCL, ms (Millisekunden)
Durchführungsdauer mit OpenCL, ms
Performancegewinn
AMD Radeon HD 7970 20.361 ms
171 ms
 119.07 Mal
Nvidia GeForce GT 630
24.742 ms
578 ms
 42.8 Mal
Intel Core i5 430M
27.222 ms
5.428 ms
 5.01 Mal
AMD Athlon X2 Dual-Core QL-65
45.723 ms
9.516 ms  4.8 Mal

Wie Sie sehen können, bewirkt die Verwendung von OpenCL in Kombination mit Highend-AMD-Grafikkarten eine 100-fache Reduktion der Berechnungszeiten! Selbst der ein wenig älteren GeForce GT 630 von 2011 gelingt immer noch eine 42-fach verkürzte Berechnungszeit. Die CPUs von Intel und AMD bilden dabei das Schlusslicht. Gleichwohl ist ihr Performancegewinn immer noch ein Segen, wenn man mit komplexen Kalkulationen interagiert.

Und das wäre soweit alles. Die vergleichende Tabelle demonstriert einen ganz eindeutigen Vorteil von Parallelkalkulationen während der Massendatenverarbeitung. Alles, was Sie tun müssen, ist lediglich einen geeigneten Treiber für Ihre Grafikkarte bzw. CPU zu installieren.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/690

Beigefügte Dateien |
opencl_sample.mq5 (12.93 KB)
Eine andere MQL5-OOP-Klasse Eine andere MQL5-OOP-Klasse

Dieser Artikel soll Sie damit vertraut machen, wie Sie von Grund auf einen objektorientierten Expert Advisor konstruieren: und zwar beginnend mit der theoretischen Konzeption bis hin zur praktischen Programmierung eines MQL5-EAs. Ich persönliche vertrete die Einstellung, dass nichts über die Learning-by-Doing-Methode geht. Ich werde Ihnen daher anhand eines praktischen Beispiels vorführen, wie Sie Ihre Ideen ordnen können, um Ihren Forex-Roboter mit einem Code zu versehen. Ich habe außerdem die Absicht, Ihnen einige OO-, also objektorientierte Prinzipien näherzubringen.

Creating Neural Network EAs Using MQL5 Wizard and Hlaiman EA Generator Creating Neural Network EAs Using MQL5 Wizard and Hlaiman EA Generator

Dieser Artikel befasst sich mit einer Methode zur automatischen Generierung von auf einem neuronalen Netzwerk basierenden EAs mithilfe des MQL5-Assistenten und Hlaiman EA Generator. Er zeigt Ihnen, wie Sie ganz einfach mit neuronalen Netzwerken arbeiten können - und zwar ohne großartige Hintergrundinformationen zu besitzen oder einen eigenen Code zu schreiben.

MQL5-Kochbuch: Umgang mit typischen Chartereignissen MQL5-Kochbuch: Umgang mit typischen Chartereignissen

Dieser Artikel beschäftigt sich mit den üblichsten Chartereignissen und veranschaulicht deren Ablauf anhand von Beispielen. Wir werden uns auf Mausereignisse, Tastenanschläge, die Erstellung/Veränderung/Entfernung grafischer Objekte, Mausklicks auf einen Chart oder ein grafisches Objekt, das Verschieben eines solchen Objekts mit der Maus, das Beenden der Editierung eines Textes in einem Textfeld sowie die Modifikation von Chartereignissen fokussieren. Für jeden Ereignistyp wird dabei ein Beispiel aus einer Reihe von MQL5-Programmen angeführt.

MQL5 Cloud Network Kalkulieren Sie noch? MQL5 Cloud Network Kalkulieren Sie noch?

Die Veröffentlichung von MQL5 Cloud Network ist nun schon beinahe anderthalb Jahre her. Dieser Zeitpunkt läutete gewissermaßen den Beginn einer neuen Ära des algorithmischen Tradings ein - mit nur einigen wenigen Klicks stehen Tradern nun mehrere hundert bis tausend Computerkerne zur Verfügung, um Ihre Handelsstrategien zu optimieren.