OpenCL‎ > ‎

OpenCL 教學(一)

OpenCL 簡介

OpenCL 是由 Khronos Group 針對異質性計算裝置(heterogeneous device)進行平行化運算所設計的標準 API 以及程式語言。所謂的「異質性計算裝置」,是指在同一個電腦系統中,有兩種以上架構差異很大的計算裝置,例如一般的 CPU 以及顯示晶片,或是像 CELL 的 PPE 以及 SPE。目前,最為常見的就是所謂的 GPGPU 應用,也就是利用一般的顯示晶片(即 GPU)進行 3D 繪圖以外的計算工作。

過去 GPGPU 的應用,有各種不同的使用方式。最早的 GPGPU,多半是直接透過 3D 繪圖的 API 進行,例如 OpenGL 或 D3D 的 HLSL(High Level Shading Language)。但是,這樣做有很多缺點,主要是即使想要進行的運算和 3D 繪圖無關,仍需要處理很多 3D 繪圖方面的動作(例如建立 texture,安排 render-to-texture 動作等等)。這讓 GPGPU 變得十分複雜。後來開始有些嘗試把這些 3D 繪圖部份隱藏起來的想法,例如由 Stanford 大學設計的 BrookGPU,可以透過不同的 backend 將 Brook 程式轉換成由 CPU、Direct3D、或 OpenGL 來執行。另外,也有各家顯示卡廠商自行開發的系統,包括 ATI 針對其產品設計的 Close to Metal(以及後來的 AMD Stream),以及 NVIDIA 的 CUDA。Microsoft 也在 DirectX 11 中加入了特別為 GPGPU 設計的 DirectCompute。

由於各家廠商的 GPGPU 方案都是互不相容的(例如 AMD Stream 的程式無法在 NVIDIA 的顯示晶片上執行,而 CUDA 的程式也不能在 AMD 的顯示晶片上執行),這對 GPGPU 的發展是不利的,因為程式開發者必須為不同廠商的顯示晶片分別撰寫程式,或是選擇只支援某個顯示晶片廠商。由於顯示晶片的發展愈來愈彈性化,GPGPU 的應用範圍也增加,因此 Apple 決定提出一個統一的 GPGPU 方案。這個方案得到包括 AMD、IBM、Intel、NVIDIA 等相關廠商的支持,並很快就交由 Khronos Group 進行標準化。整個計畫只花了五個月的時間,並在 2008 年十二月時正式公開。第一個正式支援 OpenCL 的作業系統是 Apple 的 MacOS X 10.6 "Snow Leopard"。AMD 和 NVIDIA 也隨後推出了在 Windows 及 Linux 上的 OpenCL 實作。IBM 也推出了支援 CELL 的 OpenCL 實作。

OpenCL 的主要設計目的,是要提供一個容易使用、且適用於各種不同裝置的平行化計算平台。因此,它提供了兩種平行化的模式,包括 task parallel 以及 data parallel。目前 GPGPU 的應用,主要是以 data parallel 為主,這裡也是以這個部份為主要重點。所謂的 data parallel,指的是有大量的資料,都進行同樣的處理。這種形式的平行化,在很多工作上都可以見到。例如,影像處理的程式,經常要對一個影像的每個 pixel 進行同樣的動作(例如 Gaussian blur)。因此,這類工作很適合 data parallel 的模式。

OpenCL 的架構

OpenCL 包括一組 API 和一個程式語言。基本上,程式透過 OpenCL API 取得 OpenCL 裝置(例如顯示晶片)的相關資料,並將要在裝置上執行的程式(使用 OpenCL 程式語言撰寫)編繹成適當的格式,在裝置上執行。OpenCL API 也提供許多裝置控制方面的動作,例如在 OpenCL 裝置上取得一塊記憶體、把資料從主記憶體複製到 OpenCL 裝置上(或從 OpenCL 裝置上複製到主記憶體中)、取得裝置動作的資訊(例如上一個程式執行所花費的時間)等等。

例如,我們先考慮一個簡單的工作:把一群數字相加。在一般的 C 程式中,可能是如下:

float a[DATA_SIZE];
float b[DATA_SIZE];
float result[DATA_SIZE];

// ...

for(int i = 0; i < DATA_SIZE; i++) {
result[i] = a[i] + b[i];
}

在 OpenCL 中,則大致的流程是:
  1. 把 OpenCL 裝置初始化。
  2. 在 OpenCL 裝置上配置三塊記憶體,以存放 a、b、c 三個陣列的資料。
  3. 把 a 陣列和 b 陣列的內容,複製到 OpenCL 裝置上。
  4. 編譯要執行的 OpenCL 程式(稱為 kernel)。
  5. 執行編譯好的 kernel。
  6. 把計算結果從 OpenCL 裝置上,複製到 result 陣列中。
透過 data parallel 的模式,這裡的 OpenCL 程式非常簡單,如下所示:

__kernel void adder(__global const float* a, __global const float* b, __global float* result)
{
int idx = get_global_id(0);
result[idx] = a[idx] + b[idx];
}


在一般的版本中,是透過一個迴圈,執行 DATA_SIZE 次數的加法動作。而在 OpenCL 中,則是建立 DATA_SIZE 個 work item,每個 work item 都執行上面所示的 kernel。可以看到,OpenCL 程式語言和一般的 C 語言非常類似。__kernel 表示這個函式是在 OpenCL 裝置上執行的。__global 則表示這個指標是在 global memory 中(即 OpenCL 裝置上的主要記憶體)。而 get_global_id(0) 會傳回 work item 的編號,例如,如果有 1024 個 work item,則編號會分別是 0 ~ 1023(實際上編號可以是二維或三維,但在這裡先只考慮一維的情形)。

要如何讓上面這個簡單的 OpenCL kernel 實際在 OpenCL 裝置上執行呢?這就需要透過 OpenCL API 的幫助了。以下會一步一步說明使用 OpenCL API 的方法。

OpenCL 環境設定

在使用 OpenCL API 之前,不免要進行一些環境的設定。相關的動作可以參考下列的文章:

開始撰寫 OpenCL 程式

在使用 OpenCL API 之前,和絕大部份所有其它的 API 一樣,都需要 include 相關的 header 檔案。由於在 MacOS X 10.6 下 OpenCL 的 header 檔案命名方式和在其它作業系統下不同,因此,通常要使用一個 #ifdef 來進行區分。如下所示:

#ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif

這樣就可以在 MacOS X 10.6 下,以及其它的作業系統下,都可以 include 正確的 OpenCL header 檔。

接著,要先取得系統上所有的 OpenCL platform。在 MacOS X 10.6 下,目前只有一個由 Apple 提供的 OpenCL platform,但是在其它系統上,可能會有不同廠商提供的多個不同的 OpenCL platform,因此需要先取得 platform 的數目:

cl_int err;
cl_uint num;
err = clGetPlatformIDs(0, 0, &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platforms\n";
return 0;
}

大部份的 OpenCL API 會傳回錯誤值。如果傳回值是 CL_SUCCESS 則表示執行成功,否則會傳回某個錯誤值,表示失敗的原因。

接著,再取得 platform 的 ID,這在建立 OpenCL context 時會用到:

std::vector<cl_platform_id> platforms(num);
err = clGetPlatformIDs(num, &platforms[0], &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platform ID\n";
return 0;
}

在 OpenCL 中,類似這樣的模式很常出現:先呼叫第一次以取得數目,以便配置足夠的記憶體量。接著,再呼叫第二次,取得實際的資料。

接下來,要建立一個 OpenCL context。如下:

cl_context_properties prop[] = { CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platforms[0]), 0 };
cl_context context = clCreateContextFromType(prop, CL_DEVICE_TYPE_DEFAULT, NULL, NULL, NULL);
if(context == 0) {
std::cerr << "Can't create OpenCL context\n";
return 0;
}

clReleaseContext(context);
return 0;

在上面的程式中,clCreateContextFromType 是一個 OpenCL 的 API,它可以從指定的裝置類別中,建立一個 OpenCL context。第一個參數是指定 context 的 property。在 OpenCL 中,是透過一個 property 的陣列,以「property 種類」及「property 內容」成對出現,並以 0 做為結束。例如,以上面的例子來說,要指定的 property 種類是 CL_CONTEXT_PLATFORM,即要使用的 platform ID,而 property 內容則是由之前取得的 platform ID 中的第一個(即 platforms[0])。由於 property 的內容可能是不同的資料型態,因此需要使用 reinterpret_cast 來進行強制轉型。

第二個參數可以指定要使用的裝置類別。目前可以使用的類別包括:
  • CL_DEVICE_TYPE_CPU:使用 CPU 裝置
  • CL_DEVICE_TYPE_GPU:使用顯示晶片裝置
  • CL_DEVICE_TYPE_ACCELERATOR:特定的 OpenCL 加速裝置,例如 CELL
  • CL_DEVICE_TYPE_DEFAULT:系統預設的 OpenCL 裝置
  • CL_DEVICE_TYPE_ALL:所有系統中的 OpenCL 裝置
這裡使用的是 CL_DEVICE_TYPE_DEFAULT,也就是指定使用預設的裝置。另外,在這裡,直接使用了之前取得的 OpenCL platform ID 中的第一個 ID(實際的程式中,可能會需要讓使用者可以指定要使用哪一個 platform)。

如果建立 OpenCL context 失敗,會傳回 0。因此,要進行檢查,並顯示錯誤訊息。如果建立成功的話,在使用完後,要記得將 context 釋放。這可以透過呼叫 clReleaseContext 來達成。
這個程式基本上已經可以編譯執行了,但是當然它並沒有真的做什麼事情。

一個 OpenCL context 中可以包括一個或多個裝置,所以接下來的工作是要取得裝置的列表。要取得任何和 OpenCL context 相關的資料,可以使用 clGetContextInfo 函式。以下是取得裝置列表的方式:

size_t cb;
clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &cb);
std::vector<cl_device_id> devices(cb / sizeof(cl_device_id));
clGetContextInfo(context, CL_CONTEXT_DEVICES, cb, &devices[0], 0);

CL_CONTEXT_DEVICES 表示要取得裝置的列表。和前面取得 platform ID 的情形相同,clGetContextInfo 被呼叫了兩次:第一次是要取得需要存放裝置列表所需的記憶體空間大小(也就是傳入 &cb),然後第二次呼叫才真正取得所有裝置的列表。

接下來,可能會想要確定倒底找到的 OpenCL 裝置是什麼。所以,可以透過 OpenCL API 取得裝置的名稱,並將它印出來。取得和裝置相關的資料,是使用 clGetDeviceInfo 函式,和前面的 clGetContextInfo 函式相當類似。以下是取得裝置名稱的方式:

clGetDeviceInfo(devices[0], CL_DEVICE_NAME, 0, NULL, &cb);
std::string devname;
devname.resize(cb);
clGetDeviceInfo(devices[0], CL_DEVICE_NAME, cb, &devname[0], 0);
std::cout << "Device: " << devname.c_str() << "\n";

到目前為止,完整的程式應該如下所示:

// OpenCL tutorial 1

#include <iostream>
#include <string>
#include <vector>

#ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif


int main()
{
cl_int err;
cl_uint num;
err = clGetPlatformIDs(0, 0, &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platforms\n";
return 0;
}

std::vector<cl_platform_id> platforms(num);
err = clGetPlatformIDs(num, &platforms[0], &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platform ID\n";
return 0;
}

cl_context_properties prop[] = { CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platforms[0]), 0 };
cl_context context = clCreateContextFromType(prop, CL_DEVICE_TYPE_DEFAULT, NULL, NULL, NULL);
if(context == 0) {
std::cerr << "Can't create OpenCL context\n";
return 0;
}

size_t cb;
clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &cb);
std::vector<cl_device_id> devices(cb / sizeof(cl_device_id));
clGetContextInfo(context, CL_CONTEXT_DEVICES, cb, &devices[0], 0);

clGetDeviceInfo(devices[0], CL_DEVICE_NAME, 0, NULL, &cb);
std::string devname;
devname.resize(cb);
clGetDeviceInfo(devices[0], CL_DEVICE_NAME, cb, &devname[0], 0);
std::cout << "Device: " << devname.c_str() << "\n";

clReleaseContext(context);
return 0;
}

執行這個程式,如果建立 OpenCL context 成功的話,應該會顯示出找到的 OpenCL 裝置的名稱,例如

Device: GeForce GTX 285

建立 Command Queue

大部份 OpenCL 的操作,都要透過 command queue。Command queue 可以接收對一個 OpenCL 裝置的各種操作,並按照順序執行(OpenCL 也容許把一個 command queue 指定成不照順序執行,即 out-of-order execution,但是這裡先不討論這個使用方式)。所以,下一步是建立一個 command queue:

cl_command_queue queue = clCreateCommandQueue(context, devices[0], 0, 0);
if(queue == 0) {
std::cerr << "Can't create command queue\n";
clReleaseContext(context);
return 0;
}

和 context 一樣,在程式結束前,要把 command queue 釋放,即:

clReleaseCommandQueue(queue);

上面的程式中,是把裝置列表中的第一個裝置(即 devices[0])建立 command queue。如果想要同時使用多個 OpenCL 裝置,則每個裝置都要有自己的 command queue。

產生資料

由於這個程式的目的是要把一大堆數字進行相加,所以需要產生一些「測試資料」:

const int DATA_SIZE = 1048576;
std::vector<float> a(DATA_SIZE), b(DATA_SIZE), res(DATA_SIZE);
for(int i = 0; i < DATA_SIZE; i++) {
a[i] = std::rand();
b[i] = std::rand();
}

配置記憶體並複製資料

要使用 OpenCL 裝置進行運算時,通常會需要在 OpenCL 裝置上配置記憶體,並把資料從主記憶體中複製到裝置上。有些 OpenCL 裝置可以直接從主記憶體存取資料,但是速度通常會比較慢,因為 OpenCL 裝置(例如顯示卡)通常會有專用的高速記憶體。以下的程式配置三塊記憶體:

cl_mem cl_a = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_float) * DATA_SIZE, &a[0], NULL);
cl_mem cl_b = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_float) * DATA_SIZE, &b[0], NULL);
cl_mem cl_res = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_float) * DATA_SIZE, NULL, NULL);
if(cl_a == 0 || cl_b == 0 || cl_res == 0) {
std::cerr << "Can't create OpenCL buffer\n";
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

clCreateBuffer 函式可以用來配置記憶體。它的第二個參數可以指定記憶體的使用方式,包括:
  • CL_MEM_READ_ONLY:表示 OpenCL kernel 只會對這塊記憶體進行讀取的動作
  • CL_MEM_WRITE_ONLY:表示 OpenCL kernel 只會對這塊記憶體進行寫入的動作
  • CL_MEM_READ_WRITE:表示 OpenCL kernel 會對這塊記憶體進行讀取和寫入的動作
  • CL_MEM_USE_HOST_PTR:表示希望 OpenCL 裝置直接使用指定的主記憶體位址。要注意的是,如果 OpenCL 裝置無法直接存取主記憶體,它可能會將指定的主記憶體位址的資料複製到 OpenCL 裝置上。
  • CL_MEM_ALLOC_HOST_PTR:表示希望配置的記憶體是在主記憶體中,而不是在 OpenCL 裝置上。不能和 CL_MEM_USE_HOST_PTR 同時使用。
  • CL_MEM_COPY_HOST_PTR:將指定的主記憶體位址的資料,複製到配置好的記憶體中。不能和 CL_MEM_USE_HOST_PTR 同時使用。
第三個參數是指定要配置的記憶體大小,以 bytes 為單位。在上面的程式中,指定的大小是 sizeof(cl_float) * DATA_SIZE
第四個參數是指定主記憶體的位置。因為對 cl_a cl_b 來說,在第二個參數中,指定了 CL_MEM_COPY_HOST_PTR,因此要指定想要複製的資料的位址。cl_res 則不需要指定。
第五個參數是指定錯誤碼的傳回位址。在這裡並沒有使用到。

如果 clCreateBuffer 因為某些原因無法配置記憶體(例如 OpenCL 裝置上的記憶體不夠),則會傳回 0。要釋放配置的記憶體,可以使用 clReleaseMemObject 函式。

編譯 OpenCL kernel 程式

現在執行 OpenCL kernel 的準備工作已經大致完成了。所以,現在剩下的工作,就是把 OpenCL kernel 程式編釋並執行。首先,先把前面提過的 OpenCL kernel 程式,存放在一個文字檔中,命名為 shader.cl:

__kernel void adder(__global const float* a, __global const float* b, __global float* result)
{
int idx = get_global_id(0);
result[idx] = a[idx] + b[idx];
}

要編譯這個 kernel 程式,首先要把檔案內容讀進來,再使用 clCreateProgramWithSource 這個函式,然後再使用 clBuildProgram 編譯。如下所示:

cl_program load_program(cl_context context, const char* filename)
{
std::ifstream in(filename, std::ios_base::binary);
if(!in.good()) {
return 0;
}

// get file length
in.seekg(0, std::ios_base::end);
size_t length = in.tellg();
in.seekg(0, std::ios_base::beg);

// read program source
std::vector<char> data(length + 1);
in.read(&data[0], length);
data[length] = 0;

// create and build program 
const char* source = &data[0];
cl_program program = clCreateProgramWithSource(context, 1, &source, 0, 0);
if(program == 0) {
return 0;
}

if(clBuildProgram(program, 0, 0, 0, 0, 0) != CL_SUCCESS) {
return 0;
}

return program;
}

上面的程式,就是直接將檔案讀到記憶體中,再呼叫 clCreateProgramWithSource 建立一個 program object。建立成功後,再呼叫 clBuildProgram 函式編譯程式。clBuildProgram 函式可以指定很多參數,不過在這裡暫時沒有使用到。
有了這個函式,在 main 函式中,直接呼叫:

cl_program program = load_program(context, "shader.cl");
if(program == 0) {
std::cerr << "Can't load or build program\n";
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

同樣的,在程式結束前,要記得將 program object 釋放:

clReleaseProgram(program);

一個 OpenCL kernel 程式裡面可以有很多個函式。因此,還要取得程式中函式的進入點:

cl_kernel adder = clCreateKernel(program, "adder", 0);
if(adder == 0) {
std::cerr << "Can't load kernel\n";
clReleaseProgram(program);
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

和 program object 一樣,取得的 kernel object 也需要在程式結束前釋放:

clReleaseKernel(adder);

執行 OpenCL kernel

弄了這麼多,總算可以執行 OpenCL kernel 程式了。要執行 kernel 程式,只需要先設定好函式的參數。adder 函式有三個參數要設定:

clSetKernelArg(adder, 0, sizeof(cl_mem), &cl_a);
clSetKernelArg(adder, 1, sizeof(cl_mem), &cl_b);
clSetKernelArg(adder, 2, sizeof(cl_mem), &cl_res);

設定參數是使用 clSetKernelArg 函式。它的參數很簡單:第一個參數是要設定的 kernel object,第二個是參數的編號(從 0 開始),第三個參數是要設定的參數的大小,第四個參數則是實際上要設定的參數內部。以這裡的 adder 函式來說,三個參數都是指向 memory object 的指標。
設定好參數後,就可以開始執行了。如下:

size_t work_size = DATA_SIZE;
err = clEnqueueNDRangeKernel(queue, adder, 1, 0, &work_size, 0, 0, 0, 0);

clEnqueueNDRangeKernel 會把執行一個 kernel 的動作加到 command queue 裡面。第三個參數(1)是指定 work item 數目的維度,在這裡就是一維。第五個參數是指定 work item 的總數目,也就是 DATA_SIZE。後面的參數現在暫時先不用管。如果成功加入的話,會傳回 CL_SUCCESS。否則會傳回錯誤值。
在執行 kernel 被加到 command queue 之後,就可能會開始執行(如果 command queue 現在沒有別的工作的話)。但是 clEnqueueNDRangeKernel 是非同步的,也就是說,它並不會等待 OpenCL 裝置執行完畢才傳回。這樣可以讓 CPU 在 OpenCL 裝置在進行運算的同時,進行其它的動作。
由於執行的結果是在 OpenCL 裝置的記憶體中,所以要取得結果,需要把它的內容複製到 CPU 能存取的主記憶體中。這可以透過下面的程式完成:

if(err == CL_SUCCESS) {
err = clEnqueueReadBuffer(queue, cl_res, CL_TRUE, 0, sizeof(float) * DATA_SIZE, &res[0], 0, 0, 0);
}

clEnqueueReadBuffer 函式會把「將記憶體資料從 OpenCL 裝置複製到主記憶體」的動作加到 command queue 中。第三個參數表示是否要等待複製的動作完成才傳回,CL_TRUE 表示要等待。第五個參數是要複製的資料大小,第六個參數則是目標的位址。
由於這裡指定要等待複製動作完成,所以當函式傳回時,資料已經完全複製完成了。最後是進行驗證,確定資料正確:

if(err == CL_SUCCESS) {
bool correct = true;
for(int i = 0; i < DATA_SIZE; i++) {
if(a[i] + b[i] != res[i]) {
correct = false;
break;
}
}

if(correct) {
std::cout << "Data is correct\n";
}
else {
std::cout << "Data is incorrect\n";
}
}
else {
std::cerr << "Can't run kernel or read back data\n";
}

到這裡,整個程式就算是完成了。編譯後執行,如果順利的話,應該會印出

Data is correct

的訊息。

以下是整個程式的全貌:

// OpenCL tutorial 1

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdlib>

#ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif


cl_program load_program(cl_context context, const char* filename)
{
std::ifstream in(filename, std::ios_base::binary);
if(!in.good()) {
return 0;
}

// get file length
in.seekg(0, std::ios_base::end);
size_t length = in.tellg();
in.seekg(0, std::ios_base::beg);

// read program source
std::vector<char> data(length + 1);
in.read(&data[0], length);
data[length] = 0;

// create and build program 
const char* source = &data[0];
cl_program program = clCreateProgramWithSource(context, 1, &source, 0, 0);
if(program == 0) {
return 0;
}

if(clBuildProgram(program, 0, 0, 0, 0, 0) != CL_SUCCESS) {
return 0;
}

return program;
}


int main()
{
cl_int err;
cl_uint num;
err = clGetPlatformIDs(0, 0, &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platforms\n";
return 0;
}

std::vector<cl_platform_id> platforms(num);
err = clGetPlatformIDs(num, &platforms[0], &num);
if(err != CL_SUCCESS) {
std::cerr << "Unable to get platform ID\n";
return 0;
}

cl_context_properties prop[] = { CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platforms[0]), 0 };
cl_context context = clCreateContextFromType(prop, CL_DEVICE_TYPE_DEFAULT, NULL, NULL, NULL);
if(context == 0) {
std::cerr << "Can't create OpenCL context\n";
return 0;
}

size_t cb;
clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &cb);
std::vector<cl_device_id> devices(cb / sizeof(cl_device_id));
clGetContextInfo(context, CL_CONTEXT_DEVICES, cb, &devices[0], 0);

clGetDeviceInfo(devices[0], CL_DEVICE_NAME, 0, NULL, &cb);
std::string devname;
devname.resize(cb);
clGetDeviceInfo(devices[0], CL_DEVICE_NAME, cb, &devname[0], 0);
std::cout << "Device: " << devname.c_str() << "\n";

cl_command_queue queue = clCreateCommandQueue(context, devices[0], 0, 0);
if(queue == 0) {
std::cerr << "Can't create command queue\n";
clReleaseContext(context);
return 0;
}

const int DATA_SIZE = 1048576;
std::vector<float> a(DATA_SIZE), b(DATA_SIZE), res(DATA_SIZE);
for(int i = 0; i < DATA_SIZE; i++) {
a[i] = std::rand();
b[i] = std::rand();
}

cl_mem cl_a = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_float) * DATA_SIZE, &a[0], NULL);
cl_mem cl_b = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_float) * DATA_SIZE, &b[0], NULL);
cl_mem cl_res = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_float) * DATA_SIZE, NULL, NULL);
if(cl_a == 0 || cl_b == 0 || cl_res == 0) {
std::cerr << "Can't create OpenCL buffer\n";
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

cl_program program = load_program(context, "shader.cl");
if(program == 0) {
std::cerr << "Can't load or build program\n";
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

cl_kernel adder = clCreateKernel(program, "adder", 0);
if(adder == 0) {
std::cerr << "Can't load kernel\n";
clReleaseProgram(program);
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

clSetKernelArg(adder, 0, sizeof(cl_mem), &cl_a);
clSetKernelArg(adder, 1, sizeof(cl_mem), &cl_b);
clSetKernelArg(adder, 2, sizeof(cl_mem), &cl_res);

size_t work_size = DATA_SIZE;
err = clEnqueueNDRangeKernel(queue, adder, 1, 0, &work_size, 0, 0, 0, 0);

if(err == CL_SUCCESS) {
err = clEnqueueReadBuffer(queue, cl_res, CL_TRUE, 0, sizeof(float) * DATA_SIZE, &res[0], 0, 0, 0);
}

if(err == CL_SUCCESS) {
bool correct = true;
for(int i = 0; i < DATA_SIZE; i++) {
if(a[i] + b[i] != res[i]) {
correct = false;
break;
}
}

if(correct) {
std::cout << "Data is correct\n";
}
else {
std::cout << "Data is incorrect\n";
}
}
else {
std::cerr << "Can't run kernel or read back data\n";
}

clReleaseKernel(adder);
clReleaseProgram(program);
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);

return 0;
}

在附件中可以下載包括 Xcode project 以及 Visual Studio 2008 project 檔的原始碼。

ċ
cltut_1.zip
(7k)
Chen Ping-Che,
Feb 3, 2010, 8:54 AM
Comments