Come installare e utilizzare OpenCL per i calcoli
390
0
OpenCL nel terminale client MetaTrader 5
È passato più di un anno da quando è diventato possibile scrivere programmi per OpenCL in MQL5. Le voci di qualsiasi dispositivo OpenCL trovato possono ora essere visualizzate nel Journal al lancio del terminale MetaTrader 5, come mostrato di seguito.
In questo caso, il terminale MetaTrader 5 ha rilevato 4 metodi disponibili per avviare OpenCL direttamente da un programma MQL5: una scheda grafica di NVIDIA (OpenCL 1.1) e una di AMD (OpenCL 1.2), oltre a due utilizzi della CPU Intel Core-i7 opzioni, a seconda del driver installato. Se il tuo computer dispone già di un dispositivo OpenCL versione 1.1 o successiva, puoi tranquillamente saltare la parte della descrizione e procedere direttamente al Confronto delle prestazioni per essere in grado di vedere di persona il miglioramento delle prestazioni per le attività che consentono il calcolo parallelo.
OpenCL è affascinante!
Tuttavia, non molti utenti hanno approfittato dell'utilizzo del calcolo parallelo nei loro Expert Advisor, indicatori o script poiché non sono consapevoli delle nuove possibilità offerte e non dispongono delle conoscenze necessarie.
Il fatto è che l'avvio di qualsiasi programma MQL5 che utilizza OpenCL richiede l'installazione del software appropriato. Ecco perché molti utenti semplicemente non erano in grado di eseguire lo script set di Mandelbrot, così come molti altri programmi disponibili nel forum MQL5.community.
In questo articolo, ti mostreremo come installare OpenCL sul tuo computer in modo che tu possa vedere in prima persona i vantaggi dell'utilizzo del calcolo parallelo in MQL5. Non prenderemo in considerazione i dettagli della scrittura di programmi per OpenCL in MQL5 poiché il sito Web presenta già due ottimi articoli che trattano questo argomento:
- OpenCL OpenCL: il ponte verso mondi paralleli e
- OpenCL OpenCL: da ingenuo verso una programmazione più perspicace
Cos'è OpenCL?
OpenCL è lo standard aperto per la programmazione parallela sviluppato dal consorzio Khronos Group nel 2008. Questo standard consente di sviluppare applicazioni che potrebbero essere eseguite in parallelo su GPUs o CPUs con architettura diversa in un sistema eterogeneo.
In altre parole, OpenCL consente di utilizzare tutti i core della CPU o l'enorme capacità di calcolo della GPU durante il calcolo di un'attività, riducendo così i tempi di esecuzione del programma. L'uso di OpenCL è quindi molto utile quando si ha a che fare con attività associate a calcoli laboriosi e che consumano risorse.
Ad esempio, parlando di MQL5, il guadagno di prestazioni può essere molto gratificante quando si gestisce un determinato script (indicatore o Expert Advisor) che esegue un'analisi complessa e lunga dei dati storici mediante diversi simboli e intervalli di tempo (va qui notato che un programma MQL5 che è destinato a utilizzare l'esecuzione parallela dovrebbe essere scritto in un modo speciale utilizzando OpenCL API).
Supporto OpenCL
Il supporto per OpenCL in MQL5 è fornito a partire dalla versione 1.1 rilasciata nel giugno 2010. Quindi, per utilizzare il calcolo parallelo, è necessario disporre di un software e di un hardware relativamente nuovi appropriati per lo standard.
Detto questo, va notato che per iniziare a utilizzare OpenCL non importa se hai o meno una scheda grafica sul tuo PC: una CPU basterà. Ciò significa che OpenCL è disponibile praticamente per ogni utente che desidera ridurre il tempo di esecuzione dei propri programmi MQL5.
Le CPU sono decisamente molto indietro rispetto ai loro rivali grafici in termini di velocità di elaborazione distribuita. Tuttavia, una buona CPU multi-core dovrebbe andare bene per ottenere un aumento significativo della velocità. Ma torniamo all'argomento della nostra discussione.
Come già accennato in precedenza, puoi utilizzare sia le schede grafiche che le CPU per il calcolo parallelo. Ci sono tre principali produttori di dispositivi rilevanti sul mercato: Intel, AMD e NVIDIA. La tabella seguente fornisce informazioni sui dispositivi e sui sistemi operativi che supportano OpenCL 1.1 per ciascuno dei tre produttori:
| Produttore | Dispositivi | Sistemi operativi |
|---|---|---|
| Intel | CPU: Core i3, i5, i7 - per PC; Xeon - per server; Xeon Phi - per coprocessori (per approfondire). | Windows 7, 8; openSUSE; Cappello rosso. |
| AMD | Schede grafiche: AMD Radeon HD Graphics dalla serie 6400 in su; ATI Radeon HD Graphics dalla serie 5400 in su; Grafica ATI FirePro serie A300, S, W, V; ATI Mobility Radeon HD dalla serie 5400 in su; ATI FirePro M7820 M5800 (leggi di più). CPU basate su architettura K8 e successive: Opteron, Athlon 64, Athlon 64 FX, Athlon 64 X2, Sempron, Turion 64, Turion 64 X2, Phenom, Phenom II (leggi di più). APU (processore ibrido CPU/GPU): CPU serie A, C, E, E2, G, R. | Windows Vista SP2, 7, 8; openSUSE 11.x; Ubuntu 11.04; Red Hat 6.x. |
| NVidia | GPUs (with CUDA Architecture): Tesla, Quadro, GeForce (leggi di più). | Windows XP, Vista, 7, 8 Linux e Mac OS (leggi di più) |
Assicurati di avere almeno un dispositivo (CPU o GPU) disponibile sul tuo computer e controlla se quel dispositivo, così come il sistema operativo installato, supporta OpenCL 1.1. Se questi requisiti sono soddisfatti, puoi tranquillamente passare alla sezione successiva che descrive come configurare OpenCL, a seconda del produttore dell'hardware.
Configurazione di OpenCL
Se hai installato l'hardware e il software necessari sul tuo computer, tutto ciò che devi fare per iniziare a utilizzare il calcolo parallelo in MetaTrader 5 è configurare OpenCL per uno dei tuoi dispositivi.
La procedura di configurazione di OpenCL varia a seconda dell'hardware che si intende utilizzare: GPU o CPU. Se il terminale MetaTrader 5 ha trovato una scheda grafica con supporto OpenCL, devi solo aggiornare i suoi driver all'ultima versione.
Ti verrà richiesto di installare un SDK per la CPU solo se il tuo computer non ha la scheda grafica appropriata.
Importante: Se hai già una scheda grafica con supporto OpenCL installato, non è necessario installare una versione software per l'emulazione OpenCL sulla CPU!
A meno che non sia richiesto per esperimenti in quanto le schede grafiche per OpenCL offrono indiscutibili vantaggi.
I paragrafi seguenti descrivono la procedura di configurazione di OpenCL, a seconda del produttore. È possibile accedere alle relative istruzioni di configurazione utilizzando il collegamento corrispondente:
- Configurazione per CPU Intel;
- Configurazione per GPU AMD;
- Configurazione per CPU AMD;
- Configurazione per GPU NVidia.
1. Intel
Per poter utilizzare OpenCL su CPU Intel, è necessario scaricare e installare Intel SDK for OpenCL Applications. Per fare ciò, vai alla pagina di download dello sviluppatore ufficiale.
Fig. 1.1. Pagina di download di Intel SDK per OpenCL.
Qui puoi trovare informazioni generali su OpenCL, nonché un elenco di prodotti disponibili per il download. Per scaricare i prodotti disponibili, fare clic sul pulsante Confronta e scarica prodotti nell'angolo in alto a destra della pagina.
Fig. 1.2. Informazioni sui prodotti disponibili e requisiti di installazione.
Dopo aver fatto clic, verrà visualizzata una finestra con le informazioni sui requisiti del prodotto in merito ai tipi di processore e ai sistemi operativi supportati. Seleziona e scarica un prodotto adatto facendo clic sul pulsante Download sopra l'icona del prodotto.
Fig. 1.3. Scarica il link
Verrà visualizzata un'altra finestra con i collegamenti per il download. Seleziona e scarica l'SDK a 32 o 64 bit. Attendi un paio di minuti ed esegui il file ottenuto al termine del download. Conferma l'installazione dei componenti SDK ed estrai i file in una delle cartelle.
Fig. 1.4. Avvio dell'installazione di Intel SDK per OpenCL.
Vedrai la finestra di installazione che dice Intel SDK per applicazioni OpenCL con supporto OpenCL 1.2. Fare clic su Avanti e seguire le istruzioni di installazione.
Fig. 1.5. Accettazione del contratto di licenza con l'utente finale.
Accetta i termini e le condizioni del contratto di licenza. Successivamente, nella finestra verranno visualizzati i componenti da installare - fare clic suAvanti per continuare.
Fig. 1.6. Integrazione dell'SDK con Visual Studio.
Se il software Microsoft Visual Studio 2008 (o versioni successive) è già disponibile sul tuo PC, ti verrà chiesto di integrarlo per scopi OpenCL. Quindi dovrai solo selezionare gli utenti che saranno in grado di accedere ai componenti installati, specificare il percorso di installazione dell'SDK e fare clic su Installa.
Fig. 1.7. Installazione
L'installazione richiederà un paio di minuti. Una volta completato con successo, vedrai il risultato sullo schermo. Fare clic su Fine per completare il processo di installazione.
Fig. 1.8. Completamento dell'installazione
2.1. Schede grafiche e APU AMD
Per installare OpenCL per una scheda grafica AMD, aggiorniamo il suo driver all'ultima versione disponibile. Questo può essere fatto dalla pagina download del driver.
Fig. 2.1.1. Pagina di download del driver AMD.
Se conosci le specifiche della tua scheda grafica, il driver può essere facilmente trovato compilando un modulo sul lato sinistro della pagina. Dopo aver selezionato le opzioni necessarie in tutti i campi del modulo, fare clic su Visualizza risultati per trovare il driver appropriato.
Fig. 2.1.2. Download del catalizzatore AMD.
Il sistema offrirà alcuni driver in Catalyst Software Suite, incluso il driver OpenCL. Scarica Catalyst ed esegui il file ottenuto.
Fig. 2.1.3. Pagina di download dell'applicazione per l'identificazione del tipo di scheda grafica e della versione del driver.
È inoltre possibile utilizzare il sistema Driver Autodetect facendo clic sul collegamento corrispondente nell'angolo in alto a destra della pagina (Fig. 2.1.1.). Ti verrà chiesto di scaricare l'applicazione AMD Driver Autodetect: fallo e avviala.
Fig. 2.1.4. Applicazione per il rilevamento e il download del driver appropriato.
L'applicazione analizzerà il sistema e ti offrirà di scaricare il driver della scheda grafica appropriato. Scaricalo ed esegui il file ottenuto. Il Gestore installazione ti chiederà di selezionare la cartella per decomprimere i file: seleziona e fai clic su Installa.
Fig. 2.1.5. Gestione dell'installazione di AMD Catalyst.
Il contratto di licenza con l'utente finale apparirà in una finestra pop-up. Dobbiamo accettare i suoi termini e condizioni. Selezioniamo ulteriormente l'installazione rapida, specifichiamo la posizione di installazione di AMD Catalyst e facciamo clic su Avanti.
Fig. 2.1.6. Installazione
L'installazione richiederà un paio di minuti. Una volta completata, vedrai il relativo messaggio sullo schermo.
Fig. 2.1.7. Completamento dell'installazione
2.2. CPU AMD
Per installare OpenCL per una CPU AMD, è necessario scaricare e installare l'ultima versione di AMD APP SDK. A tal fine, vai alla pagina following sul sito ufficiale dello sviluppatore.
Fig. 2.2.1. Pagina di download dell'SDK dell'APP AMD.
Questa pagina fornisce alcune informazioni sull'SDK in quanto tale e dà un'idea di OpenCL. Ciò di cui abbiamo bisogno qui è trovare e fare clic sul collegamento Vai a download sotto la descrizione.
Fig. 2.2.2. Tabella degli SDK disponibili per il download.
Nella parte inferiore della pagina, vedrai una tabella con un elenco delle ultime versioni dell'SDK per vari sistemi operativi, a 32 o 64 bit, nonché i collegamenti per il download. Selezionare la versione richiesta facendo clic sul collegamento pertinente. Verrai indirizzato alla pagina con il contratto di licenza con l'utente finale. Accettalo per avviare il download.
Dopo aver eseguito il programma di installazione scaricato, ti verrà chiesto di estrarre i file di installazione in una cartella. Questo sarà seguito dall'installazione dell'AMD Catalyst sopra descritto contenente AMD APP SDK per la tua CPU. La procedura di installazione di Catalyst è mostrata nelle Fig. 2.1.5 - 2.1.7 della sezione 2.1. sopra.
3. NVidia
Se hai una scheda grafica NVidia, devi aggiornare il suo driver all'ultima versione per poter installare OpenCL. Puoi scaricarlo dalla pagina download del driver sul sito Web dello sviluppatore.
Fig. 3.1. Pagina di download del driver Nvidia.
Questa pagina offre opzioni per trovare il driver richiesto manualmente o automaticamente. Utilizzando l'opzione manuale, è necessario selezionare il tipo di prodotto, la serie, il sistema operativo e fare clic su Cerca. Il sistema troverà il driver più recente adatto alla tua scheda grafica e ti chiederà di scaricarlo.
Fig. 3.2. Download del driver selezionato.
Se si opta per l'opzione 2, è necessario fare clic su Driver di grafica per cui verrà chiesto di eseguire la scansione del sistema utilizzando l'applicazione Java GPU_Reader.
Fig. 3.3. Esecuzione dell'applicazione per identificare il tipo di scheda grafica e la versione del driver.
Eseguire l'applicazione facendo clic su Esegui. Attendi qualche secondo per poter vedere le informazioni sulla scheda grafica, la versione corrente del driver installato e l'ultima versione del driver consigliata. Fare clic su Download per essere indirizzati alla pagina di download mostrata in Fig. 3.2.
Fig. 3.4. Risultati dell'identificazione automatica del tipo di scheda grafica e della versione del driver.
Fare clic su Scarica ora e accettare il contratto di licenza del software NVidia facendo clic sul pulsante Accetta e scarica.
Fig. 3.5. Accettazione del contratto di licenza e download del driver.
Pertanto, otteniamo l'ultima versione del driver per la scheda grafica. Quindi eseguiamo il file ottenuto: ti verrà chiesto di estrarre i file di installazione del driver in una delle cartelle. L'installazione verrà avviata dopo aver decompresso i file. Innanzitutto, è necessario accettare nuovamente i termini e le condizioni del contratto di licenza del software NVidia.
Fig. 3.6. Accettazione del contratto di licenza nella prima fase di installazione.
Quindi selezionare l'opzione di installazione rapida e fare clic su Avanti. Inoltre, ti verrà offerto di installare il programma aggiuntivo NVidia Experience che è opzionale.
Fig. 3.7. Selezione dell'opzione di installazione.
L'installazione del driver inizierà subito dopo, accompagnata dalla pubblicità degli ultimi sviluppi di NVidia.
Fig. 3.8. Installazione
Questo è tutto. Il driver è stato installato e dobbiamo solo riavviare il sistema per poter utilizzare OpenCL nel terminale MetaTrader 5.
Fig. 3.9. Completamento dell'installazione
Confronto delle prestazioni
OpenCL_Sample.mq5 è stato scritto per dimostrare i vantaggi dell'utilizzo di OpenCL in MQL5. Calcola i valori della funzione di due variabili in alcuni set e visualizza i risultati nella finestra del grafico utilizzando un'etichetta grafica (OBJ_BITMAP_LABEL). I calcoli vengono eseguiti in due modi: utilizzando e senza utilizzare OpenCL. Questi blocchi sono implementati rispettivamente sotto forma di funzioni WithOpenCL() e WithoutOpenCL():
//+------------------------------------------------------------------+ //| 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); }
Dopo aver eseguito lo script, per alcuni secondi sarai in grado di vedere l'insieme dipinto di valori di funzione nella finestra del grafico. Ciascuno di essi corrisponde ad uno dei toni del colore selezionato nei parametri di input (rosso, verde o blu).
Risultati dell'esecuzione dello script per l'insieme di punti nel piano da -22 a 22 al passo 0.1.
Oltre all'immagine stessa, il tempo di calcolo della funzione per entrambi i metodi viene visualizzato nel giornale "Expert Advisors" in modo da poter vedere chiaramente i vantaggi e il valore pratico dell'utilizzo di OpenCL in MQL5. Aumenta il valore del passaggio e ottieni i risultati dell'esecuzione dello script:
Risultati del calcolo della funzione e dei valori di colore della pittura utilizzando due metodi.
Il tempo totale di calcolo delle funzioni sulla CPU utilizzando OpenCL sembra essere più di 5 volte inferiore e questo è lungi dall'essere il limite! È risaputo che i calcoli su GPU avanzate con supporto OpenCL sono molto più veloci rispetto alle CPU. Puoi trovare una chiara prova di questo fatto nei risultati dell'esecuzione dello script su diversi dispositivi OpenCL, come mostrato nella tabella seguente:
| Dispositivo OpenCL | Tempo di esecuzione senza utilizzare OpenCL, ms | Tempo di esecuzione utilizzando OpenCL, ms | Guadagno di prestazioni |
|---|---|---|---|
| AMD Radeon HD 7970 | 20.361 ms | 171 ms | 119.07 volte |
| NVidia GeForce GT 630 | 24.742 ms | 578 ms | 42,8 volte |
| Intel Core i5 430M | 27,222 ms | 5,428 ms | 5,01 volte |
| AMD Athlon X2 Dual-Core QL-65 | 45,723 ms | 9,516 ms | 4,8 volte |
Come si può notare, l'utilizzo di OpenCL sulla scheda grafica AMD top di gamma ha comportato una riduzione di 100 volte dei tempi di calcolo! Risultati significativi sono stati ottenuti anche sulla GeForce GT 630 del 2011, leggermente più vecchia, con una riduzione dei tempi di 42 volte. Le CPU di Intel e AMD sono arrivate per ultime. Tuttavia, il guadagno di prestazioni ottenuto su di essi sarà anche molto utile quando si ha a che fare con calcoli complessi.
Questo è tutto. La tabella dei confronti dimostra un chiaro vantaggio dell'utilizzo del calcolo parallelo nell'elaborazione di dati di massa. Tutto quello che dovresti fare è installare il driver appropriato per la tua scheda grafica o CPU.
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/690
Un'altra classe OOP MQL5
Manuale MQL5: Gestire gli eventi tipici dei grafici
Creazione di EA di reti neurali utilizzando MQL5 Wizard e Hlaiman EA Generator
MQL5 Cloud Network: Stai ancora calcolando?
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso