OpenCL 三种内存对象的使用

▶ 包括带有 CL_MEM_READ_ONLY，CL_MEM_WRITE_ONLY，CL_MEM_READ_WRITE 标识的显示拷贝（函数 clEnqueueWriteBuffer 和 clEnqueueReadBuffer）；带有 CL_MEM_COPY_HOST_PTR 标识的隐式拷贝（不用拷贝函数，在设备上直接使用）；以及使用函数 clEnqueueMapBuffer 直接在设备和主机之间映射（转换）一段内存的指针

● 代码

 #include <cl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <iostream>

 using namespace std;
 const int nElement = ;

 const char *programSource = "                                              \
 __kernel void vectorAdd(__global int *A, __global int *B, __global int *C) \
 {                                                                          \
     int idx = get_global_id();                                            \
     C[idx] = A[idx] + B[idx];                                              \
     return;                                                                \
 }                                                                          \
 ";

 int main(int argc, char* argv[])
 {
     const size_t dataSize = sizeof(int) * nElement;
     int i, *A, *B, *C, *returnC;

     A = (int *)malloc(dataSize);
     B = (int *)malloc(dataSize);
     C = (int *)malloc(dataSize);
     for (srand((unsigned)time(NULL)), i = ; i < nElement; A[i] = rand() % , B[i] = rand() % , C[i] = A[i] + B[i], i++);

     cl_int status;
     cl_platform_id platform;
     clGetPlatformIDs(, &platform, NULL);
     cl_device_id device;
     clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, , &device, NULL);
     cl_context context = clCreateContext(NULL, , &device, NULL, NULL, &status);
     cl_command_queue queue = clCreateCommandQueue(context, device, , &status);
     cl_program program = clCreateProgramWithSource(context, , &programSource, NULL, &status);
     clBuildProgram(program, , &device, NULL, NULL, NULL);
     cl_kernel kernel = clCreateKernel(program, "vectorAdd", NULL);
     cl_event writeEvent, runEvent, mapEvent;

     //创建三个内存对象，把 A 隐式拷贝到 clA，把 B 显示拷贝到 clB，clC 接收计算结果映射给 returnC
     cl_mem clA = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, dataSize, A, NULL);
     cl_mem clB = clCreateBuffer(context, CL_MEM_READ_ONLY, dataSize, NULL, NULL);
     cl_mem clC = clCreateBuffer(context, CL_MEM_WRITE_ONLY, dataSize, NULL, NULL);

     clEnqueueWriteBuffer(queue, clB, , , dataSize, B, , , &writeEvent);

     clFlush(queue);// 出现需要等待的事件之前，把队列中的任务全部提交掉
     clWaitForEvents(, &writeEvent);// 等待指定事件完成

                                     // 执行内核
     size_t global_work_size = nElement;
     clSetKernelArg(kernel, , sizeof(cl_mem), (void*)&clA);
     clSetKernelArg(kernel, , sizeof(cl_mem), (void*)&clB);
     clSetKernelArg(kernel, , sizeof(cl_mem), (void*)&clC);
     clEnqueueNDRangeKernel(queue, kernel, , NULL, &global_work_size, NULL, , NULL, &runEvent);
     clFlush(queue);
     clWaitForEvents(, &runEvent);

     // 结果拷回
     returnC = (cl_int *)clEnqueueMapBuffer(queue, clC, CL_TRUE, CL_MAP_READ, , dataSize, , NULL, &mapEvent, NULL);
     clFlush(queue);
     clWaitForEvents(, &mapEvent);

     //结果验证
     printf("Verify %s.\n", !memcmp(C, returnC, dataSize) ? "passed" : "failed");// 定义在 iostream

     free(C);
     free(A);
     free(B);
     clReleaseMemObject(clA);
     clReleaseMemObject(clB);
     clReleaseMemObject(clC);
     clReleaseContext(context);
     clReleaseCommandQueue(queue);
     clReleaseProgram(program);
     clReleaseEvent(writeEvent);
     clReleaseEvent(runEvent);
     clReleaseEvent(mapEvent);
     getchar();
     return ;
 }

● 输出结果

Verify passed.

● 注意

■ 事件在声明以后一定要通过某个函数的  cl_event * /* event */  参数定义它，才能进行 clWaitForEvents 或 clReleaseEvent，否则会报错

● 使用 CL_MEM_COPY_HOST_PTR 和 CL_MEM_USE_HOST_PTR 的区别，前者创建一个独立的缓冲区，只是使用了 host_ptr 的值来初始化，后续使用过程中主机端对 host_ptr 的修改不会影响到缓冲区的内容；后者直接使用 host_ptr （转化为设备指针来使用），后续使用过程中主机端对 host_ptr 的修改仍会影响缓冲区内容

● 代码

 #include <cl.h>
 #include <stdio.h>
 #include <stdlib.h>

 using namespace std;
 const int nElement = ;

 const char *programSource = "               \
 __kernel void vectorAdd(__global int *A)    \
 {                                           \
     return;                                 \
 }                                           \
 ";

 int main(int argc, char* argv[])
 {
     const size_t dataSize = sizeof(int) * nElement;
     int i, sum, *A, *returnA, *mapReturnA;

     A = (int *)malloc(dataSize);
     returnA = (int *)malloc(dataSize);
     //mapReturnA = (int *)malloc(dataSize);// 注意用作内存映射的指针不需要申请内存，使用这个表达式会造成结尾处的运行时错误
     for (i = ; i < nElement; A[i++] = );

     cl_int status;
     cl_platform_id platform;
     clGetPlatformIDs(, &platform, NULL);
     cl_device_id device;
     clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, , &device, NULL);
     cl_context context = clCreateContext(NULL, , &device, NULL, NULL, &status);
     cl_command_queue queue = clCreateCommandQueue(context, device, , &status);
     cl_program program = clCreateProgramWithSource(context, , &programSource, NULL, &status);
     status = clBuildProgram(program, , &device, NULL, NULL, NULL);
     cl_kernel kernel = clCreateKernel(program, "vectorAdd", &status);

     cl_mem clA = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, dataSize, A, NULL);
     //cl_mem clA = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, dataSize, A, NULL);

     for (i = ; i < nElement; A[i++]++);// 在创建缓冲区以后再修改 A 的值

     size_t global_work_size = nElement;
     clSetKernelArg(kernel, , sizeof(cl_mem), (void*)&clA);
     clEnqueueNDRangeKernel(queue, kernel, , NULL, &global_work_size, NULL, , NULL, NULL);    

     clEnqueueReadBuffer(queue, clA, CL_TRUE, , dataSize, returnA, , NULL, NULL);
     mapReturnA = (cl_int *)clEnqueueMapBuffer(queue, clA, CL_TRUE, CL_MAP_READ, , dataSize, , NULL, NULL, &status);   

     for (i = sum = ; i < nElement; sum += A[i++]);
     printf("sum A = %d\n", sum);
     for (i = sum = ; i < nElement; sum += returnA[i++]);
     printf("sum returnA = %d\n", sum);
     for (i = sum = ; i < nElement; sum += mapReturnA[i++]);
     printf("sum mapReturnA = %d\n", sum);

     free(A);
     free(returnA);
     clReleaseMemObject(clA);
     clReleaseContext(context);
     clReleaseCommandQueue(queue);
     clReleaseProgram(program);
     getchar();
     return ;
 }

● 输出结果

■ 使用 CL_MEM_COPY_HOST_PTR，仅有主机端的值被修改

sum A =
sum returnA =
sum mapReturnA = 

■ 使用 CL_MEM_USE_HOST_PTR，设备端使用的缓冲区也遭到了修改

sum A =
sum returnA =
sum mapReturnA =