原文地址：Android AARCH64 平台的 OpenCL 配置

Android AARCH64 平台的 OpenCL 配置

开发环境

IDE: Android Studio 3.4.1

Android: 7.1

minSdkVersion: 25

targetSdkVersion: 26

JNI CMake: 3.4.1

ABI: arm64-v8a

OpenCL: 1.2

配置 OpenCL 使用项目中的 so 库

这里以编译 openclTest.cpp 为 libopenclTest.so 并导入 OpenCL 的动态库为例

注1: 下列 so 库需要从开发板上 pull 到项目中，其中 libGLES_mali.so 用于驱动 OpenCL，其他库为依赖库

注2: 不同平台的驱动库位于不同位置，可以下载 OpenCL-Z 查看

注3: set_target_properties 中第一项参数设置了生成库的名称，例如设置为 openclTest，则生成 libopenclTest.so 库，这里使用了 lib_* 作为前缀，则生成liblib_*.so 库，实际开发中要避免这种情况

查看依赖库

  1. objdump -x libGLES_mali.so | grep NEEDED

目录结构

  1. opencltest
  2. ├─ app
  3. │  ├─ build
  4. │  ├─ libs
  5. │  └─ src
  6. │      ├─ androidTest
  7. │      ├─ main
  8. │      │  ├─ java
  9. │      │  │  └─ com
  10. │      │  │      └─ example
  11. │      │  │          └─ opencltest
  12. │      │  │                  MainActivity.java
  13. │      │  ├─ jni    #C/C++ 源码目录
  14. │      │  │  └─ openclTest.cpp
  15. │      │  ├─ jniLibs    #JNI 需要调用的运行库
  16. │      │  │  └─ arm64-v8a   #对应 ABI 版本建立文件夹
  17. │      │  │      ├─ libbinder.so
  18. │      │  │      ├─ libc++.so
  19. │      │  │      ├─ libc.so
  20. │      │  │      ├─ libcrypto.so
  21. │      │  │      ├─ libcutils.so
  22. │      │  │      ├─ libdl.so
  23. │      │  │      ├─ libGLES_mali.so
  24. │      │  │      ├─ libhardware.so
  25. │      │  │      ├─ liblog.so
  26. │      │  │      ├─ libm.so
  27. │      │  │      ├─ libui.so
  28. │      │  │      ├─ libutils.so
  29. │      │  │      └─ libz.so
  30. │      │  └─ res
  31. │      └─ test
  32. └─ gradle

CMakeLists.txt 增加配置

  1. add_library(openclTest
  2.         SHARED
  3.         src/main/jni/openclTest.cpp )
  5. add_library(lib_opencl SHARED IMPORTED)
  7. set_target_properties(lib_opencl
  8.         PROPERTIES
  9.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libGLES_mali.so )
  11. add_library(lib_z SHARED IMPORTED)
  12. set_target_properties(lib_z
  13.         PROPERTIES
  14.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libz.so )
  16. add_library(lib_log SHARED IMPORTED)
  17. set_target_properties(lib_log
  18.         PROPERTIES
  19.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/liblog.so )
  21. add_library(lib_utils SHARED IMPORTED)
  22. set_target_properties(lib_utils
  23.         PROPERTIES
  24.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libutils.so )
  26. add_library(lib_ui SHARED IMPORTED)
  27. set_target_properties(lib_ui
  28.         PROPERTIES
  29.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libui.so )
  31. add_library(lib_cutils SHARED IMPORTED)
  32. set_target_properties(lib_cutils
  33.         PROPERTIES
  34.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcutils.so )
  36. add_library(lib_binder SHARED IMPORTED)
  37. set_target_properties(lib_binder
  38.         PROPERTIES
  39.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libbinder.so )
  41. add_library(lib_crypto SHARED IMPORTED)
  42. set_target_properties(lib_crypto
  43.         PROPERTIES
  44.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcrypto.so )
  46. add_library(lib_dl SHARED IMPORTED)
  47. set_target_properties(lib_dl
  48.         PROPERTIES
  49.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libdl.so )
  51. add_library(lib_hardware SHARED IMPORTED)
  52. set_target_properties(lib_hardware
  53.         PROPERTIES
  54.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libhardware.so )
  56. add_library(lib_c++ SHARED IMPORTED)
  57. set_target_properties(lib_c++
  58.         PROPERTIES
  59.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libc++.so )
  61. add_library(lib_c SHARED IMPORTED)
  62. set_target_properties(lib_c
  63.         PROPERTIES
  64.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libc.so )
  66. add_library(lib_m SHARED IMPORTED)
  67. set_target_properties(lib_m
  68.         PROPERTIES
  69.         IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libm.so )
  71. target_link_libraries(openclTest
  72.         ${log-lib}
  73.         lib_opencl )

配置 OpenCL 使用 dlopen 打开开发板上的运行库

这种配置方法需要从 Github - KhronosGroup/OpenCL-Headers 仓库下载 OpenCL 的头文件，并且需要自行实现 OpenCL 的函数

注: 需要在源码中定义 CL_TARGET_OPENCL_VERSION 120，否则会报找不到版本号的错误

目录结构

  1. opencltest
  2. ├─ app
  3. │  ├─ build
  4. │  ├─ libs
  5. │  └─ src
  6. │      ├─ androidTest
  7. │      ├─ main
  8. │      │  ├─ java
  9. │      │  │  └─ com
  10. │      │  │      └─ example
  11. │      │  │          └─ opencltest
  12. │      │  │                  MainActivity.java
  13. │      │  ├─ jni    #C/C++ 源码目录
  14. │      │  │  ├─ dlopencl.cpp    #dlopen 打开运行库，实现 OpenCL 中的函数
  15. │      │  │  ├─ openclTest.cpp
  16. │      │  │  └─ include     #JNI 调用的头文件
  17. │      │  │      ├─ dlopencl.h  #定义 OpenCL 中的函数
  18. │      │  │      └─ CL      #OpenCL 需要使用的头文件
  19. │      │  │          ├─ cl.h
  20. │      │  │          ├─ cl_ext.h
  21. │      │  │          ├─ cl_gl.h
  22. │      │  │          ├─ cl_gl_ext.h
  23. │      │  │          ├─ cl_platform.h
  24. │      │  │          ├─ cl_version.h
  25. │      │  │          └─ opencl.h
  26. │      │  └─ res
  27. │      └─ test
  28. └─ gradle

CMakeLists.txt 增加配置

  1. include_directories(${PROJECT_SOURCE_DIR}/src/main/jni/include)
  3. add_library(openclTest
  4.         SHARED
  5.         src/main/jni/openclTest.cpp )
  7. add_library(lib_dlopencl
  8.         SHARED
  9.         src/main/jni/dlopencl.cpp )
  11. target_link_libraries(openclTest
  12.         ${log-lib}
  13.         lib_dlopencl )

需要导入的 dlopencl.h 和 dlopencl.cpp 写在文末

OpenCL 使用

以下均以使用 dlopen 导入运行库的方式为例

  1. 定义 OpenCL 版本
  1. #define CL_TARGET_OPENCL_VERSION 120
  1. 包含头文件
  1. #include <CL/cl.h>
  2. #include "dlopencl.h"
  1. 使用 Logcat 打印日志

由于 C 语言工作在 JNI 层，无法获取控制台，导致了 printf() 函数失效，这里使用 __android_log_print 方法打印日志到 Logcat

  1. #include <android/log.h>
  3. #define DEBUG
  5. #ifdef DEBUG
  6. #define LOG    "LOG-TAG"
  7. #define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG, __VA_ARGS__)
  8. #define LOGI(...)  __android_log_print(ANDROID_LOG_INFO, LOG, __VA_ARGS__)
  9. #define LOGW(...)  __android_log_print(ANDROID_LOG_WARN, LOG, __VA_ARGS__)
  10. #define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR, LOG, __VA_ARGS__)
  11. #define LOGF(...)  __android_log_print(ANDROID_LOG_FATAL, LOG, __VA_ARGS__)
  12. #else
  13. #define LOG
  14. #define LOGD(...)
  15. #define LOGI(...)
  16. #define LOGW(...)
  17. #define LOGE(...)
  18. #define LOGF(...)
  19. #endif

使用方法同 printf()，例:

  1. LOGI("Device ID: %d", device_id);
  1. 创建用于初始化 OpenCL 的 JNI 接口

建议在同一个文件中编写多个操作 OpenCL 的函数，这里的初始化实际上是将操作 OpenCL 的变量建立为全局变量，通过 JNI 一次调用后其他函数再使用这些被初始化过的变量

定义变量

  1. cl_uint num_device;
  2. cl_uint num_platform;
  3. cl_platform_id *platform;
  4. cl_device_id *devices;
  5. cl_int err;
  6. cl_context context;
  1. extern "C"
  2. JNIEXPORT jint JNICALL
  3. Java_com_example_opencltest_MainActivity_initOpencl(JNIEnv *env, jobject instance) {
  4.     initFns();
  5.     LOGI("getPlatformNum");
  6.     // 获取可用平台数量
  7.     err = clGetPlatformIDs(0, 0, &num_platform);
  8.     platform = (cl_platform_id*)malloc(sizeof(cl_platform_id)*num_platform);
  9.     LOGI("getPlatformIDs");
  10.     // 获取平台 ID
  11.     err = clGetPlatformIDs(num_platform, platform, nullptr);
  12.     if(err < 0) {
  13.         LOGE("clGetPlatformIDs failed");
  14.         return -1;
  15.     }
  17.     LOGI("getDeviceNum");
  18.     // 获取可用设备数量
  19.     err = clGetDeviceIDs(platform[0], CL_DEVICE_TYPE_GPU, 0, nullptr, &num_device);
  20.     devices = (cl_device_id*)malloc(sizeof(cl_device_id)*num_device);
  21.     LOGI("getDeviceIDs");
  22.     // 获取设备 ID
  23.     err = clGetDeviceIDs(platform[0], CL_DEVICE_TYPE_GPU, num_device, devices, nullptr);
  24.     if (err < 0) {
  25.         LOGE("clGetDeviceIDs failed");
  26.         return -1;
  27.     }
  29.     return 0;
  30. }

使用 OpenCL 执行 Kernel 函数

通常编写 OpenCL 中的 Kernel 函数要求单独写在 *.cl 文件中，调用时使用 fopen 打开，将里面的代码作为字符串读入之后再进行 runtime 编译，比较麻烦，这里直接将整个 Kernel 函数写成字符串

本例中因为测试原因没有释放掉创建的资源

可以使用允许正则替换的编辑器例如 VSCode，先写好 Kernel 函数，然后使用正则表达式 (.*) 选择所有行并将每一行作为一个参数($1)，替换为 "$1\\n"，例如替换前: int a = 0;，替换后: "int a = 0;\n"

注1: 经测试发现 OpenCL 在 PC 端允许每次调用任意数量的矢量数据，而在开发板上只允许一次调用 1.2.3.4.8.16 个

PC 端允许的矢量调用:

  1. Integralgraph.s0
  2. Integralgraph.s01
  3. Integralgraph.s012
  4. Integralgraph.s0123
  5. Integralgraph.s01234
  6. Integralgraph.s0123456
  7. Integralgraph.s01234567
  8. Integralgraph.s012345678
  9. Integralgraph.s0123456789
  10. Integralgraph.s0123456789a
  11. Integralgraph.s0123456789ab
  12. Integralgraph.s0123456789abc
  13. Integralgraph.s0123456789abcd
  14. Integralgraph.s0123456789abcde
  15. Integralgraph.s0123456789abcdef

开发板允许的矢量调用:

  1. Integralgraph.s0
  2. Integralgraph.s01
  3. Integralgraph.s012
  4. Integralgraph.s0123
  5. Integralgraph.s01234567
  6. Integralgraph.s0123456789abcdef

所以在编写运行于 AARCH64 架构的 OpenCL Kernel 函数时需要将被调用的矢量数组分组相加

例如在 PC 端为

  1. TableInteg1 = (int16)(Integralgraph[index1].sf*flagx0, Integralgraph[index4].s0123456789abcde);

在开发板中需要改为

  1. TableInteg1 = (int16)(Integralgraph[index1].sf*flagx0, Integralgraph[index4].s01234567, Integralgraph[index4].s89ab, Integralgraph[index4].scde);

注2: 测试中发现 PC 端的 OpenCL 遇到数组越界问题会直接跳过不予处理，但在 AARCH64 中会导致执行失败

注3: AARCH64 平台上 OpenCL 能申请到的可调用内存远小于 PC 端，如果出现输入或输出的数据超出 OpenCL 申请到的内存可能会导致数据输出不完整，读取数据时错误代码返回 -14 等问题

先在 Activity 中调用 initOpencl()，初始化 OpenCL 及其平台和设备

  1. // 定义积分图宽度
  2. #define CLL_IMAGE_W (400)
  3. // 定义积分图高度
  4. #define CLL_IMAGE_H (80)
  6. // 构建 Kernel 函数字符串
  7. const char *clkernel[] = {
  8.         "__kernel void kernel_Integralgraph_45int(__global int16 * grayImage,\n"
  9.         "    __global int16 * Integralgraph,\n"
  10.         "    __global unsigned * const p_height) {\n"
  11.         "    int x = get_global_id(0);\n"
  12.         "    int height = *p_height;\n"
  13.         "    int width = get_global_size(0);\n"
  14.         "    __local int index, index1, index2, index3, index4, index5;\n"
  15.         "    __local bool flagx0, flagxw, flagy1, flagy2;\n"
  16.         "    __local int16 TableInteg1, TableInteg2, TableInteg3;\n"
  17.         "    flagx0 = min(0, -x);\n"
  18.         "    flagxw = min(0, x - width + 1);\n"
  19.         "    for (int j = 0; j < height; j++) {\n"
  20.         "        flagy1 = min(0, -j);\n"
  21.         "        flagy2 = min(0, 1 - j);\n"
  22.         "        index = j * width + x;\n"
  23.         "        if(j==0) {\n"
  24.         "            Integralgraph[index] = (int16)grayImage[index];\n"
  25.         "        } else if(j==1) {\n"
  26.         "            index1 = (j - 1)*width + x - 1;\n"
  27.         "            index3 = (j - 1)*width + x + 1;\n"
  28.         "            index4 = (j - 1)*width + x;\n"
  29.         "            TableInteg1 = (int16)(Integralgraph[index1].sf*flagx0, Integralgraph[index4].s01234567, Integralgraph[index4].s89ab, Integralgraph[index4].scde);\n"
  30.         "            TableInteg3 = (int16)(Integralgraph[index4].s12345678, Integralgraph[index4].s9abc, Integralgraph[index4].sdef, Integralgraph[index3].s0*flagxw);\n"
  31.         "            Integralgraph[index] = (int16)((int16)TableInteg1*flagy1 + (int16)TableInteg3*flagy1 + (int16)grayImage[index4] * flagy1 + (int16)grayImage[index]);\n"
  32.         "        } else {\n"
  33.         "            index1 = (j - 1)*width + x - 1;\n"
  34.         "            index2 = (j - 2)*width + x;\n"
  35.         "            index3 = (j - 1)*width + x + 1;\n"
  36.         "            index4 = (j - 1)*width + x;\n"
  37.         "            TableInteg1 = (int16)(Integralgraph[index1].sf*flagx0, Integralgraph[index4].s01234567, Integralgraph[index4].s89ab, Integralgraph[index4].scde);\n"
  38.         "            TableInteg2 = (int16)(Integralgraph[index2].s0*flagx0, Integralgraph[index2].s12345678, Integralgraph[index2].s9ab, Integralgraph[index2].scde, Integralgraph[index2].sf*flagxw);\n"
  39.         "            TableInteg3 = (int16)(Integralgraph[index4].s12345678, Integralgraph[index4].s9abc, Integralgraph[index4].sdef, Integralgraph[index3].s0*flagxw);\n"
  40.         "            Integralgraph[index] = (int16)((int16)TableInteg1*flagy1 + (int16)TableInteg3*flagy1 - (int16)TableInteg2 * flagy2 + (int16)grayImage[index4] * flagy1 + (int16)grayImage[index]);\n"
  41.         "        }\n"
  42.         "    }\n"
  43.         "}\n"
  44. };
  46. // 创建 Context
  47. context = clCreateContext(nullptr, 1, devices, nullptr, nullptr, &err);
  48. if(err < 0) {
  49.     LOGE("Create context failed, error code: [%d]", err);
  50.     return -1;
  51. }
  53. int inputData[CLL_IMAGE_W * CLL_IMAGE_H];
  54. int outputData[CLL_IMAGE_W * CLL_IMAGE_H];
  55. int width = CLL_IMAGE_W;
  56. int height = CLL_IMAGE_H;
  57. // 初始化输入输出数据
  58. for (int i = 0; i < height; i++) {
  59.     for (int j = 0; j < width; j++) {
  60.         inputData[i * width + j] = 1;
  61.         outputData[i * width + j] = 0;
  62.     }
  63. }
  65. clock_t time_start;
  66. clock_t time_finish;
  67. double total_time;
  69. char *program_log;
  70. cl_command_queue queue;
  71. cl_kernel kernel;
  72. size_t log_size;
  73. cl_program program;
  75. // 创建命令队列
  76. queue = clCreateCommandQueue(context, devices[0], 0, &err);
  77. if (err < 0) {
  78.     LOGE("Create command queue failed, error code: [%d]", err);
  79. }
  81. // 创建程序
  82. program = clCreateProgramWithSource(context, sizeof(clkernel) / sizeof(clkernel[0]), clkernel, nullptr, nullptr);
  84. // 构建/编译程序
  85. err = clBuildProgram(program, 0, nullptr, nullptr, nullptr, nullptr);
  86. if (err < 0) {
  87.     clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size);
  88.     program_log = (char*)malloc(sizeof(log_size));
  89.     // 查询构建/编译过程中的 log
  90.     clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, log_size, program_log, nullptr);
  91.     LOGE("program_build_info: \n[%s]\n", program_log);
  92.     free(program_log);
  93. }
  95. // 创建 Kernel
  96. kernel = clCreateKernel(program, "kernel_Integralgraph_45int", &err);
  97. if (err < 0) {
  98.     LOGE("Create kernel failed, error code: [%d]", err);
  99. }
  101. // 创建用于输入参数、输出数据的内存空间
  102. cl_mem meminput_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * height * width, inputData, &err);
  103. cl_mem memoutput_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(int) * height * width, nullptr, &err);
  104. cl_mem memHeight_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int), &height, &err);
  105. // 向 Kernel 传递参数
  106. err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &meminput_buffer);
  107. err = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memoutput_buffer);
  108. err = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memHeight_buffer);
  110. size_t global_work_offset[2] = {0, 0};
  111. size_t localThreads[2] = {1, 1};
  112. size_t globalThreads[2] = {(size_t)(width / 16), 1};
  114. // 获得程序开始执行的时间戳
  115. time_start = clock();
  117. // 排布工作组与工作项并执行
  118. err = clEnqueueNDRangeKernel(queue, kernel, 2, global_work_offset, globalThreads, localThreads, 0, nullptr, nullptr);
  119. if (err < 0) {
  120.     LOGE("Run Kernel failed, error code: [%d]", err);
  121. }
  123. // 获得程序执行完成的时间戳
  124. time_finish = clock();
  125. // 计算运行时间
  126. total_time = (double)(time_finish - time_start) / CLOCKS_PER_SEC;
  127. LOGI("Total time: [%f]s", total_time);
  129. // 从输出的内存空间中读取数据
  130. err = clEnqueueReadBuffer(queue, memoutput_buffer, CL_TRUE, 0, sizeof(int) * height * width, outputData, 0, nullptr, nullptr);
  131. if (err < 0) {
  132.     LOGE("Read buffer failed, error code: [%d]", err);
  133. }
  135. // 输出数据，积分图中的每一行拼接为一条 LOG
  136. char outputDataTemp[2048];
  137. for (int i = 0; i < height ; i++) {
  138.     // 清空字符串，拼接下一行
  139.     memset(outputDataTemp, 0x00, 2048);
  140.     for (int j = 0; j < width ; j++) {
  141.         // 将一行数据拼接在一个字符串中
  142.         sprintf(outputDataTemp, "%s %d", outputDataTemp, outputData[i * width + j]);
  143.     }
  144.     // LOG打印
  145.     LOGI("line [%d]\n%s", i, outputDataTemp);
  146. }

附加

dlopencl.h

  1. #ifndef __AOPENCL_CL_H
  2. #define __AOPENCL_CL_H
  4. #ifdef __APPLE__
  5. #include <OpenCL/cl_platform.h>
  6. #else
  7. #include <CL/cl_platform.h>
  8. #endif
  10. #ifdef __cplusplus
  11. extern "C" {
  12. #endif
  14. #define IAH()
  15. //#define IAH() printf("File:%s, Line:%d\n",__FILE__, __LINE__);
  17. void initFns();
  19. /* Platform API */
  20. #define clGetPlatformIDs aclGetPlatformIDs
  21. cl_int
  22. (*aclGetPlatformIDs)(cl_uint          /* num_entries */,
  23.                      cl_platform_id * /* platforms */,
  24.                      cl_uint *        /* num_platforms */);
  26. #define clGetPlatformInfo aclGetPlatformInfo
  27. cl_int
  28. (*aclGetPlatformInfo)(cl_platform_id   /* platform */,
  29.                       cl_platform_info /* param_name */,
  30.                       size_t           /* param_value_size */,
  31.                       void *           /* param_value */,
  32.                       size_t *         /* param_value_size_ret */);
  34. /* Device APIs */
  35. #define clGetDeviceIDs aclGetDeviceIDs
  36. cl_int
  37. (*aclGetDeviceIDs)(cl_platform_id   /* platform */,
  38.                    cl_device_type   /* device_type */,
  39.                    cl_uint          /* num_entries */,
  40.                    cl_device_id *   /* devices */,
  41.                    cl_uint *        /* num_devices */);
  43. #define clGetDeviceInfo aclGetDeviceInfo
  44. cl_int
  45. (*aclGetDeviceInfo)(cl_device_id    /* device */,
  46.                     cl_device_info  /* param_name */,
  47.                     size_t          /* param_value_size */,
  48.                     void *          /* param_value */,
  49.                     size_t *        /* param_value_size_ret */);
  51. /* Context APIs  */
  52. #define clCreateContext aclCreateContext
  53. cl_context
  54. (*aclCreateContext)(const cl_context_properties * /* properties */,
  55.                     cl_uint                 /* num_devices */,
  56.                     const cl_device_id *    /* devices */,
  57.                     void (CL_CALLBACK * /* pfn_notify */)(const char *, const void *, size_t, void *),
  58.                     void *                  /* user_data */,
  59.                     cl_int *                /* errcode_ret */);
  61. #define clCreateContextFromType aclCreateContextFromType
  62. cl_context
  63. (*aclCreateContextFromType)(const cl_context_properties * /* properties */,
  64.                             cl_device_type          /* device_type */,
  65.                             void (CL_CALLBACK *     /* pfn_notify*/ )(const char *, const void *, size_t, void *),
  66.                             void *                  /* user_data */,
  67.                             cl_int *                /* errcode_ret */);
  69. #define clRetainContext aclRetainContext
  70. cl_int
  71. (*aclRetainContext)(cl_context /* context */);
  73. #define clReleaseContext aclReleaseContext
  74. cl_int
  75. (*aclReleaseContext)(cl_context /* context */);
  77. #define clGetContextInfo aclGetContextInfo
  78. cl_int
  79. (*aclGetContextInfo)(cl_context         /* context */,
  80.                      cl_context_info    /* param_name */,
  81.                      size_t             /* param_value_size */,
  82.                      void *             /* param_value */,
  83.                      size_t *           /* param_value_size_ret */);
  85. /* Command Queue APIs */
  86. #define clCreateCommandQueue aclCreateCommandQueue
  87. cl_command_queue
  88. (*aclCreateCommandQueue)(cl_context                     /* context */,
  89.                          cl_device_id                   /* device */,
  90.                          cl_command_queue_properties    /* properties */,
  91.                          cl_int *                       /* errcode_ret */);
  93. #define clRetainCommandQueue aclRetainCommandQueue
  94. cl_int
  95. (*aclRetainCommandQueue)(cl_command_queue /* command_queue */);
  97. #define clReleaseCommandQueue aclReleaseCommandQueue
  98. cl_int
  99. (*aclReleaseCommandQueue)(cl_command_queue /* command_queue */);
  101. #define clGetCommandQueueInfo aclGetCommandQueueInfo
  102. cl_int
  103. (*aclGetCommandQueueInfo)(cl_command_queue      /* command_queue */,
  104.                           cl_command_queue_info /* param_name */,
  105.                           size_t                /* param_value_size */,
  106.                           void *                /* param_value */,
  107.                           size_t *              /* param_value_size_ret */);
  109. /* Memory Object APIs */
  110. #define clCreateBuffer aclCreateBuffer
  111. cl_mem
  112. (*aclCreateBuffer)(cl_context   /* context */,
  113.                    cl_mem_flags /* flags */,
  114.                    size_t       /* size */,
  115.                    void *       /* host_ptr */,
  116.                    cl_int *     /* errcode_ret */);
  118. #define clCreateSubBuffer aclCreateSubBuffer
  119. cl_mem
  120. (*aclCreateSubBuffer)(cl_mem                   /* buffer */,
  121.                       cl_mem_flags             /* flags */,
  122.                       cl_buffer_create_type    /* buffer_create_type */,
  123.                       const void *             /* buffer_create_info */,
  124.                       cl_int *                 /* errcode_ret */);
  126. #define clRetainMemObject aclRetainMemObject
  127. cl_int
  128. (*aclRetainMemObject)(cl_mem /* memobj */);
  130. #define clReleaseMemObject aclReleaseMemObject
  131. cl_int
  132. (*aclReleaseMemObject)(cl_mem /* memobj */);
  134. #define clGetSupportedImageFormats aclGetSupportedImageFormats
  135. cl_int
  136. (*aclGetSupportedImageFormats)(cl_context           /* context */,
  137.                                cl_mem_flags         /* flags */,
  138.                                cl_mem_object_type   /* image_type */,
  139.                                cl_uint              /* num_entries */,
  140.                                cl_image_format *    /* image_formats */,
  141.                                cl_uint *            /* num_image_formats */);
  143. #define clGetMemObjectInfo aclGetMemObjectInfo
  144. cl_int
  145. (*aclGetMemObjectInfo)(cl_mem           /* memobj */,
  146.                        cl_mem_info      /* param_name */,
  147.                        size_t           /* param_value_size */,
  148.                        void *           /* param_value */,
  149.                        size_t *         /* param_value_size_ret */);
  151. #define clGetImageInfo aclGetImageInfo
  152. cl_int
  153. (*aclGetImageInfo)(cl_mem           /* image */,
  154.                    cl_image_info    /* param_name */,
  155.                    size_t           /* param_value_size */,
  156.                    void *           /* param_value */,
  157.                    size_t *         /* param_value_size_ret */);
  159. #define clSetMemObjectDestructorCallback aclSetMemObjectDestructorCallback
  160. cl_int
  161. (*aclSetMemObjectDestructorCallback)(  cl_mem /* memobj */,
  162.                                        void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/),
  163.                                        void * /*user_data */ );
  165. /* Sampler APIs */
  166. #define clCreateSampler aclCreateSampler
  167. cl_sampler
  168. (*aclCreateSampler)(cl_context          /* context */,
  169.                     cl_bool             /* normalized_coords */,
  170.                     cl_addressing_mode  /* addressing_mode */,
  171.                     cl_filter_mode      /* filter_mode */,
  172.                     cl_int *            /* errcode_ret */);
  174. #define clRetainSampler aclRetainSampler
  175. cl_int
  176. (*aclRetainSampler)(cl_sampler /* sampler */);
  178. #define clReleaseSampler aclReleaseSampler
  179. cl_int
  180. (*aclReleaseSampler)(cl_sampler /* sampler */);
  182. #define clGetSamplerInfo aclGetSamplerInfo
  183. cl_int
  184. (*aclGetSamplerInfo)(cl_sampler         /* sampler */,
  185.                      cl_sampler_info    /* param_name */,
  186.                      size_t             /* param_value_size */,
  187.                      void *             /* param_value */,
  188.                      size_t *           /* param_value_size_ret */);
  190. /* Program Object APIs  */
  191. #define clCreateProgramWithSource aclCreateProgramWithSource
  192. cl_program
  193. (*aclCreateProgramWithSource)(cl_context        /* context */,
  194.                               cl_uint           /* count */,
  195.                               const char **     /* strings */,
  196.                               const size_t *    /* lengths */,
  197.                               cl_int *          /* errcode_ret */);
  199. #define clCreateProgramWithBinary aclCreateProgramWithBinary
  200. cl_program
  201. (*aclCreateProgramWithBinary)(cl_context                     /* context */,
  202.                               cl_uint                        /* num_devices */,
  203.                               const cl_device_id *           /* device_list */,
  204.                               const size_t *                 /* lengths */,
  205.                               const unsigned char **         /* binaries */,
  206.                               cl_int *                       /* binary_status */,
  207.                               cl_int *                       /* errcode_ret */);
  209. #define clRetainProgram aclRetainProgram
  210. cl_int
  211. (*aclRetainProgram)(cl_program /* program */);
  213. #define clReleaseProgram aclReleaseProgram
  214. cl_int
  215. (*aclReleaseProgram)(cl_program /* program */);
  217. #define clBuildProgram aclBuildProgram
  218. cl_int
  219. (*aclBuildProgram)(cl_program           /* program */,
  220.                    cl_uint              /* num_devices */,
  221.                    const cl_device_id * /* device_list */,
  222.                    const char *         /* options */,
  223.                    void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */),
  224.                    void *               /* user_data */);
  226. #define clGetProgramInfo aclGetProgramInfo
  227. cl_int
  228. (*aclGetProgramInfo)(cl_program         /* program */,
  229.                      cl_program_info    /* param_name */,
  230.                      size_t             /* param_value_size */,
  231.                      void *             /* param_value */,
  232.                      size_t *           /* param_value_size_ret */);
  234. #define clGetProgramBuildInfo aclGetProgramBuildInfo
  235. cl_int
  236. (*aclGetProgramBuildInfo)(cl_program            /* program */,
  237.                           cl_device_id          /* device */,
  238.                           cl_program_build_info /* param_name */,
  239.                           size_t                /* param_value_size */,
  240.                           void *                /* param_value */,
  241.                           size_t *              /* param_value_size_ret */);
  243. /* Kernel Object APIs */
  244. #define clCreateKernel aclCreateKernel
  245. cl_kernel
  246. (*aclCreateKernel)(cl_program      /* program */,
  247.                    const char *    /* kernel_name */,
  248.                    cl_int *        /* errcode_ret */);
  250. #define clCreateKernelsInProgram aclCreateKernelsInProgram
  251. cl_int
  252. (*aclCreateKernelsInProgram)(cl_program     /* program */,
  253.                              cl_uint        /* num_kernels */,
  254.                              cl_kernel *    /* kernels */,
  255.                              cl_uint *      /* num_kernels_ret */);
  257. #define clRetainKernel aclRetainKernel
  258. cl_int
  259. (*aclRetainKernel)(cl_kernel    /* kernel */);
  261. #define clReleaseKernel aclReleaseKernel
  262. cl_int
  263. (*aclReleaseKernel)(cl_kernel   /* kernel */);
  265. #define clSetKernelArg aclSetKernelArg
  266. cl_int
  267. (*aclSetKernelArg)(cl_kernel    /* kernel */,
  268.                    cl_uint      /* arg_index */,
  269.                    size_t       /* arg_size */,
  270.                    const void * /* arg_value */);
  272. #define clGetKernelInfo aclGetKernelInfo
  273. cl_int
  274. (*aclGetKernelInfo)(cl_kernel       /* kernel */,
  275.                     cl_kernel_info  /* param_name */,
  276.                     size_t          /* param_value_size */,
  277.                     void *          /* param_value */,
  278.                     size_t *        /* param_value_size_ret */);
  280. #define clGetKernelWorkGroupInfo aclGetKernelWorkGroupInfo
  281. cl_int
  282. (*aclGetKernelWorkGroupInfo)(cl_kernel                  /* kernel */,
  283.                              cl_device_id               /* device */,
  284.                              cl_kernel_work_group_info  /* param_name */,
  285.                              size_t                     /* param_value_size */,
  286.                              void *                     /* param_value */,
  287.                              size_t *                   /* param_value_size_ret */);
  289. /* Event Object APIs */
  290. #define clWaitForEvents aclWaitForEvents
  291. cl_int
  292. (*aclWaitForEvents)(cl_uint             /* num_events */,
  293.                     const cl_event *    /* event_list */);
  295. #define clGetEventInfo aclGetEventInfo
  296. cl_int
  297. (*aclGetEventInfo)(cl_event         /* event */,
  298.                    cl_event_info    /* param_name */,
  299.                    size_t           /* param_value_size */,
  300.                    void *           /* param_value */,
  301.                    size_t *         /* param_value_size_ret */);
  303. #define clCreateUserEvent aclCreateUserEvent
  304. cl_event
  305. (*aclCreateUserEvent)(cl_context    /* context */,
  306.                       cl_int *      /* errcode_ret */);
  308. #define clRetainEvent aclRetainEvent
  309. cl_int
  310. (*aclRetainEvent)(cl_event /* event */);
  312. #define clReleaseEvent aclReleaseEvent
  313. cl_int
  314. (*aclReleaseEvent)(cl_event /* event */);
  316. #define clSetUserEventStatus aclSetUserEventStatus
  317. cl_int
  318. (*aclSetUserEventStatus)(cl_event   /* event */,
  319.                          cl_int     /* execution_status */);
  321. #define clSetEventCallback aclSetEventCallback
  322. cl_int
  323. (*aclSetEventCallback)( cl_event    /* event */,
  324.                         cl_int      /* command_exec_callback_type */,
  325.                         void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *),
  326.                         void *      /* user_data */);
  328. /* Profiling APIs */
  329. #define clGetEventProfilingInfo aclGetEventProfilingInfo
  330. cl_int
  331. (*aclGetEventProfilingInfo)(cl_event            /* event */,
  332.                             cl_profiling_info   /* param_name */,
  333.                             size_t              /* param_value_size */,
  334.                             void *              /* param_value */,
  335.                             size_t *            /* param_value_size_ret */);
  337. /* Flush and Finish APIs */
  338. #define clFlush aclFlush
  339. cl_int
  340. (*aclFlush)(cl_command_queue /* command_queue */);
  342. #define clFinish aclFinish
  343. cl_int
  344. (*aclFinish)(cl_command_queue /* command_queue */);
  346. /* Enqueued Commands APIs */
  347. #define clEnqueueReadBuffer aclEnqueueReadBuffer
  348. cl_int
  349. (*aclEnqueueReadBuffer)(cl_command_queue    /* command_queue */,
  350.                         cl_mem              /* buffer */,
  351.                         cl_bool             /* blocking_read */,
  352.                         size_t              /* offset */,
  353.                         size_t              /* size */,
  354.                         void *              /* ptr */,
  355.                         cl_uint             /* num_events_in_wait_list */,
  356.                         const cl_event *    /* event_wait_list */,
  357.                         cl_event *          /* event */);
  359. #define clEnqueueReadBufferRect aclEnqueueReadBufferRect
  360. cl_int
  361. (*aclEnqueueReadBufferRect)(cl_command_queue    /* command_queue */,
  362.                             cl_mem              /* buffer */,
  363.                             cl_bool             /* blocking_read */,
  364.                             const size_t *      /* buffer_offset */,
  365.                             const size_t *      /* host_offset */,
  366.                             const size_t *      /* region */,
  367.                             size_t              /* buffer_row_pitch */,
  368.                             size_t              /* buffer_slice_pitch */,
  369.                             size_t              /* host_row_pitch */,
  370.                             size_t              /* host_slice_pitch */,
  371.                             void *              /* ptr */,
  372.                             cl_uint             /* num_events_in_wait_list */,
  373.                             const cl_event *    /* event_wait_list */,
  374.                             cl_event *          /* event */);
  376. #define clEnqueueWriteBuffer aclEnqueueWriteBuffer
  377. cl_int
  378. (*aclEnqueueWriteBuffer)(cl_command_queue   /* command_queue */,
  379.                          cl_mem             /* buffer */,
  380.                          cl_bool            /* blocking_write */,
  381.                          size_t             /* offset */,
  382.                          size_t             /* size */,
  383.                          const void *       /* ptr */,
  384.                          cl_uint            /* num_events_in_wait_list */,
  385.                          const cl_event *   /* event_wait_list */,
  386.                          cl_event *         /* event */);
  388. #define clEnqueueWriteBufferRect aclEnqueueWriteBufferRect
  389. cl_int
  390. (*aclEnqueueWriteBufferRect)(cl_command_queue    /* command_queue */,
  391.                              cl_mem              /* buffer */,
  392.                              cl_bool             /* blocking_write */,
  393.                              const size_t *      /* buffer_offset */,
  394.                              const size_t *      /* host_offset */,
  395.                              const size_t *      /* region */,
  396.                              size_t              /* buffer_row_pitch */,
  397.                              size_t              /* buffer_slice_pitch */,
  398.                              size_t              /* host_row_pitch */,
  399.                              size_t              /* host_slice_pitch */,
  400.                              const void *        /* ptr */,
  401.                              cl_uint             /* num_events_in_wait_list */,
  402.                              const cl_event *    /* event_wait_list */,
  403.                              cl_event *          /* event */);
  405. #define clEnqueueCopyBuffer aclEnqueueCopyBuffer
  406. cl_int
  407. (*aclEnqueueCopyBuffer)(cl_command_queue    /* command_queue */,
  408.                         cl_mem              /* src_buffer */,
  409.                         cl_mem              /* dst_buffer */,
  410.                         size_t              /* src_offset */,
  411.                         size_t              /* dst_offset */,
  412.                         size_t              /* size */,
  413.                         cl_uint             /* num_events_in_wait_list */,
  414.                         const cl_event *    /* event_wait_list */,
  415.                         cl_event *          /* event */);
  417. #define clEnqueueCopyBufferRect aclEnqueueCopyBufferRect
  418. cl_int
  419. (*aclEnqueueCopyBufferRect)(cl_command_queue    /* command_queue */,
  420.                             cl_mem              /* src_buffer */,
  421.                             cl_mem              /* dst_buffer */,
  422.                             const size_t *      /* src_origin */,
  423.                             const size_t *      /* dst_origin */,
  424.                             const size_t *      /* region */,
  425.                             size_t              /* src_row_pitch */,
  426.                             size_t              /* src_slice_pitch */,
  427.                             size_t              /* dst_row_pitch */,
  428.                             size_t              /* dst_slice_pitch */,
  429.                             cl_uint             /* num_events_in_wait_list */,
  430.                             const cl_event *    /* event_wait_list */,
  431.                             cl_event *          /* event */);
  433. #define clEnqueueReadImage aclEnqueueReadImage
  434. cl_int
  435. (*aclEnqueueReadImage)(cl_command_queue     /* command_queue */,
  436.                        cl_mem               /* image */,
  437.                        cl_bool              /* blocking_read */,
  438.                        const size_t *       /* origin[3] */,
  439.                        const size_t *       /* region[3] */,
  440.                        size_t               /* row_pitch */,
  441.                        size_t               /* slice_pitch */,
  442.                        void *               /* ptr */,
  443.                        cl_uint              /* num_events_in_wait_list */,
  444.                        const cl_event *     /* event_wait_list */,
  445.                        cl_event *           /* event */);
  447. #define clEnqueueWriteImage aclEnqueueWriteImage
  448. cl_int
  449. (*aclEnqueueWriteImage)(cl_command_queue    /* command_queue */,
  450.                         cl_mem              /* image */,
  451.                         cl_bool             /* blocking_write */,
  452.                         const size_t *      /* origin[3] */,
  453.                         const size_t *      /* region[3] */,
  454.                         size_t              /* input_row_pitch */,
  455.                         size_t              /* input_slice_pitch */,
  456.                         const void *        /* ptr */,
  457.                         cl_uint             /* num_events_in_wait_list */,
  458.                         const cl_event *    /* event_wait_list */,
  459.                         cl_event *          /* event */);
  461. #define clEnqueueCopyImage aclEnqueueCopyImage
  462. cl_int
  463. (*aclEnqueueCopyImage)(cl_command_queue     /* command_queue */,
  464.                        cl_mem               /* src_image */,
  465.                        cl_mem               /* dst_image */,
  466.                        const size_t *       /* src_origin[3] */,
  467.                        const size_t *       /* dst_origin[3] */,
  468.                        const size_t *       /* region[3] */,
  469.                        cl_uint              /* num_events_in_wait_list */,
  470.                        const cl_event *     /* event_wait_list */,
  471.                        cl_event *           /* event */);
  473. #define clEnqueueCopyImageToBuffer aclEnqueueCopyImageToBuffer
  474. cl_int
  475. (*aclEnqueueCopyImageToBuffer)(cl_command_queue /* command_queue */,
  476.                                cl_mem           /* src_image */,
  477.                                cl_mem           /* dst_buffer */,
  478.                                const size_t *   /* src_origin[3] */,
  479.                                const size_t *   /* region[3] */,
  480.                                size_t           /* dst_offset */,
  481.                                cl_uint          /* num_events_in_wait_list */,
  482.                                const cl_event * /* event_wait_list */,
  483.                                cl_event *       /* event */);
  485. #define clEnqueueCopyBufferToImage aclEnqueueCopyBufferToImage
  486. cl_int
  487. (*aclEnqueueCopyBufferToImage)(cl_command_queue /* command_queue */,
  488.                                cl_mem           /* src_buffer */,
  489.                                cl_mem           /* dst_image */,
  490.                                size_t           /* src_offset */,
  491.                                const size_t *   /* dst_origin[3] */,
  492.                                const size_t *   /* region[3] */,
  493.                                cl_uint          /* num_events_in_wait_list */,
  494.                                const cl_event * /* event_wait_list */,
  495.                                cl_event *       /* event */);
  497. void *
  498. (*aclEnqueueMapBuffer)(cl_command_queue /* command_queue */,
  499.                        cl_mem           /* buffer */,
  500.                        cl_bool          /* blocking_map */,
  501.                        cl_map_flags     /* map_flags */,
  502.                        size_t           /* offset */,
  503.                        size_t           /* size */,
  504.                        cl_uint          /* num_events_in_wait_list */,
  505.                        const cl_event * /* event_wait_list */,
  506.                        cl_event *       /* event */,
  507.                        cl_int *         /* errcode_ret */);
  509. void *
  510. (*aclEnqueueMapImage)(cl_command_queue  /* command_queue */,
  511.                       cl_mem            /* image */,
  512.                       cl_bool           /* blocking_map */,
  513.                       cl_map_flags      /* map_flags */,
  514.                       const size_t *    /* origin[3] */,
  515.                       const size_t *    /* region[3] */,
  516.                       size_t *          /* image_row_pitch */,
  517.                       size_t *          /* image_slice_pitch */,
  518.                       cl_uint           /* num_events_in_wait_list */,
  519.                       const cl_event *  /* event_wait_list */,
  520.                       cl_event *        /* event */,
  521.                       cl_int *          /* errcode_ret */);
  523. #define clEnqueueUnmapMemObject aclEnqueueUnmapMemObject
  524. cl_int
  525. (*aclEnqueueUnmapMemObject)(cl_command_queue /* command_queue */,
  526.                             cl_mem           /* memobj */,
  527.                             void *           /* mapped_ptr */,
  528.                             cl_uint          /* num_events_in_wait_list */,
  529.                             const cl_event *  /* event_wait_list */,
  530.                             cl_event *        /* event */);
  532. #define clEnqueueNDRangeKernel aclEnqueueNDRangeKernel
  533. cl_int
  534. (*aclEnqueueNDRangeKernel)(cl_command_queue /* command_queue */,
  535.                            cl_kernel        /* kernel */,
  536.                            cl_uint          /* work_dim */,
  537.                            const size_t *   /* global_work_offset */,
  538.                            const size_t *   /* global_work_size */,
  539.                            const size_t *   /* local_work_size */,
  540.                            cl_uint          /* num_events_in_wait_list */,
  541.                            const cl_event * /* event_wait_list */,
  542.                            cl_event *       /* event */);
  544. #define clEnqueueTask aclEnqueueTask
  545. cl_int
  546. (*aclEnqueueTask)(cl_command_queue  /* command_queue */,
  547.                   cl_kernel         /* kernel */,
  548.                   cl_uint           /* num_events_in_wait_list */,
  549.                   const cl_event *  /* event_wait_list */,
  550.                   cl_event *        /* event */);
  552. #define clEnqueueNativeKernel aclEnqueueNativeKernel
  553. cl_int
  554. (*aclEnqueueNativeKernel)(cl_command_queue  /* command_queue */,
  555.                           void (CL_CALLBACK * /*user_func*/)(void *),
  556.                           void *            /* args */,
  557.                           size_t            /* cb_args */,
  558.                           cl_uint           /* num_mem_objects */,
  559.                           const cl_mem *    /* mem_list */,
  560.                           const void **     /* args_mem_loc */,
  561.                           cl_uint           /* num_events_in_wait_list */,
  562.                           const cl_event *  /* event_wait_list */,
  563.                           cl_event *        /* event */);
  565. #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS
  566. //#warning CL_USE_DEPRECATED_OPENCL_1_0_APIS is defined. These APIs are unsupported and untested in OpenCL 1.1!
  567.     /*
  568.      *  WARNING:
  569.      *     This API introduces mutable state into the OpenCL implementation. It has been REMOVED
  570.      *  to better facilitate thread safety.  The 1.0 API is not thread safe. It is not tested by the
  571.      *  OpenCL 1.1 conformance test, and consequently may not work or may not work dependably.
  572.      *  It is likely to be non-performant. Use of this API is not advised. Use at your own risk.
  573.      *
  574.      *  Software developers previously relying on this API are instructed to set the command queue
  575.      *  properties when creating the queue, instead.
  576.      */
  577. #define clSetCommandQueueProperty aclSetCommandQueueProperty
  578.  cl_int
  579. (*aclSetCommandQueueProperty)(cl_command_queue              /* command_queue */,
  580.                               cl_command_queue_properties   /* properties */,
  581.                               cl_bool                        /* enable */,
  582.                               cl_command_queue_properties * /* old_properties */);
  583. #endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */
  585. #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS
  586. #define clCreateImage2D aclCreateImage2D
  587.  cl_mem
  588. (*aclCreateImage2D)(cl_context              /* context */,
  589.                     cl_mem_flags            /* flags */,
  590.                     const cl_image_format * /* image_format */,
  591.                     size_t                  /* image_width */,
  592.                     size_t                  /* image_height */,
  593.                     size_t                  /* image_row_pitch */,
  594.                     void *                  /* host_ptr */,
  595.                     cl_int *                /* errcode_ret */);
  597. #define clCreateImage3D aclCreateImage3D
  598.  cl_mem
  599. (*aclCreateImage3D)(cl_context              /* context */,
  600.                     cl_mem_flags            /* flags */,
  601.                     const cl_image_format * /* image_format */,
  602.                     size_t                  /* image_width */,
  603.                     size_t                  /* image_height */,
  604.                     size_t                  /* image_depth */,
  605.                     size_t                  /* image_row_pitch */,
  606.                     size_t                  /* image_slice_pitch */,
  607.                     void *                  /* host_ptr */,
  608.                     cl_int *                /* errcode_ret */);
  610. #define clEnqueueMarker aclEnqueueMarker
  611.  cl_int
  612. (*aclEnqueueMarker)(cl_command_queue    /* command_queue */,
  613.                     cl_event *          /* event */);
  615. #define clEnqueueWaitForEvents aclEnqueueWaitForEvents
  616.  cl_int
  617. (*aclEnqueueWaitForEvents)(cl_command_queue /* command_queue */,
  618.                            cl_uint          /* num_events */,
  619.                            const cl_event * /* event_list */);
  621. #define clEnqueueBarrier aclEnqueueBarrier
  622.  cl_int
  623. (*aclEnqueueBarrier)(cl_command_queue /* command_queue */);
  625. #define clUnloadCompiler aclUnloadCompiler
  626.  cl_int
  627. (*aclUnloadCompiler)(void);
  629. void *
  630. (*aclGetExtensionFunctionAddress)(const char * /* func_name */);
  631. #endif
  633. #ifdef __cplusplus
  634. }
  635. #endif
  637. #endif  /* __AOPENCL_CL_H */

dlopencl.cpp

根据实际情况自行修改 so_path 的路径

  1. #define CL_TARGET_OPENCL_VERSION 120
  2. #include "CL/cl.h"
  3. #include <dlfcn.h>
  4. #include <cstdio>
  5. #include <string.h>
  6. #include "dlopencl.h"
  8. int loadedCL;
  10. void *getCLHandle() {
  11.     LOGD("get_handle");
  12.     void *res = nullptr;
  13.     char *so_path = (char*)"/system/vendor/lib64/egl/libGLES_mali.so";
  14.     res = dlopen(so_path, RTLD_LAZY);
  16.     if (res == nullptr) {
  17.         LOGD("Open library failed");
  18.     } else {
  19.         LOGD("Loaded library name: [%s]", so_path);
  20.     }
  22.     return res;
  23. }
  25. void initFns() {
  26.     loadedCL = 0;
  27.     void *handle = getCLHandle();
  28.     if (handle == nullptr) return;
  30. /* Platform API */
  31.     IAH();
  32.     aclGetPlatformIDs = (cl_int  (*)(cl_uint          /* num_entries */,
  33.                                      cl_platform_id * /* platforms */,
  34.                                      cl_uint *        /* num_platforms */)) dlsym(handle, "clGetPlatformIDs");
  36.     IAH();
  37.     aclGetPlatformInfo = (cl_int   (*)(cl_platform_id   /* platform */,
  38.                                        cl_platform_info /* param_name */,
  39.                                        size_t           /* param_value_size */,
  40.                                        void *           /* param_value */,
  41.                                        size_t *         /* param_value_size_ret */)) dlsym(handle, "clGetPlatformInfo");
  43. /* Device APIs */
  44.     IAH();
  45.     aclGetDeviceIDs = (cl_int  (*)(cl_platform_id   /* platform */,
  46.                                    cl_device_type   /* device_type */,
  47.                                    cl_uint          /* num_entries */,
  48.                                    cl_device_id *   /* devices */,
  49.                                    cl_uint *        /* num_devices */)) dlsym(handle, "clGetDeviceIDs");
  51.     IAH();
  52.     aclGetDeviceInfo = (cl_int  (*)(cl_device_id    /* device */,
  53.                                     cl_device_info  /* param_name */,
  54.                                     size_t          /* param_value_size */,
  55.                                     void *          /* param_value */,
  56.                                     size_t *        /* param_value_size_ret */)) dlsym(handle, "clGetDeviceInfo");
  58. /* Context APIs  */
  59.     IAH();
  60.     aclCreateContext = (cl_context  (*)(const cl_context_properties * /* properties */,
  61.     cl_uint                 /* num_devices */,
  62.     const cl_device_id *    /* devices */,
  63.     void (CL_CALLBACK *     /* pfn_notify */)(const char *, const void *, size_t, void *),
  64.     void *                  /* user_data */,
  65.     cl_int *                /* errcode_ret */)) dlsym(handle, "clCreateContext");
  67.     IAH();
  68.     aclCreateContextFromType = (cl_context  (*)(const cl_context_properties * /* properties */,
  69.     cl_device_type          /* device_type */,
  70.     void (CL_CALLBACK *     /* pfn_notify*/ )(const char *, const void *, size_t, void *),
  71.     void *                  /* user_data */,
  72.     cl_int *                /* errcode_ret */)) dlsym(handle, "clCreateContextFromType");
  74.     IAH();
  75.     aclRetainContext = (cl_int  (*)(cl_context /* context */)) dlsym(handle, "clRetainContext");
  77.     IAH();
  78.     aclReleaseContext = (cl_int  (*)(cl_context /* context */)) dlsym(handle, "clReleaseContext");
  80.     IAH();
  81.     aclGetContextInfo = (cl_int  (*)(cl_context         /* context */,
  82.                                      cl_context_info    /* param_name */,
  83.                                      size_t             /* param_value_size */,
  84.                                      void *             /* param_value */,
  85.                                      size_t *           /* param_value_size_ret */)) dlsym(handle, "clGetContextInfo");
  87. /* Command Queue APIs */
  88.     IAH();
  89.     aclCreateCommandQueue = (cl_command_queue  (*)(cl_context                     /* context */,
  90.                                                    cl_device_id                   /* device */,
  91.                                                    cl_command_queue_properties    /* properties */,
  92.                                                    cl_int *                       /* errcode_ret */)) dlsym(handle, "clCreateCommandQueue");
  94.     IAH();
  95.     aclRetainCommandQueue = (cl_int  (*)(cl_command_queue /* command_queue */)) dlsym(handle, "clRetainCommandQueue");
  97.     IAH();
  98.     aclReleaseCommandQueue = (cl_int  (*)(cl_command_queue /* command_queue */)) dlsym(handle, "clReleaseCommandQueue");
  100.     IAH();
  101.     aclGetCommandQueueInfo = (cl_int  (*)(cl_command_queue      /* command_queue */,
  102.                                           cl_command_queue_info /* param_name */,
  103.                                           size_t                /* param_value_size */,
  104.                                           void *                /* param_value */,
  105.                                           size_t *              /* param_value_size_ret */)) dlsym(handle, "clGetCommandQueueInfo");
  107. /* Memory Object APIs */
  108.     IAH();
  109.     aclCreateBuffer = (cl_mem  (*)(cl_context   /* context */,
  110.                                    cl_mem_flags /* flags */,
  111.                                    size_t       /* size */,
  112.                                    void *       /* host_ptr */,
  113.                                    cl_int *     /* errcode_ret */)) dlsym(handle, "clCreateBuffer");
  115.     IAH();
  116.     aclCreateSubBuffer = (cl_mem  (*)(cl_mem                   /* buffer */,
  117.                                       cl_mem_flags             /* flags */,
  118.                                       cl_buffer_create_type    /* buffer_create_type */,
  119.                                       const void *             /* buffer_create_info */,
  120.                                       cl_int *                 /* errcode_ret */)) dlsym(handle, "clCreateSubBuffer");
  122.     IAH();
  123.     aclRetainMemObject = (cl_int  (*)(cl_mem /* memobj */)) dlsym(handle, "clRetainMemObject");
  125.     IAH();
  126.     aclReleaseMemObject = (cl_int  (*)(cl_mem /* memobj */)) dlsym(handle, "clReleaseMemObject");
  128.     IAH();
  129.     aclGetSupportedImageFormats = (cl_int  (*)(cl_context           /* context */,
  130.                                                cl_mem_flags         /* flags */,
  131.                                                cl_mem_object_type   /* image_type */,
  132.                                                cl_uint              /* num_entries */,
  133.                                                cl_image_format *    /* image_formats */,
  134.                                                cl_uint *            /* num_image_formats */)) dlsym(handle, "clGetSupportedImageFormats");
  136.     IAH();
  137.     aclGetMemObjectInfo = (cl_int  (*)(cl_mem           /* memobj */,
  138.                                        cl_mem_info      /* param_name */,
  139.                                        size_t           /* param_value_size */,
  140.                                        void *           /* param_value */,
  141.                                        size_t *         /* param_value_size_ret */)) dlsym(handle, "clGetMemObjectInfo");
  143.     IAH();
  144.     aclGetImageInfo = (cl_int  (*)(cl_mem           /* image */,
  145.                                    cl_image_info    /* param_name */,
  146.                                    size_t           /* param_value_size */,
  147.                                    void *           /* param_value */,
  148.                                    size_t *         /* param_value_size_ret */)) dlsym(handle, "clGetImageInfo");
  150.     IAH();
  151.     aclSetMemObjectDestructorCallback = (cl_int  (*)(  cl_mem /* memobj */,
  152.                                                        void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/),
  153.             void * /*user_data */ )) dlsym(handle, "clSetMemObjectDestructorCallback");
  155. /* Sampler APIs */
  156.     IAH();
  157.     aclCreateSampler = (cl_sampler  (*)(cl_context          /* context */,
  158.                                         cl_bool             /* normalized_coords */,
  159.                                         cl_addressing_mode  /* addressing_mode */,
  160.                                         cl_filter_mode      /* filter_mode */,
  161.                                         cl_int *            /* errcode_ret */)) dlsym(handle, "clCreateSampler");
  163.     IAH();
  164.     aclRetainSampler = (cl_int  (*)(cl_sampler /* sampler */)) dlsym(handle, "clRetainSampler");
  166.     IAH();
  167.     aclReleaseSampler = (cl_int  (*)(cl_sampler /* sampler */)) dlsym(handle, "clReleaseSampler");
  169.     IAH();
  170.     aclGetSamplerInfo = (cl_int  (*)(cl_sampler         /* sampler */,
  171.                                      cl_sampler_info    /* param_name */,
  172.                                      size_t             /* param_value_size */,
  173.                                      void *             /* param_value */,
  174.                                      size_t *           /* param_value_size_ret */)) dlsym(handle, "clGetSamplerInfo");
  176. /* Program Object APIs  */
  177.     IAH();
  178.     aclCreateProgramWithSource = (cl_program  (*)(cl_context        /* context */,
  179.                                                   cl_uint           /* count */,
  180.                                                   const char **     /* strings */,
  181.                                                   const size_t *    /* lengths */,
  182.                                                   cl_int *          /* errcode_ret */)) dlsym(handle, "clCreateProgramWithSource");
  184.     IAH();
  185.     aclCreateProgramWithBinary = (cl_program  (*)(cl_context                /* context */,
  186.                                                   cl_uint                   /* num_devices */,
  187.                                                   const cl_device_id *      /* device_list */,
  188.                                                   const size_t *            /* lengths */,
  189.                                                   const unsigned char **    /* binaries */,
  190.                                                   cl_int *                  /* binary_status */,
  191.                                                   cl_int *                  /* errcode_ret */)) dlsym(handle, "clCreateProgramWithBinary");
  193.     IAH();
  194.     aclRetainProgram = (cl_int  (*)(cl_program /* program */)) dlsym(handle, "clRetainProgram");
  196.     IAH();
  197.     aclReleaseProgram = (cl_int  (*)(cl_program /* program */)) dlsym(handle, "clReleaseProgram");
  199.     IAH();
  200.     aclBuildProgram = (cl_int  (*)(cl_program           /* program */,
  201.                                    cl_uint              /* num_devices */,
  202.     const cl_device_id * /* device_list */,
  203.     const char *         /* options */,
  204.     void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */),
  205.     void *               /* user_data */)) dlsym(handle, "clBuildProgram");
  207.     IAH();
  208.     aclGetProgramInfo = (cl_int  (*)(cl_program         /* program */,
  209.                                      cl_program_info    /* param_name */,
  210.                                      size_t             /* param_value_size */,
  211.                                      void *             /* param_value */,
  212.                                      size_t *           /* param_value_size_ret */)) dlsym(handle, "clGetProgramInfo");
  214.     IAH();
  215.     aclGetProgramBuildInfo = (cl_int  (*)(cl_program            /* program */,
  216.                                           cl_device_id          /* device */,
  217.                                           cl_program_build_info /* param_name */,
  218.                                           size_t                /* param_value_size */,
  219.                                           void *                /* param_value */,
  220.                                           size_t *              /* param_value_size_ret */)) dlsym(handle, "clGetProgramBuildInfo");
  222. /* Kernel Object APIs */
  223.     IAH();
  224.     aclCreateKernel = (cl_kernel  (*)(cl_program      /* program */,
  225.                                       const char *    /* kernel_name */,
  226.                                       cl_int *        /* errcode_ret */)) dlsym(handle, "clCreateKernel");
  228.     IAH();
  229.     aclCreateKernelsInProgram = (cl_int  (*)(cl_program     /* program */,
  230.                                              cl_uint        /* num_kernels */,
  231.                                              cl_kernel *    /* kernels */,
  232.                                              cl_uint *      /* num_kernels_ret */)) dlsym(handle, "clCreateKernelsInProgram");
  234.     IAH();
  235.     aclRetainKernel = (cl_int  (*)(cl_kernel    /* kernel */)) dlsym(handle, "clRetainKernel");
  237.     IAH();
  238.     aclReleaseKernel = (cl_int  (*)(cl_kernel   /* kernel */)) dlsym(handle, "clReleaseKernel");
  240.     IAH();
  241.     aclSetKernelArg = (cl_int  (*)(cl_kernel    /* kernel */,
  242.                                    cl_uint      /* arg_index */,
  243.                                    size_t       /* arg_size */,
  244.                                    const void * /* arg_value */)) dlsym(handle, "clSetKernelArg");
  246.     IAH();
  247.     aclGetKernelInfo = (cl_int  (*)(cl_kernel       /* kernel */,
  248.                                     cl_kernel_info  /* param_name */,
  249.                                     size_t          /* param_value_size */,
  250.                                     void *          /* param_value */,
  251.                                     size_t *        /* param_value_size_ret */)) dlsym(handle, "clGetKernelInfo");
  253.     IAH();
  254.     aclGetKernelWorkGroupInfo = (cl_int  (*)(cl_kernel                  /* kernel */,
  255.                                              cl_device_id               /* device */,
  256.                                              cl_kernel_work_group_info  /* param_name */,
  257.                                              size_t                     /* param_value_size */,
  258.                                              void *                     /* param_value */,
  259.                                              size_t *                   /* param_value_size_ret */)) dlsym(handle, "clGetKernelWorkGroupInfo");
  261. /* Event Object APIs */
  262.     IAH();
  263.     aclWaitForEvents = (cl_int  (*)(cl_uint             /* num_events */,
  264.                                     const cl_event *    /* event_list */)) dlsym(handle, "clWaitForEvents");
  266.     IAH();
  267.     aclGetEventInfo = (cl_int  (*)(cl_event         /* event */,
  268.                                    cl_event_info    /* param_name */,
  269.                                    size_t           /* param_value_size */,
  270.                                    void *           /* param_value */,
  271.                                    size_t *         /* param_value_size_ret */)) dlsym(handle, "clGetEventInfo");
  273.     IAH();
  274.     aclCreateUserEvent = (cl_event  (*)(cl_context    /* context */,
  275.                                         cl_int *      /* errcode_ret */)) dlsym(handle, "clCreateUserEvent");
  277.     IAH();
  278.     aclRetainEvent = (cl_int  (*)(cl_event /* event */)) dlsym(handle, "clRetainEvent");
  280.     IAH();
  281.     aclReleaseEvent = (cl_int  (*)(cl_event /* event */)) dlsym(handle, "clReleaseEvent");
  283.     IAH();
  284.     aclSetUserEventStatus = (cl_int  (*)(cl_event   /* event */,
  285.                                          cl_int     /* execution_status */)) dlsym(handle, "clSetUserEventStatus");
  287.     IAH();
  288.     aclSetEventCallback = (cl_int  (*)( cl_event    /* event */,
  289.                                         cl_int      /* command_exec_callback_type */,
  290.                                         void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *),
  291.             void *      /* user_data */)) dlsym(handle, "clSetEventCallback");
  293. /* Profiling APIs */
  294.     IAH();
  295.     aclGetEventProfilingInfo = (cl_int  (*)(cl_event            /* event */,
  296.                                             cl_profiling_info   /* param_name */,
  297.                                             size_t              /* param_value_size */,
  298.                                             void *              /* param_value */,
  299.                                             size_t *            /* param_value_size_ret */)) dlsym(handle, "clGetEventProfilingInfo");
  301. /* Flush and Finish APIs */
  302.     IAH();
  303.     aclFlush = (cl_int  (*)(cl_command_queue /* command_queue */)) dlsym(handle, "clFlush");
  305.     IAH();
  306.     aclFinish = (cl_int  (*)(cl_command_queue /* command_queue */)) dlsym(handle, "clFinish");
  308. /* Enqueued Commands APIs */
  309.     IAH();
  310.     aclEnqueueReadBuffer = (cl_int  (*)(cl_command_queue    /* command_queue */,
  311.                                         cl_mem              /* buffer */,
  312.                                         cl_bool             /* blocking_read */,
  313.                                         size_t              /* offset */,
  314.                                         size_t              /* size */,
  315.                                         void *              /* ptr */,
  316.                                         cl_uint             /* num_events_in_wait_list */,
  317.                                         const cl_event *    /* event_wait_list */,
  318.                                         cl_event *          /* event */)) dlsym(handle, "clEnqueueReadBuffer");
  320.     IAH();
  321.     aclEnqueueReadBufferRect = (cl_int  (*)(cl_command_queue    /* command_queue */,
  322.                                             cl_mem              /* buffer */,
  323.                                             cl_bool             /* blocking_read */,
  324.                                             const size_t *      /* buffer_offset */,
  325.                                             const size_t *      /* host_offset */,
  326.                                             const size_t *      /* region */,
  327.                                             size_t              /* buffer_row_pitch */,
  328.                                             size_t              /* buffer_slice_pitch */,
  329.                                             size_t              /* host_row_pitch */,
  330.                                             size_t              /* host_slice_pitch */,
  331.                                             void *              /* ptr */,
  332.                                             cl_uint             /* num_events_in_wait_list */,
  333.                                             const cl_event *    /* event_wait_list */,
  334.                                             cl_event *          /* event */)) dlsym(handle, "clEnqueueReadBufferRect");
  336.     IAH();
  337.     aclEnqueueWriteBuffer = (cl_int  (*)(cl_command_queue   /* command_queue */,
  338.                                          cl_mem             /* buffer */,
  339.                                          cl_bool            /* blocking_write */,
  340.                                          size_t             /* offset */,
  341.                                          size_t             /* size */,
  342.                                          const void *       /* ptr */,
  343.                                          cl_uint            /* num_events_in_wait_list */,
  344.                                          const cl_event *   /* event_wait_list */,
  345.                                          cl_event *         /* event */)) dlsym(handle, "clEnqueueWriteBuffer");
  347.     IAH();
  348.     aclEnqueueWriteBufferRect = (cl_int  (*)(cl_command_queue    /* command_queue */,
  349.                                              cl_mem              /* buffer */,
  350.                                              cl_bool             /* blocking_write */,
  351.                                              const size_t *      /* buffer_offset */,
  352.                                              const size_t *      /* host_offset */,
  353.                                              const size_t *      /* region */,
  354.                                              size_t              /* buffer_row_pitch */,
  355.                                              size_t              /* buffer_slice_pitch */,
  356.                                              size_t              /* host_row_pitch */,
  357.                                              size_t              /* host_slice_pitch */,
  358.                                              const void *        /* ptr */,
  359.                                              cl_uint             /* num_events_in_wait_list */,
  360.                                              const cl_event *    /* event_wait_list */,
  361.                                              cl_event *          /* event */)) dlsym(handle, "clEnqueueWriteBufferRect");
  363.     IAH();
  364.     aclEnqueueCopyBuffer = (cl_int  (*)(cl_command_queue    /* command_queue */,
  365.                                         cl_mem              /* src_buffer */,
  366.                                         cl_mem              /* dst_buffer */,
  367.                                         size_t              /* src_offset */,
  368.                                         size_t              /* dst_offset */,
  369.                                         size_t              /* size */,
  370.                                         cl_uint             /* num_events_in_wait_list */,
  371.                                         const cl_event *    /* event_wait_list */,
  372.                                         cl_event *          /* event */)) dlsym(handle, "clEnqueueCopyBuffer");
  374.     IAH();
  375.     aclEnqueueCopyBufferRect = (cl_int  (*)(cl_command_queue    /* command_queue */,
  376.                                             cl_mem              /* src_buffer */,
  377.                                             cl_mem              /* dst_buffer */,
  378.                                             const size_t *      /* src_origin */,
  379.                                             const size_t *      /* dst_origin */,
  380.                                             const size_t *      /* region */,
  381.                                             size_t              /* src_row_pitch */,
  382.                                             size_t              /* src_slice_pitch */,
  383.                                             size_t              /* dst_row_pitch */,
  384.                                             size_t              /* dst_slice_pitch */,
  385.                                             cl_uint             /* num_events_in_wait_list */,
  386.                                             const cl_event *    /* event_wait_list */,
  387.                                             cl_event *          /* event */)) dlsym(handle, "clEnqueueCopyBufferRect");
  389.     IAH();
  390.     aclEnqueueReadImage = (cl_int  (*)(cl_command_queue     /* command_queue */,
  391.                                        cl_mem               /* image */,
  392.                                        cl_bool              /* blocking_read */,
  393.                                        const size_t *       /* origin[3] */,
  394.                                        const size_t *       /* region[3] */,
  395.                                        size_t               /* row_pitch */,
  396.                                        size_t               /* slice_pitch */,
  397.                                        void *               /* ptr */,
  398.                                        cl_uint              /* num_events_in_wait_list */,
  399.                                        const cl_event *     /* event_wait_list */,
  400.                                        cl_event *           /* event */)) dlsym(handle, "clEnqueueReadImage");
  402.     IAH();
  403.     aclEnqueueWriteImage = (cl_int  (*)(cl_command_queue    /* command_queue */,
  404.                                         cl_mem              /* image */,
  405.                                         cl_bool             /* blocking_write */,
  406.                                         const size_t *      /* origin[3] */,
  407.                                         const size_t *      /* region[3] */,
  408.                                         size_t              /* input_row_pitch */,
  409.                                         size_t              /* input_slice_pitch */,
  410.                                         const void *        /* ptr */,
  411.                                         cl_uint             /* num_events_in_wait_list */,
  412.                                         const cl_event *    /* event_wait_list */,
  413.                                         cl_event *          /* event */)) dlsym(handle, "clEnqueueWriteImage");
  415.     IAH();
  416.     aclEnqueueCopyImage = (cl_int  (*)(cl_command_queue     /* command_queue */,
  417.                                        cl_mem               /* src_image */,
  418.                                        cl_mem               /* dst_image */,
  419.                                        const size_t *       /* src_origin[3] */,
  420.                                        const size_t *       /* dst_origin[3] */,
  421.                                        const size_t *       /* region[3] */,
  422.                                        cl_uint              /* num_events_in_wait_list */,
  423.                                        const cl_event *     /* event_wait_list */,
  424.                                        cl_event *           /* event */)) dlsym(handle, "clEnqueueCopyImage");
  426.     IAH();
  427.     aclEnqueueCopyImageToBuffer = (cl_int  (*)(cl_command_queue /* command_queue */,
  428.                                                cl_mem           /* src_image */,
  429.                                                cl_mem           /* dst_buffer */,
  430.                                                const size_t *   /* src_origin[3] */,
  431.                                                const size_t *   /* region[3] */,
  432.                                                size_t           /* dst_offset */,
  433.                                                cl_uint          /* num_events_in_wait_list */,
  434.                                                const cl_event * /* event_wait_list */,
  435.                                                cl_event *       /* event */)) dlsym(handle, "clEnqueueCopyImageToBuffer");
  437.     IAH();
  438.     aclEnqueueCopyBufferToImage = (cl_int  (*)(cl_command_queue /* command_queue */,
  439.                                                cl_mem           /* src_buffer */,
  440.                                                cl_mem           /* dst_image */,
  441.                                                size_t           /* src_offset */,
  442.                                                const size_t *   /* dst_origin[3] */,
  443.                                                const size_t *   /* region[3] */,
  444.                                                cl_uint          /* num_events_in_wait_list */,
  445.                                                const cl_event * /* event_wait_list */,
  446.                                                cl_event *       /* event */)) dlsym(handle, "clEnqueueCopyBufferToImage");
  448.     #if 0
  449.     void *
  450. (*aclEnqueueMapBuffer)(cl_command_queue /* command_queue */,
  451.                    cl_mem           /* buffer */,
  452.                    cl_bool          /* blocking_map */,
  453.                    cl_map_flags     /* map_flags */,
  454.                    size_t           /* offset */,
  455.                    size_t           /* size */,
  456.                    cl_uint          /* num_events_in_wait_list */,
  457.                    const cl_event * /* event_wait_list */,
  458.                    cl_event *       /* event */,
  459.                    cl_int *         /* errcode_ret */)) dlsym(handle,"");
  461. void *
  462. (*aclEnqueueMapImage)(cl_command_queue  /* command_queue */,
  463.                   cl_mem            /* image */,
  464.                   cl_bool           /* blocking_map */,
  465.                   cl_map_flags      /* map_flags */,
  466.                   const size_t *    /* origin[3] */,
  467.                   const size_t *    /* region[3] */,
  468.                   size_t *          /* image_row_pitch */,
  469.                   size_t *          /* image_slice_pitch */,
  470.                   cl_uint           /* num_events_in_wait_list */,
  471.                   const cl_event *  /* event_wait_list */,
  472.                   cl_event *        /* event */,
  473.                   cl_int *          /* errcode_ret */)) dlsym(handle,"");
  474. #endif
  476.     IAH();
  477.     aclEnqueueUnmapMemObject = (cl_int  (*)(cl_command_queue /* command_queue */,
  478.                                             cl_mem           /* memobj */,
  479.                                             void *           /* mapped_ptr */,
  480.                                             cl_uint          /* num_events_in_wait_list */,
  481.                                             const cl_event * /* event_wait_list */,
  482.                                             cl_event *       /* event */)) dlsym(handle, "clEnqueueUnmapMemObject");
  484.     IAH();
  485.     aclEnqueueNDRangeKernel = (cl_int  (*)(cl_command_queue /* command_queue */,
  486.                                            cl_kernel        /* kernel */,
  487.                                            cl_uint          /* work_dim */,
  488.                                            const size_t *   /* global_work_offset */,
  489.                                            const size_t *   /* global_work_size */,
  490.                                            const size_t *   /* local_work_size */,
  491.                                            cl_uint          /* num_events_in_wait_list */,
  492.                                            const cl_event * /* event_wait_list */,
  493.                                            cl_event *       /* event */)) dlsym(handle, "clEnqueueNDRangeKernel");
  495.     IAH();
  496.     aclEnqueueTask = (cl_int  (*)(cl_command_queue  /* command_queue */,
  497.                                   cl_kernel         /* kernel */,
  498.                                   cl_uint           /* num_events_in_wait_list */,
  499.                                   const cl_event *  /* event_wait_list */,
  500.                                   cl_event *        /* event */)) dlsym(handle, "clEnqueueTask");
  502.     IAH();
  503.     aclEnqueueNativeKernel = (cl_int  (*)(cl_command_queue      /* command_queue */,
  504.                                           void (CL_CALLBACK *   /*user_func*/)(void *),
  505.             void *            /* args */,
  506.             size_t            /* cb_args */,
  507.             cl_uint           /* num_mem_objects */,
  508.     const cl_mem *    /* mem_list */,
  509.     const void **     /* args_mem_loc */,
  510.     cl_uint           /* num_events_in_wait_list */,
  511.     const cl_event *  /* event_wait_list */,
  512.     cl_event *        /* event */)) dlsym(handle, "clEnqueueNativeKernel");
  514. #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS
  515.     //#warning CL_USE_DEPRECATED_OPENCL_1_0_APIS is defined. These APIs are unsupported and untested in OpenCL 1.1!
  516.     /*
  517.      *  WARNING:
  518.      *     This API introduces mutable state into the OpenCL implementation. It has been REMOVED
  519.      *  to better facilitate thread safety.  The 1.0 API is not thread safe. It is not tested by the
  520.      *  OpenCL 1.1 conformance test, and consequently may not work or may not work dependably.
  521.      *  It is likely to be non-performant. Use of this API is not advised. Use at your own risk.
  522.      *
  523.      *  Software developers previously relying on this API are instructed to set the command queue
  524.      *  properties when creating the queue, instead.
  525.      */
  526.  IAH();
  527.  aclSetCommandQueueProperty = (cl_int  (*)(cl_command_queue              /* command_queue */,
  528.                               cl_command_queue_properties   /* properties */,
  529.                               cl_bool                        /* enable */,
  530.                               cl_command_queue_properties * /* old_properties */)) dlsym(handle,"clSetCommandQueueProperty");
  531. #endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */
  533. #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS
  534.     IAH();
  535.  aclCreateImage2D = (cl_mem  (*)(cl_context              /* context */,
  536.                     cl_mem_flags            /* flags */,
  537.                     const cl_image_format * /* image_format */,
  538.                     size_t                  /* image_width */,
  539.                     size_t                  /* image_height */,
  540.                     size_t                  /* image_row_pitch */,
  541.                     void *                  /* host_ptr */,
  542.                     cl_int *                /* errcode_ret */)) dlsym(handle,"clCreateImage2D");
  544.  IAH();
  545.  aclCreateImage3D = (cl_mem  (*)(cl_context              /* context */,
  546.                     cl_mem_flags            /* flags */,
  547.                     const cl_image_format * /* image_format */,
  548.                     size_t                  /* image_width */,
  549.                     size_t                  /* image_height */,
  550.                     size_t                  /* image_depth */,
  551.                     size_t                  /* image_row_pitch */,
  552.                     size_t                  /* image_slice_pitch */,
  553.                     void *                  /* host_ptr */,
  554.                     cl_int *                /* errcode_ret */)) dlsym(handle,"clCreateImage3D");
  556.  IAH();
  557.  aclEnqueueMarker = (cl_int  (*)(cl_command_queue    /* command_queue */,
  558.                     cl_event *          /* event */)) dlsym(handle,"clEnqueueMarker");
  560.  IAH();
  561.  aclEnqueueWaitForEvents = (cl_int  (*)(cl_command_queue /* command_queue */,
  562.                            cl_uint          /* num_events */,
  563.                            const cl_event * /* event_list */)) dlsym(handle,"clEnqueueWaitForEvents");
  565.  IAH();
  566.  aclEnqueueBarrier = (cl_int  (*)(cl_command_queue /* command_queue */)) dlsym(handle,"clEnqueueBarrier");
  568.  IAH();
  569.  aclUnloadCompiler = (cl_int  (*)(void)) dlsym(handle,"clUnloadCompiler");
  570. #endif
  572. #if 0
  573.     void *
  574. (*aclGetExtensionFunctionAddress)(const char * /* func_name */)) dlsym(handle,"");
  576. #endif
  578.     loadedCL = 1;
  579. }

Android AARCH64 平台的 OpenCL 配置的更多相关文章

  1. Android 开发平台的演变史

    Android开发平台的发展(并不是很懂) Eclipse 首先是由IBM的一个项目小组花了两年时间开发完成的,当时主要解决IBM开发工具 Visual Age for Java 和 WebSpher ...

  2. 论文第5章：Android绘图平台的实现

    面向移动设备的矢量绘图平台设计与实现 Design and Implementation of Mobile Device-oriented Vector Drawing Platform 引用本论文 ...

  3. Android 2D游戏引擎AndEngine配置环境

    Android 2D游戏引擎AndEngine配置环境 1.2  配置环境 在任何编程中,都需要一些软件或者硬件的支持.否则,没有硬件软件是不可能存在的,而想要编写对应语言的的程序,这需要对应语言库和 ...

  4. 第三章Android移植平台工具介绍

    第三章Android移植平台工具介绍 进行 Android 移植的学习并不一定需要一款 Android 手机,但必须要有一款主流的开发板,开发板是用来进行嵌入式系统开发的电路板,包括中央处理器.存储器 ...

  5. 2018年Unity结合Android SDK下载安装及配置教程

    原文:2018年Unity结合Android SDK下载安装及配置教程 首先声明: Unity版本2017.1f3        最近试着在Unity中利用网易做AR开发时,发布项目文件需要发布到An ...

  6. 使用ndk交叉编译android各平台版本的第三方库

    只要弄明白了ndk-bundle的目录结构,交叉编译的基本原理就可以自行编写脚本去编译了.从仓库拿下代码包后,一般在linux平台下编译当前平台使用的库,只要使用其自动配置脚本configure进行平 ...

  7. Unity5.2.1上Android真机调试环境配置

    下载SDK,JDK安装,配置JAVA环境 1.下载SDK,下载adt-bundle-windows-x86_64-20131030.zip,下载地址:http://pan.baidu.com/shar ...

  8. 作业一：android开发平台的演变以及Android Studio设置

    目录:     ①. 从Eclipse到Android Studio   ②. Android Studio的下载和安装   ③. 用户习惯设置以及快捷键   ④. SDK路径重新设置 ↓点此跳转到文 ...

  9. Android SDK 国内镜像及配置方法

    东软信息学院的 Android SDK 镜像,比配置代理下载快. 配置地址, http://mirrors.neusoft.edu.cn/configurations.we#android 配置步骤: ...

随机推荐

  1. Transformer, ELMo, GPT, 到Bert

    RNN:难以并行 CNN:filter只能考虑局部的信息,要叠多层 Self-attention:可以考虑全局的信息,并且可以并行 (Attention Is All You Need) 示意图:x1 ...

  2. java8学习之收集器用法详解与多级分组和分区

    收集器用法详解: 在上次已经系统的阅读了Collector收集器的Javadoc对它已经有一个比较详细的认知了,但是!!!它毕境是只是一个接口,要使用的话还得用它的实现类,所以在Java8中有它进行了 ...

  3. Python——枚举（enum）

  4. QR分解迭代求特征值——原生python实现(不使用numpy)

    QR分解: 有很多方法可以进行QR迭代,本文使用的是Schmidt正交化方法 具体证明请参考链接 https://wenku.baidu.com/view/c2e34678168884868762d6 ...

  5. Http请求Response Code含义

    http状态返回代码 1xx(临时响应) 表示临时响应并需要请求者继续执行操作的状态代码.100 (继续) 请求者应当继续提出请求. 服务器返回此代码表示已收到请求的第一部分,正在等待其余部分.101 ...

  6. 在CentOS/Windows下配置Nginx（以及踩坑）

    在CentOS/Windows下配置Nginx(以及踩坑) 1. 序言 因为这类文章网上比较多,实际操作起来也大同小异,所以我并不会着重于详细配置方面,而是将我配置时踩的坑写出来. 2. CentOS ...

  7. python 的pip安装

    C:\Python27>C:\Python27\Scripts\pip.exe install gevent gevent是安装的模块名

  8. <label>标签的相关内容

    ㈠<label>标签的定义与用法 ⑴<label> 标签为 input 元素定义标注(标记). ⑵label 元素不会向用户呈现任何特殊效果.不过,它为鼠标用户改进了可用性.如 ...

  9. head first 设计模式笔记2-观察者模式：气象观测站

    设计原则:为了交互对象之间的松耦合设计而努力. 1.设计模式的一些理解 1)知道OO基础,并不足以让你设计出良好的OO系统 2)良好的OO设计必须具备可复用.可扩充.可维护三个特性 3)模式可以让我们 ...

  10. js获取iframe里面的dom

    最近在写页面遇到了问题,一个dom好多地方用到,然后我就单独写了个html页面,然后用iframe引入,但是,想获取iframe里面input的value,获取不到input,后面才知道原来js不能直 ...