cl_wrapper.cc

/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.

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. */

#include <dlfcn.h>
#include <glog/logging.h>
#include <string>
#include <vector>
#include "paddle/fluid/lite/opencl/cl2_header.h"

/**
 * Wrapper of OpenCL 2.0, based on file opencl20/CL/cl.h
 */

#if CL_HPP_TARGET_OPENCL_VERSION < 200
#define CL_API_SUFFIX__VERSION_2_0
#endif

namespace paddle {
namespace lite {

class OpenCLLibrary final {
 private:
  OpenCLLibrary();
  OpenCLLibrary(const OpenCLLibrary &) = delete;
  OpenCLLibrary &operator=(const OpenCLLibrary &) = delete;

  bool Load();
  void *LoadFromPath(const std::string &path);

 public:
  static OpenCLLibrary *Get();

  using clGetPlatformIDsFunc = cl_int (*)(cl_uint, cl_platform_id *, cl_uint *);
  using clGetPlatformInfoFunc = cl_int (*)(cl_platform_id, cl_platform_info,
                                           size_t, void *, size_t *);
  using clBuildProgramFunc = cl_int (*)(cl_program, cl_uint,
                                        const cl_device_id *, const char *,
                                        void (*pfn_notify)(cl_program, void *),
                                        void *);
  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 *);
  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);
  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 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 clEnqueueReadBufferFunc = cl_int (*)(cl_command_queue, cl_mem, cl_bool,
                                             size_t, size_t, 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 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_API_CALL *)(  // NOLINT
      cl_context, cl_device_id, cl_command_queue_properties, cl_int *);
  using clCreateCommandQueueWithPropertiesFunc = cl_command_queue (*)(
      cl_context, cl_device_id, const cl_queue_properties *, cl_int *);
  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_API_CALL *)(cl_context,  // NOLINT
                                                    cl_mem_flags,
                                                    const cl_image_format *,
                                                    size_t, size_t, size_t,
                                                    void *, cl_int *);
  using clCreateImageFunc = cl_mem (*)(cl_context, cl_mem_flags,
                                       const cl_image_format *,
                                       const cl_image_desc *, void *, cl_int *);
  using clCreateUserEventFunc = cl_event (*)(cl_context, 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 clRetainDeviceFunc = cl_int (*)(cl_device_id);
  using clReleaseDeviceFunc = cl_int (*)(cl_device_id);
  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 *);

#define PADDLE_CL_DEFINE_FUNC_PTR(func) func##Func func = nullptr

  PADDLE_CL_DEFINE_FUNC_PTR(clGetPlatformIDs);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetPlatformInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clBuildProgram);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueNDRangeKernel);
  PADDLE_CL_DEFINE_FUNC_PTR(clSetKernelArg);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseKernel);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateProgramWithSource);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateBuffer);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateImage);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateImage2D);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateUserEvent);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainKernel);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateKernel);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetProgramInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clFlush);
  PADDLE_CL_DEFINE_FUNC_PTR(clFinish);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseProgram);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainContext);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetContextInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateProgramWithBinary);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateCommandQueue);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateCommandQueueWithProperties);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseCommandQueue);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueMapBuffer);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueMapImage);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainProgram);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetProgramBuildInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueReadBuffer);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueReadImage);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueWriteBuffer);
  PADDLE_CL_DEFINE_FUNC_PTR(clWaitForEvents);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseEvent);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateContext);
  PADDLE_CL_DEFINE_FUNC_PTR(clCreateContextFromType);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseContext);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainCommandQueue);
  PADDLE_CL_DEFINE_FUNC_PTR(clEnqueueUnmapMemObject);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainMemObject);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseMemObject);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetDeviceInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetDeviceIDs);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainDevice);
  PADDLE_CL_DEFINE_FUNC_PTR(clReleaseDevice);
  PADDLE_CL_DEFINE_FUNC_PTR(clRetainEvent);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetKernelWorkGroupInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetEventInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetEventProfilingInfo);
  PADDLE_CL_DEFINE_FUNC_PTR(clGetImageInfo);

#undef PADDLE_CL_DEFINE_FUNC_PTR

 private:
  void *handle_ = nullptr;
};

OpenCLLibrary *OpenCLLibrary::Get() {
  static OpenCLLibrary library;
  return &library;
}

OpenCLLibrary::OpenCLLibrary() {
  this->Load();
  // Do not call dlclose which may unload all OpenCL symbols.
  // If close the OpenCL library, the static OpenCLlite destructor may fail.
  // If there is no dlclose, the library will be closed when the program exist.
  // Besides, the library will not be load repeatedly even dlopen many times.
}

bool OpenCLLibrary::Load() {
  if (handle_ != nullptr) {
    return true;
  }

  // Add customized OpenCL search path here
  const std::vector<std::string> paths = {
    "libOpenCL.so",
#if defined(__aarch64__)
    // Qualcomm Adreno with Android
    "/system/vendor/lib64/libOpenCL.so",
    "/system/lib64/libOpenCL.so",
    // Mali with Android
    "/system/vendor/lib64/egl/libGLES_mali.so",
    "/system/lib64/egl/libGLES_mali.so",
    // Typical Linux board
    "/usr/lib/aarch64-linux-gnu/libOpenCL.so",
#else
    // Qualcomm Adreno with Android
    "/system/vendor/lib/libOpenCL.so",
    "/system/lib/libOpenCL.so",
    // Mali with Android
    "/system/vendor/lib/egl/libGLES_mali.so",
    "/system/lib/egl/libGLES_mali.so",
    // Typical Linux board
    "/usr/lib/arm-linux-gnueabihf/libOpenCL.so",
#endif
  };

  for (const auto &path : paths) {
    VLOG(3) << "Loading OpenCL from " << path;
    void *handle = LoadFromPath(path);
    if (handle != nullptr) {
      handle_ = handle;
      break;
    }
  }

  if (handle_ == nullptr) {
    LOG(ERROR)
        << "Failed to load OpenCL library, "
           "please make sure there exists OpenCL library on your device, "
           "and your APP have right to access the library.";
    return false;
  }

  return true;
}

void *OpenCLLibrary::LoadFromPath(const std::string &path) {
  void *handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);

  if (handle == nullptr) {
    VLOG(3) << "Failed to load OpenCL library from path " << path
            << " error code: " << dlerror();
    return nullptr;
  }

#define PADDLE_CL_ASSIGN_FROM_DLSYM(func)                        \
  do {                                                           \
    void *ptr = dlsym(handle, #func);                            \
    if (ptr == nullptr) {                                        \
      VLOG(1) << "Failed to load " << #func << " from " << path; \
      continue;                                                  \
    }                                                            \
    func = reinterpret_cast<func##Func>(ptr);                    \
    VLOG(3) << "Loaded " << #func << " from " << path;           \
  } while (false)

  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetPlatformIDs);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetPlatformInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clBuildProgram);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueNDRangeKernel);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clSetKernelArg);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseKernel);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateProgramWithSource);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateBuffer);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateImage);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateImage2D);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateUserEvent);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainKernel);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateKernel);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetProgramInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clFlush);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clFinish);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseProgram);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainContext);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetContextInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateProgramWithBinary);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateCommandQueue);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateCommandQueueWithProperties);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseCommandQueue);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueMapBuffer);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueMapImage);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainProgram);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetProgramBuildInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueReadBuffer);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueReadImage);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueWriteBuffer);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clWaitForEvents);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseEvent);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateContext);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clCreateContextFromType);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseContext);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainCommandQueue);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clEnqueueUnmapMemObject);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainMemObject);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseMemObject);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetDeviceInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetDeviceIDs);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainDevice);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clReleaseDevice);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clRetainEvent);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetKernelWorkGroupInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetEventInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetEventProfilingInfo);
  PADDLE_CL_ASSIGN_FROM_DLSYM(clGetImageInfo);

#undef PADDLE_CL_ASSIGN_FROM_DLSYM

  return handle;
}

}  // namespace lite
}  // namespace paddle

CL_API_ENTRY cl_event clCreateUserEvent(cl_context context, cl_int *errcode_ret)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateUserEvent;
  if (func != nullptr) {
    return func(context, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

// Platform APIs
CL_API_ENTRY cl_int
clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platforms,
                 cl_uint *num_platforms) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetPlatformIDs;
  if (func != nullptr) {
    return func(num_entries, platforms, num_platforms);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetPlatformInfo;
  if (func != nullptr) {
    return func(platform, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Device APIs
CL_API_ENTRY cl_int clGetDeviceIDs(
    cl_platform_id platform, cl_device_type device_type, cl_uint num_entries,
    cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetDeviceIDs;
  if (func != nullptr) {
    return func(platform, device_type, num_entries, devices, num_devices);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetDeviceInfo;
  if (func != nullptr) {
    return func(device, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clRetainDevice(cl_device_id device)
    CL_API_SUFFIX__VERSION_1_2 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainDevice;
  if (func != nullptr) {
    return func(device);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseDevice(cl_device_id device)
    CL_API_SUFFIX__VERSION_1_2 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseDevice;
  if (func != nullptr) {
    return func(device);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Context APIs
CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateContext;
  if (func != nullptr) {
    return func(properties, num_devices, devices, pfn_notify, user_data,
                errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateContextFromType;
  if (func != nullptr) {
    return func(properties, device_type, pfn_notify, user_data, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY cl_int clRetainContext(cl_context context)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainContext;
  if (func != nullptr) {
    return func(context);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseContext(cl_context context)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseContext;
  if (func != nullptr) {
    return func(context);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetContextInfo;
  if (func != nullptr) {
    return func(context, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Program Object APIs
CL_API_ENTRY cl_program clCreateProgramWithSource(
    cl_context context, cl_uint count, const char **strings,
    const size_t *lengths, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateProgramWithSource;
  if (func != nullptr) {
    return func(context, count, strings, lengths, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY cl_program clCreateProgramWithBinary(
    cl_context context, cl_uint num_devices, const cl_device_id *device_list,
    const size_t *lengths, const unsigned char **binaries,
    cl_int *binary_status, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateProgramWithBinary;
  if (func != nullptr) {
    return func(context, num_devices, device_list, lengths, binaries,
                binary_status, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetProgramInfo;
  if (func != nullptr) {
    return func(program, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetProgramBuildInfo;
  if (func != nullptr) {
    return func(program, device, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clRetainProgram(cl_program program)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainProgram;
  if (func != nullptr) {
    return func(program);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseProgram(cl_program program)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseProgram;
  if (func != nullptr) {
    return func(program);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clBuildProgram;
  if (func != nullptr) {
    return func(program, num_devices, device_list, options, pfn_notify,
                user_data);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Kernel Object APIs
CL_API_ENTRY cl_kernel
clCreateKernel(cl_program program, const char *kernel_name,
               cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateKernel;
  if (func != nullptr) {
    return func(program, kernel_name, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY cl_int clRetainKernel(cl_kernel kernel)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainKernel;
  if (func != nullptr) {
    return func(kernel);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseKernel(cl_kernel kernel)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseKernel;
  if (func != nullptr) {
    return func(kernel);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clSetKernelArg(cl_kernel kernel, cl_uint arg_index,
                                   size_t arg_size, const void *arg_value)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clSetKernelArg;
  if (func != nullptr) {
    return func(kernel, arg_index, arg_size, arg_value);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Memory Object APIs
CL_API_ENTRY cl_mem
clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size,
               void *host_ptr, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateBuffer;
  if (func != nullptr) {
    return func(context, flags, size, host_ptr, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_2 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateImage;
  if (func != nullptr) {
    return func(context, flags, image_format, image_desc, host_ptr,
                errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY cl_int clRetainMemObject(cl_mem memobj)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainMemObject;
  if (func != nullptr) {
    return func(memobj);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseMemObject(cl_mem memobj)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseMemObject;
  if (func != nullptr) {
    return func(memobj);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetImageInfo;
  if (func != nullptr) {
    return func(image, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Command Queue APIs
CL_API_ENTRY cl_command_queue clCreateCommandQueueWithProperties(
    cl_context context, cl_device_id device,
    const cl_queue_properties *properties,
    cl_int *errcode_ret) CL_API_SUFFIX__VERSION_2_0 {
  auto func =
      paddle::lite::OpenCLLibrary::Get()->clCreateCommandQueueWithProperties;
  if (func != nullptr) {
    return func(context, device, properties, errcode_ret);
  } else {
    // Fix MediaTek MT6771 OpenCL driver breakage
    VLOG(3) << "Fallback to clCreateCommandQueue";
    if (properties[0] == CL_QUEUE_PROPERTIES) {
// When calling with OpenCL-CLHPP, the 2nd param is provided by caller.
#pragma GCC diagnostic push  // disable warning both for clang and gcc
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      return clCreateCommandQueue(context, device, properties[1], errcode_ret);
#pragma GCC diagnostic pop
    } else {
      LOG(FATAL) << "Unknown calling parameters, check the code here";
      if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
      return nullptr;
    }
  }
}

CL_API_ENTRY cl_int clRetainCommandQueue(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainCommandQueue;
  if (func != nullptr) {
    return func(command_queue);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseCommandQueue(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseCommandQueue;
  if (func != nullptr) {
    return func(command_queue);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Enqueued Commands APIs
CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueReadBuffer;
  if (func != nullptr) {
    return func(command_queue, buffer, blocking_read, offset, size, ptr,
                num_events_in_wait_list, event_wait_list, event);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueReadImage;
  if (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);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueWriteBuffer;
  if (func != nullptr) {
    return func(command_queue, buffer, blocking_write, offset, size, ptr,
                num_events_in_wait_list, event_wait_list, event);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueMapBuffer;
  if (func != nullptr) {
    return func(command_queue, buffer, blocking_map, map_flags, offset, size,
                num_events_in_wait_list, event_wait_list, event, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueMapImage;
  if (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);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueUnmapMemObject;
  if (func != nullptr) {
    return func(command_queue, memobj, mapped_ptr, num_events_in_wait_list,
                event_wait_list, event);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetKernelWorkGroupInfo;
  if (func != nullptr) {
    return func(kernel, device, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clEnqueueNDRangeKernel;
  if (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);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Event Object APIs
CL_API_ENTRY cl_int clWaitForEvents(
    cl_uint num_events, const cl_event *event_list) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clWaitForEvents;
  if (func != nullptr) {
    return func(num_events, event_list);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clRetainEvent;
  if (func != nullptr) {
    return func(event);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clReleaseEvent;
  if (func != nullptr) {
    return func(event);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Event API
CL_API_ENTRY 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)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetEventInfo;
  if (func != nullptr) {
    return func(event, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Profiling APIs
CL_API_ENTRY 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) CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clGetEventProfilingInfo;
  if (func != nullptr) {
    return func(event, param_name, param_value_size, param_value,
                param_value_size_ret);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Flush and Finish APIs
CL_API_ENTRY cl_int clFlush(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clFlush;
  if (func != nullptr) {
    return func(command_queue);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

CL_API_ENTRY cl_int clFinish(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  auto func = paddle::lite::OpenCLLibrary::Get()->clFinish;
  if (func != nullptr) {
    return func(command_queue);
  } else {
    return CL_INVALID_PLATFORM;
  }
}

// Deprecated OpenCL 1.1 APIs
CL_API_ENTRY /* CL_EXT_PREFIX__VERSION_1_1_DEPRECATED */ cl_mem clCreateImage2D(
    cl_context context, cl_mem_flags flags, const cl_image_format *image_format,
    size_t image_width, size_t image_height, size_t image_row_pitch,
    void *host_ptr,
    cl_int *errcode_ret) /* CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED */ {
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateImage2D;
  if (func != nullptr) {
    return func(context, flags, image_format, image_width, image_height,
                image_row_pitch, host_ptr, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}

// Deprecated OpenCL 2.0 APIs
CL_API_ENTRY /*CL_EXT_PREFIX__VERSION_1_2_DEPRECATED*/ cl_command_queue
clCreateCommandQueue(cl_context context, cl_device_id device,
                     cl_command_queue_properties properties,
                     cl_int *errcode_ret)
/* CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED */ {  // NOLINT
  auto func = paddle::lite::OpenCLLibrary::Get()->clCreateCommandQueue;
  if (func != nullptr) {
    return func(context, device, properties, errcode_ret);
  } else {
    if (errcode_ret != nullptr) *errcode_ret = CL_INVALID_PLATFORM;
    return nullptr;
  }
}