**โอเพนซีแอล** (อังกฤษ: OpenCL: Open Computing Language) เป็นภาษาโปรแกรมที่ใช้แยกงานจากการประมวลผลตามปรกติไปให้ หน่วยประมวลผลกราฟิกส์ และ CPU อื่นๆประมวลผลร่วมด้วยเพื่อใช้ GPU ในการประมวลผลอื่นๆนอกเหนือไปจากการประมวลผลคอมพิวเตอร์กราฟิกส์ตามปรกติ พัฒนาขึ้นโดย Khronos Group ร่วมกับบริษัทอื่นๆ มี C99 เป็นพื้นฐาน โดยบริษัทแอปเปิลได้เสนอให้ Khronos Group เป็นตัวกลางเพื่อกำหนด OpenCL เป็นมาตรฐานเพื่อจะได้ใช้งานใน Mac OS 10.6

ตัวอย่างการใช้งาน
-----------------

ตัวอย่างนี้เป็นการใช้ OpenCL ในการคำนวณ Fast Fourier transform:

```
// 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);

```

ส่วนที่ใช้คำนวณจริง: (อิงจาก Fitting FFT onto the G80 Architecture)

```
// This kernel computes FFT of length 1024. The 1024 length FFT is decomposed into
// calls to a radix 16 function, another radix 16 function and then a radix 4 function

\_\_kernel void fft1D\_1024 (\_\_global float2 \*in, \_\_global float2 \*out,
 \_\_local float \*sMemx, \_\_local float \*sMemy) {
 int tid = get\_local\_id(0);
 int blockIdx = get\_group\_id(0) \* 1024 + tid;
 float2 data[16];
 // starting index of data to/from global memory
 in = in + blockIdx; out = out + blockIdx;
 globalLoads(data, in, 64); // coalesced global reads
 fftRadix16Pass(data); // in-place radix-16 pass
 twiddleFactorMul(data, tid, 1024, 0);
 // local shuffle using local memory
 localShuffle(data, sMemx, sMemy, tid, (((tid & 15) \* 65) + (tid >> 4)));
 fftRadix16Pass(data); // in-place radix-16 pass
 twiddleFactorMul(data, tid, 64, 4); // twiddle factor multiplication
 localShuffle(data, sMemx, sMemy, tid, (((tid >> 4) \* 64) + (tid & 15)));
 // four radix-4 function calls
 fftRadix4Pass(data); fftRadix4Pass(data + 4);
 fftRadix4Pass(data + 8); fftRadix4Pass(data + 12);
 // coalesced global writes
 globalStores(data, out, 64);
}

```

อ้างอิง
-------

  

1. ↑  "OpenCL" (PDF). SIGGRAPH2008. 2008-08-14. คลังข้อมูลเก่าเก็บจากแหล่งเดิม (PDF)เมื่อ 2012-03-19. สืบค้นเมื่อ 2008-08-14.
2. ↑  
"Fitting FFT onto G80 Architecture" (PDF). Vasily Volkov and Brian Kazian, UC Berkeley CS258 project report. May 2008. สืบค้นเมื่อ 2008-11-14.