Cet exemple calcule une Transformée de Fourier rapide
// create a compute context with GPU device context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL); // list the available devices clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &nb_devices); clGetContextInfo(context, CL_CONTEXT_DEVICES, nb_devices, devices, NULL); // create a command queue on the first GPU queue = clCreateCommandQueue(context, devices[0], 0, NULL); // allocate the buffer memory objects 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); // create the compute program program = clCreateProgramWithSource(context, 1, &fft1D_1024_kernel_src, NULL, NULL); // build the compute program executable clBuildProgram(program, 0, NULL, NULL, NULL, NULL); // create the compute kernel kernel = clCreateKernel(program, "fft1D_1024", NULL); // set the args values 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); // create N-D range object with work-item dimensions and execute kernel 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)
// 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); }
Des implémentations d'OpenCL existent pour la majorité des plateformes aujourd'hui. IBM pour ses supercalculateurs Linux utilisant des processeur 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 de Linux) contient un state-tracker OpenCL pour Gallium3D en cours de développement, nommé Clover
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émonstratrion 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.
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.
Le 20 avril 2009, Nvidia annonce la sortie de son pilote OpenCL et du SDK aux développeurs participant à son OpenCL Early Access Program.
Le 5 août 2009, AMD révèle les premiers outils de développement pour sa plateforme OpenCL comme partie de son programmme ATI Stream SDK v2.0 Beta.
Le 28 août 2009, Apple sort Mac OS X Snow Leopard, qui contient une implémentation complète d'OpenCL.
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.
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 fourni 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 Linux et Windows.
Le 30 octobre 2009, IBM sort la version 0.1 de son SDK OpenCL pour Linux sur l'architecture Power utilisé dans une majorité des plus puissants supercalculateurs au monde.
Le 26 novembre 2009, Nvidia sort des pilotes pour l'implémentation OpenCL 1.0 (rev 48).
Les implémentations OpenCL d'Apple, Nvidia, RapidMind et Mesa Gallium3D 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.
Le 21 décembre 2009, AMD sort la version de production de l'ATI Stream SDK 2.0, qui fournit un support d'OpenCL 1.0 pour les R800 GPUs et un support bêta pour R700.