OpenCL

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Ne doit pas être confondu avec OpenGL.
OpenCL
Image illustrative de l'article OpenCL
Logo

Développeur Khronos Group
Dernière version 1.2 ()
Environnement Cross-platform
Type API
Licence Format Ouvert Libre de Droits
Site web www.khronos.org

OpenCL (Open Computing Language) est la combinaison d'une API et d'un langage de programmation dérivé du C, proposé comme un standard ouvert par le Khronos Group. OpenCL est conçu pour programmer des systèmes parallèles hétérogènes comprenant par exemple à la fois un CPU multi-cœur et un GPU. OpenCL propose donc un modèle de programmation se situant à l'intersection naissante entre le monde des CPU et des GPU, les premiers étant de plus en plus parallèles, les seconds étant de plus en plus programmables.

Présentation[modifier | modifier le code]

OpenCL distingue le processeur hôte (processeur central faisant office de chef d'orchestre) des périphériques (CPU, GPU, ou autre) dont la mission est d'exécuter des noyaux de calcul intensifs. OpenCL distingue donc d'un coté l'application tournant sur le processeur hôte (et qui va appeler l'API OpenCL), et de l'autre coté les noyaux qui sont programmés en OpenCL-C (et dont la vocation est d'être exécutés sur les périphériques).

OpenCL permet d'exprimer du parallélisme de tâches mais aussi du parallélisme de données sous deux formes ; SPMD (Single Program Multiple Data) et SIMD (Single Instruction Multiple Data), le tout de manière hiérarchique. Un graphe de tâches peut être créé dynamiquement via l'API OpenCL. Chaque tâche peut être représentée soit sous forme d'une instance unique (appelée tâche), soit sous forme d'une collection d'instances (appelée NDRange) d'un même noyau. Les NDRanges peuvent être de 1, 2 ou 3 dimensions. Chaque instance de kernel appartenant à un NDRange est appelée work-item. Le NDrange peut lui-même être structuré en work-groups, ce qui permet aux work-items à l’intérieur des work-groups de partager des données et de se synchroniser via des barrières.

Si parmi certains de ses objectifs techniques, OpenCL semble se rapprocher de C pour CUDA, modèle de programmation propriétaire de la société Nvidia, OpenCL a des objectifs plus larges car n'étant pas uniquement dédié aux GPU. Dans le monde du calcul haute performance ou du jeu, OpenCL permettra de tirer parti de la puissance des processeurs graphiques, des CPU multi-cœurs ou d'autres systèmes de calcul intensifs tels le CELL d'IBM, qui équipe notamment la PlayStation 3 de Sony. Dans le monde des systèmes embarqués sur puce (SoC), tels qu'on les trouve dans les smartphones, OpenCL permettra l'accès, via une infrastructure de programmation unique, au processeur central, ainsi qu'aux différents sous-systèmes multimédia embarqués (GPU, DSP, computing array ou autres).

Il existe actuellement peu de moyens de déboguer des noyaux OpenCL. Tout d'abord, le débogueur NVIDIA Parallel Nsight, capable de déboguer CUDA thread par thread, ne supporte actuellement pas OpenCL, mais permet seulement de traquer les appels à l'API[1]. Ensuite, AMD propose une extension permettant de mettre des traces directement dans le code OpenCL (cl_amd_printf). Enfin, un programme appelé gDebugger (par Gremedy puis par AMD[2]) permet de suivre le déroulement de l'algorithme thread par thread.

Historique[modifier | modifier le code]

OpenCL a été initialement conçu par Apple[3] (qui en possède les droits d'auteur), et affiné dans le cadre d'une collaboration avec AMD, Intel et Nvidia. Apple soumet d'abord sa proposition initiale au Khronos Group. Le , le Khronos Compute Working Group est formé, comprenant des représentants des fabricants de matériel informatique et de logiciels. Celui-ci travaille durant cinq mois à boucler les détails techniques de la spécification OpenCL 1.0. La spécification est révisée par les membres de Khronos et approuvée pour une version d'essai le 8 décembre. Une nouvelle version, OpenCL 1.1, est publiée en juin 2010 par le Khronos Group. OpenCL 1.1 clarifie certains aspects de la spécification précédente et apporte de nouvelles fonctionnalités telles que les sous-buffers, les vecteurs à 3 éléments, les événements utilisateur, de nouvelles fonctions builtin, le support en standard d'extensions optionnelles 1.0 (telles que les fonctions atomiques 32 bits) .

OpenCL est intégré dans Mac OS X 10.6[3] (Snow Leopard). AMD décide de supporter OpenCL et DirectX 11 plutôt que Close to Metal dans son framework Stream SDK. RapidMind annonce l'adoption de OpenCL sous sa plate-forme de développement, afin de supporter les processeurs graphiques de plusieurs fabricants avec une interface unique. Nvidia confirme également le 9 décembre 2008 le support complet de la spécification 1.0 dans son GPU Computing Toolkit[4].

Le 15 novembre 2011, Le Khronos Group a publié les spécifications d'OpenCL 1.2. On y trouve notamment des fonctionnalités liées à la mobilité et à la portabilité, avec par exemple la possibilité de dissocier compilation et édition de liens des noyaux [5].

WebCL[modifier | modifier le code]

Article détaillé : WebCL.

Le Khronos Group a également développé une intégration d'OpenCL, bibliothèque de calcul parallèle, dans l'ensemble des interfaces de programmation d'HTML5[6]. Actuellement, les navigateurs utilisent des extensions pour gérer OpenCL.

Nokia et Mozilla [7] ont développé des extensions pour Firefox. Samsung pour WebKit et Motorola pour Node.js.

Historique des implémentations[modifier | modifier le code]

Des implémentations d'OpenCL existent pour la majorité des plateformes aujourd'hui. IBM pour ses supercalculateurs sous GNU/Linux utilisant des processeurs Power, les processeurs X86 d'Intel et AMD et les GPU les accompagnant traditionnellement (ATI, nVidia, VIA), les processeurs ARM Cortex-A9 (parties SSE et fpu 128bits Neon), ainsi que les DSP, GPU et autres computing array les accompagnant dans les nombreuses implémentations des System on chip (SoC) (nVidia Tegra2, Qualcomm Snapdragon, Apple A4, Marvell Armada, etc.). Mesa (Implémentation OpenGL/OpenVG sous GNU/Linux) contient un state-tracker OpenCL pour Gallium3D en cours de développement, nommé Clover[8],[9]

Le 10 décembre 2008, AMD et Nvidia font la première démonstration publique d'OpenCL, une présentation de 75 minutes à SIGGRAPH Asia 2008. AMD effectue une démonstration d'OpenCL accélérée sur CPU et explique la scalabilité d'OpenCL sur un ou plusieurs cœurs tandis qu'Nvidia fait une démonstration accélérée par GPU[10],[11].

Le 26 mars 2009, à la GDC 2009, AMD et Havok font une démonstration de la première implémentation accélérée par OpenCL, Havok Cloth sur un GPU de la série Radeon HD 4000 d'AMD[12].

Le 20 avril 2009, Nvidia annonce la sortie de son pilote OpenCL et du SDK aux développeurs participant à son OpenCL Early Access Program[13].

Le 5 août 2009, AMD révèle les premiers outils de développement pour sa plateforme OpenCL comme partie de son programme ATI Stream SDK v2.0 Beta[14].

Le 28 août 2009, Apple sort Mac OS X Snow Leopard, qui contient une implémentation complète d'OpenCL[15].

Dans Snow Leopard, OpenCL est initialement supporté sur les puces ATI Radeon HD 4850, ATI Radeon HD 4870 ainsi que les puces Nvidia Geforce 8600M GT, GeForce 8800 GS, GeForce 8800 GT, GeForce 8800 GTS, Geforce 9400M, GeForce 9600M GT, GeForce GT 120, GeForce GT 130, GeForce GTX 285, Quadro FX 4800, et Quadro FX 5600[16].

Le 28 septembre 2009, Nvidia sort ses propres pilotes OpenCL et son implémentation du SDK.

Le 13 octobre 2009, AMD sort la quatrième bêta du ATI Stream SDK 2.0, qui fournit une implémentation OpenCL complète sur tous les GPU des familles R700/R800, utilisant également les unités SSE3 des CPUs. Le SDK est disponible à la fois pour GNU/Linux et Windows[17].

Le 30 octobre 2009, IBM sort la version 0.1 de son SDK OpenCL pour GNU/Linux sur l'architecture Power utilisé dans une majorité des plus puissants supercalculateurs au monde[18].

Le 26 novembre 2009, Nvidia sort des pilotes pour l'implémentation OpenCL 1.0 (rev 48).

Les implémentations OpenCL d'Apple[19], Nvidia[20], RapidMind[21] et Mesa Gallium3D[22] sont toutes basées sur la technologie de compilation LLVM et utilisent le compilateur Clang comme frontend.

Le 10 décembre 2009, VIA sort son premier produit supportant OpenCL 1.0 - Le processeur vidéo ChromotionHD 2.0 inclus dans les puces VN1000[23].

Le 21 décembre 2009, AMD sort la version de production de l'ATI Stream SDK 2.0[24], qui fournit un support d'OpenCL 1.0 pour les R800 GPUs et un support bêta pour R700.

Le 29 juin 2011, Intel sort la version finale de son kit de développement supportant OpenCL version 1.1[25].

Le 3 août 2011 AMD annonce son kit de développement ATI Stream SDK 2.5 [26], qui améliore, entre autres, la bande passante CPU/GPU pour tirer un meilleur parti de ses récents APU.

Chez Intel, les processeurs graphiques inclus dans sa gamme de processeurs Ivy Bridge, sortis le 29 avril 2012, Intel HD 2500 ainsi que HD 4000 et supérieurs, sont les premières architectures à supporter matériellement OpenCL, en version 1.1[27].

La bibliothèque Beignet[28] est une bibliothèque OpenCL libre pour les processeurs Intel IvryBridge GT2, dans le cadre du projet freedesktop.org, et développé principalement par Intel. Il utilise principalement LLVM, mais est également compatible avec GCC.

Fin 2013, ARM annonce à son tour son « Mali OpenCL SDK », pour ses processeurs graphiques Mali T600 et supérieurs, dont les premiers modèles sont sortis en 2012. Les sources sont disponibles, mais la licence est propriétaire et contraignante quant à la redistribution[29].

Implémentations Open-source[modifier | modifier le code]

Clover [1] et libCLC [2] pour les fonctions de la librairie standard OpenCL
POCL (Portable OpenCL) [3]

Exemple[modifier | modifier le code]

Cet exemple calcule une Transformée de Fourier rapide

/* creation d'un contexte de calcul sur GPU */
context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);
 
/* récupération de la liste des cartes disponibles */
clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &nb_devices);
clGetContextInfo(context, CL_CONTEXT_DEVICES, nb_devices, devices, NULL);
 
/* creation d'une queue de commande sur le premier GPU */ 
queue = clCreateCommandQueue(context, devices[0], 0, NULL);
 
/* allocation des tampons mémoire */
memobjs[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float)*2*num_entries, srcA, NULL);
memobjs[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*2*num_entries, NULL, NULL);
 
/* création du programme de calcul (le programme qui s'execute sur le GPU) */ 
program = clCreateProgramWithSource(context, 1, &fft1D_1024_kernel_src, NULL, NULL);
 
/* compilation du programme */
clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
 
/* création du noyau de calcul */
kernel = clCreateKernel(program, "fft1D_1024", NULL);
 
/* mise en place des paramètres */
clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&memobjs[0]);
clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&memobjs[1]);
clSetKernelArg(kernel, 2, sizeof(float)*(local_work_size[0]+1)*16, NULL);
clSetKernelArg(kernel, 3, sizeof(float)*(local_work_size[0]+1)*16, NULL);
 
/* création des objets de travail
   et lancement du calcul */
global_work_size[0] = num_entries;
local_work_size[0] = 64;
clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);

Le calcul : (basé sur Fitting FFT onto the G80 Architecture)[30]

// This kernel computes FFT of length 1024. The 1024 length FFT is decomposed into 
// calls to a radix 16 function, another radix 16 function and then a radix 4 function 
 
__kernel void fft1D_1024 (__global float2 *in, __global float2 *out, 
                          __local float *sMemx, __local float *sMemy) { 
  int tid = get_local_id(0); 
  int blockIdx = get_group_id(0) * 1024 + tid; 
  float2 data[16]; 
  // starting index of data to/from global memory 
  in = in + blockIdx;  out = out + blockIdx; 
  globalLoads(data, in, 64); // coalesced global reads 
  fftRadix16Pass(data);      // in-place radix-16 pass 
  twiddleFactorMul(data, tid, 1024, 0); 
  // local shuffle using local memory 
  localShuffle(data, sMemx, sMemy, tid, (((tid & 15) * 65) + (tid >> 4))); 
  fftRadix16Pass(data);               // in-place radix-16 pass 
  twiddleFactorMul(data, tid, 64, 4); // twiddle factor multiplication 
  localShuffle(data, sMemx, sMemy, tid, (((tid >> 4) * 64) + (tid & 15))); 
  // four radix-4 function calls 
  fftRadix4Pass(data); fftRadix4Pass(data + 4); 
  fftRadix4Pass(data + 8); fftRadix4Pass(data + 12); 
  // coalesced global writes 
  globalStores(data, out, 64); 
}

Références[modifier | modifier le code]

  1. http://developer.download.nvidia.com/assets/tools/docs/Nsight_Datasheet_Feb_11_Screen.pdf
  2. http://developer.amd.com/TOOLS/GDEBUGGER/Pages/default.aspx
  3. a et b (en) « Apple Previews Mac OS X Snow Leopard to Developers », Apple,‎ 2008-06-09
  4. Communiqué de presse de Nvidia
  5. http://www.khronos.org/news/press/khronos-releases-opencl-1.2-specification
  6. (en)OpenCL
  7. http://webcl.nokiaresearch.com/
  8. (en) « Clover git repo »,‎ 2010-01-04 (consulté en 2010-01-30)
  9. (en) « OpenCL Over Mesa, Gallium3D Discussion »,‎ 2009-12-09 (consulté en 2010-01-30)
  10. (en) « OpenCL Demo, AMD CPU »,‎ 2008-12-10 (consulté en 2009-03-28)
  11. (en) « OpenCL Demo, NVIDIA GPU »,‎ 2008-12-10 (consulté en 2009-03-28)
  12. (en) « AMD and Havok demo OpenCL accelerated physics », PC Perspective,‎ 2009-03-26 (consulté en 2009-03-28)
  13. (en) « NVIDIA Releases OpenCL Driver To Developers », NVIDIA,‎ 2009-04-20 (consulté en 2009-04-27)
  14. (en) « AMD does reverse GPGPU, announces OpenCL SDK for x86 », Ars Technica,‎ 2009-08-05 (consulté en 2009-08-06)
  15. (en) Dan Moren, Jason Snell, « Live Update: WWDC 2009 Keynote », macworld.com, MacWorld,‎ 2009-06-08 (consulté en 2009-06-12)
  16. (en) « Mac OS X Snow Leopard – Technical specifications and system requirements », Apple Inc,‎ 2009-06-08 (consulté en 2009-08-25)
  17. (en) « ATI Stream Software Development Kit (SDK) v2.0 Beta Program » (consulté en 2009-10-14)
  18. (en) « OpenCL Development Kit for Linux on Power » (consulté en 2009-10-30)
  19. (en) « Apple entry on LLVM Users page » (consulté en 2009-08-29)
  20. (en) « Nvidia entry on LLVM Users page » (consulté en 2009-08-06)
  21. (en) « Rapidmind entry on LLVM Users page » (consulté en 2009-10-01)
  22. (en) « Zack Rusin's blog post about the Mesa Gallium3D OpenCL implementation » (consulté en 2009-10-01))
  23. http://www.via.com.tw/en/resources/pressroom/pressrelease.jsp?press_release_no=4327
  24. (en) « ATI Stream SDK v2.0 with OpenCL™ 1.0 Support » (consulté en 2009-10-23)
  25. http://software.intel.com/en-us/blogs/2011/06/29/intel-opencl-sdk-11-gold-released/
  26. (en) « AMD APP SDK 2.5 provides enhanced performance and major new capabilities » (consulté en 2011-08-03)
  27. « Nouveaux pilotes chez Intel : OpenGL 4.0 et Ultra HD pour Ivy Bridge »,‎ 2012-10-24 (consulté en 2013-12-10)
  28. « Beignet » (consulté en 2013-12-10)
  29. « Mali OpenCL SDK » (consulté en 2013-12-10)
  30. (en) « Fitting FFT onto G80 Architecture », Vasily Volkov and Brian Kazian, UC Berkeley CS258 project report,‎ May 2008 (consulté en 2008-11-14)

Voir aussi[modifier | modifier le code]