OpenCL

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
OpenCL
Desarrollador
Grupo Khronos
http://www.khronos.org/opencl
Información general
Diseñador Apple
Última versión estable 2.0[1] (info)
22 de julio de 2013; hace 1 año (2013-07-22)[1]
Género Interfaz de programación de aplicaciones, GPGPU
Sistema operativo Multiplataforma
Licencia Libre de derechos
[editar datos en Wikidata ]

OpenCL (Open Computing Language, en español lenguaje de computación abierto) consta de una interfaz de programación de aplicaciones y de un lenguaje de programación. Juntos permiten crear aplicaciones con paralelismo a nivel de datos y de tareas que pueden ejecutarse tanto en unidades centrales de procesamiento como unidades de procesamiento gráfico. El lenguaje está basado en C99, eliminando cierta funcionalidad y extendiéndolo con operaciones vectoriales.[2]

Apple creó la especificación original y fue desarrollada en conjunto con AMD, IBM, Intel y NVIDIA. Apple la propuso al Grupo Khronos para convertirla en un estándar abierto y libre de derechos. El 16 de junio de 2008 Khronos creó el Compute Working Group[3] para llevar a cabo el proceso de estandarización. En 2013 se publicó la versión 2.0 del estándar[1]

OpenCL forma parte de Mac OS X v10.6 ('Snow Leopard'),[4] mientras que AMD decidió apoyar OpenCL en lugar de su antigua API Close to Metal. [5] [6] Intel también dispone de su propio entorno de desarrollo y NVIDIA además de tener su propia API para chips gráficos llamada CUDA, también soporta OpenCL.

Ejemplo[editar]

Este ejemplo calcula una Transformada rápida de Fourier.[2] Las llamadas a la API son las siguientes:

// create a compute context with GPU device
context = clCreateContextFromType(CL_DEVICE_TYPE_GPU);
 
// create a work-queue
queue = clCreateWorkQueue(context, NULL, NULL, 0);
 
// allocate the buffer memory objects
memobjs[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float)*2*num_entries, srcA);
memobjs[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*2*num_entries, NULL);
 
// create the compute program
program = clCreateProgramFromSource(context, 1, &fft1D_1024_kernel_src, NULL);
 
// build the compute program executable
clBuildProgramExecutable(program, false, NULL, NULL);
 
// create the compute kernel
kernel = clCreateKernel(program, “fft1D_1024”);
 
// create N-D range object with work-item dimensions
global_work_size[0] = n;
local_work_size[0] = 64;
range = clCreateNDRangeContainer(context, 0, 1, global_work_size, local_work_size);
 
// set the args values
clSetKernelArg(kernel, 0, (void *)&memobjs[0], sizeof(cl_mem), NULL);
clSetKernelArg(kernel, 1, (void *)&memobjs[1], sizeof(cl_mem), NULL);
clSetKernelArg(kernel, 2, NULL, sizeof(float)*(local_work_size[0]+1)*16, NULL);
clSetKernelArg(kernel, 3, NULL, sizeof(float)*(local_work_size[0]+1)*16, NULL);
 
 // execute kernel
clExecuteKernel(queue, kernel, NULL, range, NULL, 0, NULL);

El cómputo en sí es éste:

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

Véase también[editar]

Referencias[editar]

  1. a b c Khronos Releases OpenCL 2.0
  2. a b «OpenCL». SIGGRAPH2008 (14 de agosto de 2008). Consultado el 14 de agosto de 2008.
  3. «Khronos Launches Heterogeneous Computing Initiative». Khronos Group (16-06-2008). Consultado el 18-06-2008.
  4. «Apple Previews Mac OS X Snow Leopard to Developers». Apple (09-06-2008). Consultado el 09-06-2008.
  5. «AMD Drives Adoption of Industry Standards in GPGPU Software Development». AMD (06-08-2008). Consultado el 14-08-2008.
  6. «AMD Backs OpenCL, Microsoft DirectX 11». eWeek (06-08-2008). Consultado el 14-08-2008.

Enlaces externos[editar]