Comment installer et utiliser OpenCL pour les calculs

OpenCL dans le terminal client MetaTrader 5

Cela fait plus d'un an qu'il est devenu possible d'écrire des programmes pour OpenCL en MQL5. Les entrées de tous les dispositifs OpenCL trouvés peuvent désormais être consultées dans le Journal au lancement du terminal MetaTrader 5, comme indiqué ci-dessous.

Dans ce cas, le terminal MetaTrader 5 a détecté 4 méthodes disponibles pour lancer OpenCL directement depuis un programme MQL5 : une carte graphique de NVIDIA (OpenCL 1.1) et une d'AMD (OpenCL 1.2), ainsi que deux processeurs Intel Core-i7 d'utilisation options, selon le pilote installé. Si votre ordinateur dispose déjà d'un dispositif OpenCL approprié version 1.1 ou supérieure, vous pouvez ignorer en toute sécurité la partie description et passer directement à la comparaison des performances pour pouvoir constater par vous-même le gain de performances pour les tâches permettant le calcul parallèle.

OpenCL est fascinant !

Cependant, peu d'utilisateurs ont profité de l'utilisation du calcul parallèle dans leurs Expert Advisors, indicateurs ou scripts car ils ne sont pas au courant des nouvelles possibilités offertes et n'ont pas les connaissances requises.

Le fait est que le lancement de tout programme MQL5 utilisant OpenCL nécessite l'installation d'un logiciel approprié. C'est pourquoi de nombreux utilisateurs n'étaient tout simplement pas en mesure d'exécuter le script d'ensemble de Mandelbrot, ainsi que de nombreux autres programmes disponibles sur le forum MQL5.community.

Dans cet article, nous allons vous montrer comment installer OpenCL sur votre ordinateur afin que vous puissiez constater par vous-même les avantages de l'utilisation du calcul parallèle dans MQL5. Nous n'allons pas considérer les détails de l'écriture de programmes pour OpenCL en MQL5 car le site Web propose déjà deux excellents articles qui couvrent ce sujet :

• OpenCL : Le pont vers les mondes parallèles et
• OpenCL : De la programmation naïve à une programmation plus perspicace.

Qu'est-ce qu'OpenCL ?

OpenCL est le standard ouvert pour la programmation parallèle développé par le consortium Khronos Group en 2008. Cette norme vous permet de développer des applications pouvant être exécutées en parallèle sur GPUs ou CPUs avec une architecture différente dans un système hétérogène.

En d'autres termes, OpenCL permet d'utiliser tous les cœurs CPU ou l'énorme capacité de calcul du GPU lors du calcul d'une tâche, réduisant ainsi le temps d'exécution du programme. L'utilisation d'OpenCL est donc très bénéfique lorsqu'il s'agit de tâches associées à des calculs laborieux et consommateurs de ressources.

Par exemple, en parlant de MQL5, le gain de performance peut être très gratifiant lors de la manipulation d'un certain script (indicateur ou Expert Advisor) qui effectue une analyse complexe et longue des données historiques par plusieurs symboles et délais (il faut noter ici qu'un programme MQL5 qui est destiné à utiliser l'exécution parallèle doit être écrit d'une manière spéciale à l'aide de OpenCL API).

Support OpenCL

Le support d'OpenCL dans MQL5 est fournie à partir de la version 1.1 publiée en juin 2010. Ainsi, pour utiliser le calcul parallèle, vous devez disposer d'un logiciel et d'un matériel relativement nouveaux et adaptés à la norme.

Cela dit, il convient de noter que pour commencer à utiliser OpenCL, peu importe que vous ayez ou non une carte graphique sur votre PC - un processeur fera l'affaire. Cela signifie qu'OpenCL est disponible pour pratiquement chaque utilisateur qui souhaite réduire le temps d'exécution de ses programmes MQL5.

Les processeurs sont définitivement loin derrière leurs rivaux graphiques en termes de vitesse de calcul distribué. Cependant, un bon processeur multicœur devrait faire l'affaire pour obtenir une augmentation significative de la vitesse. Mais revenons au sujet de notre discussion.

Comme déjà mentionné précédemment, vous pouvez utiliser à la fois des cartes graphiques et des processeurs pour le calcul parallèle. Il existe trois principaux fabricants des appareils concernés sur le marché : Intel, AMD et NVidia. Le tableau suivant fournit des informations sur les dispositifs et les systèmes d'exploitation qui prennent en charge OpenCL 1.1 pour chacun des trois fabricants :

Fabricant	Dispositifs	Systèmes d'exploitation
Intel	Processeurs : Core i3, i5, i7 - pour les PC ; Xeon - pour les serveurs ; Xeon Phi - pour les coprocesseurs (en savoir plus).	Windows 7, 8 ; openSUSE ; Red Hat.
AMD	Cartes graphiques : Cartes graphiques AMD Radeon HD à partir de la série 6400 ; Cartes graphiques ATI Radeon HD à partir de la série 5400 ; ATI FirePro Graphics A300, séries S, W, V ; ATI Mobility Radeon HD à partir de la série 5400 ; ATI FirePro M7820 M5800 (en savoir plus). Processeurs basés sur l'architecture K8 et versions ultérieures : Opteron, Athlon 64, Athlon 64 FX, Athlon 64 X2, Sempron, Turion 64, Turion 64 X2, Phenom, Phenom II (en savoir plus). APU (processeur hybride CPU/GPU) : CPU séries A, C, E, E2, G, R.	Windows Vista SP2, 7, 8 ; openSUSE 11.x ; Ubuntu 11.04; Red Hat 6.x.
NVidia	GPU (avec Architecture CUDA) : Tesla, Quadro, GeForce (en savoir plus).	Windows XP, Vista, 7, 8 Linux et Mac OS (en savoir plus)

De plus, le site Web officiel du développeur, le groupe Khronos, fournit des informations complètes sur le matériel et les logiciels requis pour chaque version d'OpenCL.

Assurez-vous qu'au moins un dispositif (CPU ou GPU) est disponible sur votre ordinateur et vérifiez si ce dispositif, ainsi que le système d'exploitation installé, prennent en charge OpenCL 1.1. Si ces conditions sont remplies, vous pouvez passer en toute sécurité à la section suivante qui décrit comment configurer OpenCL, en fonction du fabricant du matériel.

 

Configuration d'OpenCL

Si vous avez le matériel et les logiciels requis installés sur votre ordinateur, tout ce que vous avez à faire pour commencer à utiliser le calcul parallèle dans MetaTrader 5 est de configurer OpenCL pour l'un de vos appareils.

La procédure d'installation d'OpenCL varie en fonction du matériel que vous avez l'intention d'utiliser - GPU ou CPU. Si le terminal MetaTrader 5 a trouvé une carte graphique prenant en charge OpenCL, il vous suffit de mettre à jour ses pilotes vers la dernière version.

Vous devrez installer un SDK pour le processeur uniquement si votre ordinateur ne dispose pas de la carte graphique appropriée.

Importan : Si vous avez déjà une carte graphique avec le support OpenCL installé, vous n'avez pas besoin d'installer une version logicielle pour l'émulation OpenCL sur le CPU !

A moins que cela ne soit requis pour des expérimentations car les cartes graphiques pour OpenCL offrent des avantages incontestables.

Les paragraphes suivants décrivent la procédure d'installation d'OpenCL, selon le fabricant. Vous pouvez accéder aux instructions de configuration appropriées en utilisant le lien correspondant :

• Configuration pour les CPU Intel ;
• Configuration pour les GPU AMD ;
• Configuration pour les CPU AMD ;
• Configuration pour les GPU NVidia.
  

1. Intel

Pour pouvoir utiliser OpenCL sur les processeurs Intel, vous devez télécharger et installer le Intel SDK pour les applications OpenCL. Pour ce faire, rendez-vous sur aller sur la page de téléchargement officielle du développeur.

Fig. 1.1. Page de téléchargement du Intel SDK pour OpenCL.

Vous trouverez ici des informations générales sur OpenCL, ainsi qu'une liste de produits disponibles en téléchargement. Pour télécharger les produits disponibles, cliquez sur le bouton Comparer et télécharger des produits dans le coin supérieur droit de la page.

Fig. 1.2. Informations sur les produits disponibles et les exigences d'installation.

Après avoir cliqué, vous verrez une fenêtre avec des informations sur les exigences du produit quant aux types de processeurs et systèmes d'exploitation pris en charge. Sélectionnez et téléchargez un produit approprié en cliquant sur le bouton Télécharger au-dessus de l'icône du produit.

Fig. 1.3. Liens de téléchargement du SDK

Une autre fenêtre apparaîtra avec des liens de téléchargement. Sélectionnez et téléchargez le SDK 32 bits ou 64 bits. Attendez quelques minutes et exécutez le fichier obtenu une fois le téléchargement terminé. Confirmez l'installation des composants SDK et extrayez les fichiers dans l'un des dossiers.

Fig. 1.4. Démarrage de l'installation de Intel SDK pour OpenCL.

Vous verrez la fenêtre d'installation indiquant SDK Intel pour les applications OpenCL avec support OpenCL 1.2. Cliquez sur Next et suivez les instructions d'installation.

Fig. 1.5. Acceptation du contrat de licence utilisateur final.

Acceptez les termes et conditions du contrat de licence. Ensuite, les composants à installer seront affichés dans la fenêtre - cliquez sur Next pour continuer.

Fig. 1.6. Intégration du SDK avec Visual Studio.

Si le logiciel Microsoft Visual Studio 2008 (ou des versions ultérieures) est déjà disponible sur votre PC, vous serez invité à l'intégrer à des fins OpenCL. Ensuite, vous n'aurez qu'à sélectionner les utilisateurs qui pourront accéder aux composants installés, spécifier l'emplacement d'installation du SDK et cliquer sur Install.

Fig. 1.7. Installation.

L'installation prendra quelques minutes. Une fois qu'il a été complété avec succès, vous verrez le résultat à l'écran. Cliquez sur Finish pour terminer le processus d'installation.

Fig. 1.8. Fin de l'installation.

 

2.1. Cartes graphiques AMD et APU

Pour installer OpenCL pour une carte graphique AMD, mettons à jour son pilote vers la dernière version disponible. Cela peut être fait à partir de la http://support.amd.com/us/gpudownload/Pages/index.aspx.

Fig. 2.1.1. Page de téléchargement du pilote AMD.

Si vous connaissez les spécifications de votre carte graphique, le pilote peut facilement être trouvé en remplissant un formulaire sur le côté gauche de la page. Une fois que vous avez sélectionné les options nécessaires dans tous les champs du formulaire, cliquez sur Afficher les résultats pour trouver le pilote approprié.

Fig. 2.1.2. Téléchargement de AMD Catalyst.

Le système proposera quelques pilotes dans Catalyst Software Suite, y compris le pilote OpenCL. Téléchargez Catalyst et exécutez le fichier obtenu.

Fig. 2.1.3. Page de téléchargement de l'application pour l'identification du type de carte graphique et de la version du pilote.

Vous pouvez également utiliser le système Driver Autodetect en cliquant sur le lien correspondant dans le coin supérieur droit de la page (Fig. 2.1.1.). Vous serez invité à télécharger l'application AMD Driver Autodetect - faites-le et démarrez-la.

Fig. 2.1.4. Application pour la détection et le téléchargement du pilote approprié.

L'application analysera le système et vous proposera de télécharger le pilote de carte graphique approprié. Téléchargez-le et exécutez le fichier obtenu. Le gestionnaire d'installation vous demandera de sélectionner le dossier pour décompresser les fichiers - sélectionnez et cliquez sur Install.

Fig. 2.1.5. Gestionnaire d'installation AMD Catalyst.

Le contrat de licence utilisateur final apparaîtra dans une fenêtre contextuelle. Nous devons accepter ses termes et conditions. Nous sélectionnons ensuite l'installation express, spécifions l'emplacement d'installation d'AMD Catalyst et cliquez sur Suivant.

Fig. 2.1.6. Installation.

L'installation prendra quelques minutes. Une fois terminé, vous verrez le message correspondant à l'écran.

Fig. 2.1.7. Fin de l'installation.

 

2.2. Processeurs AMD

Pour installer OpenCL pour un processeur AMD, nous devons télécharger et installer la dernière version d'AMD APP SDK. Pour cela, rendez-vous sur http://developer.amd.com/tools-and-sdks/heterogeneous-computing/amd-accelerated-parallel-processing-app-sdk/ sur le site officiel du développeur.

Fig. 2.2.1. Page de téléchargement du AMD APP SDK.

Cette page fournit quelques informations sur le SDK en tant que tel et donne une idée d'OpenCL. Ce dont nous avons besoin ici, c'est de trouver et de cliquer sur le lien Aller aux téléchargements sous la description.

Fig. 2.2.2. Tableau des SDK disponibles en téléchargement.

Au bas de la page, vous verrez un tableau avec une liste des dernières versions du SDK pour divers systèmes d'exploitation, soit 32 bits ou 64 bits, ainsi que des liens de téléchargement. Sélectionnez la version souhaitée en cliquant sur le lien correspondant. Vous serez dirigé vers la page contenant le contrat de licence utilisateur final. Acceptez-le pour lancer le téléchargement.

Après avoir exécuté le programme d'installation téléchargé, vous serez invité à extraire les fichiers d'installation dans un dossier. Ceci sera suivi de l'installation du catalyseur AMD décrit ci-dessus contenant le SDK APP AMD pour votre CPU. La procédure d'installation de Catalyst est illustrée dans les Fig. 2.1.5 - 2.1.7 de la section 2.1. dessus.

 

3. NVidia

Si vous avez une carte graphique NVidia, vous devez mettre à jour son pilote vers la dernière version pour pouvoir installer OpenCL. Vous pouvez le télécharger à partir de http://www.nvidia.com/Download/index.aspx?lang=en-us sur le site Web du développeur.

Fig. 3.1. Page de téléchargement du pilote NVidia.

Cette page vous offre des options pour trouver le pilote requis manuellement ou automatiquement. En utilisant l'option manuelle, vous devez sélectionner le type de produit, la série, le système d'exploitation et cliquer sur Search. Le système trouvera le dernier pilote adapté à votre carte graphique et vous invitera à le télécharger.

.

Fig. 3.2. Téléchargement du pilote sélectionné.

Si vous optez pour l'option 2, vous devez cliquer sur Pilotes graphiques, ce qui vous demandera d'analyser votre système à l'aide de l'application Java GPU_Reader.

Fig. 3.3. Exécution de l'application pour identifier le type de carte graphique et la version du pilote.

Exécutez l'application en cliquant sur Run. Attendez quelques secondes pour pouvoir voir les informations sur la carte graphique, la version actuelle du pilote installé et la dernière version du pilote recommandée. Cliquez sur Download pour être dirigé vers la page de téléchargement illustrée à la Fig. 3.2.

Fig. 3.4. Résultats de l'identification automatique du type de carte graphique et de la version du pilote.

Cliquez sur Download Now et acceptez le contrat de licence du logiciel NVidia en cliquant sur le bouton Agree and Download.

Fig. 3.5. Acceptation du contrat de licence et téléchargement du pilote.

Ainsi, nous obtenons la dernière version du pilote pour la carte graphique. Ensuite, nous exécutons le fichier obtenu - il vous sera demandé d'extraire les fichiers d'installation du pilote dans l'un des dossiers. L'installation commencera après avoir décompressé les fichiers. Tout d'abord, vous devez à nouveau accepter les termes et conditions du contrat de licence logicielle NVidia.

Fig. 3.6. Acceptation du contrat de licence lors de la première étape de l'installation.

Sélectionnez ensuite l'option d'installation Express et cliquez sur Next. De plus, il vous sera proposé d'installer le programme complémentaire NVidia Experience qui est facultatif.

Fig. 3.7. Sélection de l'option d'installation.

L'installation du pilote commencera immédiatement après cela, accompagnée de la publicité des derniers développements de NVidia.

Fig. 3.8. Installation.

C'est ça. Le pilote a été installé et il nous suffit de redémarrer le système pour pouvoir utiliser OpenCL dans le terminal MetaTrader 5.

Fig. 3.9. Fin de l'installation.

 

Comparaison des performances

OpenCL_Sample.mq5 a été écrit pour démontrer les avantages d'utiliser OpenCL dans MQL5. Il calcule les valeurs de la fonction de deux variables à un certain ensemble et affiche les résultats dans la fenêtre graphique à l'aide d'une étiquette graphique (OBJ_BITMAP_LABEL). Les calculs sont effectués de deux manières - en utilisant et sans utiliser OpenCL. Ces blocs sont implémentés sous la forme des fonctions WithOpenCL() et WithoutOpenCL(), respectivement :

//+------------------------------------------------------------------+
//| 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);
  }

Après avoir exécuté le script, vous pourrez voir pendant quelques secondes l'ensemble peint de valeurs de fonction dans la fenêtre du graphique. Chacun d'eux correspond à l'un des tons de la couleur sélectionnée dans les paramètres d'entrée (rouge, vert ou bleu).

Résultats de l'exécution du script pour l'ensemble de points dans le plan de -22 à 22 à l'étape 0.1.

En plus de l'image elle-même, le temps de calcul de la fonction pour les deux méthodes est affiché dans le journal "Expert Advisors" afin que vous puissiez clairement voir les avantages et la valeur pratique de l'utilisation d'OpenCL dans MQL5. Augmentez la valeur du pas et obtenez les résultats de l'exécution du script :

Résultats du calcul des fonctions et des valeurs de couleur de peinture à l'aide de deux méthodes.

Le temps total de calcul des fonctions sur le CPU en utilisant OpenCL est apparu plus de 5 fois inférieur et c'est loin d'être la limite ! Il est bien connu que les calculs sur les GPU avancés avec support OpenCL sont beaucoup plus rapides que sur les CPU. Vous pouvez trouver une preuve claire de ce fait dans les résultats de l'exécution du script sur différents appareils OpenCL, comme indiqué dans le tableau ci-dessous :

Dispositif OpenCL	Temps d'exécution sans utiliser OpenCL, ms	Temps d'exécution avec OpenCL, ms	Gain de performances
AMD Radeon HD 7970	20 361 ms	171 ms	119,07 fois
NVidia GeForce GT 630	24 742 ms	578 ms	42,8 fois
Intel Core i5 430M	27 222 ms	5 428 ms	5,01 fois
AMD Athlon X2 double cœur QL-65	45 723 ms	9 516 ms	4,8 fois

Comme on le voit, l'utilisation d'OpenCL sur la carte graphique AMD haut de gamme a permis de réduire par 100 le temps de calcul ! Des résultats significatifs ont également été obtenus sur la GeForce GT 630 de 2011, un peu plus ancienne, avec une réduction de temps de 42 fois. Les processeurs d'Intel et d'AMD sont arrivés en dernier. Cependant, le gain de performances obtenu sur ces derniers sera également très bénéfique lorsqu'il s'agira de calculs complexes.

C'est à peu près ça. Le tableau des comparaisons démontre un net avantage de l'utilisation du calcul parallèle dans le traitement de données en masse. Tout ce que vous devez faire est d'installer le pilote approprié pour votre carte graphique ou votre CPU.