OpenCL 使用函数 clCreateProgramWithBinary 来创建程序

▶ 函数 clCreateProgramWithSource 接收 OpenCL 代码（设备无关）来创建程序，而函数 clCreateProgramWithBinary 接收已经经过函数 clBuildProgram 的 build 过的代码（设备有关）来创建程序

● 范例代码，还是计算两向量和

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

 const int nElement = ;
 const char *binaryFileName = "D:\\Code\\OpenCL\\OpenCLProjectTemp\\OpenCLProjectTemp\\vectorAdd.bin";
 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 readSource(const char* kernelPath, unsigned char **output)// 读取文本文件，存储为字符串，返回字符数
 {
     FILE *pf;
     long int size;
     printf("readSource, Program file: %s\n", kernelPath);
     fopen_s(&pf, kernelPath, "rb");
     if (!pf)
     {
         printf("Open kernel file failed\n");
         exit(-);
     }
     if (fseek(pf, , SEEK_END) != )
     {
         printf("Seek end of file faildd\n");
         exit(-);
     }
     if ((size = ftell(pf)) < )
     {
         printf("Get file position failed\n");
         exit(-);
     }
     rewind(pf);
     if ((*output = (unsigned char *)malloc(size + )) == NULL)
     {
         printf("Allocate space failed\n");
         exit(-);
     }
     fread(*output, , size, pf);
     fclose(pf);
     (*output)[size] = '\0';
     return strlen((char*)*output);
 }

 int main()
 {
     const size_t datasize = sizeof(int) * nElement;
     int i, *A, *B, *C;
     cl_int status;
     unsigned char *programBinary;
     FILE *pf;

     A = (int*)malloc(datasize);
     B = (int*)malloc(datasize);
     C = (int*)malloc(datasize);
     for (i = ; i < nElement; A[i] = B[i] = i, i++);

     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 cmdQueue = clCreateCommandQueue(context, device, , &status);
     cl_mem bufferA, bufferB, bufferC;
     bufferA = clCreateBuffer(context, CL_MEM_READ_ONLY, datasize, NULL, &status);
     bufferB = clCreateBuffer(context, CL_MEM_READ_ONLY, datasize, NULL, &status);
     bufferC = clCreateBuffer(context, CL_MEM_WRITE_ONLY, datasize, NULL, &status);
     clEnqueueWriteBuffer(cmdQueue, bufferA, CL_FALSE, , datasize, A, , NULL, NULL);
     clEnqueueWriteBuffer(cmdQueue, bufferB, CL_FALSE, , datasize, B, , NULL, NULL);
     cl_program program = clCreateProgramWithSource(context, , &programSource, NULL, &status);
     clBuildProgram(program, , &device, NULL, NULL, NULL);

     // 抽取已经 build 的 program 的代码
     size_t programBinarySize;
     clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, sizeof(cl_device_id), &programBinarySize, NULL); // 获取 build 的 program 的大小
     programBinary = (unsigned char *)malloc(sizeof(unsigned char)*programBinarySize);
     clGetProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(unsigned char *), &programBinary, NULL);      // 获取代码

     // 将代码写入文件，再读回来，这说明可以从外部文件中直接读取已经 build 的 program 来使用
     fopen_s(&pf, binaryFileName, "w");
     fwrite(programBinary, , programBinarySize, pf);
     free(programBinary);
     fclose(pf);
     programBinarySize = readSource(binaryFileName, &programBinary);

     // 使用clCreateProgramWithBinary 来建立 program
     cl_program program2 = clCreateProgramWithBinary(context, , &device, &programBinarySize, (const unsigned char **)&programBinary, NULL, NULL);
     clBuildProgram(program2, , &device, NULL, NULL, NULL);

     cl_kernel kernel = clCreateKernel(program2, "vectorAdd", &status);
     status = clSetKernelArg(kernel, , sizeof(cl_mem), &bufferA);
     status = clSetKernelArg(kernel, , sizeof(cl_mem), &bufferB);
     status = clSetKernelArg(kernel, , sizeof(cl_mem), &bufferC);
     size_t globalSize[] = { nElement }, localSize[] = {  };
     status = clEnqueueNDRangeKernel(cmdQueue, kernel, , NULL, globalSize, localSize, , NULL, NULL);
     clEnqueueReadBuffer(cmdQueue, bufferC, CL_TRUE, , datasize, C, , NULL, NULL);

     for (i = ; i < nElement; i++)
     {
         if (C[i] != i + i)
             break;
     }
     printf("Output is %s.\n", (i == nElement) ? "correct" : "incorrect");

     free(A);
     free(B);
     free(C);
     free(programBinary);
     clReleaseContext(context);
     clReleaseMemObject(bufferA);
     clReleaseMemObject(bufferB);
     clReleaseMemObject(bufferC);
     clReleaseCommandQueue(cmdQueue);
     clReleaseProgram(program);
     clReleaseProgram(program2);
     clReleaseKernel(kernel);
     getchar();
     return ;
 }

● 输出结果

readSource, Program file: D:\Code\OpenCL\OpenCLProjectTemp\OpenCLProjectTemp\vectorAdd.bin
Output is correct.

● 由代码中的向量加法生成的 program 代码文件

 //
 // Generated by NVIDIA NVVM Compiler
 //
 // Compiler Build ID: UNKNOWN
 // Driver
 // Based on LLVM 3.4svn
 //

 .version 6.1
 .target sm_61, texmode_independent
 .address_size 

     // .globl    vectorAdd

 .entry vectorAdd(
     .param .u64 .ptr .global .align  vectorAdd_param_0,
     .param .u64 .ptr .global .align  vectorAdd_param_1,
     .param .u64 .ptr .global .align  vectorAdd_param_2
 )
 {
     .reg .b32     %r<>;
     .reg .b64     %rd<>;

     ld.param.u64     %rd1, [vectorAdd_param_0];
     ld.param.u64     %rd2, [vectorAdd_param_1];
     ld.param.u64     %rd3, [vectorAdd_param_2];
     mov.b32    %r1, %envreg3;
     mov.u32     %r2, %ntid.x;
     mov.u32     %r3, %ctaid.x;
     mad.lo.s32     %r4, %r3, %r2, %r1;
     mov.u32     %r5, %tid.x;
     add.s32     %r6, %r4, %r5;
     mul.wide.s32     %rd4, %r6, ;
     add.s64     %rd5, %rd1, %rd4;
     ld.global.u32     %r7, [%rd5];
     add.s64     %rd6, %rd2, %rd4;
     ld.global.u32     %r8, [%rd6];
     add.s32     %r9, %r8, %r7;
     add.s64     %rd7, %rd3, %rd4;
     st.global.u32     [%rd7], %r9;
     ret;
 }