Wie Sie OpenCl öffnen und für Kalkulationen verwenden.
4 050
0
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).
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) |
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:
- Setup für Intel-Prozessoren;
- Setup für AMD-Grafikprozessoren;
- Setup für AMD-Prozessoren;
- Setup für Nvidia-Grafikprozessoren.
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
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Die Installation der Treiber, die von verschiedene Werbeeinblendungen von Nvidia begleitet wird, wird unmittelbar im Anschluss daran beginnen.
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.
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).
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.
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 Ltd.
Originalartikel: https://www.mql5.com/ru/articles/690
MQL5-Kochbuch: Umgang mit typischen Chartereignissen
Eine andere MQL5-OOP-Klasse
MQL5 Cloud Network Kalkulieren Sie noch?
Creating Neural Network EAs Using MQL5 Wizard and Hlaiman EA Generator
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.