AbrirCL
La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la
versión revisada el 15 de marzo de 2022; las comprobaciones requieren
2 ediciones .
OpenCL ( Eng. Open Computing L anguage - lenguaje de computación abierta ) es un marco para escribir programas de computadora relacionados con la computación paralela en varios gráficos y procesadores centrales , así como FPGA . OpenCL incluye un lenguaje de programación que se basa en el estándar de lenguaje de programación C99 y una interfaz de programación de aplicaciones . OpenCL proporciona paralelismo a nivel de instrucciones y de datos y es una implementación de la técnica GPGPU .. OpenCL es un estándar completamente abierto y no hay tarifas de licencia para usarlo.
El objetivo de OpenCL es complementar los estándares abiertos de la industria para gráficos y sonido de computadora en 3D ( OpenGL y OpenAL , respectivamente) con capacidades de GPU para computación de alto rendimiento. OpenCL es desarrollado y mantenido por Khronos Group , un consorcio sin fines de lucro que incluye muchas compañías importantes, incluidas AMD , Apple , ARM , Intel , Nvidia , Sony Computer Entertainment y otras.
Historia
OpenCL fue desarrollado originalmente por Apple Inc. Apple ha presentado propuestas para el desarrollo de la especificación al comité de Khronos. Pronto, AMD decidió apoyar el desarrollo de OpenCL (y DirectX 11 ), que debería reemplazar el marco Close to Metal . [1] [2]
El 16 de junio de 2008, se formó el Grupo de trabajo de computación de Khronos para desarrollar las especificaciones de OpenCL. Incluye Apple , nVidia , AMD , IBM , Intel , ARM , Motorola y otras empresas, incluidas las que se especializan en la creación de juegos de computadora. El trabajo se llevó a cabo durante cinco meses, luego de los cuales , el 9 de diciembre de 2008, el Grupo Khronos presentó la primera versión del estándar.
OpenCL 1.0 se mostró por primera vez al público el 9 de junio de 2008 y se lanzó con Mac OS X 10.6 el 28 de agosto de 2009. [3]
El 5 de abril de 2009, AMD anunció la disponibilidad para descargar la versión beta de ATI Stream SDK v2.0, que incluye el lenguaje de programación multiprocesador OpenCL.
El 20 de abril de 2009, nVidia lanzó un controlador beta y un kit de desarrollo de software ( SDK ) compatible con el estándar abierto GPGPU OpenCL. Este controlador beta está destinado a los desarrolladores que participan en el programa OpenCL Early Access, que pueden participar en la prueba beta a partir del 20 de abril. Para los miembros de GPU Computing Registered Developers, una versión beta del controlador OpenCL estará disponible en una fecha posterior. [4] [5] [6]
El 26 de noviembre de 2009, nVidia lanzó un controlador compatible con OpenCL 1.0 (rev. 48).
Para obtener una representación visual de cómo la tecnología OpenCL usa las capacidades de un sistema de 24 núcleos para generar efectos de video, se recomienda ver la siguiente demostración: [1] Archivado el 9 de marzo de 2017 en Wayback Machine .
OpenCL 1.1 fue presentado por Khronos Group el 14 de junio de 2010 . La nueva versión amplía significativamente la funcionalidad para la programación paralela, la flexibilidad y el rendimiento, y agrega nuevas funciones.
- Nuevos tipos de datos que incluyen vectores de 3 componentes y formatos de imagen adicionales.
- Comandos de procesamiento de múltiples subprocesos de host y procesamiento de búfer entre múltiples dispositivos.
- Operaciones de región de búfer que incluyen lectura, escritura y copia de regiones rectangulares 1D, 2D o 3D.
- Uso extendido del evento para administrar y controlar la ejecución de comandos.
- Interoperabilidad mejorada con OpenGL a través del intercambio eficiente de imágenes.
OpenCL 1.2 se presentó el 15 de noviembre de 2011 . La nueva versión contiene muchas pequeñas mejoras relacionadas con una mayor flexibilidad del idioma y optimizaciones de rendimiento. OpenCL 1.2 agregó una serie de innovaciones significativas.
- La partición de dispositivos es la capacidad de dividir un dispositivo en varios subdispositivos en el nivel de la aplicación OpenCL para vincular directamente trabajos a unidades informáticas específicas, reservar recursos para tareas de mayor prioridad o compartir recursos de hardware de manera más eficiente, como el caché.
- Compilación separada y vinculación de objetos: se hizo posible crear bibliotecas dinámicas que permiten usar rutinas implementadas previamente con cálculos OpenCL en programas de terceros.
- Compatibilidad ampliada con imágenes, incluida la capacidad de trabajar con imágenes 1D y conjuntos de imágenes 1D o 2D. Además, la extensión para compartir agrega la capacidad de crear una imagen OpenCL basada en texturas OpenGL individuales o matrices de texturas.
- Los núcleos OpenCL integrados ahora le permiten aprovechar el hardware personalizado o no programable y el firmware asociado. Por ejemplo, se hizo posible utilizar las capacidades y una mayor integración con el marco OpenCL de dispositivos como procesadores DSP o codificadores/descodificadores de video.
- Capacidad para compartir superficies sin problemas (Uso compartido de superficies multimedia) entre OpenCL y API DirectX 9/11.
OpenCL 2.0 se introdujo el 22 de julio de 2013 [7] y se estandarizó el 18 de noviembre del mismo año [8] .
- Memoria virtual compartida: permite que los núcleos del host y del dispositivo compartan estructuras de datos basadas en referencias de direcciones complejas, lo que elimina las transferencias explícitas entre el host y los dispositivos y aumenta la flexibilidad de programación.
- Paralelismo anidado: la actualización mejoró la experiencia de programación y aumentó el rendimiento de la aplicación.
- Espacio de direcciones universal: le permite escribir funciones sin nombrar un espacio de direcciones, lo que aumenta la flexibilidad y ahorra tiempo al eliminar la necesidad de escribir varias funciones.
- Operaciones atómicas C11 del lado del dispositivo: un subconjunto de operaciones atómicas y de sincronización C11 permite la ejecución paralela de subprocesos para trabajar de forma segura en conjuntos de datos compartidos.
- Canales: objetos de memoria organizados de forma FIFO, lo que simplifica las estructuras de datos de una cola compartida.
OpenCL 2.1 se introdujo el 3 de marzo de 2015 y se estandarizó el 16 de noviembre del mismo año. Reescribió el núcleo de C a C++14 .
OpenCL 3.0 se introdujo el 27 de abril de 2020 [9] y se estandarizó el 30 de septiembre del mismo año [10] . Los cambios notables incluyen que la API de OpenCL 3.0 ahora cubre todas las versiones de OpenCL (1.2, 2.x), sin proporcionar especificaciones separadas para cada versión.
Eventos
- 3 de marzo de 2011 : Khronos Group anuncia la creación del grupo de trabajo WebCL para desarrollar una interfaz de JavaScript para el estándar OpenCL. Esto crea la posibilidad de utilizar GPU y procesadores multinúcleo para procesar cálculos en paralelo en un navegador web. [once]
- 4 de mayo de 2011: Nokia Research lanzó una extensión WebCL de código abierto para el navegador Firefox . [once]
- 1 de julio de 2011: Samsung Electronics lanzó un prototipo WebCL abierto para el motor WebKit . [once]
- 8 de agosto de 2011: AMD lanzó el controlador OpenCL v2.5 del kit de desarrollo de software (SDK) de procesamiento paralelo acelerado (APP) de AMD, que reemplazó al SDK de ATI Stream.
- 15 de noviembre de 2011: el comité de Khronos publicó una especificación OpenCL 1.2 actualizada. La nueva versión contiene muchas pequeñas mejoras relacionadas con una mayor flexibilidad del idioma y optimizaciones de rendimiento.
- 1 de diciembre de 2012 : el comité de Khronos lanzó otra actualización de la especificación OpenCL 1.2. La nueva versión ha mejorado la interacción con OpenGL, mejoró la seguridad en WebGL, agregó soporte para cargar programas OpenCL desde la representación intermedia de SPIR.
Características del lenguaje
Las diferencias clave entre el lenguaje utilizado y C (estándar ISO de 1999) son:
- falta de soporte para punteros de función , recursividad , campos de bits , matrices de longitud variable (VLA), archivos de encabezado estándar [12] ;
- extensiones de lenguaje para concurrencia: tipos de vectores, sincronización, funciones para elementos de trabajo/grupos de trabajo [12] ;
- calificadores de tipo de memoria: __global, __local, __constant, __private;
- conjunto diferente de funciones integradas.
Ejemplos
Ejemplo de cálculo de FFT :
[13]
// creando un contexto informático para la GPU (tarjeta de video)
context = clCreateContextFromType ( NULL , CL_DEVICE_TYPE_GPU , NULL , NULL , NULL );
// crear una cola de comandos
queue = clCreateCommandQueue ( contexto , NULL , 0 , NULL );
// asignación de memoria en forma de búferes
memobjs [ 0 ] = clCreateBuffer ( contexto , CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , sizeof ( float ) * 2 * num_entries , srcA , NULL );
memobjs [ 1 ] = clCreateBuffer ( contexto , CL_MEM_READ_WRITE , tamaño de ( float ) * 2 * num_entries , NULL , NULL );
// crear un programa a partir del programa fuente
= clCreateProgramWithSource ( context , 1 , & fft1D_1024_kernel_src , NULL , NULL ) ;
// compilar el programa
clBuildProgram ( programa , 0 , NULL , NULL , NULL , NULL );
// crea un objeto kernel a partir de un programa compilado
kernel = clCreateKernel ( program , "fft1D_1024" , NULL );
// preparar argumentos
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 );
// establecer el rango ND con las dimensiones del elemento de trabajo y enviarlo a la
cola de ejecución global_work_size [ 0 ] = num_entries ;
tamaño_trabajo_local [ 0 ] = 64 ;
clEnqueueNDRangeKernel ( cola , kernel , 1 , NULL , global_work_size , local_work_size , 0 , NULL , NULL );
Cálculos directos (basados en Fitting FFT on the G80 Architecture report) [14] :
// Este código calcula la FFT de longitud 1024 dividiéndola en 16, 16 y 4
__kernel void fft1D_1024 ( __global float2 * entrada , __global float2 * salida ,
__flotante local * sMemx , __flotante local * sMemy ) {
int tid = get_local_id ( 0 );
int blockIdx = get_group_id ( 0 ) * 1024 + tid ;
flotar2datos [ 16 ] ;
// dirección del comienzo de los datos procesados en la memoria global
in = in + blockIdx ; salida = salida + blockIdx ;
cargas globales ( datos , en , 64 ); // lecturas globales fusionadas fftRadix16Pass ( datos ); // pase radix-16 en el lugar twiddleFactorMul ( datos , tid , 1024 , 0 );
// reproducción aleatoria local utilizando la memoria local
localShuffle ( data , sMemx , sMemy , tid , ((( tid & 15 ) * 65 ) + ( tid >> 4 )));
fftRadix16Pass ( datos ); // in situ radix-16 pasar twiddleFactorMul ( datos , tid , 64 , 4 ); // multiplicación de factor de giro
localShuffle ( data , sMemx , sMemy , tid , ((( tid >> 4 ) * 64 ) + ( tid & 15 )));
// 4 llamadas FFT de orden 4
fftRadix4Pass ( datos ); // función radix-4 número 1 fftRadix4Pass ( datos + 4 ); // función radix-4 número 2 fftRadix4Pass ( datos + 8 ); // número de función radix-4 3 fftRadix4Pass ( datos + 12 ); // base-4 funcion numero 4
// escrituras globales fusionadas
globalStores ( data , out , 64 );
}
Una implementación completa de la FFT en OpenCL está disponible en el sitio web de Apple [15] .
Aplicación
OpenCL se utiliza, como una de las implementaciones del concepto de GPU de propósito general , en varios software.
- WinZip v16.5 ( 2012 ) de Corel - además del motor actualizado para mejorar su optimización para procesadores multinúcleo, se ha agregado soporte OpenCL para GPU AMD (sin embargo, no para Intel y Nvidia) - mientras que el rendimiento aumenta en este la aplicación en las APU Trinity y Llano fue de hasta un 45%. [dieciséis]
Véase también
Notas
- ↑ AMD impulsa la adopción de estándares industriales en el desarrollo de software GPGPU . AMD. Archivado desde el original el 19 de marzo de 2012. (indefinido)
- ↑ AMD respalda OpenCL, Microsoft DirectX 11 . Semana electrónica. Archivado desde el original el 19 de marzo de 2012. (indefinido)
- ↑ Apple Previews Mac OS X Snow Leopard para desarrolladores . Manzana. Archivado desde el original el 19 de marzo de 2012. (indefinido)
- ↑ Andrés Humber. NVIDIA lanza el controlador OpenCL para desarrolladores . NVIDIA (20 de abril de 2009). - Noticia original en el sitio web oficial de NVIDIA Corporation. Consultado el 21 de abril de 2009. Archivado desde el original el 19 de marzo de 2012.
- ↑ Pavel Shubski. NVIDIA ha abierto la GPGPU para desarrolladores bajo OpenCL (enlace no disponible) . Igromania (revista) (21 de abril de 2009). Consultado el 21 de abril de 2009. Archivado desde el original el 25 de abril de 2009. (indefinido)
- ↑ Serguéi y Marina Bondarenko. Controlador OpenCL para desarrolladores de NVIDIA . 3DNoticias (21 de abril de 2009). Consultado el 21 de abril de 2009. Archivado desde el original el 23 de abril de 2009. (indefinido)
- ↑ Khronos lanza OpenCL 2.0 . khronos.org (22 de julio de 2013). Consultado el 22 de julio de 2013. Archivado desde el original el 17 de agosto de 2013.
- ↑ Khronos finaliza la especificación OpenCL 2.0 para computación heterogénea , Khronos Group ( 18 de noviembre de 2013). Archivado el 11 de noviembre de 2020. Consultado el 20 de noviembre de 2013.
- ↑ Khronos Group publica las especificaciones provisionales de OpenCL 3.0 . Grupo Khronos (27 de abril de 2020). Consultado el 27 de abril de 2020. Archivado desde el original el 18 de enero de 2021.
- ↑ Especificación de OpenCL 3.0 finalizada y lanzamiento inicial del SDK OpenCL de código abierto de Khronos . Grupo Khronos (30 de septiembre de 2020). Consultado el 30 de septiembre de 2020. Archivado desde el original el 30 de septiembre de 2020.
- ↑ 1 2 3 Implementación de la tecnología WebCL presentada para WebKit . opennet.ru (4 de julio de 2011). Consultado el 31 de octubre de 2011. Archivado desde el original el 18 de mayo de 2012. (Ruso)
- ↑ 12 AMD . Introducción a la programación OpenCL 201005, página 89-90
- ↑ OpenCL . SIGGRAPH2008 (14 de agosto de 2008). Consultado el 14 de agosto de 2008. Archivado desde el original el 19 de marzo de 2012. (indefinido)
- ↑ Ajuste de FFT en la arquitectura G80 (PDF). Vasily Volkov y Brian Kazian, informe del proyecto UC Berkeley CS258 (mayo de 2008). Consultado el 14 de noviembre de 2008. Archivado desde el original el 19 de marzo de 2012.
(indefinido)
- ↑ .
OpenCL en FFT (enlace no disponible) . Manzana (16 de noviembre de 2009). Consultado el 7 de diciembre de 2009. Archivado desde el original el 30 de noviembre de 2009. (indefinido)
- ↑ AMD Trinity Benchmarks - OpenCL Archivado el 29 de agosto de 2012 en Wayback Machine // THG
Literatura
- Aftab Munshi; Benedicto R. Gaster; Timoteo G. Mattson; James Fung; Dan Ginsburg. Guía de programación de OpenCL. - Addison-Wesley Professional, 2011. - 648 p. — ISBN 978-0-321-74964-2 .
Enlaces