OpenCL

OpenCL API

Original author(s)	Apple Inc.
Developer(s)	Khronos Group
Initial release	August 28, 2009 (2009-08-28)
Stable release	2.2-3[1] / May 12, 2017 (2017-05-12)
Written in	C/C++
Operating system	Android (vendor dependent),[2] FreeBSD,[3] Linux, macOS, Windows
Platform	ARMv7, ARMv8,[4] Cell, IA-32, POWER, x86-64
Type	Heterogeneous computing API
License	OpenCL specification license
Website	www.khronos.org/opencl

Open Computing Language (OpenCL) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators. OpenCL specifies programming languages (based on C99 and C++11) for programming these devices and application programming interfaces (APIs) to control the platform and execute programs on the compute devices. OpenCL provides a standard interface for parallel computing using task- and data-based parallelism.

OpenCL is an open standard maintained by the non-profit technology consortium Khronos Group. Conformant implementations are available from Altera, AMD, Apple, ARM, Creative, IBM, Imagination, Intel, Nvidia, Qualcomm, Samsung, Vivante, Xilinx, and ZiiLABS.^[7][8]

Overview

OpenCL views a computing system as consisting of a number of compute devices, which might be central processing units (CPUs) or "accelerators" such as graphics processing units (GPUs), attached to a host processor (a CPU). It defines a C-like language for writing programs. Functions executed on an OpenCL device are called "kernels".^[9]:17 A single compute device typically consists of several compute units, which in turn comprise multiple processing elements (PEs). A single kernel execution can run on all or many of the PEs in parallel. How a compute device is subdivided into compute units and PEs is up to the vendor; a compute unit can be thought of as a "core", but the notion of core is hard to define across all the types of devices supported by OpenCL (or even within the category of "CPUs"),^[10]:49–50 and the number of compute units may not correspond to the number of cores claimed in vendors' marketing literature (which may actually be counting SIMD lanes).^[11]

In addition to its C-like programming language, OpenCL defines an application programming interface (API) that allows programs running on the host to launch kernels on the compute devices and manage device memory, which is (at least conceptually) separate from host memory. Programs in the OpenCL language are intended to be compiled at run-time, so that OpenCL-using applications are portable between implementations for various host devices.^[12] The OpenCL standard defines host APIs for C and C++; third-party APIs exist for other programming languages and platforms such as Python,^[13] Java and .NET.^[10]:15 An implementation of the OpenCL standard consists of a library that implements the API for C and C++, and an OpenCL C compiler for the compute device(s) targeted.

In order to open the OpenCL programming model to other languages or to protect the kernel source from inspection, the Standard Portable Intermediate Representation (SPIR)^[14] can be used as a target-independent way to ship kernels between a front-end compiler and the OpenCL back-end.

More recently Khronos Group has ratified SYCL,^[15] a higher-level programming model for OpenCL as single-source DSEL based on pure C++14 to improve programming productivity.

Memory hierarchy

OpenCL defines a four-level memory hierarchy for the compute device:^[12]

• global memory: shared by all processing elements, but has high access latency;
• read-only memory: smaller, low latency, writable by the host CPU but not the compute devices;
• local memory: shared by a group of processing elements;
• per-element private memory (registers).

Not every device needs to implement each level of this hierarchy in hardware. Consistency between the various levels in the hierarchy is relaxed, and only enforced by explicit synchronization constructs, notably barriers.

Devices may or may not share memory with the host CPU.^[12] The host API provides handles on device memory buffers and functions to transfer data back and forth between host and devices.

OpenCL C language

The programming language that is used to write compute kernels is called OpenCL C and is based on C99,^[16] but adapted to fit the device model in OpenCL. Memory buffers reside in specific levels of the memory hierarchy, and pointers are annotated with the region qualifiers __global, __local, __constant, and __private, reflecting this. Instead of a device program having a main function, OpenCL C functions are marked __kernel to signal that they are entry points into the program to be called from the host program. Function pointers, bit fields and variable-length arrays are omitted, recursion is forbidden.^[17] The C standard library is replaced by a custom set of standard functions, geared toward math programming.

OpenCL C is extended to facilitate use of parallelism with vector types and operations, synchronization, and functions to work with work-items and work-groups.^[17] In particular, besides scalar types such as float and double, which behave similarly to the corresponding types in C, OpenCL provides fixed-length vector types such as float4 (4-vector of single-precision floats); such vector types are available in lengths two, three, four, eight and sixteen for various base types.^{[16]:§ 6.1.2} Vectorized operations on these types are intended to map onto SIMD instructions sets, e.g., SSE or VMX, when running OpenCL programs on CPUs.^[12] Other specialized types include 2-d and 3-d image types.^[16]:10–11

Example: matrix-vector multiplication

Each invocation (work-item) of the kernel takes a row of the green matrix (A in the code), multiplies this row with the red vector (x) and places the result in an entry of the blue vector (y). The number of columns n is passed to the kernel as ncols; the number of rows is implicit in the number of work-items produced by the host program.

The following is a matrix-vector multiplication algorithm in OpenCL C.

// Multiplies A*x, leaving the result in y.
// A is a row-major matrix, meaning the (i,j) element is at A[i*ncols+j].
__kernel void matvec(__global const float *A, __global const float *x,
                     uint ncols, __global float *y)
{
    size_t i = get_global_id(0);              // Global id, used as the row index.
    __global float const *a = &A[i*ncols];    // Pointer to the i'th row.
    float sum = 0.f;                          // Accumulator for dot product.
    for (size_t j = 0; j < ncols; j++) {
        sum += a[j] * x[j];
    }
    y[i] = sum;
}

The kernel function matvec computes, in each invocation, the dot product of a single row of a matrix A and a vector x:

.

To extend this into a full matrix-vector multiplication, the OpenCL runtime maps the kernel over the rows of the matrix. On the host side, the clEnqueueNDRangeKernel function does this; it takes as arguments the kernel to execute, its arguments, and a number of work-items, corresponding to the number of rows in the matrix A.

Example: computing the FFT

This example will load a fast Fourier transform (FFT) implementation and execute it. The implementation is shown below.^[18] The code asks the OpenCL library for the first available graphics card, creates memory buffers for reading and writing (from the perspective of the graphics card), JIT-compiles the FFT-kernel and then finally asynchronously runs the kernel. The result from the transform is not read in this example.

#include <stdio.h>
#include <time.h>
#include "CL\opencl.h"

#define NUM_ENTRIES 1024

int main() // (int argc, const char * argv[])
{
	// CONSTANTS
	const char *KernelSource = "fft1D_1024_kernel_src.cl";

	// Looking up the available GPUs
	const cl_uint num = 1;
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, 0, NULL, (cl_uint*)num);

	cl_device_id devices[1];
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, num, devices, NULL);

	// create a compute context with GPU device
	cl_context context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);

	// create a command queue
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_DEFAULT, 1, devices, NULL);
	cl_command_queue queue = clCreateCommandQueue(context, devices[0], 0, NULL);

	// allocate the buffer memory objects
	cl_mem memobjs[] = { clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * 2 * NUM_ENTRIES, NULL, NULL),
						 clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float) * 2 * NUM_ENTRIES, NULL, NULL) };
	// cl_mem memobjs[0] = // FIXED, SEE ABOVE
	// cl_mem memobjs[1] = // FIXED, SEE ABOVE

	// create the compute program
	// const char * fft1D_1024_kernel_src[1] = {  };
	cl_program program = clCreateProgramWithSource(context, 1, (const char **)& KernelSource, NULL, NULL);

	// build the compute program executable
	clBuildProgram(program, 0, NULL, NULL, NULL, NULL);

	// create the compute kernel
	cl_kernel kernel = clCreateKernel(program, "fft1D_1024", NULL);

	// set the args values

	size_t local_work_size[1] = { 256 };

	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
	size_t global_work_size[1] = { 256 };
	
	global_work_size[0] = NUM_ENTRIES;
	local_work_size[0] = 64; //Nvidia: 192 or 256
	clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
}

The actual calculation (based on Fitting FFT onto the G80 Architecture):^[19]

  // 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);      // radix-4 function number 1
    fftRadix4Pass(data + 4);  // radix-4 function number 2
    fftRadix4Pass(data + 8);  // radix-4 function number 3
    fftRadix4Pass(data + 12); // radix-4 function number 4

    // coalesced global writes
    globalStores(data, out, 64);
  }

A full, open source implementation of an OpenCL FFT can be found on Apple's website.^[20]

History

OpenCL was initially developed by Apple Inc., which holds trademark rights, and refined into an initial proposal in collaboration with technical teams at AMD, IBM, Qualcomm, Intel, and Nvidia. Apple submitted this initial proposal to the Khronos Group. On June 16, 2008, the Khronos Compute Working Group was formed^[21] with representatives from CPU, GPU, embedded-processor, and software companies. This group worked for five months to finish the technical details of the specification for OpenCL 1.0 by November 18, 2008.^[22] This technical specification was reviewed by the Khronos members and approved for public release on December 8, 2008.^[23]

OpenCL 1.0

OpenCL 1.0 released with Mac OS X Snow Leopard on August 28, 2009. According to an Apple press release:^[24]

Snow Leopard further extends support for modern hardware with Open Computing Language (OpenCL), which lets any application tap into the vast gigaflops of GPU computing power previously available only to graphics applications. OpenCL is based on the C programming language and has been proposed as an open standard.

AMD decided to support OpenCL instead of the now deprecated Close to Metal in its Stream framework.^[25][26] RapidMind announced their adoption of OpenCL underneath their development platform to support GPUs from multiple vendors with one interface.^[27] On December 9, 2008, Nvidia announced its intention to add full support for the OpenCL 1.0 specification to its GPU Computing Toolkit.^[28] On October 30, 2009, IBM released its first OpenCL implementation as a part of the XL compilers.^[29]

OpenCL 1.1

OpenCL 1.1 was ratified by the Khronos Group on June 14, 2010^[30] and adds significant functionality for enhanced parallel programming flexibility, functionality, and performance including:

• New data types including 3-component vectors and additional image formats;
• Handling commands from multiple host threads and processing buffers across multiple devices;
• Operations on regions of a buffer including read, write and copy of 1D, 2D, or 3D rectangular regions;
• Enhanced use of events to drive and control command execution;
• Additional OpenCL built-in C functions such as integer clamp, shuffle, and asynchronous strided copies;
• Improved OpenGL interoperability through efficient sharing of images and buffers by linking OpenCL and OpenGL events.

OpenCL 1.2

On November 15, 2011, the Khronos Group announced the OpenCL 1.2 specification,^[31] which added significant functionality over the previous versions in terms of performance and features for parallel programming. Most notable features include:

• Device partitioning: the ability to partition a device into sub-devices so that work assignments can be allocated to individual compute units. This is useful for reserving areas of the device to reduce latency for time-critical tasks.
• Separate compilation and linking of objects: the functionality to compile OpenCL into external libraries for inclusion into other programs.
• Enhanced image support: 1.2 adds support for 1D images and 1D/2D image arrays. Furthermore, the OpenGL sharing extensions now allow for OpenGL 1D textures and 1D/2D texture arrays to be used to create OpenCL images.
• Built-in kernels: custom devices that contain specific unique functionality are now integrated more closely into the OpenCL framework. Kernels can be called to use specialised or non-programmable aspects of underlying hardware. Examples include video encoding/decoding and digital signal processors.
• DirectX functionality: DX9 media surface sharing allows for efficient sharing between OpenCL and DX9 or DXVA media surfaces. Equally, for DX11, seamless sharing between OpenCL and DX11 surfaces is enabled.
• The ability to force IEEE 754 compliance for single precision floating point math: OpenCL by default allows the single precision versions of the division, reciprocal, and square root operation to be less accurate than the correctly rounded values that IEEE 754 requires.^[32] If the programmer passes the "-cl-fp32-correctly-rounded-divide-sqrt" command line argument to the compiler, these three operations will be computed to IEEE 754 requirements if the OpenCL implementation supports this, and will fail to compile if the OpenCL implementation does not support computing these operations to their correctly-rounded values as defined by the IEEE 754 specification.^[32] This ability is supplemented by the ability to query the OpenCL implementation to determine if it can perform these operations to IEEE 754 accuracy.^[32]

OpenCL 2.0

On November 18, 2013, the Khronos Group announced the ratification and public release of the finalized OpenCL 2.0 specification.^[33] Updates and additions to OpenCL 2.0 include:

• Shared virtual memory
• Nested parallelism
• Generic address space
• Images
• C11 atomics
• Pipes
• Android installable client driver extension

OpenCL 2.1

The ratification and release of the OpenCL 2.1 provisional specification was announced on March 3, 2015 at the Game Developer Conference in San Francisco. It was released on November 16, 2015.^[34] It introduced the OpenCL C++ kernel language, based on a subset of C++14, while maintaining support for the preexisting OpenCL C kernel language. Vulkan and OpenCL 2.1 share SPIR-V as an intermediate representation allowing high-level language front-ends to share a common compilation target. Updates to the OpenCL API include:

• Additional subgroup functionality
• Copying of kernel objects and states
• Low-latency device timer queries
• Ingestion of SPIR-V code by runtime
• Execution priority hints for queues
• Zero-sized dispatches from host

AMD, ARM, Intel, HPC, and YetiWare have declared support for OpenCL 2.1.^[35][36]

OpenCL 2.2

OpenCL 2.2 brings the OpenCL C++ kernel language into the core specification for significantly enhanced parallel programming productivity.^[37][38][39] It was released on 16 May 2017.^[40]

• The OpenCL C++ kernel language is a static subset of the C++14 standard and includes classes, templates, lambda expressions, function overloads and many other constructs for generic and meta-programming.
• Leverages the new Khronos SPIR-V 1.1 intermediate language which fully supports the OpenCL C++ kernel language.
• OpenCL library functions can now take advantage of the C++ language to provide increased safety and reduced undefined behavior while accessing features such as atomics, iterators, images, samplers, pipes, and device queue built-in types and address spaces.
• Pipe storage is a new device-side type in OpenCL 2.2 that is useful for FPGA implementations by making connectivity size and type known at compile time, enabling efficient device-scope communication between kernels.
• OpenCL 2.2 also includes features for enhanced optimization of generated code: Applications can provide the value of specialization constant at SPIR-V compilation time, a new query can detect non-trivial constructors and destructors of program scope global objects, and user callbacks can be set at program release time.
• Runs on any OpenCL 2.0-capable hardware (Only driver update required)

Future

The International Workshop on OpenCL (IWOCL) held by the Khronos Group.

When releasing OpenCL version 2.2, the Khronos Group announced that OpenCL would be merging into Vulkan in the future.^[41]

Implementations

OpenCL consists of a set of headers and a shared object that is loaded at runtime. An installable client driver (ICD) must be installed on the platform for every class of vendor for which the runtime would need to support. That is, for example, in order to support Nvidia devices on a Linux platform, the Nvidia ICD would need to be installed such that the OpenCL runtime (the ICD loader) would be able to locate the ICD for the vendor and redirect the calls appropriately. The standard OpenCL header is used by the consumer application; calls to each function are then proxied by the OpenCL runtime to the appropriate driver using the ICD. Each vendor must implement each OpenCL call in their driver.^[42]

The Apple,^[43] Nvidia,^[44] RapidMind^[45] and Gallium3D^[46] implementations of OpenCL are all based on the LLVM Compiler technology and use the Clang Compiler as its frontend.

MESA Gallium Compute 

An implementation of OpenCL (actual 1.1 incomplete, mostly done AMD Radeon GCN) for a number of platforms is maintained as part of the Gallium Compute Project,^[47] which builds on the work of the Mesa project to support multiple platforms. Formerly this was known as CLOVER.^[48]

BEIGNET 

An implementation by Intel for its Ivy Bridge + hardware was released in 2013.^[49] This software from Intel's China Team, has attracted criticism from developers at AMD and Red Hat,^[50] as well as Michael Larabel of Phoronix.^[51] Actual Version 1.3.1 support OpenCL 1.2 complete (Ivy Bridge and higher) and OpenCL 2.0 optional for Skylake and newer.^[52][53] support for Android has been added to Beignet.^[54]

ROCm 

Created as part of AMD's GPUOpen, ROCm (Radeon Open Compute) is an open source Linux project built on OpenCL 1.2 with language support for 2.0. The system is compatible with all modern AMD CPUs and APUs, as well as Intel Gen7.5+ CPUs.^[55][56]

POCL 

A CPU-only version building on Clang and LLVM, called pocl, is intended to be a portable OpenCL implementation.^[57][58] With Version 0.14 OpenCL 1.2 is nearly fully implemented.^[59][60] In Next Version an experimental Nvidia CUDA backend is available for using NVidia GPUs.^[61]

Shamrock 

A Port of Mesa Clover for ARM with full support of OpenCL 1.2^[62][63]

FreeOCL 

A CPU focused implementation of OpenCL 1.2 that implements an external compiler to create a more reliable platform^[64]

triSYCL

free OpenCL 2.2 Implementation with SYCL 1.2.1 and 2.2 C++ Layer^[65]

Khronos Conformance Test Suite (CTS)

CTS is for all developers and all actual OpenCL levels free (since 2017) available.^[66]

Timeline of vendor implementations

• December 10, 2008: AMD and Nvidia held the first public OpenCL demonstration, a 75-minute presentation at Siggraph Asia 2008. AMD showed a CPU-accelerated OpenCL demo explaining the scalability of OpenCL on one or more cores while Nvidia showed a GPU-accelerated demo.^[67][68]
• March 16, 2009: at the 4th Multicore Expo, Imagination Technologies announced the PowerVR SGX543MP, the first GPU of this company to feature OpenCL support.^[69]
• March 26, 2009: at GDC 2009, AMD and Havok demonstrated the first working implementation for OpenCL accelerating Havok Cloth on AMD Radeon HD 4000 series GPU.^[70]
• April 20, 2009: Nvidia announced the release of its OpenCL driver and SDK to developers participating in its OpenCL Early Access Program.^[71]
• August 5, 2009: AMD unveiled the first development tools for its OpenCL platform as part of its ATI Stream SDK v2.0 Beta Program.^[72]
• August 28, 2009: Apple released Mac OS X Snow Leopard, which contains a full implementation of OpenCL.^[73]
• September 28, 2009: Nvidia released its own OpenCL drivers and SDK implementation.
• October 13, 2009: AMD released the fourth beta of the ATI Stream SDK 2.0, which provides a complete OpenCL implementation on both R700/R800 GPUs and SSE3 capable CPUs. The SDK is available for both Linux and Windows.^[74]
• November 26, 2009: Nvidia released drivers for OpenCL 1.0 (rev 48).
• October 27, 2009: S3 released their first product supporting native OpenCL 1.0 – the Chrome 5400E embedded graphics processor.^[75]
• December 10, 2009: VIA released their first product supporting OpenCL 1.0 – ChromotionHD 2.0 video processor included in VN1000 chipset.^[76]
• December 21, 2009: AMD released the production version of the ATI Stream SDK 2.0,^[77] which provides OpenCL 1.0 support for R800 GPUs and beta support for R700 GPUs.
• June 1, 2010: ZiiLABS released details of their first OpenCL implementation for the ZMS processor for handheld, embedded and digital home products.^[78]
• June 30, 2010: IBM released a fully conformant version of OpenCL 1.0.^[4]
• September 13, 2010: Intel released details of their first OpenCL implementation for the Sandy Bridge chip architecture. Sandy Bridge will integrate Intel's newest graphics chip technology directly onto the central processing unit.^[79]
• November 15, 2010: Wolfram Research released Mathematica 8 with OpenCLLink package.
• March 3, 2011: Khronos Group announces the formation of the WebCL working group to explore defining a JavaScript binding to OpenCL. This creates the potential to harness GPU and multi-core CPU parallel processing from a Web browser.^[80][81]
• March 31, 2011: IBM released a fully conformant version of OpenCL 1.1.^[4][82]
• April 25, 2011: IBM released OpenCL Common Runtime v0.1 for Linux on x86 Architecture.^[83]
• May 4, 2011: Nokia Research releases an open source WebCL extension for the Firefox web browser, providing a JavaScript binding to OpenCL.^[84]
• July 1, 2011: Samsung Electronics releases an open source prototype implementation of WebCL for WebKit, providing a JavaScript binding to OpenCL.^[85]
• August 8, 2011: AMD released the OpenCL-driven AMD Accelerated Parallel Processing (APP) Software Development Kit (SDK) v2.5, replacing the ATI Stream SDK as technology and concept.^[86]
• December 12, 2011: AMD released AMD APP SDK v2.6^[87] which contains a preview of OpenCL 1.2.
• February 27, 2012: The Portland Group released the PGI OpenCL compiler for multi-core ARM CPUs.^[88]
• April 17, 2012: Khronos released a WebCL working draft.^[89]
• May 6, 2013: Altera released the Altera SDK for OpenCL, version 13.0.^[90] It is conformant to OpenCL 1.0.^[91]
• November 18, 2013: Khronos announced that the specification for OpenCL 2.0 had been finalized.^[92]
• March 19, 2014: Khronos releases the WebCL 1.0 specification^[93][94]
• August 29, 2014: Intel releases HD Graphics 5300 driver that supports OpenCL 2.0.^[95]
• September 25, 2014: AMD releases Catalyst 14.41 RC1, which includes an OpenCL 2.0 driver.^[96]
• January 14, 2015: Xilinx Inc. annouces SDAccel development environment for OpenCL, C, and C++, achieves Khronos Conformance^[97]
• April 13, 2015: Nvidia releases WHQL driver v350.12, which includes OpenCL 1.2 support for GPUs based on Kepler or later architectures.^[98] Driver 340+ support OpenCL 1.1 for Tesla and Fermi.
• August 26, 2015: AMD released AMD APP SDK v3.0^[99] which contains full support of OpenCL 2.0 and sample coding.
• November 16, 2015: Khronos announced that the specification for OpenCL 2.1 had been finalized.^[100]
• April 18, 2016: Khronos announced that the specification for OpenCL 2.2 had been provisional finalized.^[38]
• November 03, 2016 Intel support for Gen7+ of OpenCL 2.1 in SDK 2016 r3^[101]
• February 17, 2017: Nvidia begins evaluation support of OpenCL 2.0 with driver 378.66.^{[102][103][104]}
• May 16, 2017: Khronos announced that the specification for OpenCL 2.2 had been finalized with Spir-V1.2.^[105]

Devices

As of 2016 OpenCL runs on Graphics processing units, CPUs with SIMD instructions, FPGAs, Movidius Myriad 2, Adapteva epiphany and DSPs.

Conformant products

The Khronos Group maintains an extended list of OpenCL-conformant products.^[4]

All standard-conformant implementations can be queried using one of the clinfo tools (there are multiple tools with the same name and similar feature set).^{[115][116][117]}

Version support

Products and their version of OpenCL support include:^[118]

OpenCL 2.2 support

None yet: Khronos Test Suite ready, with Driver Update all Hardware with 2.0 and 2.1 support possible

OpenCL 2.1 support

• (2017+) Intel 7th gen processors (Kaby Lake)
• Khronos: with Driver Update all Hardware with 2.0 support possible

OpenCL 2.0 support

• (2011+) AMD GCN GPU's (HD 7700+/HD 8000/Rx 200/Rx 300/Rx 400/Rx 500-Series), some GCN 1st Gen only 1.2 with some Extensions
• (2013+) AMD GCN APU's (Jaguar, Steamroller, Puma, Excavator & Zen-based)
• (2014+) Intel 5th & 6th gen processors (Broadwell, Skylake)
• (2015+) Qualcomm Adreno 5xx series

OpenCL 1.2 support

• (2011+) for some AMD GCN 1st Gen some OpenCL 2.0 Features not possible today, but many more Extensions than Terascale
• (2009+) AMD TeraScale 2 & 3 GPU's (RV8xx, RV9xx in HD 5000, 6000 & 7000 Series)
• (2011+) AMD TeraScale APU's (K10, Bobcat & Piledriver-based)
• (2012+) Nvidia Kepler, Maxwell & Pascal GPU's (GeForce 600, 700, 800, 900 & 10-series, Quadro K-, M- & P-series, Tesla K-, M- & P-series)
• (2012+) Intel 3rd & 4th gen processors (Ivy Bridge, Haswell)
• (2013+) Qualcomm Adreno 4xx series

OpenCL 1.1 support

• (2008+) some AMD TeraScale 1 GPU's (RV7xx in HD4000-series)
• (2008+) Nvidia Tesla, Fermi GPU's (GeForce 9, 100, 200, 300, 400, 500-series, Quadro-series or Tesla-series with Tesla or Fermi GPU)
• (2011+) Qualcomm Adreno 3xx series

OpenCL 1.0 support

• mostly updated to 1.1 and 1.2 after first Driver for 1.0 only

Portability, performance and alternatives

A key feature of OpenCL is portability, via its abstracted memory and execution model, and the programmer is not able to directly use hardware-specific technologies such as inline Parallel Thread Execution (PTX) for Nvidia GPUs unless they are willing to give up direct portability on other platforms. It is possible to run any OpenCL kernel on any conformant implementation.

However, performance of the kernel is not necessarily portable across platforms. Existing implementations have been shown to be competitive when kernel code is properly tuned, though, and auto-tuning has been suggested as a solution to the performance portability problem,^[119] yielding "acceptable levels of performance" in experimental linear algebra kernels.^[120] Portability of an entire application containing multiple kernels with differing behaviors was also studied, and shows that portability only required limited tradeoffs.^[121]

A study at Delft University that compared CUDA programs and their straightforward translation into OpenCL C found CUDA to outperform OpenCL by at most 30% on the Nvidia implementation. The researchers noted that their comparison could be made fairer by applying manual optimizations to the OpenCL programs, in which case there was "no reason for OpenCL to obtain worse performance than CUDA". The performance differences could mostly be attributed to differences in the programming model (especially the memory model) and to NVIDIA's compiler optimizations for CUDA compared to those for OpenCL.^[119]

Another study at D-Wave Systems Inc. found that "The OpenCL kernel’s performance is between about 13% and 63% slower, and the end-to-end time is between about 16% and 67% slower" than CUDA's performance.^[122]

The fact that OpenCL allows workloads to be shared by CPU and GPU, executing the same programs, means that programmers can exploit both by dividing work among the devices.^[123] This leads to the problem of deciding how to partition the work, because the relative speeds of operations differ among the devices. Machine learning has been suggested to solve this problem: Grewe and O'Boyle describe a system of support vector machines trained on compile-time features of program that can decide the device partitioning problem statically, without actually running the programs to measure their performance.^[124]

• Project Coriander: Conversion CUDA to OpenCL 1.2 with CUDA-on-CL^{[125][126][127]}

See also

References

External links

• Official website for OpenCL
• Official website for WebCL
• IWOCL - Annual International Workshop on OpenCL sponsored by The Khronos Group