add wrapper

Signed-off-by: xu <chenxu25@huawei.com>

BUILD.gn

@@ -11,10 +11,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-config("libOpenCL_public_config") {
+import("//build/ohos.gni")
-    include_dirs = [ "./" ]
+
+config("cl_config") {
+  cflags = [
+    "-std=c++17",
+    "-Wno-error=implicit-fallthrough",
+    "-Wno-deprecated-declarations",
+  ]
 }
 
-group("libOpenCL") {
+config("cl_public_config") {
-    public_configs = [ ":libOpenCL_public_config" ]
+  include_dirs = [
+    "./",
+    "include",
+    #"//base/hiviewdfx/hilog/interfaces/native/innerkits/include",
+  ]
 }
+
+ohos_shared_library("libcl") {
+  visibility = [ "*" ]
+  sources = [
+    "src/opencl_wrapper.cpp",
+  ]
+  configs = [ ":cl_config" ]
+  public_configs = [ ":cl_public_config" ]
+  output_name = "OpenCL"
+  output_extension = "so"
+  part_name = "opencl"
+  subsystem_name = "thirdparty"
+}

NOTICE

@@ -1,22 +0,0 @@
-Software: opencl-headers v2020.12.18
-
-Copyright (c) 2008-2020 The Khronos Group Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and /or associated documentation files (the "Materials "), to
-deal in the Materials without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Materials, and to permit persons to whom the Materials are
-furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Materials.
-
-THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE
-MATERIALS.

OAT.xml

@@ -71,7 +71,7 @@ Note:If the text contains special characters, please escape them according to th
             <filefilter name="defaultFilter" desc="Filters for compatibility, license header policies">
                 <filteritem type="filename" name="README.OpenSource"/>
                 <filteritem type="filename" name="README"/>
-                <filteritem type="filename" name="NOTICE"/>
+                <filteritem type="filename" name="README_zh.md"/>
                 <filteritem type="filename" name="BUILD.gn"/>
                 <filteritem type="filename" name="tests/conan/conanfile.py"  desc=""/>
                 <filteritem type="filename" name="build.py"  desc=""/>

README_zh.md

@@ -0,0 +1,95 @@
+# OpenCL<sup>TM</sup> API Headers
+
+仓库包含C语言的OpenCL API。OpenCL扩展了GPU用于图形渲染之外的能力，将通用计算并行化。OpenCL可用于图像处理、AI、高性能计算等场景的加速。推荐在计算密集型的任务以及可以并行计算的场景使用OpenCL。
+
+例如在图像处理场景，CPU进行编解码、滤镜等特效处理较慢，使用OpenCL有十倍的加速效果。
+
+例如在AI推理场景，使用OpenCL可以将推理性能提高一倍。
+
+OpenHarmony引入后，新增了一层封装层，动态链接查找OpenCL库，以此进行解耦。目前仅支持native层调用OpenCL。
+
+## 目录结构
+
+```
+README.md               英文说明
+README_zh.md            中文说明
+LICENSE                 证书文件
+CL/                     原CL头文件
+include/                封装层CL头文件
+src/                    封装层CL实现
+```
+
+## OpenHarmony如何集成OpenCL
+### 1.头文件引入
+```c
+#define USE_OPENCL_WRAPPER
+#include "opencl_wrapper.h"
+```
+### 2.BUILD.gn添加引用
+```c
+deps += ["//third_party/openCL:libcl"]
+```
+### 3.调用OpenCL函数过程举例
+```c
+// 准备OpenCL的kernel程序
+const char* program_source =
+      "__kernel void test_main(read_only image2d_t inputImage) {\n"
+      "  ...\n"
+      "}";
+```
+
+```c
+// 通过wrapper层的函数判断是否cl初始化成功
+// 如果返回false，说明没有实际的驱动
+bool cl_ok = OHOS::InitOpenCL();
+
+// 获取设备信息
+cl_int err;
+cl_platform_id platform_id;
+cl_device_id device_id;
+clGetPlatformIDs(1, &platform_id, NULL);
+clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
+// 创建OpenCL上下文
+context_ = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
+queue_ = clCreateCommandQueueWithProperties(context_, device_id, 0, &err);
+// 使用上述源码创建OpenCL程序
+cl_program p = clCreateProgramWithSource(context, 1, &program_source, nullptr, nullptr);
+// 创建kernel程序，对应上述源码中的函数名
+kernel_ = clCreateKernel(program, "test_main", &err);
+// 创建OpenCL可以识别的图片
+cl_image_format image_format;
+image_format.image_channel_order = CL_RGBA;
+image_format.image_channel_data_type = CL_UNORM_INT8;
+cl_image_desc desc = {CL_MEM_OBJECT_IMAGE2D, width, height};
+cl_mem input_image = clCreateImage(context_, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, image_format, &desc, const_cast<void*(pixmap.addr()), &err);
+// 将该图片传入kernel程序
+err |= clSetKernelArg(kernel_, 0, sizeof(cl_mem), &input_image);
+// 在GPU上执行OpenCL程序
+err = clEnqueueNDRangeKernel(queue_, kernel_, 2, NULL, global,local, 0, NULL, NULL);
+// 等待执行结束
+clFinish(queue_);
+// 读取执行结果，从GPU传输回CPU
+err = clEnqueueReadBuffer(queue_, cl_errs, CL_TRUE, 0, pixmap.size(), errs, 0, NULL, NULL);
+// 使用完毕需要释放cl内存
+clReleaseMemObject(input_image);
+// 程序不再需要执行的时候需要释放GPU资源(OpenCL上下文)
+clReleaseKernel(kernel_);
+clReleaseCommandQueue(queue_);
+clReleaseContext(context_);
+```
+
+## OpenCL使用文档
+
+API官方文档  https://registry.khronos.org/OpenCL/
+
+API详细定义 https://registry.khronos.org/OpenCL/sdk/3.0/docs/man/html/
+
+API一张图的使用说明 https://www.khronos.org/files/opencl30-reference-guide.pdf
+
+## License
+
+见 [LICENSE](LICENSE).
+
+---
+
+OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission by Khronos.

include/opencl_wrapper.h

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OPENCL_WRAPPER_H_
+#define OPENCL_WRAPPER_H_
+
+#include <memory>
+#include <string>
+#define CL_TARGET_OPENCL_VERSION 300
+#include <CL/cl.h>
+
+#ifdef USE_OPENCL_WRAPPER
+#define MS_ASSERT(f) ((void)0)
+
+namespace OHOS {
+// This is a opencl function wrapper.
+bool LoadOpenCLLibrary(void **handle_ptr);
+bool UnLoadOpenCLLibrary(void *handle);
+bool InitOpenCL();
+
+// get platform id
+using clGetPlatformIDsFunc = cl_int (*)(cl_uint, cl_platform_id *, cl_uint *);
+// get platform info
+using clGetPlatformInfoFunc = cl_int (*)(cl_platform_id, cl_platform_info, size_t, void *, size_t *);
+// build program
+using clBuildProgramFunc = cl_int (*)(cl_program, cl_uint, const cl_device_id *, const char *,
+                                      void (*pfn_notify)(cl_program, void *), void *);
+// enqueue run kernel
+using clEnqueueNDRangeKernelFunc = cl_int (*)(cl_command_queue, cl_kernel, cl_uint, const size_t *, const size_t *,
+                                              const size_t *, cl_uint, const cl_event *, cl_event *);
+// set kernel parameter
+using clSetKernelArgFunc = cl_int (*)(cl_kernel, cl_uint, size_t, const void *);
+using clRetainMemObjectFunc = cl_int (*)(cl_mem);
+using clReleaseMemObjectFunc = cl_int (*)(cl_mem);
+using clEnqueueUnmapMemObjectFunc = cl_int (*)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *, cl_event *);
+using clRetainCommandQueueFunc = cl_int (*)(cl_command_queue command_queue);
+// create context
+using clCreateContextFunc = cl_context (*)(const cl_context_properties *, cl_uint, const cl_device_id *,
+                                           void(CL_CALLBACK *)(  // NOLINT(readability/casting)
+                                             const char *, const void *, size_t, void *),
+                                           void *, cl_int *);
+using clEnqueueCopyImageFunc = cl_int (*)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *,
+                                          const size_t *, cl_uint, const cl_event *, cl_event *);
+
+using clCreateContextFromTypeFunc = cl_context (*)(const cl_context_properties *, cl_device_type,
+                                                   void(CL_CALLBACK *)(  // NOLINT(readability/casting)
+                                                     const char *, const void *, size_t, void *),
+                                                   void *, cl_int *);
+using clReleaseContextFunc = cl_int (*)(cl_context);
+using clWaitForEventsFunc = cl_int (*)(cl_uint, const cl_event *);
+using clReleaseEventFunc = cl_int (*)(cl_event);
+using clEnqueueWriteBufferFunc = cl_int (*)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void *, cl_uint,
+                                            const cl_event *, cl_event *);
+using clEnqueueWriteImageFunc = cl_int (*)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t,
+                                           size_t, const void *, cl_uint, const cl_event *, cl_event *);
+using clEnqueueReadImageFunc = cl_int (*)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t,
+                                          size_t, void *, cl_uint, const cl_event *, cl_event *);
+using clEnqueueReadBufferFunc = cl_int (*)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint,
+                                           const cl_event *, cl_event *);
+using clGetProgramBuildInfoFunc = cl_int (*)(cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *);
+using clRetainProgramFunc = cl_int (*)(cl_program program);
+using clEnqueueMapBufferFunc = void *(*)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint,
+                                         const cl_event *, cl_event *, cl_int *);
+using clEnqueueMapImageFunc = void *(*)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t *, const size_t *,
+                                        size_t *, size_t *, cl_uint, const cl_event *, cl_event *, cl_int *);
+using clCreateCommandQueueFunc = cl_command_queue (*)(cl_context, cl_device_id, cl_command_queue_properties, cl_int *);
+using clGetCommandQueueInfoFunc = cl_int (*)(cl_command_queue, cl_command_queue_info, size_t, void *, size_t *);
+using clReleaseCommandQueueFunc = cl_int (*)(cl_command_queue);
+using clCreateProgramWithBinaryFunc = cl_program (*)(cl_context, cl_uint, const cl_device_id *, const size_t *,
+                                                     const unsigned char **, cl_int *, cl_int *);
+using clRetainContextFunc = cl_int (*)(cl_context context);
+using clGetContextInfoFunc = cl_int (*)(cl_context, cl_context_info, size_t, void *, size_t *);
+using clReleaseProgramFunc = cl_int (*)(cl_program program);
+using clFlushFunc = cl_int (*)(cl_command_queue command_queue);
+using clFinishFunc = cl_int (*)(cl_command_queue command_queue);
+using clGetProgramInfoFunc = cl_int (*)(cl_program, cl_program_info, size_t, void *, size_t *);
+using clCreateKernelFunc = cl_kernel (*)(cl_program, const char *, cl_int *);
+using clRetainKernelFunc = cl_int (*)(cl_kernel kernel);
+using clCreateBufferFunc = cl_mem (*)(cl_context, cl_mem_flags, size_t, void *, cl_int *);
+using clCreateImage2DFunc = cl_mem (*)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t,
+                                       void *, cl_int *);
+using clImportMemoryARMFunc = cl_mem (*)(cl_context, cl_mem_flags, const cl_image_format *, void *, ssize_t, cl_int *);
+using clCreateImage3DFunc = cl_mem (*)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t,
+                                       size_t, size_t, void *, cl_int *);
+using clCreateProgramWithSourceFunc = cl_program (*)(cl_context, cl_uint, const char **, const size_t *, cl_int *);
+using clReleaseKernelFunc = cl_int (*)(cl_kernel kernel);
+using clGetDeviceInfoFunc = cl_int (*)(cl_device_id, cl_device_info, size_t, void *, size_t *);
+using clGetDeviceIDsFunc = cl_int (*)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *);
+using clRetainEventFunc = cl_int (*)(cl_event);
+using clGetKernelWorkGroupInfoFunc = cl_int (*)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *,
+                                                size_t *);
+using clGetEventInfoFunc = cl_int (*)(cl_event event, cl_event_info param_name, size_t param_value_size,
+                                      void *param_value, size_t *param_value_size_ret);
+using clGetEventProfilingInfoFunc = cl_int (*)(cl_event event, cl_profiling_info param_name, size_t param_value_size,
+                                               void *param_value, size_t *param_value_size_ret);
+using clGetImageInfoFunc = cl_int (*)(cl_mem, cl_image_info, size_t, void *, size_t *);
+using clEnqueueCopyBufferToImageFunc = cl_int (*)(cl_command_queue, cl_mem, cl_mem, size_t, const size_t *,
+                                                  const size_t *, cl_uint, const cl_event *, cl_event *);
+using clEnqueueCopyImageToBufferFunc = cl_int (*)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *,
+                                                  size_t, cl_uint, const cl_event *, cl_event *);
+#if CL_TARGET_OPENCL_VERSION >= 120
+using clRetainDeviceFunc = cl_int (*)(cl_device_id);
+using clReleaseDeviceFunc = cl_int (*)(cl_device_id);
+using clCreateImageFunc = cl_mem (*)(cl_context, cl_mem_flags, const cl_image_format *, const cl_image_desc *, void *,
+                                     cl_int *);
+using clEnqueueFillImageFunc = cl_int (*)(cl_command_queue, cl_mem, const void *, const size_t *, const size_t *,
+                                          cl_uint, const cl_event *, cl_event *);
+#endif
+#if CL_TARGET_OPENCL_VERSION >= 200
+using clCreateProgramWithILFunc = cl_program (*)(cl_context, const void *, size_t, cl_int *);
+using clSVMAllocFunc = void *(*)(cl_context, cl_mem_flags, size_t size, cl_uint);
+using clSVMFreeFunc = void (*)(cl_context, void *);
+using clEnqueueSVMMapFunc = cl_int (*)(cl_command_queue, cl_bool, cl_map_flags, void *, size_t, cl_uint,
+                                       const cl_event *, cl_event *);
+using clEnqueueSVMUnmapFunc = cl_int (*)(cl_command_queue, void *, cl_uint, const cl_event *, cl_event *);
+using clSetKernelArgSVMPointerFunc = cl_int (*)(cl_kernel, cl_uint, const void *);
+// opencl 2.0 can get sub group info and wave size.
+using clGetKernelSubGroupInfoKHRFunc = cl_int (*)(cl_kernel, cl_device_id, cl_kernel_sub_group_info, size_t,
+                                                  const void *, size_t, void *, size_t *);
+using clCreateCommandQueueWithPropertiesFunc = cl_command_queue (*)(cl_context, cl_device_id,
+                                                                    const cl_queue_properties *, cl_int *);
+using clGetExtensionFunctionAddressFunc = void *(*)(const char *);
+#endif
+
+#define CL_DECLARE_FUNC_PTR(func) extern func##Func func
+
+CL_DECLARE_FUNC_PTR(clGetPlatformIDs);
+CL_DECLARE_FUNC_PTR(clGetPlatformInfo);
+CL_DECLARE_FUNC_PTR(clBuildProgram);
+CL_DECLARE_FUNC_PTR(clEnqueueNDRangeKernel);
+CL_DECLARE_FUNC_PTR(clSetKernelArg);
+CL_DECLARE_FUNC_PTR(clReleaseKernel);
+CL_DECLARE_FUNC_PTR(clCreateProgramWithSource);
+CL_DECLARE_FUNC_PTR(clCreateBuffer);
+CL_DECLARE_FUNC_PTR(clCreateImage2D);
+CL_DECLARE_FUNC_PTR(clImportMemoryARM);
+CL_DECLARE_FUNC_PTR(clCreateImage3D);
+CL_DECLARE_FUNC_PTR(clRetainKernel);
+CL_DECLARE_FUNC_PTR(clCreateKernel);
+CL_DECLARE_FUNC_PTR(clGetProgramInfo);
+CL_DECLARE_FUNC_PTR(clFlush);
+CL_DECLARE_FUNC_PTR(clFinish);
+CL_DECLARE_FUNC_PTR(clReleaseProgram);
+CL_DECLARE_FUNC_PTR(clRetainContext);
+CL_DECLARE_FUNC_PTR(clGetContextInfo);
+CL_DECLARE_FUNC_PTR(clCreateProgramWithBinary);
+CL_DECLARE_FUNC_PTR(clCreateCommandQueue);
+CL_DECLARE_FUNC_PTR(clGetCommandQueueInfo);
+CL_DECLARE_FUNC_PTR(clReleaseCommandQueue);
+CL_DECLARE_FUNC_PTR(clEnqueueMapBuffer);
+CL_DECLARE_FUNC_PTR(clEnqueueMapImage);
+CL_DECLARE_FUNC_PTR(clEnqueueCopyImage);
+CL_DECLARE_FUNC_PTR(clRetainProgram);
+CL_DECLARE_FUNC_PTR(clGetProgramBuildInfo);
+CL_DECLARE_FUNC_PTR(clEnqueueReadBuffer);
+CL_DECLARE_FUNC_PTR(clEnqueueWriteBuffer);
+CL_DECLARE_FUNC_PTR(clEnqueueWriteImage);
+CL_DECLARE_FUNC_PTR(clEnqueueReadImage);
+CL_DECLARE_FUNC_PTR(clWaitForEvents);
+CL_DECLARE_FUNC_PTR(clReleaseEvent);
+CL_DECLARE_FUNC_PTR(clCreateContext);
+CL_DECLARE_FUNC_PTR(clCreateContextFromType);
+CL_DECLARE_FUNC_PTR(clReleaseContext);
+CL_DECLARE_FUNC_PTR(clRetainCommandQueue);
+CL_DECLARE_FUNC_PTR(clEnqueueUnmapMemObject);
+CL_DECLARE_FUNC_PTR(clRetainMemObject);
+CL_DECLARE_FUNC_PTR(clReleaseMemObject);
+CL_DECLARE_FUNC_PTR(clGetDeviceInfo);
+CL_DECLARE_FUNC_PTR(clGetDeviceIDs);
+CL_DECLARE_FUNC_PTR(clRetainEvent);
+CL_DECLARE_FUNC_PTR(clGetKernelWorkGroupInfo);
+CL_DECLARE_FUNC_PTR(clGetEventInfo);
+CL_DECLARE_FUNC_PTR(clGetEventProfilingInfo);
+CL_DECLARE_FUNC_PTR(clGetImageInfo);
+CL_DECLARE_FUNC_PTR(clEnqueueCopyBufferToImage);
+CL_DECLARE_FUNC_PTR(clEnqueueCopyImageToBuffer);
+#if CL_TARGET_OPENCL_VERSION >= 120
+CL_DECLARE_FUNC_PTR(clRetainDevice);
+CL_DECLARE_FUNC_PTR(clReleaseDevice);
+CL_DECLARE_FUNC_PTR(clCreateImage);
+CL_DECLARE_FUNC_PTR(clEnqueueFillImage);
+#endif
+#if CL_TARGET_OPENCL_VERSION >= 200
+CL_DECLARE_FUNC_PTR(clGetKernelSubGroupInfoKHR);
+CL_DECLARE_FUNC_PTR(clCreateCommandQueueWithProperties);
+CL_DECLARE_FUNC_PTR(clGetExtensionFunctionAddress);
+CL_DECLARE_FUNC_PTR(clCreateProgramWithIL);
+CL_DECLARE_FUNC_PTR(clSVMAlloc);
+CL_DECLARE_FUNC_PTR(clSVMFree);
+CL_DECLARE_FUNC_PTR(clEnqueueSVMMap);
+CL_DECLARE_FUNC_PTR(clEnqueueSVMUnmap);
+CL_DECLARE_FUNC_PTR(clSetKernelArgSVMPointer);
+#endif
+
+#undef CL_DECLARE_FUNC_PTR
+}  // namespace OHOS
+#endif  // USE_OPENCL_WRAPPER
+#endif  // OPENCL_WRAPPER_H_

src/opencl_wrapper.cpp

@@ -0,0 +1,789 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define USE_OPENCL_WRAPPER
+#ifdef USE_OPENCL_WRAPPER
+
+#include "opencl_wrapper.h"
+#include <dlfcn.h>
+#include <memory>
+#include <string>
+#include <vector>
+#include <iostream>
+
+namespace OHOS {
+// default opencl library path
+static const std::vector<std::string> g_opencl_library_paths = {
+#if defined(__APPLE__) || defined(__MACOSX)
+    "libOpenCL.so", "/System/Library/Frameworks/OpenCL.framework/OpenCL"
+#else
+    "/system/lib64/libGLES_mali.so",
+    "libGLES_mali.so",
+#endif
+};
+
+
+static std::mutex gInitMutex;
+bool isInit = false;
+void *handle_{nullptr};
+
+bool InitOpenCL() {
+    std::lock_guard<std::mutex> lock(gInitMutex);
+    if (isInit){
+      return true;
+    }
+    isInit = LoadOpenCLLibrary(&handle_);
+    return isInit;
+}
+
+bool UnLoadOpenCLLibrary(void *handle) {
+    if (handle != nullptr) {
+      if (dlclose(handle) != 0) {
+        return false;
+      }
+      return true;
+    }
+    return true;
+}
+
+bool LoadLibraryFromPath(const std::string &library_path, void **handle_ptr) {
+    if (handle_ptr == nullptr) {
+      return false;
+    }
+
+    *handle_ptr = dlopen(library_path.c_str(), RTLD_NOW | RTLD_LOCAL);
+    if (*handle_ptr == nullptr) {
+      return false;
+    }
+
+// load function ptr use dlopen and dlsym.
+#define LOAD_OPENCL_FUNCTION_PTR(func_name)                                                    \
+    func_name = reinterpret_cast<func_name##Func>(dlsym(*handle_ptr, #func_name));               \
+    if (func_name == nullptr) {                                                                  \
+      UnLoadOpenCLLibrary(*handle_ptr);                                                          \
+      return false;                                                                              \
+    }
+
+    LOAD_OPENCL_FUNCTION_PTR(clGetPlatformIDs);
+    LOAD_OPENCL_FUNCTION_PTR(clGetPlatformInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clBuildProgram);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueNDRangeKernel);
+    LOAD_OPENCL_FUNCTION_PTR(clSetKernelArg);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseKernel);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateProgramWithSource);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateBuffer);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateImage2D);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateImage3D);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainKernel);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateKernel);
+    LOAD_OPENCL_FUNCTION_PTR(clGetProgramInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clFlush);
+    LOAD_OPENCL_FUNCTION_PTR(clFinish);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseProgram);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainContext);
+    LOAD_OPENCL_FUNCTION_PTR(clGetContextInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateProgramWithBinary);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateCommandQueue);
+    LOAD_OPENCL_FUNCTION_PTR(clGetCommandQueueInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseCommandQueue);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueMapBuffer);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueMapImage);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainProgram);
+    LOAD_OPENCL_FUNCTION_PTR(clGetProgramBuildInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueReadBuffer);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueWriteBuffer);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueReadImage);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueWriteImage);
+    LOAD_OPENCL_FUNCTION_PTR(clWaitForEvents);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseEvent);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateContext);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateContextFromType);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseContext);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainCommandQueue);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueUnmapMemObject);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainMemObject);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseMemObject);
+    LOAD_OPENCL_FUNCTION_PTR(clGetDeviceInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clGetDeviceIDs);
+    LOAD_OPENCL_FUNCTION_PTR(clRetainEvent);
+    LOAD_OPENCL_FUNCTION_PTR(clGetKernelWorkGroupInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clGetEventInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clGetEventProfilingInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clGetImageInfo);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueCopyImage);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueCopyBufferToImage);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueCopyImageToBuffer);
+#if CL_TARGET_OPENCL_VERSION >= 120
+    LOAD_OPENCL_FUNCTION_PTR(clRetainDevice);
+    LOAD_OPENCL_FUNCTION_PTR(clReleaseDevice);
+    LOAD_OPENCL_FUNCTION_PTR(clCreateImage);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueFillImage);
+#endif
+#if CL_TARGET_OPENCL_VERSION >= 200
+    LOAD_OPENCL_FUNCTION_PTR(clCreateCommandQueueWithProperties);
+    LOAD_OPENCL_FUNCTION_PTR(clGetExtensionFunctionAddress);
+    LOAD_OPENCL_FUNCTION_PTR(clSVMAlloc);
+    LOAD_OPENCL_FUNCTION_PTR(clSVMFree);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueSVMMap);
+    LOAD_OPENCL_FUNCTION_PTR(clEnqueueSVMUnmap);
+    LOAD_OPENCL_FUNCTION_PTR(clSetKernelArgSVMPointer);
+#endif
+
+    return true;
+}
+// load default library path
+bool LoadOpenCLLibrary(void **handle_ptr) {
+    if (handle_ptr == nullptr) {
+      return false;
+    }
+    if (*handle_ptr != nullptr) {
+      return true;
+    }
+    auto it =
+      std::find_if(g_opencl_library_paths.begin(), g_opencl_library_paths.end(),
+                   [&](const std::string &lib_path) { return OHOS::LoadLibraryFromPath(lib_path, handle_ptr); });
+    if (it != g_opencl_library_paths.end()) {
+      return true;
+    }
+    return false;
+}
+
+#define CL_DEFINE_FUNC_PTR(func) func##Func func = nullptr
+
+CL_DEFINE_FUNC_PTR(clGetPlatformIDs);
+CL_DEFINE_FUNC_PTR(clGetPlatformInfo);
+CL_DEFINE_FUNC_PTR(clBuildProgram);
+CL_DEFINE_FUNC_PTR(clEnqueueNDRangeKernel);
+CL_DEFINE_FUNC_PTR(clSetKernelArg);
+CL_DEFINE_FUNC_PTR(clReleaseKernel);
+CL_DEFINE_FUNC_PTR(clCreateProgramWithSource);
+CL_DEFINE_FUNC_PTR(clCreateBuffer);
+CL_DEFINE_FUNC_PTR(clCreateImage2D);
+CL_DEFINE_FUNC_PTR(clImportMemoryARM);
+CL_DEFINE_FUNC_PTR(clCreateImage3D);
+CL_DEFINE_FUNC_PTR(clRetainKernel);
+CL_DEFINE_FUNC_PTR(clCreateKernel);
+CL_DEFINE_FUNC_PTR(clGetProgramInfo);
+CL_DEFINE_FUNC_PTR(clFlush);
+CL_DEFINE_FUNC_PTR(clFinish);
+CL_DEFINE_FUNC_PTR(clReleaseProgram);
+CL_DEFINE_FUNC_PTR(clRetainContext);
+CL_DEFINE_FUNC_PTR(clGetContextInfo);
+CL_DEFINE_FUNC_PTR(clCreateProgramWithBinary);
+CL_DEFINE_FUNC_PTR(clCreateCommandQueue);
+CL_DEFINE_FUNC_PTR(clGetCommandQueueInfo);
+CL_DEFINE_FUNC_PTR(clReleaseCommandQueue);
+CL_DEFINE_FUNC_PTR(clEnqueueMapBuffer);
+CL_DEFINE_FUNC_PTR(clEnqueueMapImage);
+CL_DEFINE_FUNC_PTR(clEnqueueCopyImage);
+CL_DEFINE_FUNC_PTR(clRetainProgram);
+CL_DEFINE_FUNC_PTR(clGetProgramBuildInfo);
+CL_DEFINE_FUNC_PTR(clEnqueueReadBuffer);
+CL_DEFINE_FUNC_PTR(clEnqueueWriteBuffer);
+CL_DEFINE_FUNC_PTR(clEnqueueWriteImage);
+CL_DEFINE_FUNC_PTR(clEnqueueReadImage);
+CL_DEFINE_FUNC_PTR(clWaitForEvents);
+CL_DEFINE_FUNC_PTR(clReleaseEvent);
+CL_DEFINE_FUNC_PTR(clCreateContext);
+CL_DEFINE_FUNC_PTR(clCreateContextFromType);
+CL_DEFINE_FUNC_PTR(clReleaseContext);
+CL_DEFINE_FUNC_PTR(clRetainCommandQueue);
+CL_DEFINE_FUNC_PTR(clEnqueueUnmapMemObject);
+CL_DEFINE_FUNC_PTR(clRetainMemObject);
+CL_DEFINE_FUNC_PTR(clReleaseMemObject);
+CL_DEFINE_FUNC_PTR(clGetDeviceInfo);
+CL_DEFINE_FUNC_PTR(clGetDeviceIDs);
+CL_DEFINE_FUNC_PTR(clRetainEvent);
+CL_DEFINE_FUNC_PTR(clGetKernelWorkGroupInfo);
+CL_DEFINE_FUNC_PTR(clGetEventInfo);
+CL_DEFINE_FUNC_PTR(clGetEventProfilingInfo);
+CL_DEFINE_FUNC_PTR(clGetImageInfo);
+CL_DEFINE_FUNC_PTR(clEnqueueCopyBufferToImage);
+CL_DEFINE_FUNC_PTR(clEnqueueCopyImageToBuffer);
+#if CL_TARGET_OPENCL_VERSION >= 120
+CL_DEFINE_FUNC_PTR(clRetainDevice);
+CL_DEFINE_FUNC_PTR(clReleaseDevice);
+CL_DEFINE_FUNC_PTR(clCreateImage);
+CL_DEFINE_FUNC_PTR(clEnqueueFillImage);
+#endif
+#if CL_TARGET_OPENCL_VERSION >= 200
+CL_DEFINE_FUNC_PTR(clGetKernelSubGroupInfoKHR);
+CL_DEFINE_FUNC_PTR(clCreateCommandQueueWithProperties);
+CL_DEFINE_FUNC_PTR(clGetExtensionFunctionAddress);
+CL_DEFINE_FUNC_PTR(clCreateProgramWithIL);
+CL_DEFINE_FUNC_PTR(clSVMAlloc);
+CL_DEFINE_FUNC_PTR(clSVMFree);
+CL_DEFINE_FUNC_PTR(clEnqueueSVMMap);
+CL_DEFINE_FUNC_PTR(clEnqueueSVMUnmap);
+CL_DEFINE_FUNC_PTR(clSetKernelArgSVMPointer);
+#endif
+#undef LOAD_OPENCL_FUNCTION_PTR
+}  // namespace OHOS
+
+// clGetPlatformIDs wrapper, use OpenCLWrapper function. use OpenCLWrapper function.
+cl_int clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetPlatformIDs;
+    MS_ASSERT(func != nullptr);
+    return func(num_entries, platforms, num_platforms);
+}
+
+// clGetPlatformInfo wrapper, use OpenCLWrapper function. use OpenCLWrapper function.
+cl_int clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name, size_t param_value_size,
+                         void *param_value, size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetPlatformInfo;
+    MS_ASSERT(func != nullptr);
+    return func(platform, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clGetDeviceIDs wrapper, use OpenCLWrapper function.
+cl_int clGetDeviceIDs(cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id *devices,
+                      cl_uint *num_devices) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetDeviceIDs;
+    MS_ASSERT(func != nullptr);
+    return func(platform, device_type, num_entries, devices, num_devices);
+}
+
+// clGetDeviceInfo wrapper, use OpenCLWrapper function.
+cl_int clGetDeviceInfo(cl_device_id device, cl_device_info param_name, size_t param_value_size, void *param_value,
+                       size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetDeviceInfo;
+    MS_ASSERT(func != nullptr);
+    return func(device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clCreateContext wrapper, use OpenCLWrapper function.
+cl_context clCreateContext(const cl_context_properties *properties, cl_uint num_devices, const cl_device_id *devices,
+                           void(CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), void *user_data,
+                           cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateContext;
+    MS_ASSERT(func != nullptr);
+    return func(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
+}
+
+// clCreateContextFromType wrapper, use OpenCLWrapper function.
+cl_context clCreateContextFromType(const cl_context_properties *properties, cl_device_type device_type,
+                                   void(CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
+                                   void *user_data, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateContextFromType;
+    MS_ASSERT(func != nullptr);
+    return func(properties, device_type, pfn_notify, user_data, errcode_ret);
+}
+
+// clRetainContext wrapper, use OpenCLWrapper function.
+cl_int clRetainContext(cl_context context) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainContext;
+    MS_ASSERT(func != nullptr);
+    return func(context);
+}
+
+// clReleaseContext wrapper, use OpenCLWrapper function.
+cl_int clReleaseContext(cl_context context) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseContext;
+    MS_ASSERT(func != nullptr);
+    return func(context);
+}
+
+// clGetContextInfo wrapper, use OpenCLWrapper function.
+cl_int clGetContextInfo(cl_context context, cl_context_info param_name, size_t param_value_size, void *param_value,
+                        size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetContextInfo;
+    MS_ASSERT(func != nullptr);
+    return func(context, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clCreateProgramWithSource wrapper, use OpenCLWrapper function.
+cl_program clCreateProgramWithSource(cl_context context, cl_uint count, const char **strings, const size_t *lengths,
+                                     cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateProgramWithSource;
+    MS_ASSERT(func != nullptr);
+    return func(context, count, strings, lengths, errcode_ret);
+}
+
+// clCreateProgramWithBinary wrapper, use OpenCLWrapper function.
+cl_program clCreateProgramWithBinary(cl_context context, cl_uint num_devices, const cl_device_id *devices_list,
+                                     const size_t *lengths, const unsigned char **binaries, cl_int *binary_status,
+                                     cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateProgramWithBinary;
+    MS_ASSERT(func != nullptr);
+    return func(context, num_devices, devices_list, lengths, binaries, binary_status, errcode_ret);
+}
+
+// clGetProgramInfo wrapper, use OpenCLWrapper function.
+cl_int clGetProgramInfo(cl_program program, cl_program_info param_name, size_t param_value_size, void *param_value,
+                        size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetProgramInfo;
+    MS_ASSERT(func != nullptr);
+    return func(program, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clGetProgramBuildInfo wrapper, use OpenCLWrapper function.
+cl_int clGetProgramBuildInfo(cl_program program, cl_device_id device, cl_program_build_info param_name,
+                             size_t param_value_size, void *param_value, size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetProgramBuildInfo;
+    MS_ASSERT(func != nullptr);
+    return func(program, device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clRetainProgram wrapper, use OpenCLWrapper function.
+cl_int clRetainProgram(cl_program program) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainProgram;
+    MS_ASSERT(func != nullptr);
+    return func(program);
+}
+
+// clReleaseProgram wrapper, use OpenCLWrapper function.
+cl_int clReleaseProgram(cl_program program) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseProgram;
+    MS_ASSERT(func != nullptr);
+    return func(program);
+}
+
+// clBuildProgram wrapper, use OpenCLWrapper function.
+cl_int clBuildProgram(cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options,
+                      void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), void *user_data) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clBuildProgram;
+    MS_ASSERT(func != nullptr);
+    return func(program, num_devices, device_list, options, pfn_notify, user_data);
+}
+
+// clCreateKernel wrapper, use OpenCLWrapper function.
+cl_kernel clCreateKernel(cl_program program, const char *kernelName, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateKernel;
+    MS_ASSERT(func != nullptr);
+    return func(program, kernelName, errcode_ret);
+}
+
+// clRetainKernel wrapper, use OpenCLWrapper function.
+cl_int clRetainKernel(cl_kernel kernel) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainKernel;
+    MS_ASSERT(func != nullptr);
+    return func(kernel);
+}
+
+// clReleaseKernel wrapper, use OpenCLWrapper function.
+cl_int clReleaseKernel(cl_kernel kernel) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseKernel;
+    MS_ASSERT(func != nullptr);
+    return func(kernel);
+}
+
+// clSetKernelArg wrapper, use OpenCLWrapper function.
+cl_int clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void *arg_value) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clSetKernelArg;
+    MS_ASSERT(func != nullptr);
+    return func(kernel, arg_index, arg_size, arg_value);
+}
+
+// clCreateBuffer wrapper, use OpenCLWrapper function.
+cl_mem clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateBuffer;
+    MS_ASSERT(func != nullptr);
+    return func(context, flags, size, host_ptr, errcode_ret);
+}
+
+// clRetainMemObject wrapper, use OpenCLWrapper function.
+cl_int clRetainMemObject(cl_mem memobj) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainMemObject;
+    MS_ASSERT(func != nullptr);
+    return func(memobj);
+}
+
+// clReleaseMemObject wrapper, use OpenCLWrapper function.
+cl_int clReleaseMemObject(cl_mem memobj) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseMemObject;
+    MS_ASSERT(func != nullptr);
+    return func(memobj);
+}
+
+// clGetImageInfo wrapper, use OpenCLWrapper function.
+cl_int clGetImageInfo(cl_mem image, cl_image_info param_name, size_t param_value_size, void *param_value,
+                      size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetImageInfo;
+    MS_ASSERT(func != nullptr);
+    return func(image, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clRetainCommandQueue wrapper, use OpenCLWrapper function.
+cl_int clRetainCommandQueue(cl_command_queue command_queue) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainCommandQueue;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue);
+}
+
+// clReleaseCommandQueue wrapper, use OpenCLWrapper function.
+cl_int clReleaseCommandQueue(cl_command_queue command_queue) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseCommandQueue;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue);
+}
+
+// clEnqueueReadBuffer wrapper, use OpenCLWrapper function.
+cl_int clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset,
+                           size_t size, void *ptr, cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
+                           cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueReadBuffer;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+// clEnqueueWriteBuffer wrapper, use OpenCLWrapper function.
+cl_int clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t offset,
+                            size_t size, const void *ptr, cl_uint num_events_in_wait_list,
+                            const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueWriteBuffer;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list,
+              event);
+}
+
+// clEnqueueWriteImage wrapper, use OpenCLWrapper function.
+cl_int clEnqueueWriteImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, const size_t *origin,
+                           const size_t *region, size_t input_row_pitch, size_t input_slice_pitch, const void *ptr,
+                           cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueWriteImage;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr,
+              num_events_in_wait_list, event_wait_list, event);
+}
+
+// clEnqueueReadImage wrapper, use OpenCLWrapper function.
+cl_int clEnqueueReadImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, const size_t *origin,
+                          const size_t *region, size_t row_pitch, size_t slice_pitch, void *ptr,
+                          cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueReadImage;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list,
+              event_wait_list, event);
+}
+
+// clEnqueueMapBuffer wrapper, use OpenCLWrapper function.
+void *clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags,
+                         size_t offset, size_t size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
+                         cl_event *event, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueMapBuffer;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list,
+              event, errcode_ret);
+}
+
+// clEnqueueMapImage wrapper, use OpenCLWrapper function.
+void *clEnqueueMapImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, cl_map_flags map_flags,
+                        const size_t *origin, const size_t *region, size_t *image_row_pitch, size_t *image_slice_pitch,
+                        cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event,
+                        cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueMapImage;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch,
+              num_events_in_wait_list, event_wait_list, event, errcode_ret);
+}
+
+// clEnqueueUnmapMemObject wrapper, use OpenCLWrapper function.
+cl_int clEnqueueUnmapMemObject(cl_command_queue command_queue, cl_mem memobj, void *mapped_ptr,
+                               cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueUnmapMemObject;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+// clGetKernelWorkGroupInfo wrapper, use OpenCLWrapper function.
+cl_int clGetKernelWorkGroupInfo(cl_kernel kernel, cl_device_id device, cl_kernel_work_group_info param_name,
+                                size_t param_value_size, void *param_value, size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetKernelWorkGroupInfo;
+    MS_ASSERT(func != nullptr);
+    return func(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clGetEventProfilingInfo wrapper, use OpenCLWrapper function.
+cl_int clGetEventProfilingInfo(cl_event event, cl_profiling_info param_name, size_t param_value_size, void *param_value,
+                               size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetEventProfilingInfo;
+    MS_ASSERT(func != nullptr);
+    return func(event, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clEnqueueNDRangeKernel wrapper, use OpenCLWrapper function.
+cl_int clEnqueueNDRangeKernel(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
+                              const size_t *global_work_offset, const size_t *global_work_size,
+                              const size_t *local_work_size, cl_uint num_events_in_wait_list,
+                              const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueNDRangeKernel;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size,
+              num_events_in_wait_list, event_wait_list, event);
+}
+
+// clWaitForEvents wrapper, use OpenCLWrapper function.
+cl_int clWaitForEvents(cl_uint num_events, const cl_event *event_list) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clWaitForEvents;
+    MS_ASSERT(func != nullptr);
+    return func(num_events, event_list);
+}
+
+// clRetainEvent wrapper, use OpenCLWrapper function.
+cl_int clRetainEvent(cl_event event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainEvent;
+    MS_ASSERT(func != nullptr);
+    return func(event);
+}
+
+// clReleaseEvent wrapper, use OpenCLWrapper function.
+cl_int clReleaseEvent(cl_event event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseEvent;
+    MS_ASSERT(func != nullptr);
+    return func(event);
+}
+
+// clGetEventInfo wrapper, use OpenCLWrapper function.
+cl_int clGetEventInfo(cl_event event, cl_event_info param_name, size_t param_value_size, void *param_value,
+                      size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetEventInfo;
+    MS_ASSERT(func != nullptr);
+    return func(event, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clFlush wrapper, use OpenCLWrapper function.
+cl_int clFlush(cl_command_queue command_queue) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clFlush;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue);
+}
+
+// clFinish wrapper, use OpenCLWrapper function.
+cl_int clFinish(cl_command_queue command_queue) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clFinish;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue);
+}
+
+// clCreateImage2D wrapper, use OpenCLWrapper function.
+cl_mem clCreateImage2D(cl_context context, cl_mem_flags flags, const cl_image_format *image_format, size_t imageWidth,
+                       size_t imageHeight, size_t image_row_pitch, void *host_ptr, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateImage2D;
+    MS_ASSERT(func != nullptr);
+    return func(context, flags, image_format, imageWidth, imageHeight, image_row_pitch, host_ptr, errcode_ret);
+}
+
+// clCreateImage3D wrapper, use OpenCLWrapper function.
+cl_mem clCreateImage3D(cl_context context, cl_mem_flags flags, const cl_image_format *image_format, size_t imageWidth,
+                       size_t imageHeight, size_t imageDepth, size_t image_row_pitch, size_t image_slice_pitch,
+                       void *host_ptr, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateImage3D;
+    MS_ASSERT(func != nullptr);
+    return func(context, flags, image_format, imageWidth, imageHeight, imageDepth, image_row_pitch, image_slice_pitch,
+              host_ptr, errcode_ret);
+}
+
+// clCreateCommandQueue wrapper, use OpenCLWrapper function.
+cl_command_queue clCreateCommandQueue(cl_context context, cl_device_id device, cl_command_queue_properties properties,
+                                      cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateCommandQueue;
+    MS_ASSERT(func != nullptr);
+    return func(context, device, properties, errcode_ret);
+}
+
+// clGetCommandQueueInfo wrapper, use OpenCLWrapper function.
+cl_int clGetCommandQueueInfo(cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size,
+                             void *param_value, size_t *param_value_size_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetCommandQueueInfo;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+// clEnqueueCopyImage wrapper, use OpenCLWrapper function.
+cl_int clEnqueueCopyImage(cl_command_queue queue, cl_mem src_image, cl_mem dst_image, const size_t *src_origin,
+                          const size_t *dst_origin, const size_t *region, cl_uint num_events_in_wait_list,
+                          const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueCopyImage;
+    MS_ASSERT(func != nullptr);
+    return func(queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list,
+              event);
+}
+
+// clEnqueueCopyBufferToImage wrapper, use OpenCLWrapper function.
+cl_int clEnqueueCopyBufferToImage(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image,
+                                  size_t src_offset, const size_t *dst_origin, const size_t *region,
+                                  cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueCopyBufferToImage;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list,
+              event_wait_list, event);
+}
+
+// clEnqueueCopyImageToBuffer wrapper, use OpenCLWrapper function.
+cl_int clEnqueueCopyImageToBuffer(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer,
+                                  const size_t *src_origin, const size_t *region, size_t dst_offset,
+                                  cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueCopyImageToBuffer;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list,
+              event_wait_list, event);
+}
+
+#if CL_TARGET_OPENCL_VERSION >= 120
+
+// clRetainDevice wrapper, use OpenCLWrapper function.
+cl_int clRetainDevice(cl_device_id device) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clRetainDevice;
+    MS_ASSERT(func != nullptr);
+    return func(device);
+}
+
+// clReleaseDevice wrapper, use OpenCLWrapper function.
+cl_int clReleaseDevice(cl_device_id device) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clReleaseDevice;
+    MS_ASSERT(func != nullptr);
+    return func(device);
+}
+
+// clCreateImage wrapper, use OpenCLWrapper function.
+cl_mem clCreateImage(cl_context context, cl_mem_flags flags, const cl_image_format *image_format,
+                     const cl_image_desc *image_desc, void *host_ptr, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateImage;
+    MS_ASSERT(func != nullptr);
+    return func(context, flags, image_format, image_desc, host_ptr, errcode_ret);
+}
+
+cl_int clEnqueueFillImage(cl_command_queue command_queue, cl_mem image, const void *fill_color, const size_t *origin,
+                          const size_t *region, cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
+                          cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueFillImage;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event);
+}
+
+#endif
+
+#if CL_TARGET_OPENCL_VERSION >= 200
+
+// clCreateCommandQueueWithProperties wrapper, use OpenCLWrapper function.
+cl_command_queue clCreateCommandQueueWithProperties(cl_context context, cl_device_id device,
+                                                    const cl_queue_properties *properties, cl_int *errcode_ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateCommandQueueWithProperties;
+    MS_ASSERT(func != nullptr);
+    return func(context, device, properties, errcode_ret);
+}
+
+// clGetExtensionFunctionAddress wrapper, use OpenCLWrapper function.
+void *clGetExtensionFunctionAddress(const char *func_name) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clGetExtensionFunctionAddress;
+    MS_ASSERT(func != nullptr);
+    return func(func_name);
+}
+// clCreateProgramWithIL wrapper, use OpenCLWrapper function.
+cl_program clCreateProgramWithIL(cl_context context, const void *il, size_t length, cl_int *ret) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clCreateProgramWithIL;
+    MS_ASSERT(func != nullptr);
+    return func(context, il, length, ret);
+}
+
+// clSVMAlloc wrapper, use OpenCLWrapper function.
+void *clSVMAlloc(cl_context context, cl_mem_flags flags, size_t size, cl_uint align) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clSVMAlloc;
+    MS_ASSERT(func != nullptr);
+    return func(context, flags, size, align);
+}
+
+// clSVMFree wrapper, use OpenCLWrapper function.
+void clSVMFree(cl_context context, void *buffer) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clSVMFree;
+    MS_ASSERT(func != nullptr);
+  func(context, buffer);
+}
+
+// clEnqueueSVMMap wrapper, use OpenCLWrapper function.
+cl_int clEnqueueSVMMap(cl_command_queue command_queue, cl_bool blocking, cl_map_flags flags, void *host_ptr,
+                       size_t size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueSVMMap;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, blocking, flags, host_ptr, size, num_events_in_wait_list, event_wait_list, event);
+}
+
+// clEnqueueSVMUnmap wrapper, use OpenCLWrapper function.
+cl_int clEnqueueSVMUnmap(cl_command_queue command_queue, void *host_ptr, cl_uint num_events_in_wait_list,
+                         const cl_event *event_wait_list, cl_event *event) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clEnqueueSVMUnmap;
+    MS_ASSERT(func != nullptr);
+    return func(command_queue, host_ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+// clSetKernelArgSVMPointer wrapper, use OpenCLWrapper function.
+cl_int clSetKernelArgSVMPointer(cl_kernel kernel, cl_uint index, const void *host_ptr) {
+    OHOS::InitOpenCL();
+    auto func = OHOS::clSetKernelArgSVMPointer;
+    MS_ASSERT(func != nullptr);
+    return func(kernel, index, host_ptr);
+}
+#endif
+
+#endif  // USE_OPENCL_WRAPPER