OpenCL NativeKernel 计算矩阵乘法

▶ 使用函数 clEnqueueNativeKernel 来调用 C/C++ 本地函数（在 OpenCL 中将其看做回调函数），使用本地编译器（而不是 OpenCL 编译器）来编译和执行内核

● 代码，似乎很难找到有关 native kernal 的例子，感谢 stack exchange（https://stackoverflow.com/questions/18409256/how-do-you-read-arguments-passed-to-a-native-kernel，https://stackoverflow.com/questions/10140494/using-clenqueuenativekernel-in-opencl）

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

 #pragma warning(disable : 4996)

 const int rowA = , colA = , colB = ;

 struct parameter    // 传给native kernel 的参数列表
 {
     unsigned int row_A;
     unsigned int col_A;
     unsigned int col_B;
     float *input_A;
     float *input_B;
     float *output_C;
 };

 void multiplyNaive(void *in)
 {
     struct parameter *para = (struct parameter *)in;// 传入参数只有 para->col_B 错误（呈现随机数），与内存对齐有关？
     float sum;                                      // 因为用不了 para->col_B，代码中使用的全局变量代替 para 中的成员
     for (i = ; i < rowA; i++)
     {
         for (j = ; j < colB; j++)
         {
             for (k = , sum = 0.0f; k < colA; k++)
                 sum += para->input_A[i * colA + k] * para->input_B[k * colB + j];
             para->output_C[i * colB + j] = sum;
         }
     }
     return;
 }

 int main()
 {
     int i, j, k, correct;
     float *A, *B, *C, tempSum;
     cl_int status;

     A = (float*)malloc(sizeof(float) * rowA * colA);
     B = (float*)malloc(sizeof(float) * colA * colB);
     C = (float*)malloc(sizeof(float) * rowA * colB);
     for (i = ; i < rowA * colA; A[i] = , i++);
     for (i = ; i < colA * colB; B[i] = , i++);

     cl_uint nPlatform;
     clGetPlatformIDs(, NULL, &nPlatform);
     cl_platform_id *listPlatform = (cl_platform_id*)malloc(nPlatform * sizeof(cl_platform_id));
     clGetPlatformIDs(nPlatform, listPlatform, NULL);
     cl_uint nDevice = ;
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_CPU, , NULL, &nDevice);// 使用支持 NativeKernel 的 intel OpenCL
     cl_device_id *listDevice = (cl_device_id*)malloc(nDevice * sizeof(cl_device_id));
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_CPU, nDevice, listDevice, NULL);
     cl_context context = clCreateContext(NULL, nDevice, listDevice, NULL, NULL, &status);
     cl_command_queue queue = clCreateCommandQueue(context, listDevice[], , &status);

     cl_mem bufferA = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * rowA * colA, A, &status);
     cl_mem bufferB = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * colA * colB, B, &status);
     cl_mem bufferC = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * rowA * colB, NULL, &status);    

     // 设置内核参数
     cl_mem bufferList[] = { bufferA, bufferB, bufferC };
     // 结构体写法
     struct parameter para;
     para.row_A = rowA;
     para.col_A = colA;
     para.col_B = colB;
     para.input_A = NULL;
     para.input_B = NULL;
     para.output_C = NULL;
     const void *bufferLocation[] = { &para.input_A, &para.input_B, &para.output_C };
     // 列表写法
     //void *para[6] = { (void *)rowA, (void *)colA, (void *)colB, NULL, NULL, NULL };   // 参数列表，空出缓冲区的位置
     //const void *bufferLocation[3] = { &para[3], &para[4], &para[5] };                 // 指明参数列表中哪些位置应该是缓冲区

     status = clEnqueueNativeKernel(queue, (void(__stdcall *)(void*))multiplyNaive, (void*)&para, , , bufferList, &bufferLocation[], , NULL, NULL);
     // 注意第 7 个参数 &bufferLocation[0]，需要的是一个 const void**，而不是 void*[3]，不能直接传入 bufferLocation

     // 返回并检查结果
     clEnqueueReadBuffer(queue, bufferC, CL_TRUE, , sizeof(float) * rowA * colB, C, , NULL, NULL);
     for (i = , correct = ; i < rowA && correct; i++)
     {
         for (j = ; j < colB && correct; j++)
         {
             for (k = , tempSum = 0.0f; k < colA; tempSum += A[i * colA + k] * B[k * colB + j], k++);
             if (tempSum != C[i * colB + j])
             {
                 printf("Error at [%d, %d], calculation: %f, reference: %f\n", i, j, C[i*colA + j], tempSum);
                 correct = ;
             }
         }
     }
     if (correct)
         printf("Result correct.\n");

     // 释放资源
     free(A);
     free(B);
     free(C);
     free(listPlatform);
     free(listDevice);
     clReleaseContext(context);
     clReleaseMemObject(bufferA);
     clReleaseMemObject(bufferB);
     clReleaseMemObject(bufferC);
     clReleaseCommandQueue(queue);
     getchar();
     return ;
 }

● 输出结果，我的电脑不支持运行本地函数

-
Error at[, ], calculation: 0.000000, reference : 64.000000

● 输出结果，办公室的电脑，正确计算，但代码中注释的问题没有解决

Result correct.

● 检查设备是否支持 native kernel

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

 int main()
 {
     unsigned long long val;

     cl_uint nPlatform;
     clGetPlatformIDs(, NULL, &nPlatform);
     cl_platform_id *listPlatform = (cl_platform_id*)malloc(nPlatform * sizeof(cl_platform_id));
     clGetPlatformIDs(nPlatform, listPlatform, NULL);
     cl_uint nDevice = ;
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, , NULL, &nDevice);
     cl_device_id *listDevice = (cl_device_id*)malloc(nDevice * sizeof(cl_device_id));
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, nDevice, listDevice, NULL);

     if (clGetDeviceInfo(listDevice[], CL_DEVICE_EXECUTION_CAPABILITIES, sizeof(val), &val, NULL) == CL_SUCCESS)// 获取设备信息 CL_DEVICE_EXECUTION_CAPABILITIES
     {
         printf("\nEXECUTION_CAPABILITIES: ");
         if (val & CL_EXEC_KERNEL)
         {
             val &= ~CL_EXEC_KERNEL;
             printf("Kernel ");
         }
         if (val & CL_EXEC_NATIVE_KERNEL)
         {
             val &= ~CL_EXEC_NATIVE_KERNEL;
             printf("Native ");
         }
         if (val)
             printf("Unknown (0x%llx) ", val);
         printf("\n");
     }
     free(listPlatform);
     free(listDevice);
     getchar();
     return ;
 }

● 输出结果，我的电脑仅支持设备执行，而不支持本地执行

EXECUTION_CAPABILITIES: Kernel

● 用到的函数和定义

 // cl.h
 // 设备是否支持函数 clEnqueueNativeKernel 执行回调函数的值
 #define CL_EXEC_KERNEL                              (1 << 0)
 #define CL_EXEC_NATIVE_KERNEL                       (1 << 1)

 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(
     cl_command_queue,                           // 命令队列
     void (CL_CALLBACK * /*user_func*/)(void *), // 回调函数
     void *,                                     // 参数列表
     size_t,                                     // 参数总个数
     cl_uint,                                    // 数据对象（包括 bufer 和 image）个数
     const cl_mem *,                             // 数据对象列表
     const void **,                              // 数据对象在参数列表中的地址
     cl_uint,                                    // 等待列表中的事件数
     const cl_event *,                           // 等待列表
     cl_event *                                  // 本事件标记
 ) CL_API_SUFFIX__VERSION_1_0;