OpenCL

Estándar abierto para programar sistemas informáticos heterogéneos, como CPU o GPU

OpenCL ( Open Computing Language ) es un marco para escribir programas que se ejecutan en plataformas heterogéneas que consisten en unidades centrales de procesamiento (CPU), unidades de procesamiento gráfico (GPU), procesadores de señales digitales (DSP), matrices de puertas programables en campo (FPGA) y otros procesadores o aceleradores de hardware . OpenCL especifica un lenguaje de programación (basado en C99 ) para programar estos dispositivos e interfaces de programación de aplicaciones (API) para controlar la plataforma y ejecutar programas en los dispositivos de cómputo . OpenCL proporciona una interfaz estándar para computación paralela utilizando paralelismo basado en tareas y datos .

OpenCL es un estándar abierto mantenido por Khronos Group, una organización de estándares abiertos sin fines de lucro . Hay implementaciones compatibles (que pasaron el Conformance Test Suite) disponibles en una variedad de empresas, incluidas AMD , ARM , Cadence , Google , Imagination , Intel , Nvidia , Qualcomm , Samsung , SPI y Verisilicon. ^{[8] [9]}

Descripción general

OpenCL considera que un sistema informático consta de varios dispositivos de cómputo , que pueden ser unidades centrales de procesamiento (CPU) o "aceleradores", como unidades de procesamiento gráfico (GPU), conectados a un procesador host (una CPU). Define un lenguaje similar a C para escribir programas. Las funciones ejecutadas en un dispositivo OpenCL se denominan " núcleos ". ^{[10] : 17} Un solo dispositivo de cómputo normalmente consta de varias unidades de cómputo , que a su vez comprenden múltiples elementos de procesamiento (PE). Una única ejecución de núcleo puede ejecutarse en todos o muchos de los PE en paralelo. La forma en que un dispositivo de cómputo se subdivide en unidades de cómputo y PE depende del proveedor; una unidad de cómputo puede considerarse un " núcleo ", pero la noción de núcleo es difícil de definir en todos los tipos de dispositivos compatibles con OpenCL (o incluso dentro de la categoría de "CPU"), ^{[11] : 49–50} y la cantidad de unidades de cómputo puede no corresponderse con la cantidad de núcleos que se afirma en la literatura de marketing de los proveedores (que en realidad puede estar contando carriles SIMD ). ^[12]

Además de su lenguaje de programación similar a C, OpenCL define una interfaz de programación de aplicaciones (API) que permite a los programas que se ejecutan en el host lanzar núcleos en los dispositivos de cómputo y administrar la memoria del dispositivo, que está (al menos conceptualmente) separada de la memoria del host. Los programas en el lenguaje OpenCL están destinados a compilarse en tiempo de ejecución , de modo que las aplicaciones que usan OpenCL sean portables entre implementaciones para varios dispositivos host. ^[13] El estándar OpenCL define API de host para C y C++ ; existen API de terceros para otros lenguajes de programación y plataformas como Python , ^[14] Java , Perl , ^[15] D ^[16] y .NET . ^{[11] : 15} Una implementación del estándar OpenCL consiste en una biblioteca que implementa la API para C y C++, y un compilador OpenCL C para los dispositivos de cómputo de destino.

Para abrir el modelo de programación OpenCL a otros lenguajes o para proteger la fuente del núcleo de la inspección, la Representación Intermedia Portátil Estándar (SPIR) ^[17] se puede utilizar como una forma independiente del objetivo de enviar núcleos entre un compilador front-end y el back-end de OpenCL.

Más recientemente, Khronos Group ha ratificado SYCL , ^[18] un modelo de programación de alto nivel para OpenCL como eDSL de fuente única basado en C++ puro17 para mejorar la productividad de la programación . Las personas interesadas en los núcleos C++ pero no en el estilo de programación de fuente única SYCL pueden usar las características de C++ con fuentes de núcleo de cómputo escritas en lenguaje "C++ para OpenCL". ^[19]

Jerarquía de la memoria

OpenCL define una jerarquía de memoria de cuatro niveles para el dispositivo de cómputo: ^[13]

• memoria global: compartida por todos los elementos de procesamiento, pero tiene alta latencia de acceso ( __global );
• memoria de solo lectura: más pequeña, de baja latencia, escribible por la CPU del host pero no por los dispositivos de cómputo ( __constant );
• memoria local: compartida por un grupo de elementos de procesamiento ( __local );
• memoria privada por elemento ( registros ; __private ).

No todos los dispositivos necesitan implementar cada nivel de esta jerarquía en el hardware. La coherencia entre los distintos niveles de la jerarquía es flexible y solo se aplica mediante construcciones de sincronización explícitas , en particular barreras .

Los dispositivos pueden o no compartir memoria con la CPU del host. ^[13] La API del host proporciona controladores de los buffers de memoria del dispositivo y funciones para transferir datos de ida y vuelta entre el host y los dispositivos.

Lenguaje del núcleo OpenCL

El lenguaje de programación que se utiliza para escribir los núcleos de cómputo se denomina lenguaje de núcleo. OpenCL adopta lenguajes basados ​​en C / C++ para especificar los cálculos del núcleo realizados en el dispositivo con algunas restricciones y añadidos para facilitar un mapeo eficiente de los recursos de hardware heterogéneos de los aceleradores. Tradicionalmente, se utilizaba OpenCL C para programar los aceleradores en el estándar OpenCL; más tarde, se desarrolló C++ para el lenguaje de núcleo OpenCL, que heredó toda la funcionalidad de OpenCL C pero permitió utilizar las características de C++ en las fuentes del núcleo.

Lenguaje C OpenCL

OpenCL C ^[20] es un dialecto de lenguaje basado en C99 adaptado para ajustarse al modelo de dispositivo en OpenCL. Los buffers de memoria residen en niveles específicos de la jerarquía de memoria, y los punteros están anotados con los calificadores de región __global , __local , __constant y __private , lo que refleja esto. En lugar de que un programa de dispositivo tenga una función principal , las funciones de OpenCL C están marcadas como __kernel para indicar que son puntos de entrada al programa que se llamará desde el programa anfitrión. Los punteros de función , los campos de bits y las matrices de longitud variable se omiten, y la recursión está prohibida. ^[21] La biblioteca estándar de C se reemplaza por un conjunto personalizado de funciones estándar, orientadas a la programación matemática.

OpenCL C se extiende para facilitar el uso del paralelismo con tipos de vectores y operaciones, sincronización y funciones para trabajar con elementos de trabajo y grupos de trabajo. ^[21] En particular, además de los tipos escalares como float y double , que se comportan de manera similar a los tipos correspondientes en C, OpenCL proporciona tipos de vectores de longitud fija como float4 (4-vector de floats de precisión simple); dichos tipos de vectores están disponibles en longitudes de dos, tres, cuatro, ocho y dieciséis para varios tipos base. ^{[20] : § 6.1.2} Las operaciones vectorizadas en estos tipos están destinadas a mapearse en conjuntos de instrucciones SIMD , por ejemplo, SSE o VMX , cuando se ejecutan programas OpenCL en CPU. ^[13] Otros tipos especializados incluyen tipos de imágenes 2-d y 3-d. ^{[20] : 10–11}

Ejemplo: multiplicación de matrices y vectores

Cada invocación ( work-item ) del núcleo toma una fila de la matriz verde ( A en el código), multiplica esta fila con el vector rojo ( x ) y coloca el resultado en una entrada del vector azul ( y ). El número de columnas n se pasa al núcleo como ncols ; el número de filas está implícito en el número de work-items producidos por el programa anfitrión.

El siguiente es un algoritmo de multiplicación de matriz-vector en OpenCL C.

// Multiplica A*x, dejando el resultado en y. // A es una matriz de fila principal, lo que significa que el elemento (i,j) está en 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 ); // Id. global, usado como índice de fila __global float const * a = & A [ i * ncols ]; // Puntero a la fila i-ésima float sum = 0.f ; // Acumulador para producto escalar for ( size_t j = 0 ; j < ncols ; j ++ ) { sum += a [ j ] * x [ j ]; } y [ i ] = sum ; }                                                  

La función kernel matvec calcula, en cada invocación, el producto escalar de una sola fila de una matriz A y un vector x :

$${\displaystyle y_{i}=a_{i,:}\cdot x=\sum _{j}a_{i,j}x_{j}.}$$

Para ampliar esto a una multiplicación completa de matriz-vector, el entorno de ejecución de OpenCL asigna el núcleo a las filas de la matriz. En el lado del host, la función clEnqueueNDRangeKernel hace esto; toma como argumentos el núcleo que se va a ejecutar, sus argumentos y una cantidad de elementos de trabajo, correspondientes a la cantidad de filas en la matriz A .

Ejemplo: cálculo de la FFT

Este ejemplo cargará una implementación de la transformada rápida de Fourier (FFT) y la ejecutará. La implementación se muestra a continuación. ^[22] El código solicita a la biblioteca OpenCL la primera tarjeta gráfica disponible, crea buffers de memoria para lectura y escritura (desde la perspectiva de la tarjeta gráfica), compila JIT el núcleo de la FFT y, finalmente, ejecuta el núcleo de forma asincrónica. El resultado de la transformación no se lee en este ejemplo.

#incluir <stdio.h> #include <tiempo.h> #include "CL/opencl.h" #define NUM_ENTRADA 1024int principal () // (int argc, const char* argv[])  {// CONSTANTES// El código fuente del kernel se representa como una cadena// Se encuentra dentro del archivo: "fft1D_1024_kernel_src.cl". Para más detalles, consulte el siguiente listado.const char * FuenteNúcleo =   #include "fft1D_1024_kernel_src.cl" ;// Buscando las GPU disponiblesconstante cl_uint num = 1 ;    clGetDeviceIDs ( NULL , CL_DEVICE_TYPE_GPU , 0 , NULL , ( cl_uint * ) & num );    cl_device_id dispositivos [ 1 ]; clGetDeviceIDs ( NULL , CL_DEVICE_TYPE_GPU , num , dispositivos , NULL );    // crear un contexto computacional con un dispositivo GPUcl_context contexto = clCreateContextFromType ( NULL , CL_DEVICE_TYPE_GPU , NULL , NULL , NULL );       // crear una cola de comandosclGetDeviceIDs ( NULL , CL_DEVICE_TYPE_DEFAULT , 1 , dispositivos , NULL );    cl_command_queue cola = clCreateCommandQueue ( contexto , dispositivos [ 0 ], 0 , NULL );      // asignar los objetos de memoria del buffercl_mem memobjs [] = { clCreateBuffer ( contexto , CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , tamaño de ( flotante ) * 2 * NUM_ENTRIES , NULL , NULL ),               clCreateBuffer ( contexto , CL_MEM_READ_WRITE , tamaño de ( flotante ) * 2 * NUM_ENTRIES , NULL , NULL ) };         //crea el programa de cálculo// constante char* fft1D_1024_kernel_src[1] = { };cl_program programa = clCreateProgramWithSource ( contexto , 1 , ( const char ** ) & KernelSource , NULL , NULL );          // Construye el ejecutable del programa de cómputoclBuildProgram ( programa , 0 , NULL , NULL , NULL , NULL );     // crea el kernel de cómputocl_kernel kernel = clCreateKernel ( programa , "fft1D_1024" , NULL );     // establece los valores de los argumentostamaño_t tamaño_trabajo_local [ 1 ] = { 256 };     clSetKernelArg ( kernel , 0 , tamaño de ( cl_mem ), ( void * ) y memobjs [ 0 ]);    clSetKernelArg ( kernel , 1 , tamaño de ( cl_mem ), ( void * ) y memobjs [ 1 ]);    clSetKernelArg ( kernel , 2 , sizeof ( float ) * ( tamaño_trabajo_local [ 0 ] + 1 ) * 16 , NULL );       clSetKernelArg ( kernel , 3 , sizeof ( float ) * ( tamaño_trabajo_local [ 0 ] + 1 ) * 16 , NULL );       // crear un objeto de rango ND con dimensiones de elemento de trabajo y ejecutar kerneltamaño_t tamaño_trabajo_global [ 1 ] = { 256 };     tamaño_trabajo_global [ 0 ] = NUM_ENTRADAS ;  tamaño_trabajo_local [ 0 ] = 64 ; //Nvidia: 192 o 256   clEnqueueNDRangeKernel ( cola , kernel , 1 , NULL , tamaño_de_trabajo_global , tamaño_de_trabajo_local , 0 , NULL , NULL );        }

El cálculo real dentro del archivo "fft1D_1024_kernel_src.cl" (basado en "Ajuste de FFT a la arquitectura G80"): ^[23]

R "( // Este núcleo calcula una FFT de longitud 1024. La FFT de longitud 1024 se descompone en // llamadas a una función de base 16, otra función de base 16 y luego una función de base 4   __kernel void fft1D_1024 ( __float2 global * entrada , __float2 global * salida , __float local * sMemx , __float local * sMemy ) { int tid = obtener_id_local ( 0 ); int blockIdx = obtener_id_grupo ( 0 ) * 1024 + tid ; float2 datos [ 16 ];                              // índice inicial de datos hacia/desde la memoria global in = in + blockIdx ; out = out + blockIdx ;           globalLoads ( datos , en , 64 ); // lecturas globales fusionadas fftRadix16Pass ( datos ); // paso de base 16 en el lugar twiddleFactorMul ( datos , tid , 1024 , 0 );          // reproducción aleatoria local usando la memoria local localShuffle ( datos , sMemx , sMemy , tid , ((( tid & 15 ) * 65 ) + ( tid >> 4 ))); fftRadix16Pass ( datos ); // pase radix-16 in situ twiddleFactorMul ( datos , tid , 64 , 4 ); // multiplicación de factores de giro                     localShuffle ( datos , sMemx , sMemy , tid , ((( tid >> 4 ) * 64 ) + ( tid & 15 )));             // cuatro llamadas a funciones de base 4 fftRadix4Pass ( data ); // función de base 4 número 1 fftRadix4Pass ( data + 4 ); // función de base 4 número 2 fftRadix4Pass ( data + 8 ); // función de base 4 número 3 fftRadix4Pass ( data + 12 ); // función de base 4 número 4               // escrituras globales fusionadas globalStores ( datos , salida , 64 ); } ) "    

Se puede encontrar una implementación completa y de código abierto de una FFT OpenCL en el sitio web de Apple. ^[24]

C++ para lenguaje OpenCL

En 2020, Khronos anunció ^[25] la transición al lenguaje de programación C++ para OpenCL impulsado por la comunidad ^[26] que proporciona características de C++17 en combinación con las características tradicionales de OpenCL C. Este lenguaje permite aprovechar una rica variedad de características del lenguaje de C++ estándar al tiempo que conserva la compatibilidad con versiones anteriores de OpenCL C. Esto abre un camino de transición sin problemas a la funcionalidad de C++ para los desarrolladores de código del núcleo de OpenCL, ya que pueden seguir utilizando el flujo de programación familiar e incluso herramientas, así como aprovechar las extensiones y bibliotecas existentes disponibles para OpenCL C.

La semántica del lenguaje se describe en la documentación publicada en las versiones del repositorio OpenCL-Docs ^[27] alojado por Khronos Group, pero actualmente no está ratificado por Khronos Group. El lenguaje C++ para OpenCL no está documentado en un documento independiente y se basa en la especificación de C++ y OpenCL C. El compilador de código abierto Clang ha soportado C++ para OpenCL desde la versión 9. ^[28]

C++ para OpenCL se desarrolló originalmente como una extensión del compilador Clang y apareció en la versión 9. ^[29] Como estaba estrechamente acoplado con OpenCL C y no contenía ninguna funcionalidad específica de Clang, su documentación se ha vuelto a alojar en el repositorio OpenCL-Docs ^[27] desde Khronos Group junto con las fuentes de otras especificaciones y tarjetas de referencia. La primera versión oficial de este documento que describe C++ para OpenCL versión 1.0 se publicó en diciembre de 2020. ^[30] C++ para OpenCL 1.0 contiene características de C++17 y es compatible con versiones anteriores de OpenCL C 2.0. En diciembre de 2021, se lanzó una nueva versión provisional de C++ para OpenCL 2021 que es totalmente compatible con el estándar OpenCL 3.0. ^[31] Se puede encontrar un borrador en proceso de la última documentación de C++ para OpenCL en el sitio web de Khronos. ^[32]

Características

C++ para OpenCL soporta la mayoría de las características (sintáctica y semánticamente) de OpenCL C excepto paralelismo anidado y bloques. ^[33] Sin embargo, hay pequeñas diferencias en algunas características soportadas principalmente relacionadas con diferencias en semántica entre C++ y C. Por ejemplo, C++ es más estricto con las conversiones de tipo implícitas y no soporta el calificador de tipo restrict . ^[33] Las siguientes características de C++ no son soportadas por C++ para OpenCL: funciones virtuales, operador dynamic_cast , operadores new / delete sin colocación , excepciones, puntero a funciones miembro, referencias a funciones, bibliotecas estándar de C++. [ ^33] C++ para OpenCL extiende el concepto de regiones de memoria separadas ( espacios de direcciones ) de OpenCL C a características de C++ – conversiones funcionales, plantillas, miembros de clase, referencias, funciones lambda y operadores. La mayoría de las características de C++ no están disponibles para las funciones del kernel p.ej. sobrecarga o plantillas, diseño de clase arbitrario en tipo de parámetro. ^[33]

Ejemplo: aritmética de números complejos

El siguiente fragmento de código ilustra cómo se pueden implementar núcleos con aritmética de números complejos en C++ para el lenguaje OpenCL con un uso conveniente de las características de C++.

// Define una clase Complex, que puede realizar cálculos de números complejos con varias precisiones cuando se utilizan diferentes tipos para T: doble, flotante, medio. template < typename T > class complex_t { T m_re ; // Componente real. T m_im ; // Componente imaginario.         public : complex_t ( T re , T im ) : m_re { re }, m_im { im } {}; // Define el operador para la multiplicación de números complejos. complex_t operator * ( const complex_t & other ) const { return { m_re * other . m_re - m_im * other . m_im , m_re * other . m_im + m_im * other . m_re }; } T get_re ( ) const { return m_re ; } T get_im () const { return m_im ; } };                                             // Una función auxiliar para calcular la multiplicación de números complejos leídos desde el búfer de entrada y para almacenar el resultado calculado en el búfer de salida. template < typename T > void calculate_helper ( __global T * in , __global T * out ) { auto idx = get_global_id ( 0 ); // Cada elemento de trabajo utiliza 4 elementos consecutivos del búfer de entrada - dos por cada número complejo. auto offset = idx * 4 ; auto num1 = complex_t { in [ offset ], in [ offset + 1 ]}; auto num2 = complex_t { in [ offset + 2 ], in [ offset + 3 ]}; // Realizar la multiplicación de números complejos. auto res = num1 * num2 ; // Cada elemento de trabajo escribe 2 elementos consecutivos en el búfer de salida. out [ idx * 2 ] = res.get_re ( ) ; out [ idx * 2 + 1 ] = res.get_im ( ) ; }                                                         // Este kernel se utiliza para la multiplicación de números complejos con precisión simple. __kernel void calculate_sp ( __global float * in , __global float * out ) { calculate_helper ( in , out ); }          #ifdef cl_khr_fp16 // Este núcleo se utiliza para la multiplicación de números complejos con precisión media cuando el dispositivo lo admite. #pragma OPENCL EXTENSION cl_khr_fp16: enable __kernel void calculate_hp ( __global half * in , __global half * out ) { calculate_helper ( in , out ); } #endif           

Entorno de ejecución y herramientas

El lenguaje C++ para OpenCL se puede utilizar para las mismas aplicaciones o bibliotecas y de la misma manera que se utiliza el lenguaje C de OpenCL. Debido a la rica variedad de características del lenguaje C++, las aplicaciones escritas en C++ para OpenCL pueden expresar funciones complejas de manera más conveniente que las aplicaciones escritas en C de OpenCL y, en particular, el paradigma de programación genérico de C++ es muy atractivo para los desarrolladores de bibliotecas.

Las fuentes de C++ para OpenCL se pueden compilar mediante controladores OpenCL que admitan la extensión cl_ext_cxx_for_opencl . ^[34] Arm anunció el soporte para esta extensión en diciembre de 2020. ^[35] Sin embargo, debido a la creciente complejidad de los algoritmos acelerados en dispositivos OpenCL, se espera que más aplicaciones compilen C++ para kernels OpenCL sin conexión utilizando compiladores independientes como Clang ^[36] en formato binario ejecutable o formato binario portátil, por ejemplo SPIR-V. ^[37] Dicho ejecutable se puede cargar durante la ejecución de aplicaciones OpenCL utilizando una API OpenCL dedicada. ^[38]

Los binarios compilados a partir de fuentes en C++ para OpenCL 1.0 se pueden ejecutar en dispositivos compatibles con OpenCL 2.0. Según las características del lenguaje utilizadas en dichas fuentes del núcleo, también se pueden ejecutar en dispositivos compatibles con versiones anteriores de OpenCL o con OpenCL 3.0.

Además de los controladores OpenCL, los núcleos escritos en C++ para OpenCL se pueden compilar para su ejecución en dispositivos Vulkan utilizando el compilador clspv ^[39] y la capa de tiempo de ejecución clvk ^[40] de la misma manera que los núcleos C de OpenCL.

Contribuciones

C++ para OpenCL es un lenguaje abierto desarrollado por la comunidad de colaboradores enumerados en su documentación. ^[32]  Se aceptan nuevas contribuciones a la definición semántica del lenguaje o al soporte de herramientas de código abierto de cualquier persona interesada, siempre que estén alineadas con la filosofía de diseño principal y sean revisadas y aprobadas por los colaboradores experimentados. ^[19]

Historia

OpenCL fue desarrollado inicialmente por Apple Inc. , que posee los derechos de marca registrada , y refinado en una propuesta inicial en colaboración con equipos técnicos de AMD , IBM , Qualcomm , Intel y Nvidia . Apple presentó esta propuesta inicial al Grupo Khronos . El 16 de junio de 2008, se formó el Grupo de Trabajo de Computación de Khronos ^[41] con representantes de CPU, GPU, procesadores integrados y empresas de software. Este grupo trabajó durante cinco meses para terminar los detalles técnicos de la especificación para OpenCL 1.0 para el 18 de noviembre de 2008. ^[42] Esta especificación técnica fue revisada por los miembros de Khronos y aprobada para su publicación el 8 de diciembre de 2008. ^[43]

OpenCL 1.0

OpenCL 1.0 se lanzó con Mac OS X Snow Leopard el 28 de agosto de 2009. Según un comunicado de prensa de Apple: ^[44]

Snow Leopard amplía aún más la compatibilidad con hardware moderno con Open Computing Language (OpenCL), que permite a cualquier aplicación aprovechar los enormes gigaflops de potencia de procesamiento de la GPU que antes solo estaban disponibles para aplicaciones gráficas. OpenCL se basa en el lenguaje de programación C y se ha propuesto como estándar abierto.

AMD decidió dar soporte a OpenCL en lugar del ahora obsoleto Close to Metal en su marco Stream . ^{[45] [46]} RapidMind anunció su adopción de OpenCL debajo de su plataforma de desarrollo para soportar GPU de múltiples proveedores con una interfaz. ^[47] El 9 de diciembre de 2008, Nvidia anunció su intención de agregar soporte completo para la especificación OpenCL 1.0 a su GPU Computing Toolkit. ^[48] El 30 de octubre de 2009, IBM lanzó su primera implementación de OpenCL como parte de los compiladores XL. ^[49]

La aceleración de cálculos con un factor de hasta 1000 es posible con OpenCL en tarjetas gráficas en comparación con CPU normales. ^[50] Algunas características importantes de la próxima versión de OpenCL son opcionales en la versión 1.0, como las operaciones de precisión doble o media. ^[51]

OpenCL 1.1

OpenCL 1.1 fue ratificado por el Grupo Khronos el 14 de junio de 2010, ^[52] y agrega una funcionalidad significativa para mejorar la flexibilidad, la funcionalidad y el rendimiento de la programación paralela, incluyendo:

• Nuevos tipos de datos, incluidos vectores de tres componentes y formatos de imagen adicionales;
• Manejo de comandos desde múltiples subprocesos de host y procesamiento de buffers en múltiples dispositivos;
• Operaciones en regiones de un búfer que incluyen lectura, escritura y copia de regiones rectangulares 1D, 2D o 3D;
• Uso mejorado de eventos para impulsar y controlar la ejecución de comandos;
• Funciones C integradas adicionales de OpenCL, como fijación de enteros, reproducción aleatoria y copias asincrónicas;
• Se mejoró la interoperabilidad de OpenGL mediante el intercambio eficiente de imágenes y buffers al vincular eventos OpenCL y OpenGL.

OpenCL 1.2

El 15 de noviembre de 2011, el Grupo Khronos anunció la especificación OpenCL 1.2, ^[53] que agregó una funcionalidad significativa con respecto a las versiones anteriores en términos de rendimiento y características para la programación paralela. Las características más notables incluyen:

• Partición de dispositivos: la capacidad de particionar un dispositivo en subdispositivos para que las tareas se puedan asignar a unidades de cómputo individuales. Esto es útil para reservar áreas del dispositivo a fin de reducir la latencia para tareas de tiempo crítico.
• Compilación y vinculación separada de objetos: la funcionalidad para compilar OpenCL en bibliotecas externas para su inclusión en otros programas.
• Compatibilidad con imágenes mejorada (opcional): la versión 1.2 agrega compatibilidad con imágenes 1D y matrices de imágenes 1D/2D. Además, las extensiones para compartir OpenGL ahora permiten usar texturas 1D OpenGL y matrices de texturas 1D/2D para crear imágenes OpenCL.
• Kernels integrados: los dispositivos personalizados que contienen una funcionalidad única específica ahora están integrados más estrechamente en el marco OpenCL. Se puede llamar a los kernels para utilizar aspectos especializados o no programables del hardware subyacente. Algunos ejemplos incluyen la codificación/decodificación de video y los procesadores de señales digitales.
• Funcionalidad de DirectX: el uso compartido de superficies multimedia DX9 permite un uso compartido eficiente entre OpenCL y superficies multimedia DX9 o DXVA . Del mismo modo, para DX11, se habilita el uso compartido sin inconvenientes entre superficies OpenCL y DX11.
• La capacidad de forzar el cumplimiento de IEEE 754 para matemáticas de punto flotante de precisión simple: OpenCL por defecto permite que las versiones de precisión simple de la operación de división, recíproca y raíz cuadrada sean menos precisas que los valores correctamente redondeados que requiere IEEE 754. ^[54] Si el programador pasa el argumento de línea de comando "-cl-fp32-correctly-rounded-divide-sqrt" al compilador, estas tres operaciones se calcularán según los requisitos de IEEE 754 si la implementación de OpenCL lo admite, y no se compilarán si la implementación de OpenCL no admite el cálculo de estas operaciones a sus valores correctamente redondeados según lo definido por la especificación IEEE 754. ^[54] Esta capacidad se complementa con la capacidad de consultar la implementación de OpenCL para determinar si puede realizar estas operaciones con la precisión de IEEE 754. ^[54]

OpenCL 2.0

El 18 de noviembre de 2013, el Grupo Khronos anunció la ratificación y el lanzamiento público de la especificación OpenCL 2.0 finalizada. ^[55] Las actualizaciones y adiciones a OpenCL 2.0 incluyen:

• Memoria virtual compartida
• Paralelismo anidado
• Espacio de direcciones genérico
• Imágenes (opcional, incluir imagen 3D)
• átomos de C11
• Tubería
• Extensión del controlador del cliente instalable en Android
• Precisión media extendida con extensión opcional cl_khr_fp16
• cl_double: doble precisión IEEE 754 (opcional)

OpenCL 2.1

La ratificación y publicación de la especificación provisional OpenCL 2.1 se anunció el 3 de marzo de 2015 en la Game Developer Conference en San Francisco. Se publicó el 16 de noviembre de 2015. ^[56] Introdujo el lenguaje de núcleo OpenCL C++, basado en un subconjunto de C++14 , al tiempo que mantenía el soporte para el lenguaje de núcleo OpenCL C preexistente. Vulkan y OpenCL 2.1 comparten SPIR-V como una representación intermedia que permite que los front-ends de lenguaje de alto nivel compartan un objetivo de compilación común. Las actualizaciones de la API OpenCL incluyen:

• Funcionalidad adicional del subgrupo
• Copia de objetos y estados del kernel
• Consultas de temporizador de dispositivos de baja latencia
• Ingestión de código SPIR-V por parte del entorno de ejecución
• Sugerencias de prioridad de ejecución para colas
• Despachos de tamaño cero desde el host

AMD, ARM , Intel, HPC y YetiWare han declarado su compatibilidad con OpenCL 2.1. ^{[57] [58]}

OpenCL 2.2

OpenCL 2.2 incorpora el lenguaje del núcleo C++ de OpenCL a la especificación principal para mejorar significativamente la productividad de la programación paralela. ^{[59] [60] [61]} Se lanzó el 16 de mayo de 2017. ^[62] Actualización de mantenimiento lanzada en mayo de 2018 con correcciones de errores. ^[63]

• El lenguaje del núcleo C++ OpenCL es un subconjunto estático del estándar C++14 e incluye clases, plantillas, expresiones lambda, sobrecargas de funciones y muchas otras construcciones para programación genérica y meta.
• Utiliza el nuevo lenguaje intermedio Khronos SPIR-V 1.1 que admite totalmente el lenguaje del kernel OpenCL C++.
• Las funciones de la biblioteca OpenCL ahora pueden usar el lenguaje C++ para proporcionar mayor seguridad y reducir el comportamiento indefinido al acceder a características como atómicos, iteradores, imágenes, muestreadores, tuberías y tipos integrados de colas de dispositivos y espacios de direcciones.
• El almacenamiento de tuberías es un nuevo tipo del lado del dispositivo en OpenCL 2.2 que resulta útil para las implementaciones de FPGA al permitir que el tamaño y el tipo de conectividad se conozcan en el momento de la compilación, lo que permite una comunicación eficiente entre núcleos a nivel de dispositivo.
• OpenCL 2.2 también incluye características para una optimización mejorada del código generado: las aplicaciones pueden proporcionar el valor de la constante de especialización en el momento de la compilación de SPIR-V, una nueva consulta puede detectar constructores y destructores no triviales de objetos globales del alcance del programa, y ​​las devoluciones de llamadas del usuario se pueden configurar en el momento del lanzamiento del programa.
• Funciona en cualquier hardware compatible con OpenCL 2.0 (solo se requiere una actualización del controlador).

OpenCL 3.0

La especificación OpenCL 3.0 se publicó el 30 de septiembre de 2020, después de estar en versión preliminar desde abril de 2020. La funcionalidad de OpenCL 1.2 se ha convertido en una línea base obligatoria, mientras que todas las características de OpenCL 2.x y OpenCL 3.0 se hicieron opcionales. La especificación conserva el lenguaje C de OpenCL y desaprueba el lenguaje kernel OpenCL C++, reemplazándolo con el lenguaje C++ para OpenCL ^[19] basado en un compilador Clang / LLVM que implementa un subconjunto de código intermedio C++17 y SPIR-V . ^{[64] [65] [66]} La versión 3.0.7 de C++ para OpenCL con algunas extensiones de Khronos openCL se presentó en IWOCL 21. ^[67] La ​​versión actual es 3.0.11 con algunas nuevas extensiones y correcciones. NVIDIA, en estrecha colaboración con el grupo de trabajo OpenCL de Khronos, mejoró Vulkan Interop con semáforos y uso compartido de memoria. ^[68] La última actualización menor fue la 3.0.14 con corrección de errores y una nueva extensión para múltiples dispositivos. ^[69]

Hoja de ruta

Taller internacional sobre OpenCL (IWOCL) organizado por el Grupo Khronos

Al lanzar OpenCL 2.2, el Grupo Khronos anunció que OpenCL convergería donde fuera posible con Vulkan para permitir la flexibilidad de implementación del software OpenCL sobre ambas API. ^{[70] [71]} Esto ha sido demostrado ahora por Premiere Rush de Adobe usando el compilador de código abierto clspv ^{[39] para compilar cantidades significativas de código de kernel C de OpenCL para ejecutarse en un entorno de ejecución de Vulkan para su implementación en Android. [72]} OpenCL tiene una hoja de ruta con visión de futuro independiente de Vulkan, con 'OpenCL Next' en desarrollo y con lanzamiento previsto para 2020. OpenCL Next puede integrar extensiones como Vulkan / OpenCL Interop, Scratch-Pad Memory Management, Extended Subgroups, ingestión de SPIR-V 1.4 e información de depuración extendida de SPIR-V. OpenCL también está considerando un cargador y capas similares a Vulkan y un "perfil flexible" para la flexibilidad de implementación en múltiples tipos de aceleradores. ^[73]

Implementaciones de código abierto

clinfo, una herramienta de línea de comandos para ver información de OpenCL

OpenCL consta de un conjunto de encabezados y un objeto compartido que se carga en tiempo de ejecución. Se debe instalar un controlador de cliente instalable (ICD) en la plataforma para cada clase de proveedor para el que el entorno de ejecución deba brindar soporte. Es decir, por ejemplo, para brindar soporte a dispositivos Nvidia en una plataforma Linux, se debe instalar el ICD de Nvidia de manera que el entorno de ejecución de OpenCL (el cargador de ICD) pueda ubicar el ICD para el proveedor y redirigir las llamadas de manera adecuada. La aplicación del consumidor utiliza el encabezado estándar de OpenCL; luego, el entorno de ejecución de OpenCL envía las llamadas a cada función al controlador apropiado mediante el ICD. Cada proveedor debe implementar cada llamada de OpenCL en su controlador. ^[74]

Las implementaciones de OpenCL de Apple, ^[75] Nvidia, ^[76] ROCm , RapidMind ^[77] y Gallium3D ^[78] se basan en la tecnología del compilador LLVM y utilizan el compilador Clang como su interfaz.

Computación MESA Gallium

Una implementación de OpenCL (actual 1.1 incompleta, mayormente realizada AMD Radeon GCN ) para varias plataformas se mantiene como parte del Proyecto Gallium Compute, ^[79] que se basa en el trabajo del proyecto Mesa para soportar múltiples plataformas. Anteriormente esto se conocía como CLOVER., ^[80] desarrollo actual: mayormente soporte para ejecutar un marco incompleto con LLVM y CLANG actuales, algunas características nuevas como fp16 en 17.3, ^[81] Objetivo completo OpenCL 1.0, 1.1 y 1.2 para AMD y Nvidia. El nuevo desarrollo básico lo realiza Red Hat con SPIR-V también para Clover. ^{[82] [83]} El nuevo objetivo es OpenCL 3.0 modular con soporte completo de OpenCL 1.2. El estado actual está disponible en Mesamatrix. Los soportes de imágenes están aquí en el foco del desarrollo.

RustiCL es una nueva implementación para el cómputo de Gallium con Rust en lugar de C. En Mesa 22.2, la implementación experimental está disponible con soporte para openCL 3.0 e implementación de extensión de imagen para programas como Darktable. ^[84] Intel Xe (Arc) y AMD GCN+ son compatibles con Mesa 22.3+. AMD R600 y Nvidia Kepler+ también son objetivo del soporte de hardware. ^{[85] [86] [87]} RustiCL supera a AMD ROCM con hardware Radeon RX 6700 XT en Luxmark Benchmark. ^[88] Mesa 23.1 admite RustiCL oficial. En Mesa 23.2, el soporte de fp64 importante está en nivel experimental.

Windows 11 en Arm de Microsoft agregó soporte para OpenCL 1.2 a través de CLon12, una implementación de OpenCL de código abierto sobre DirectX 12 a través de Mesa Gallium . ^{[89] [90] [91]}

BUÑUELOS

Una implementación de Intel para su hardware Ivy Bridge+ fue lanzada en 2013. ^[92] Este software del equipo de China de Intel, ha atraído críticas de los desarrolladores de AMD y Red Hat , ^[93] así como de Michael Larabel de Phoronix . ^[94] La versión actual 1.3.2 admite OpenCL 1.2 completo (Ivy Bridge y superiores) y OpenCL 2.0 opcional para Skylake y posteriores. ^{[95] [96]} Se ha añadido soporte para Android a Beignet., ^[97] Objetivos de desarrollo actuales: solo soporte para 1.2 y 2.0, el camino hacia OpenCL 2.1, 2.2, 3.0 se ha ido a NEO.

NEO

Una implementación de Intel para hardware Gen. 8 Broadwell + Gen. 9 lanzado en 2018. ^[98] Este controlador reemplaza la implementación de Beignet para plataformas compatibles (no las anteriores 6.gen a Haswell). NEO proporciona compatibilidad con OpenCL 2.1 en plataformas Core y OpenCL 1.2 en plataformas Atom. ^[99] En 2020, también se admiten Graphic Gen 11 Ice Lake y Gen 12 Tiger Lake. El nuevo OpenCL 3.0 está disponible para Alder Lake, Tiger Lake a Broadwell con la versión 20.41+. Ahora incluye OpenCL 2.0 opcional, 2.1 Características completas y algunas de 2.2.

ROCM

Creado como parte de GPUOpen de AMD , ROCm (Radeon Open Compute) es un proyecto Linux de código abierto construido sobre OpenCL 1.2 con soporte de lenguaje para 2.0. El sistema es compatible con todas las CPU y APU AMD modernas (actualmente en parte GFX 7, GFX 8 y 9), así como con las CPU Intel Gen7.5+ (solo con PCI 3.0). ^{[100] [101]} Con la versión 1.9, el soporte se extiende en algunos puntos de manera experimental a hardware con PCIe 2.0 y sin atómicas. Se realizó una descripción general del trabajo real en XDC2018. ^{[102] [103]} La versión 2.0 de ROCm admite OpenCL 2.0 completo, pero algunos errores y limitaciones están en la lista de tareas pendientes. ^{[104] [105]} La versión 3.3 está mejorando en detalles. ^[106] La versión 3.5 admite OpenCL 2.2. ^[107] La ​​versión 3.10 incluía mejoras y nuevas API. ^[108] En SC20 se anunció ROCm 4.0 con soporte para AMD Compute Card Instinct MI 100. ^[109] La documentación actual de 5.5.1 y anteriores está disponible en GitHub. ^{[110] [111] [112]} OpenCL 3.0 está disponible. RocM 5.5.x+ solo admite GFX 9 Vega y versiones posteriores, por lo que las alternativas son versiones anteriores de RocM o, en el futuro, RustiCL para hardware más antiguo.

POCL

Una implementación portátil que soporta CPUs y algunas GPUs (vía CUDA y HSA ). Basada en Clang y LLVM . ^[113] Con la versión 1.0 OpenCL 1.2 fue implementado casi completamente junto con algunas características 2.x. ^[114] La versión 1.2 es con LLVM/CLANG 6.0, 7.0 y soporte completo de OpenCL 1.2 con todos los tickets cerrados en Milestone 1.2. ^{[114] [115]} OpenCL 2.0 está implementado casi completamente. ^[116] Versión 1.3 Soporta Mac OS X. ^[117] Versión 1.4 incluye soporte para LLVM 8.0 y 9.0. ^[118] Versión 1.5 implementa soporte para LLVM/Clang 10. ^[119] Versión 1.6 implementa soporte para LLVM/Clang 11 y CUDA Acceleration. ^[120] Los objetivos actuales son la implementación completa de OpenCL 2.x, OpenCL 3.0 y la mejora del rendimiento. POCL 1.6 tiene una optimización manual al mismo nivel del entorno de ejecución de cómputo de Intel. ^[121] La versión 1.7 implementa el soporte de LLVM/Clang 12 y algunas nuevas características de OpenCL 3.0. ^[122] La versión 1.8 implementa el soporte de LLVM/Clang 13. ^[123] La versión 3.0 implementa OpenCL 3.0 en el nivel mínimo y LLVM/Clang 14. ^[124] La versión 3.1 funciona con LLVM/Clang 15 y un soporte mejorado de Spir-V. ^[125]

Trébol

Un puerto de Mesa Clover para ARM con soporte completo de OpenCL 1.2, ^{[126] [127]} sin desarrollo real para 2.0.

OCL libre

Una implementación de OpenCL 1.2 centrada en la CPU que implementa un compilador externo para crear una plataforma más confiable, ^[128] sin desarrollo real.

MOCL

En 2018, los investigadores de NUDT lanzaron una implementación de OpenCL basada en POCL para Matrix-2000. La arquitectura Matrix-2000 está diseñada para reemplazar los aceleradores Intel Xeon Phi de la supercomputadora TianHe-2. Este marco de programación está construido sobre LLVM v5.0 y también reutiliza algunas piezas de código de POCL. Para liberar el potencial del hardware, el entorno de ejecución del dispositivo utiliza una estrategia de distribución de tareas basada en push y el rendimiento de los átomos del núcleo se mejora significativamente. Este marco se ha implementado en el sistema TH-2A y está disponible para el público. ^[129] A continuación, se trasladará parte del software para mejorar POCL. ^[114]

VC4CL

Una implementación de OpenCL 1.2 para el procesador VideoCore IV (BCM2763) utilizado en Raspberry Pi antes de su modelo 4. ^[130]

Implementaciones de proveedores

Cronología de las implementaciones de los proveedores

• Junio ​​de 2008: Durante la conferencia WWDC de Apple, se puso a disposición de los participantes una versión beta preliminar de Mac OS X Snow Leopard , que incluía la primera implementación beta de OpenCL, unos 6 meses antes de que se ratificara la especificación de la versión final 1.0 a finales de 2008. También mostraron dos demostraciones. Una era una cuadrícula de 8x8 pantallas renderizadas, cada una de las cuales mostraba la pantalla de una máquina Apple II emulada (64 instancias independientes en total, cada una ejecutando un famoso juego de kárate). Esto mostraba el paralelismo de tareas en la CPU. La otra demostración era una simulación de N cuerpos que se ejecutaba en la GPU de una Mac Pro, una tarea paralela de datos.
• 10 de diciembre de 2008: AMD y Nvidia realizaron la primera demostración pública de OpenCL, una presentación de 75 minutos en SIGGRAPH Asia 2008. AMD mostró una demostración de OpenCL acelerada por CPU que explicaba la escalabilidad de OpenCL en uno o más núcleos, mientras que Nvidia mostró una demostración acelerada por GPU. ^{[131] [132]}
• 16 de marzo de 2009: en la 4ª Multicore Expo, Imagination Technologies anunció la PowerVR SGX543MP, la primera GPU de esta compañía que cuenta con soporte para OpenCL. ^[133]
• 26 de marzo de 2009: en GDC 2009 , AMD y Havok demostraron la primera implementación funcional para la aceleración OpenCL de Havok Cloth en la GPU de la serie ATI Radeon HD 4000. ^[134]
• 20 de abril de 2009: Nvidia anunció el lanzamiento de su controlador y SDK OpenCL para los desarrolladores que participan en su Programa de acceso anticipado OpenCL. ^[135]
• 5 de agosto de 2009: AMD presentó las primeras herramientas de desarrollo para su plataforma OpenCL como parte de su Programa Beta ATI Stream SDK v2.0. ^[136]
• 28 de agosto de 2009: Apple lanzó Mac OS X Snow Leopard , que contiene una implementación completa de OpenCL. ^[137]
• 28 de septiembre de 2009: Nvidia lanzó sus propios controladores OpenCL y la implementación del SDK.
• 13 de octubre de 2009: AMD lanzó la cuarta versión beta del ATI Stream SDK 2.0, que proporciona una implementación completa de OpenCL tanto en las GPU R700 / HD 5000 como en las CPU compatibles con SSE3 . El SDK está disponible tanto para Linux como para Windows. ^[138]
• 26 de noviembre de 2009: Nvidia lanzó controladores para OpenCL 1.0 (rev 48).
• 27 de octubre de 2009: S3 lanzó su primer producto compatible con OpenCL 1.0 nativo: el procesador de gráficos integrado Chrome 5400E. ^[139]
• 10 de diciembre de 2009: VIA lanzó su primer producto compatible con OpenCL 1.0: el procesador de video ChromotionHD 2.0 incluido en el chipset VN1000. ^[140]
• 21 de diciembre de 2009: AMD lanzó la versión de producción del ATI Stream SDK 2.0, ^[141] que proporciona compatibilidad con OpenCL 1.0 para las GPU HD 5000 y compatibilidad beta para las GPU R700 .
• 1 de junio de 2010: ZiiLABS publicó detalles de su primera implementación de OpenCL para el procesador ZMS para productos domésticos digitales, integrados y portátiles. ^[142]
• 30 de junio de 2010: IBM lanzó una versión totalmente compatible de OpenCL 1.0. ^[4]
• 13 de septiembre de 2010: Intel publicó los detalles de su primera implementación de OpenCL para la arquitectura de chip Sandy Bridge. Sandy Bridge integrará la tecnología de chip gráfico más reciente de Intel directamente en la unidad central de procesamiento. ^[143]
• 15 de noviembre de 2010: Wolfram Research lanzó Mathematica 8 con el paquete OpenCLLink ^[144] .
• 3 de marzo de 2011: Khronos Group anuncia la formación del grupo de trabajo WebCL para explorar la definición de un enlace de JavaScript a OpenCL. Esto crea el potencial para aprovechar el procesamiento paralelo de GPU y CPU multinúcleo desde un navegador web . ^{[145] [146]}
• 31 de marzo de 2011: IBM lanzó una versión totalmente compatible de OpenCL 1.1. ^{[4] [147]}
• 25 de abril de 2011: IBM lanzó OpenCL Common Runtime v0.1 para Linux en arquitectura x86. ^[148]
• 4 de mayo de 2011: Nokia Research lanza una extensión WebCL de código abierto para el navegador web Firefox , que proporciona un enlace de JavaScript a OpenCL. ^[149]
• 1 de julio de 2011: Samsung Electronics lanza una implementación prototipo de código abierto de WebCL para WebKit, que proporciona un enlace de JavaScript a OpenCL. ^[150]
• 8 de agosto de 2011: AMD lanzó el Kit de desarrollo de software (SDK) de procesamiento paralelo acelerado (APP) AMD v2.5 impulsado por OpenCL, que reemplaza al ATI Stream SDK como tecnología y concepto. ^[151]
• 12 de diciembre de 2011: AMD lanzó AMD APP SDK v2.6 ^[152] que contiene una vista previa de OpenCL 1.2.
• 27 de febrero de 2012: Portland Group lanzó el compilador PGI OpenCL para CPU ARM de múltiples núcleos . ^[153]
• 17 de abril de 2012: Khronos publicó un borrador de trabajo de WebCL. ^[154]
• 6 de mayo de 2013: Altera lanzó el Altera SDK para OpenCL, versión 13.0. ^[155] Es compatible con OpenCL 1.0. ^[156]
• 18 de noviembre de 2013: Khronos anunció que se había finalizado la especificación para OpenCL 2.0. ^[157]
• 19 de marzo de 2014: Khronos publica la especificación WebCL 1.0. ^{[158] [159]}
• 29 de agosto de 2014: Intel lanza el controlador HD Graphics 5300 que admite OpenCL 2.0. ^[160]
• 25 de septiembre de 2014: AMD lanza Catalyst 14.41 RC1, que incluye un controlador OpenCL 2.0. ^[161]
• 14 de enero de 2015: Xilinx Inc. anuncia el entorno de desarrollo SDAccel para OpenCL, C y C++ y logra la conformidad con Khronos. ^[162]
• 13 de abril de 2015: Nvidia lanza el controlador WHQL v350.12, que incluye compatibilidad con OpenCL 1.2 para GPU basadas en Kepler o arquitecturas posteriores. ^[163] El controlador 340+ admite OpenCL 1.1 para Tesla y Fermi.
• 26 de agosto de 2015: AMD lanzó AMD APP SDK v3.0 ^[164] que contiene soporte completo para OpenCL 2.0 y codificación de muestra.
• 16 de noviembre de 2015: Khronos anunció que se había finalizado la especificación para OpenCL 2.1. ^[165]
• 18 de abril de 2016: Khronos anunció que la especificación para OpenCL 2.2 se había finalizado provisionalmente. ^[60]
• 3 de noviembre de 2016: Compatibilidad de Intel con Gen7+ de OpenCL 2.1 en SDK 2016 r3. ^[166]
• 17 de febrero de 2017: Nvidia comienza a brindar soporte de evaluación para OpenCL 2.0 con el controlador 378.66. ^{[167] [168] [169]}
• 16 de mayo de 2017: Khronos anunció que la especificación para OpenCL 2.2 se había finalizado con SPIR-V 1.2. ^[170]
• 14 de mayo de 2018: Khronos anunció una actualización de mantenimiento para OpenCL 2.2 con corrección de errores y encabezados unificados. ^[63]
• 27 de abril de 2020: Khronos anunció la versión provisional de OpenCL 3.0.
• 1 de junio de 2020: Intel NEO runtime con OpenCL 3.0 para el nuevo Tiger Lake.
• 3 de junio de 2020: AMD anunció RocM 3.5 con soporte para OpenCL 2.2. ^[171]
• 30 de septiembre de 2020: Khronos anunció que se habían finalizado las especificaciones para OpenCL 3.0 (CTS también está disponible).
• 16 de octubre de 2020: Intel anunció que NEO 20.41 admitirá OpenCL 3.0 (incluye principalmente OpenCL 2.x opcional).
• 6 de abril de 2021: Nvidia admite OpenCL 3.0 para Ampere. Las GPU Maxwell y posteriores también admiten OpenCL 3.0 con el controlador Nvidia 465+. ^[172]
• 20 de agosto de 2022: las GPU Intel Arc Alchemist (Arc A380, A350M, A370M, A550M, A730M y A770M) son compatibles con OpenCL 3.0. ^[173]
• 14 de octubre de 2022: Arm Mali-G615 y Mali-G715-Immortalis son compatibles con OpenCL 3.0. ^[173]
• 11 de noviembre de 2022: La biblioteca OpenCL Rusticl es compatible con OpenCL 3.0. ^{[173] [174]}

Dispositivos

A partir de 2016, OpenCL se ejecuta en unidades de procesamiento gráfico (GPU), CPU con instrucciones SIMD , FPGA , Movidius Myriad 2 , Adapteva Epiphany y DSP .

Conjunto de pruebas de conformidad de Khronos

Para ser oficialmente conforme, una implementación debe pasar el paquete de pruebas de conformidad de Khronos (CTS), y los resultados se envían al Programa de adopción de Khronos. ^[175] El código CTS de Khronos para todas las versiones de OpenCL está disponible en código abierto desde 2017. ^[176]

Productos conformes

El Grupo Khronos mantiene una lista ampliada de productos compatibles con OpenCL. ^[4]

Todas las implementaciones que cumplen con el estándar se pueden consultar utilizando una de las herramientas clinfo (existen múltiples herramientas con el mismo nombre y un conjunto de características similar). ^{[187] [188] [189]}

Soporte de versiones

Los productos y sus versiones compatibles con OpenCL incluyen: ^[190]

Compatibilidad con OpenCL 3.0

Todo el hardware con OpenCL 1.2+ es posible, OpenCL 2.x solo es opcional, Khronos Test Suite está disponible desde 2020-10 ^{[191] [192]}

• (2020) Intel NEO Compute: 20.41+ para Tiger Lake Gen 12 a Broadwell (incluye soporte completo para 2.0 y 2.1 y partes de 2.2) ^[193]
• (2020) Procesadores Intel de 6.ª, 7.ª, 8.ª, 9.ª, 10.ª y 11.ª generación ( Skylake , Kaby Lake , Coffee Lake , Comet Lake , Ice Lake , Tiger Lake ) con el último controlador de gráficos Intel para Windows
• (2021) Procesadores Intel de 11.ª y 12.ª generación ( Rocket Lake , Alder Lake ) con el último controlador de gráficos Intel Windows
• (2021) Arm Mali-G78, Mali-G310, Mali-G510, Mali-G610, Mali-G710 y Mali-G78AE.
• (2022) Procesadores Intel de 13.ª generación ( Raptor Lake ) con el último controlador de gráficos Intel Windows
• (2022) Gráficos discretos Intel Arc con el último controlador de gráficos Intel Arc para Windows
• (2021) Nvidia Maxwell , Pascal , Volta , Turing y Ampere con controlador de gráficos Nvidia 465+. ^[172]
• (2022) Nvidia Ada Lovelace con controlador de gráficos Nvidia 525+.
• (2022) GPU Samsung Xclipse 920 (basada en AMD RDNA2)
• (2023) Procesadores Intel de 14.ª generación ( Raptor Lake ) Actualícelos con el último controlador de gráficos Intel para Windows
• (2023) Procesadores Intel Core Ultra Serie 1 ( Meteor Lake ) con el último controlador de gráficos Intel Windows

Compatibilidad con OpenCL 2.2

Ninguno todavía : Khronos Test Suite listo, con actualización de controladores, todo el hardware con compatibilidad con 2.0 y 2.1 posible

• Intel NEO Compute: trabajo en progreso para productos reales ^[194]
• ROCm: Versión 3.5+ en su mayoría

Compatibilidad con OpenCL 2.1

• (2018+) Compatibilidad con procesadores Intel de quinta y sexta generación ( Broadwell , Skylake )
• (2017+) Procesadores Intel de séptima, octava, novena y décima generación ( Kaby Lake , Coffee Lake , Comet Lake , Ice Lake )
• Khronos: con la actualización de controladores, todo el hardware compatible con la versión 2.0 es posible

Compatibilidad con OpenCL 2.0

• (2011+) GPU AMD GCN (serie HD 7700+/HD 8000/Rx 200/Rx 300/Rx 400/Rx 500/Rx 5000), algunas GCN de 1.ª generación, solo 1.2 con algunas extensiones
• (2013+) APU AMD GCN ( basadas en Jaguar , Steamroller , Puma , Excavator y Zen )
• (2014+) Procesadores Intel de 5.ª y 6.ª generación ( Broadwell , Skylake )
• (2015+) Serie Qualcomm Adreno 5xx
• (2018+) Serie Qualcomm Adreno 6xx
• (2017+) ARM Mali (Bifrost) G51 y G71 en Android 7.1 y Linux
• (2018+) ARM Mali (Bifrost) G31, G52, G72 y G76
• (2017+) Compatibilidad de evaluación incompleta: GPU Nvidia Kepler , Maxwell , Pascal , Volta y Turing (series GeForce 600, 700, 800, 900 y 10, series Quadro K, M y P, series Tesla K, M y P) con versión de controlador 378.66+

Compatibilidad con OpenCL 1.2

• (2011+) para algunos AMD GCN de primera generación, algunas funciones de OpenCL 2.0 no son posibles hoy en día, pero hay muchas más extensiones que Terascale
• (2009+) GPU AMD TeraScale 2 y 3 (RV8xx, RV9xx en las series HD 5000, 6000 y 7000)
• (2011+) APU AMD TeraScale ( basadas en K10 , Bobcat y Piledriver )
• (2012+) GPU Nvidia Kepler, Maxwell, Pascal, Volta y Turing (series GeForce 600, 700, 800, 900, 10, 16, 20, Quadro series K, M y P, series Tesla K, M y P)
• (2012+) Procesadores Intel de 3.ª y 4.ª generación ( Ivy Bridge , Haswell )
• (2013+) Serie Qualcomm Adreno 4xx
• (2013+) ARM Mali Midgard de tercera generación (T760)
• (2015+) ARM Mali Midgard 4.ª generación (T8xx)

Compatibilidad con OpenCL 1.1

• (2008+) algunas GPU AMD TeraScale 1 (RV7xx en la serie HD4000)
• (2008+) GPU Nvidia Tesla, Fermi (serie GeForce 8, 9, 100, 200, 300, 400, 500, serie Quadro o serie Tesla con GPU Tesla o Fermi )
• (2011+) Serie Qualcomm Adreno 3xx
• (2012+) ARM Mali Midgard de 1.ª y 2.ª generación (T-6xx, T720)

Compatibilidad con OpenCL 1.0

• Actualizado principalmente a 1.1 y 1.2 después del primer controlador solo para 1.0

Portabilidad, rendimiento y alternativas

Una característica clave de OpenCL es la portabilidad, a través de su memoria abstracta y modelo de ejecución , y el programador no puede usar directamente tecnologías específicas de hardware como la ejecución de subprocesos paralelos en línea (PTX) para GPU Nvidia a menos que esté dispuesto a renunciar a la portabilidad directa en otras plataformas. Es posible ejecutar cualquier kernel de OpenCL en cualquier implementación compatible.

Sin embargo, el rendimiento del núcleo no es necesariamente portable entre plataformas. Se ha demostrado que las implementaciones existentes son competitivas cuando el código del núcleo está ajustado correctamente, y se ha sugerido el ajuste automático como una solución al problema de portabilidad del rendimiento, ^[195] produciendo "niveles aceptables de rendimiento" en núcleos de álgebra lineal experimentales. ^[196] También se estudió la portabilidad de una aplicación completa que contiene múltiples núcleos con diferentes comportamientos, y se muestra que la portabilidad solo requiere concesiones limitadas. ^[197]

Un estudio de la Universidad de Delft de 2011 que comparó los programas CUDA y su traducción directa a OpenCL C concluyó que CUDA superaba a OpenCL en un 30 % como máximo en la implementación de Nvidia. Los investigadores señalaron que su comparación podría ser más justa si se aplicaran optimizaciones manuales a los programas OpenCL, en cuyo caso "no había razón para que OpenCL obtuviera un peor rendimiento que CUDA". Las diferencias de rendimiento podrían atribuirse principalmente a diferencias en el modelo de programación (especialmente el modelo de memoria) y a las optimizaciones del compilador de NVIDIA para CUDA en comparación con las de OpenCL. ^[195]

Otro estudio realizado en D-Wave Systems Inc. descubrió que "el rendimiento del núcleo OpenCL es entre un 13% y un 63% más lento, y el tiempo de extremo a extremo es entre un 16% y un 67% más lento" que el rendimiento de CUDA. ^[198]

El hecho de que OpenCL permita que las cargas de trabajo sean compartidas por la CPU y la GPU, ejecutando los mismos programas, significa que los programadores pueden explotar ambas al dividir el trabajo entre los dispositivos. ^[199] Esto conduce al problema de decidir cómo particionar el trabajo, porque las velocidades relativas de las operaciones difieren entre los dispositivos. Se ha sugerido el aprendizaje automático para resolver este problema: Grewe y O'Boyle describen un sistema de máquinas de vectores de soporte entrenadas en características de tiempo de compilación del programa que pueden decidir el problema de partición del dispositivo de forma estática, sin ejecutar realmente los programas para medir su rendimiento. ^[200]

En una comparación de tarjetas gráficas reales de la serie AMD RDNA 2 y Nvidia RTX, se obtuvo un resultado incierto según las pruebas OpenCL. No se probaron posibles mejoras de rendimiento mediante el uso de Nvidia CUDA u OptiX. ^[201]

Véase también

• Biblioteca de simulación avanzada
• FireStream de AMD
• GPU de Brook
• C++AMPLIFICADOR
• Cerca del metal
• CUDA
• Cálculo directo
• GPGPU
• CADERA
• Larrabee
• Lib Sh
• Lista de aplicaciones OpenCL
• Acceso abierto
• OpenGL
• OpenHMPP
• OpenMP
• Metal
• Script de renderizado
• SecuenciaL
• SIMD
• SYCL
• Vulcano
• WebCL

Referencias

1. "La especificación OpenCL".
2. "Dispositivos Android compatibles con OpenCL". Google Docs . ArrayFire . Consultado el 28 de abril de 2015 .
3. "FreeBSD Graphics/OpenCL". FreeBSD . Consultado el 23 de diciembre de 2015 .
4. "Productos conformes". Khronos Group . Consultado el 9 de mayo de 2015 .
5. Sochacki, Bartosz (19 de julio de 2019). "The OpenCL C++ 1.0 Specification" (PDF) . Grupo de trabajo OpenCL de Khronos . Consultado el 19 de julio de 2019 .
6. Munshi, Aaftab; Howes, Lee; Sochaki, Barosz (27 de abril de 2020). "La especificación C de OpenCL Versión: 3.0 Revisión del documento: V3.0.7" (PDF) . Grupo de trabajo OpenCL de Khronos. Archivado desde el original (PDF) el 20 de septiembre de 2020 . Consultado el 28 de abril de 2021 .
7. "La documentación del lenguaje de programación C++ para OpenCL 1.0 y 2021". Grupo de trabajo de OpenCL de Khronos. 20 de diciembre de 2021. Consultado el 2 de diciembre de 2022 .
8. "Compañías Conformes". Khronos Group . Consultado el 19 de septiembre de 2024 .
9. Gianelli, Silvia E. (14 de enero de 2015). "Xilinx SDAccel Development Environment for OpenCL, C, and C++, Achieves Khronos Conformance". PR Newswire . Xilinx . Consultado el 27 de abril de 2015 .
10. Howes, Lee (11 de noviembre de 2015). "The OpenCL Specification Version: 2.1 Document Revision: 23" (PDF) . Grupo de trabajo de OpenCL de Khronos . Consultado el 16 de noviembre de 2015 .
11. Gaster, Benedict; Howes, Lee; Kaeli, David R .; Mistry, Perhaad; Schaa, Dana (2012). Computación heterogénea con OpenCL: Edición revisada de OpenCL 1.2 . Morgan Kaufmann.
12. Tompson, Jonathan; Schlachter, Kristofer (2012). "An Introduction to the OpenCL Programming Model" (PDF) . Laboratorio de Investigación de Medios de la Universidad de Nueva York. Archivado desde el original (PDF) el 6 de julio de 2015. Consultado el 6 de julio de 2015 .
13. Stone, John E.; Gohara, David; Shi, Guochin (2010). "OpenCL: un estándar de programación paralela para sistemas informáticos heterogéneos". Computing in Science & Engineering . 12 (3): 66–73. Bibcode :2010CSE....12c..66S. doi :10.1109/MCSE.2010.69. PMC 2964860 . PMID  21037981. 
14. Klockner, Andreas; Pinto, Nicolás; Lee, Yunsup; Catanzaro, Bryan; Ivanov, Pablo; Fasih, Ahmed (2012). "PyCUDA y PyOpenCL: un enfoque basado en scripts para la generación de código en tiempo de ejecución de GPU". Computación Paralela . 38 (3): 157-174. arXiv : 0911.3456 . doi :10.1016/j.parco.2011.09.001. S2CID  18928397.
15. "OpenCL - Enlaces de lenguajes de computación abiertos". metacpan.org . Consultado el 18 de agosto de 2018 .
16. "Enlace D para OpenCL". dlang.org . Consultado el 29 de junio de 2021 .
17. "SPIR – El primer lenguaje intermedio estándar abierto para computación paralela y gráficos". Khronos Group . 21 de enero de 2014.
18. "SYCL – Programación heterogénea de código único en C++ para OpenCL". Khronos Group . 21 de enero de 2014. Archivado desde el original el 18 de enero de 2021 . Consultado el 24 de octubre de 2016 .
19. "C++ para OpenCL, Guía de OpenCL". GitHub . Consultado el 18 de abril de 2021 .
20. Munshi, Aaftab, ed. (2014). "La especificación C de OpenCL, versión 2.0" (PDF) . Consultado el 24 de junio de 2014 .
21. "Introducción a la programación OpenCL 201005" (PDF) . AMD. págs. 89–90. Archivado desde el original (PDF) el 16 de mayo de 2011 . Consultado el 8 de agosto de 2017 .
22. "OpenCL" (PDF) . SIGGRAPH2008. 14 de agosto de 2008. Archivado desde el original (PDF) el 16 de febrero de 2012. Consultado el 14 de agosto de 2008 .
23. "Fitting FFT into G80 Architecture" (PDF) . Vasily Volkov y Brian Kazian, informe del proyecto CS258 de la UC Berkeley. Mayo de 2008. Consultado el 14 de noviembre de 2008 .
24. "OpenCL_FFT". Apple. 26 de junio de 2012. Consultado el 18 de junio de 2022 .
25. Trevett, Neil (28 de abril de 2020). "Anuncios y mesa redonda sobre Khronos" (PDF) .
26. Stulova, Anastasia; Hickey, Neil; van Haastregt, Sven; Antognini, Marco; Petit, Kevin (27 de abril de 2020). "El lenguaje de programación C++ para OpenCL". Actas del Taller internacional sobre OpenCL . IWOCL '20. Múnich, Alemania: Association for Computing Machinery. págs. 1–2. doi :10.1145/3388333.3388647. ISBN 978-1-4503-7531-3.S2CID216554183  .​
27. KhronosGroup/OpenCL-Docs, The Khronos Group, 16 de abril de 2021 , consultado el 18 de abril de 2021
28. "Documentación de la versión 9 de Clang, compatibilidad con OpenCL". releases.llvm.org . Septiembre de 2019 . Consultado el 18 de abril de 2021 .
29. "Clang 9, extensiones de lenguaje, OpenCL". releases.llvm.org . Septiembre de 2019 . Consultado el 18 de abril de 2021 .
30. "Publicación de la documentación del lenguaje kernel C++ para OpenCL, versión 1.0, revisión 1 · KhronosGroup/OpenCL-Docs". GitHub . Diciembre de 2020 . Consultado el 18 de abril de 2021 .
31. "Publicación de la documentación de C++ para el lenguaje del núcleo OpenCL, versión 1.0 y 2021 · KhronosGroup/OpenCL-Docs". GitHub . Diciembre de 2021 . Consultado el 2 de diciembre de 2022 .
32. "La documentación del lenguaje de programación C++ para OpenCL 1.0". www.khronos.org . Consultado el 18 de abril de 2021 .
33. "Lanzamiento de la documentación del lenguaje kernel de C++ para OpenCL, versión 1.0, revisión 2 · KhronosGroup/OpenCL-Docs". GitHub . Marzo de 2021 . Consultado el 18 de abril de 2021 .
34. "cl_ext_cxx_for_opencl". www.khronos.org . Septiembre de 2020 . Consultado el 18 de abril de 2021 .
35. "Mali SDK Supporting Compilation of Kernels in C++ for OpenCL" (SDK de Mali que admite la compilación de núcleos en C++ para OpenCL). community.arm.com . Diciembre de 2020 . Consultado el 18 de abril de 2021 .
36. "Manual del usuario del compilador Clang: compatibilidad con C++ para OpenCL". clang.llvm.org . Consultado el 18 de abril de 2021 .
37. "OpenCL-Guide, compilación sin conexión de fuentes del kernel de OpenCL". GitHub . Consultado el 18 de abril de 2021 .
38. "OpenCL-Guide, Programación de núcleos OpenCL". GitHub . Consultado el 18 de abril de 2021 .
39. Clspv es un compilador prototipo para un subconjunto de sombreadores computacionales de OpenCL C a Vulkan: google/clspv, 17 de agosto de 2019 , consultado el 20 de agosto de 2019
40. Petit, Kévin (17 de abril de 2021), Implementación experimental de OpenCL en Vulkan , consultado el 18 de abril de 2021
41. "Khronos lanza una iniciativa de computación heterogénea" (Nota de prensa). Khronos Group. 16 de junio de 2008. Archivado desde el original el 20 de junio de 2008. Consultado el 18 de junio de 2008 .
42. "OpenCL se promociona en Texas". MacWorld. 20 de noviembre de 2008. Consultado el 12 de junio de 2009 .
43. "El Grupo Khronos publica la especificación OpenCL 1.0" (Nota de prensa). Khronos Group. 8 de diciembre de 2008. Consultado el 4 de diciembre de 2016 .
44. "Apple presenta a los desarrolladores una versión preliminar de Mac OS X Snow Leopard" (nota de prensa). Apple Inc. 9 de junio de 2008. Archivado desde el original el 18 de marzo de 2012 . Consultado el 9 de junio de 2008 .
45. "AMD impulsa la adopción de estándares industriales en el desarrollo de software GPGPU" (nota de prensa). AMD. 6 de agosto de 2008. Consultado el 14 de agosto de 2008 .
46. "AMD respalda OpenCL y Microsoft DirectX 11". eWeek. 6 de agosto de 2008. Archivado desde el original el 6 de diciembre de 2012. Consultado el 14 de agosto de 2008 .
47. "HPCWire: RapidMind adopta proyectos de código abierto y estándares". HPCWire. 10 de noviembre de 2008. Archivado desde el original el 18 de diciembre de 2008. Consultado el 11 de noviembre de 2008 .
48. "Nvidia agrega OpenCL a su kit de herramientas de computación GPU líder en la industria" (nota de prensa). Nvidia. 9 de diciembre de 2008. Consultado el 10 de diciembre de 2008 .
49. "OpenCL Development Kit for Linux on Power". alphaWorks. 30 de octubre de 2009. Consultado el 30 de octubre de 2009 .
50. "Estándar Opencl: descripción general | Temas de ScienceDirect". www.sciencedirect.com .
51. "La especificación OpenCL Versión: 1.0 Revisión del documento: 48" (PDF) . Grupo de trabajo OpenCL de Khronos.
52. "Khronos impulsa el estándar de computación paralela con el lanzamiento de la especificación OpenCL 1.1". Archivado desde el original el 2 de marzo de 2016 . Consultado el 24 de febrero de 2016 .
53. "Khronos lanza la especificación OpenCL 1.2". Khronos Group. 15 de noviembre de 2011. Consultado el 23 de junio de 2015 .
54. "Especificación OpenCL 1.2" (PDF) . Khronos Group . Consultado el 23 de junio de 2015 .
55. "Khronos finaliza la especificación OpenCL 2.0 para computación heterogénea". Khronos Group. 18 de noviembre de 2013. Consultado el 10 de febrero de 2014 .
56. "Khronos lanza las especificaciones OpenCL 2.1 y SPIR-V 1.0 para programación paralela heterogénea". Khronos Group. 16 de noviembre de 2015. Consultado el 16 de noviembre de 2015 .
57. "Khronos anuncia OpenCL 2.1: C++ llega a OpenCL". AnandTech. 3 de marzo de 2015. Consultado el 8 de abril de 2015 .
58. "Khronos lanza la especificación provisional de OpenCL 2.1 para revisión pública". Khronos Group. 3 de marzo de 2015. Consultado el 8 de abril de 2015 .
59. "Descripción general de OpenCL". Khronos Group. 21 de julio de 2013.
60. "Khronos lanza la especificación provisional OpenCL 2.2 con lenguaje de núcleo OpenCL C++ para programación paralela". Khronos Group . 18 de abril de 2016.
61. Trevett, Neil (abril de 2016). «OpenCL: un estado de la Unión» (PDF) . IWOCL . Viena : Khronos Group . Consultado el 2 de enero de 2017 .
62. "Khronos lanza OpenCL 2.2 con SPIR-V 1.2". Khronos Group . 16 de mayo de 2017.
63. "Actualización de mantenimiento de OpenCL 2.2 publicada". The Khronos Group . 14 de mayo de 2018.
64. "OpenCL 3.0 aporta mayor flexibilidad y extensiones DMA asíncronas". www.phoronix.com .
65. "Khronos Group lanza OpenCL 3.0". 26 de abril de 2020.
66. "La especificación OpenCL" (PDF) . Grupo de trabajo OpenCL de Khronos.
67. Trevett, Neil (2021). "Estado de la Unión: Grupo de trabajo de OpenCL" (PDF) . pág. 9.
68. "Uso de extensiones de semáforo y uso compartido de memoria para la interoperabilidad de Vulkan con NVIDIA OpenCL". 24 de febrero de 2022.
69. "OpenCL 3.0.14 lanzado con nueva extensión para Command Buffer Multi-Device".
70. "Últimas noticias: Hoja de ruta de fusión de OpenCL con Vulkan | PC Perspective" www.pcper.com . Archivado desde el original el 1 de noviembre de 2017 . Consultado el 17 de mayo de 2017 .
71. "SIGGRAPH 2018: OpenCL-Next toma forma, Vulkan continúa evolucionando – Phoronix". www.phoronix.com .
72. "Actualización de Vulkan SIGGRAPH 2019" (PDF) .
73. Trevett, Neil (23 de mayo de 2019). "Taller EVS de descripción general de Khronos y OpenCL, mayo de 2019" (PDF) . Khronos Group .
74. "Especificación ICD de OpenCL" . Consultado el 23 de junio de 2015 .
75. "Entrada de Apple en la página de usuarios de LLVM" . Consultado el 29 de agosto de 2009 .
76. "Entrada de Nvidia en la página de usuarios de LLVM" . Consultado el 6 de agosto de 2009 .
77. "Entrada de Rapidmind en la página de usuarios de LLVM" . Consultado el 1 de octubre de 2009 .
78. "Entrada del blog de Zack Rusin sobre la implementación de Gallium3D OpenCL". Febrero de 2009. Consultado el 1 de octubre de 2009 .
79. "GalliumCompute". dri.freedesktop.org . Consultado el 23 de junio de 2015 .
80. "Actualización del estado de Clover" (PDF) .
81. "mesa/mesa – La biblioteca de gráficos 3D de Mesa". cgit.freedesktop.org .
82. "Gallium Clover con SPIR-V y NIR abre nuevas opciones de computación dentro de Mesa – Phoronix". www.phoronix.com . Archivado desde el original el 22 de octubre de 2020 . Consultado el 13 de diciembre de 2018 .
83. Clark, Rob; Herbst, Karol (2018). "Soporte de OpenCL dentro de mesa a través de SPIR-V y NIR" (PDF) .
84. "La implementación 'Rusticl' de Mesa ahora logra manejar Darktable OpenCL".
85. "Rusticl de Mesa logra la conformidad oficial con OpenCL 3.0".
86. "Mesa 22.3 lanzado con RDNA3 Vulkan, Rusticl OpenCL y mejores gráficos Intel Arc".
87. "El controlador OpenCL Rusticl de Mesa está casi listo con soporte para GPU AMD Radeon".
88. "La implementación de Rusticl OpenCL de Mesa puede superar la pila de cómputo ROCm de Radeon".
89. "Estado de Windows en Arm64: una perspectiva de alto nivel". Chips and Cheese . 13 de marzo de 2022 . Consultado el 23 de octubre de 2023 .
90. "Presentación de OpenCL y OpenGL en DirectX". Collabora | Consultoría de código abierto . Consultado el 23 de octubre de 2023 .
91. "Análisis profundo de las capas de OpenGL sobre DirectX". Collabora | Consultoría de código abierto . Consultado el 23 de octubre de 2023 .
92. Larabel, Michael (10 de enero de 2013). "Beignet: OpenCL/GPGPU llega para Ivy Bridge en Linux". Phoronix .
93. Larabel, Michael (16 de abril de 2013). "Más críticas sobre Beignet OpenCL de Intel". Phoronix .
94. Larabel, Michael (24 de diciembre de 2013). "Beignet OpenCL de Intel todavía se está desarrollando lentamente". Phoronix .
95. "Buñuelo". freedesktop.org.
96. "beignet – Biblioteca OpenCL Beignet para Intel Ivy Bridge y GPU más nuevas". cgit.freedesktop.org .
97. "Intel lleva Beignet a Android para OpenCL Compute – Phoronix". www.phoronix.com .
98. "01.org Intel Open Source – Compute Runtime". 7 de febrero de 2018.
99. "README de NEO GitHub". GitHub . 21 de marzo de 2019.
100. "ROCm". GitHub . Archivado desde el original el 8 de octubre de 2016.
101. "RadeonOpenCompute/ROCm: ROCm: plataforma de código abierto para computación de alto rendimiento y computación GPU a ultraescala". GitHub. 21 de marzo de 2019.
102. "Una buena descripción general de la pila de cómputo ROCm Linux – Phoronix". www.phoronix.com .
103. "XDC Lightning.pdf". Documentos de Google .
104. "Radeon ROCm 2.0 ya está disponible oficialmente con soporte para OpenCL 2.0, TensorFlow 1.12 y Vega 48-bit VA – Phoronix". www.phoronix.com .
105. "Prueba comparativa de Radeon ROCm 2.0 OpenCL: Phoronix" www.phoronix.com .
106. https://github.com/RadeonOpenCompute/ROCm/blob/master/AMD_ROCm_Release_Notes_v3.3.pdf ^{[ enlace roto ]}
107. "Radeon ROCm 3.5 lanzado con nuevas características pero aún sin soporte para Navi – Phoronix".
108. "Radeon ROCm 3.10 lanzado con mejoras en la herramienta del centro de datos, nuevas API – Phoronix".
109. "AMD lanza Arcturus como Instinct MI100, Radeon ROCm 4.0 – Phoronix".
110. "Bienvenido a la plataforma AMD ROCm™ — Documentación de ROCm 1.0.0".
111. "Inicio". docs.amd.com .
112. "Documentación de AMD – Portal".
113. Jääskeläinen, Pekka; Sánchez de La Lama, Carlos; Schnetter, Erik; Raiskila, Kalle; Takala, Jarmo; Berg, Heikki (2016). "pocl: una implementación de OpenCL portátil y de rendimiento". Int'l J. Programación paralela . 43 (5): 752–785. arXiv : 1611.07083 . Código Bib : 2016arXiv161107083J. doi :10.1007/s10766-014-0320-y. S2CID  9905244.
114. "página de inicio de pocl". pocl .
115. "GitHub - pocl/pocl: pocl: lenguaje informático portátil". 14 de marzo de 2019 – vía GitHub.
116. "Estado de implementación del soporte de HSA al 17/05/2016 — Documentación de Portable Computing Language (pocl) 1.3-pre". portablecl.org .
117. "Página de inicio de PoCL".
118. "Página de inicio de PoCL".
119. "Página de inicio de PoCL".
120. "Se lanza POCL 1.6-RC1 con mejor rendimiento de CUDA – Phoronix". Archivado desde el original el 17 de enero de 2021 . Consultado el 3 de diciembre de 2020 .
121. Baumann, Tobias; Noack, Matthias; Steinke, Thomas (2021). "Evaluación del rendimiento y mejoras de la implementación de código abierto de PoCL OpenCL en CPU Intel" (PDF) . pág. 51.
122. "Página de inicio de PoCL".
123. "Página de inicio de PoCL".
124. "Página de inicio de PoCL".
125. "Página de inicio de PoCL".
126. "Acerca de". Git.Linaro.org .
127. Gall, T.; Pitney, G. (6 de marzo de 2014). «LCA14-412: GPGPU en ARM SoC» (PDF) . Amazon Web Services . Archivado desde el original (PDF) el 26 de julio de 2020 . Consultado el 22 de enero de 2017 .
128. "zuzuf/freeocl". GitHub . Consultado el 13 de abril de 2017 .
129. Zhang, Peng; Fang, Jianbin; Yang, Canqun; Tang, Tao; Huang, Chun; Wang, Zheng (2018). MOCL: una implementación eficiente de OpenCL para la arquitectura Matrix-2000 (PDF) . Proc. Conferencia Internacional sobre Fronteras de la Computación. doi :10.1145/3203217.3203244.
130. "Estado". GitHub . 16 de marzo de 2022.
131. "Demostración de OpenCL, CPU AMD". YouTube . 10 de diciembre de 2008 . Consultado el 28 de marzo de 2009 .
132. "Demostración de OpenCL, GPU Nvidia". YouTube . 10 de diciembre de 2008 . Consultado el 28 de marzo de 2009 .
133. "Imagination Technologies lanza la familia de IP gráfica multiprocesador POWERVR SGX543MP avanzada y altamente eficiente". Imagination Technologies. 19 de marzo de 2009. Archivado desde el original el 3 de abril de 2014. Consultado el 30 de enero de 2011 .
134. "AMD y Havok muestran física acelerada con OpenCL". PC Perspective. 26 de marzo de 2009. Archivado desde el original el 5 de abril de 2009. Consultado el 28 de marzo de 2009 .
135. "Nvidia lanza el controlador OpenCL para desarrolladores". Nvidia. 20 de abril de 2009. Archivado desde el original el 4 de febrero de 2012. Consultado el 27 de abril de 2009 .
136. "AMD revierte GPGPU y anuncia OpenCL SDK para x86". Ars Technica. 5 de agosto de 2009. Consultado el 6 de agosto de 2009 .^{[ enlace muerto permanente ]}
137. Moren, Dan; Snell, Jason (8 de junio de 2009). "Actualización en vivo: discurso inaugural de la WWDC 2009". MacWorld.com . MacWorld . Consultado el 12 de junio de 2009 .
138. "Programa Beta del Kit de Desarrollo de Software (SDK) v2.0 de ATI Stream". Archivado desde el original el 9 de agosto de 2009. Consultado el 14 de octubre de 2009 .
139. "S3 Graphics lanzó el procesador gráfico integrado Chrome 5400E". Archivado desde el original el 2 de diciembre de 2009. Consultado el 27 de octubre de 2009 .
140. "VIA presenta el procesador gráfico VN1000 mejorado". Archivado desde el original el 15 de diciembre de 2009 . Consultado el 10 de diciembre de 2009 .
141. "ATI Stream SDK v2.0 con soporte para OpenCL 1.0". Archivado desde el original el 1 de noviembre de 2009. Consultado el 23 de octubre de 2009 .
142. "OpenCL". ZiiLABS . Consultado el 23 de junio de 2015 .
143. «Intel revela nuevos detalles técnicos de Sandy Bridge». Archivado desde el original el 31 de octubre de 2013. Consultado el 13 de septiembre de 2010 .
144. http://reference.wolfram.com/mathematica/OpenCLLink/tutorial/Overview.html ^{[ URL básica ]}
145. "Historias relacionadas con WebCL". Khronos Group . Consultado el 23 de junio de 2015 .
146. "Khronos lanza la especificación final de WebGL 1.0". Khronos Group. Archivado desde el original el 9 de julio de 2015. Consultado el 23 de junio de 2015 .
147. "Desarrollador de IBM". developer.ibm.com .
148. "Bienvenido a Wikis". www.ibm.com . 20 de octubre de 2009.
149. "Nokia Research lanza prototipo WebCL". Khronos Group. 4 de mayo de 2011. Archivado desde el original el 5 de diciembre de 2020. Consultado el 23 de junio de 2015 .
150. KamathK, Sharath. "Prototipo WebCL de Samsung para WebKit". Github.com. Archivado desde el original el 18 de febrero de 2015. Consultado el 23 de junio de 2015 .
151. "AMD abre el acelerador en el rendimiento de las APU con el desarrollo de software OpenCL actualizado". Amd.com. 8 de agosto de 2011. Consultado el 16 de junio de 2013 .
152. "AMD APP SDK v2.6". Forums.amd.com. 13 de marzo de 2015. Consultado el 23 de junio de 2015 .^{[ enlace muerto ]}
153. "El Grupo Portland anuncia el compilador OpenCL para los SoC NovaThor basados ​​en ARM de ST-Ericsson" . Consultado el 4 de mayo de 2012 .
154. "WebCL Latest Spec". Khronos Group . 7 de noviembre de 2013. Archivado desde el original el 1 de agosto de 2014. Consultado el 23 de junio de 2015 .
155. "Altera abre el mundo de los FPGA a los programadores de software con una amplia disponibilidad de SDK y placas listas para usar para OpenCL". Altera.com. Archivado desde el original el 9 de enero de 2014 . Consultado el 9 de enero de 2014 .
156. "Altera SDK para OpenCL es el primero en la industria en lograr la conformidad con Khronos para FPGA". Altera.com. Archivado desde el original el 9 de enero de 2014. Consultado el 9 de enero de 2014 .
157. "Khronos finaliza la especificación OpenCL 2.0 para computación heterogénea". Khronos Group. 18 de noviembre de 2013. Consultado el 23 de junio de 2015 .
158. "Comunicado de prensa de WebCL 1.0". Khronos Group. 19 de marzo de 2014. Consultado el 23 de junio de 2015 .
159. "Especificación WebCL 1.0". Khronos Group. 14 de marzo de 2014. Consultado el 23 de junio de 2015 .
160. "Controlador Intel OpenCL 2.0". Archivado desde el original el 17 de septiembre de 2014 . Consultado el 14 de octubre de 2014 .
161. "Controlador AMD OpenCL 2.0". Support.AMD.com . 17 de junio de 2015. Consultado el 23 de junio de 2015 .
162. "El entorno de desarrollo Xilinx SDAccel para OpenCL, C y C++ logra la conformidad con Khronos – noticias de khronos.org". The Khronos Group . Consultado el 26 de junio de 2017 .
163. "Controladores de gráficos Release 349 para Windows, versión 350.12" (PDF) . 13 de abril de 2015. Consultado el 4 de febrero de 2016 .
164. "Se lanzó AMD APP SDK 3.0". Developer.AMD.com . 26 de agosto de 2015. Consultado el 11 de septiembre de 2015 .
165. "Khronos publica las especificaciones OpenCL 2.1 y SPIR-V 1.0 para programación paralela heterogénea". Khronos Group . 16 de noviembre de 2015.
166. "¿Qué novedades hay? Intel® SDK para aplicaciones OpenCL™ 2016, R3". Intel Software.
167. "Los controladores NVIDIA 378.66 para Windows ofrecen compatibilidad con la evaluación de OpenCL 2.0". Khronos Group . 17 de febrero de 2017. Archivado desde el original el 6 de agosto de 2020 . Consultado el 17 de marzo de 2017 .
168. Szuppe, Jakub (22 de febrero de 2017). "NVIDIA habilita el soporte beta de OpenCL 2.0".
169. Szuppe, Jakub (6 de marzo de 2017). "La compatibilidad de la versión beta de NVIDIA con OpenCL 2.0 también funciona en Linux".
170. "El Grupo Khronos". El grupo Khronos . 21 de marzo de 2019.
171. "GitHub – RadeonOpenCompute/ROCm en roc-3.5.0". GitHub .
172. "NVIDIA ahora es compatible con OpenCL 3.0". 12 de abril de 2021.
173. "El Grupo Khronos". El grupo Khronos . 12 de diciembre de 2022 . Consultado el 12 de diciembre de 2022 .
174. "Rusticl de Mesa logra la conformidad oficial con OpenCL 3.0" www.phoronix.com . Consultado el 12 de diciembre de 2022 .
175. "El Grupo Khronos". El Grupo Khronos . 20 de agosto de 2019. Consultado el 20 de agosto de 2019 .
176. "KhronosGroup/OpenCL-CTL: Pruebas de conformidad con OpenCL". GitHub. 21 de marzo de 2019.
177. "OpenCL y el SDK de aplicaciones AMD". AMD Developer Central . developer.amd.com. Archivado desde el original el 4 de agosto de 2011 . Consultado el 11 de agosto de 2011 .
178. "Acerca de Intel OpenCL SDK 1.1". software.intel.com . intel.com . Consultado el 11 de agosto de 2011 .
179. "Notas de la versión del Intel® SDK para aplicaciones OpenCL™". software.intel.com . 14 de marzo de 2019.
180. "Soporte de producto" . Consultado el 11 de agosto de 2011 .
181. "Intel OpenCL SDK – Notas de la versión". Archivado desde el original el 17 de julio de 2011 . Consultado el 11 de agosto de 2011 .
182. "Anuncio del kit de desarrollo OpenCL para Linux en Power v0.3". IBM . Consultado el 11 de agosto de 2011 .
183. "IBM lanza OpenCL Development Kit para Linux en Power v0.3: versión compatible con OpenCL 1.1 disponible". OpenCL Lounge . ibm.com . Consultado el 11 de agosto de 2011 .
184. "IBM lanza OpenCL Common Runtime para Linux en arquitectura x86". IBM . 20 de octubre de 2009 . Consultado el 10 de septiembre de 2011 .
185. "OpenCL y el SDK de aplicaciones AMD". AMD Developer Central . developer.amd.com. Archivado desde el original el 6 de septiembre de 2011 . Consultado el 10 de septiembre de 2011 .
186. "Nvidia lanza el controlador OpenCL". 22 de abril de 2009. Consultado el 11 de agosto de 2011 .
187. "clinfo de Simon Leblanc". GitHub . Consultado el 27 de enero de 2017 .
188. "información de Oblomov". GitHub . Consultado el 27 de enero de 2017 .
189. "clinfo: openCL INFORMATION". 2 de abril de 2013. Consultado el 27 de enero de 2017 .
190. "Productos Khronos". The Khronos Group . Consultado el 15 de mayo de 2017 .
191. "OpenCL-CTS/Test_conformance en la página principal · KhronosGroup/OpenCL-CTS". GitHub .
192. "Problemas · KhronosGroup/OpenCL-CTS". GitHub .
193. "Intel Compute-Runtime 20.43.18277 incorpora compatibilidad con Alder Lake".
194. "compute-runtime". 01.org . 7 de febrero de 2018.
195. Fang, Jianbin; Varbanescu, Ana Lucia; Sips, Henk (2011). "Una comparación integral del rendimiento de CUDA y OpenCL". Conferencia internacional de 2011 sobre procesamiento paralelo . Proc. Conferencia internacional sobre procesamiento paralelo. págs. 216–225. doi :10.1109/ICPP.2011.45. ISBN 978-1-4577-1336-1.
196. Du, Peng; Weber, Rick; Luszczek, Piotr; Tomov, Stanimire; Peterson, Gregory; Dongarra, Jack (2012). "De CUDA a OpenCL: hacia una solución portátil de alto rendimiento para programación de GPU multiplataforma". Computación paralela . 38 (8): 391–407. CiteSeerX 10.1.1.193.7712 . doi :10.1016/j.parco.2011.10.002. 
197. Dolbeau, Romain; Bodin, François; de Verdière, Guillaume Colin (7 de septiembre de 2013). "¿Un OpenCL para gobernarlos a todos?". 2013 IEEE 6th International Workshop on Multi-/Many-core Computing Systems (MuCoCoS) . págs. 1–6. doi :10.1109/MuCoCoS.2013.6633603. ISBN 978-1-4799-1010-6. Número de identificación del sujeto  225784.
198. Karimi, Kamran; Dickson, Neil G.; Hamze, Firas (2011). "Una comparación de rendimiento de CUDA y OpenCL". arXiv : 1005.2581v3 [cs.PF].
199. Un estudio de técnicas de computación heterogénea CPU-GPU, ACM Computing Surveys, 2015.
200. Grewe, Dominik; O'Boyle, Michael FP (2011). "Un enfoque de particionamiento estático de tareas para sistemas heterogéneos utilizando OpenCL". Construcción de compiladores . Proc. Int'l Conf. on Compiler Construction. Lecture Notes in Computer Science. Vol. 6601. págs. 286–305. doi : 10.1007/978-3-642-19861-8_16 . ISBN 978-3-642-19860-1.
201. "La serie Radeon RX 6800 tiene un excelente rendimiento OpenCL basado en ROCm en Linux". www.phoronix.com .

Enlaces externos

• Sitio web oficial
• Sitio web oficial de WebCL
• Taller internacional sobre OpenCL Archivado el 26 de enero de 2021 en Wayback Machine ( IWOCL ) patrocinado por The Khronos Group