mirror of https://github.com/alibaba/MNN.git
299 lines
16 KiB
C++
299 lines
16 KiB
C++
//
|
|
// OpenCLWrapper.hpp
|
|
// MNN
|
|
//
|
|
// Created by MNN on 2019/01/31.
|
|
// Copyright © 2018, Alibaba Group Holding Limited
|
|
//
|
|
|
|
#ifndef OpenCLWrapper_hpp
|
|
#define OpenCLWrapper_hpp
|
|
|
|
#if defined(_WIN32)
|
|
#include <Windows.h>
|
|
#undef min
|
|
#undef max
|
|
#undef NO_ERROR
|
|
#endif
|
|
#include <memory>
|
|
#include "core/Macro.h"
|
|
#define CL_HPP_TARGET_OPENCL_VERSION 110
|
|
#define CL_HPP_MINIMUM_OPENCL_VERSION 110
|
|
|
|
#if !defined(_MSC_VER)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wignored-attributes"
|
|
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
|
#include "CL/cl2.hpp"
|
|
#pragma GCC diagnostic pop
|
|
#else
|
|
#include "CL/cl2.hpp"
|
|
#endif
|
|
|
|
#include "CL/cl_ext_qcom.h"
|
|
#include "CL/cl_ext.h"
|
|
#ifdef __ANDROID__
|
|
#include <android/hardware_buffer.h>
|
|
#endif
|
|
|
|
#define MNN_CHECK_NOTNULL(X) MNN_ASSERT(X != NULL)
|
|
|
|
#define MNN_CHECK_CL_SUCCESS(error, info) \
|
|
if (error != CL_SUCCESS) { \
|
|
MNN_PRINT("CL ERROR CODE : %d, info:%s \n", (int)error, info); \
|
|
}
|
|
#ifdef MNN_USE_LIB_WRAPPER
|
|
|
|
namespace MNN {
|
|
|
|
void LoadOpenCLSymbols();
|
|
void UnLoadOpenCLSymbols();
|
|
|
|
class OpenCLSymbols {
|
|
public:
|
|
bool LoadOpenCLLibrary();
|
|
bool UnLoadOpenCLLibrary();
|
|
bool isError();
|
|
bool isSvmError();
|
|
bool isPropError();
|
|
bool isQcomError();
|
|
bool isSupportAhardwareBufferFunc();
|
|
bool getFuncAddress(cl_platform_id platform, const char *func_name);
|
|
|
|
using clGetPlatformIDsFunc = cl_int (CL_API_CALL *)(cl_uint, cl_platform_id *, cl_uint *);
|
|
using clGetPlatformInfoFunc = cl_int (CL_API_CALL *)(cl_platform_id, cl_platform_info, size_t, void *, size_t *);
|
|
using clBuildProgramFunc = cl_int (CL_API_CALL *)(cl_program, cl_uint, const cl_device_id *, const char *,
|
|
void (CL_CALLBACK *pfn_notify)(cl_program, void *), void *);
|
|
using clEnqueueNDRangeKernelFunc = cl_int (CL_API_CALL *)(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_API_CALL *)(cl_kernel, cl_uint, size_t, const void *);
|
|
using clRetainMemObjectFunc = cl_int (CL_API_CALL *)(cl_mem);
|
|
using clReleaseMemObjectFunc = cl_int (CL_API_CALL *)(cl_mem);
|
|
using clEnqueueUnmapMemObjectFunc = cl_int (CL_API_CALL *)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *,
|
|
cl_event *);
|
|
using clRetainCommandQueueFunc = cl_int (CL_API_CALL *)(cl_command_queue command_queue);
|
|
using clCreateContextFunc = cl_context (CL_API_CALL *)(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_API_CALL *)(cl_command_queue,
|
|
cl_mem,
|
|
cl_mem,
|
|
const size_t*,
|
|
const size_t*,
|
|
const size_t*,
|
|
cl_uint,
|
|
const cl_event*,
|
|
cl_event*);
|
|
using clEnqueueCopyBufferFunc = cl_int (CL_API_CALL*)(cl_command_queue /* command_queue */,
|
|
cl_mem /* src_buffer */,
|
|
cl_mem /* dst_buffer */,
|
|
size_t /* src_offset */,
|
|
size_t /* dst_offset */,
|
|
size_t /* size */,
|
|
cl_uint /* num_events_in_wait_list */,
|
|
const cl_event * /* event_wait_list */,
|
|
cl_event * /* event */);
|
|
|
|
using clCreateContextFromTypeFunc = cl_context (CL_API_CALL *)(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_API_CALL *)(cl_context);
|
|
using clWaitForEventsFunc = cl_int (CL_API_CALL *)(cl_uint, const cl_event *);
|
|
using clReleaseEventFunc = cl_int (CL_API_CALL *)(cl_event);
|
|
using clEnqueueWriteBufferFunc = cl_int (CL_API_CALL *)(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_API_CALL *)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint,
|
|
const cl_event *, cl_event *);
|
|
using clEnqueueReadImageFunc = cl_int (CL_API_CALL *)(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 clEnqueueWriteImageFunc = cl_int (CL_API_CALL *)(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 clGetProgramBuildInfoFunc = cl_int (CL_API_CALL *)(cl_program, cl_device_id, cl_program_build_info, size_t, void *,
|
|
size_t *);
|
|
using clRetainProgramFunc = cl_int (CL_API_CALL *)(cl_program program);
|
|
using clEnqueueMapBufferFunc = void *(CL_API_CALL *)(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_API_CALL *)(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 clReleaseCommandQueueFunc = cl_int (CL_API_CALL *)(cl_command_queue);
|
|
using clCreateProgramWithBinaryFunc = cl_program (CL_API_CALL *)(cl_context, cl_uint, const cl_device_id *, const size_t *,
|
|
const unsigned char **, cl_int *, cl_int *);
|
|
using clRetainContextFunc = cl_int (CL_API_CALL *)(cl_context context);
|
|
using clGetContextInfoFunc = cl_int (CL_API_CALL *)(cl_context, cl_context_info, size_t, void *, size_t *);
|
|
using clReleaseProgramFunc = cl_int (CL_API_CALL *)(cl_program program);
|
|
using clFlushFunc = cl_int (CL_API_CALL *)(cl_command_queue command_queue);
|
|
using clFinishFunc = cl_int (CL_API_CALL *)(cl_command_queue command_queue);
|
|
using clGetProgramInfoFunc = cl_int (CL_API_CALL *)(cl_program, cl_program_info, size_t, void *, size_t *);
|
|
using clCreateKernelFunc = cl_kernel (CL_API_CALL *)(cl_program, const char *, cl_int *);
|
|
using clRetainKernelFunc = cl_int (CL_API_CALL *)(cl_kernel kernel);
|
|
using clCreateBufferFunc = cl_mem (CL_API_CALL *)(cl_context, cl_mem_flags, size_t, void *, cl_int *);
|
|
using clCreateImageFunc = cl_mem(CL_API_CALL *)(cl_context, cl_mem_flags, const cl_image_format *, const cl_image_desc *, 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 clCreateProgramWithSourceFunc = cl_program (CL_API_CALL *)(cl_context, cl_uint, const char **, const size_t *, cl_int *);
|
|
using clReleaseKernelFunc = cl_int (CL_API_CALL *)(cl_kernel kernel);
|
|
using clGetDeviceInfoFunc = cl_int (CL_API_CALL *)(cl_device_id, cl_device_info, size_t, void *, size_t *);
|
|
using clGetDeviceIDsFunc = cl_int (CL_API_CALL *)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *);
|
|
using clRetainEventFunc = cl_int (CL_API_CALL *)(cl_event);
|
|
using clGetKernelWorkGroupInfoFunc = cl_int (CL_API_CALL *)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *,
|
|
size_t *);
|
|
using clGetEventInfoFunc = cl_int (CL_API_CALL *)(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_API_CALL *)(cl_event event, cl_profiling_info param_name,
|
|
size_t param_value_size, void *param_value,
|
|
size_t *param_value_size_ret);
|
|
using clGetMemObjectInfoFunc = cl_int (CL_API_CALL *)(cl_mem memobj, cl_mem_info param_name,
|
|
size_t param_value_size, void *param_value,
|
|
size_t *param_value_size_ret);
|
|
using clGetImageInfoFunc = cl_int (CL_API_CALL *)(cl_mem, cl_image_info, size_t, void *, size_t *);
|
|
using clReleaseDeviceFunc = cl_int (CL_API_CALL *)(cl_device_id);
|
|
using clRetainDeviceFunc = cl_int (CL_API_CALL *)(cl_device_id);
|
|
|
|
// opencl 2.0 get sub group info and wave size.
|
|
using clCreateCommandQueueWithPropertiesFunc = cl_command_queue (CL_API_CALL *)(cl_context, cl_device_id,
|
|
const cl_queue_properties *, cl_int *);
|
|
using clSVMAllocFunc = void *(CL_API_CALL *)(cl_context, cl_mem_flags, size_t size, cl_uint);
|
|
using clSVMFreeFunc = void (CL_API_CALL *)(cl_context, void *);
|
|
using clEnqueueSVMMapFunc = cl_int (CL_API_CALL *)(cl_command_queue, cl_bool, cl_map_flags,
|
|
void *, size_t, cl_uint, const cl_event *, cl_event *);
|
|
using clEnqueueSVMUnmapFunc = cl_int (CL_API_CALL *)(cl_command_queue, void *, cl_uint,
|
|
const cl_event *, cl_event *);
|
|
using clSetKernelArgSVMPointerFunc = cl_int (CL_API_CALL *)(cl_kernel, cl_uint, const void *);
|
|
|
|
using clNewRecordingQCOMFunc = cl_recording_qcom(CL_API_CALL *)(cl_command_queue, cl_int *);
|
|
using clEndRecordingQCOMFunc = cl_int (CL_API_CALL *)(cl_recording_qcom);
|
|
using clReleaseRecordingQCOMFunc = cl_int (CL_API_CALL *)(cl_recording_qcom);
|
|
using clRetainRecordingQCOMFunc = cl_int (CL_API_CALL *)(cl_recording_qcom);
|
|
using clEnqueueRecordingQCOMFunc = cl_int (CL_API_CALL *)(cl_command_queue, cl_recording_qcom, size_t, const cl_array_arg_qcom*, size_t, const cl_offset_qcom*,
|
|
size_t, const cl_workgroup_qcom*, size_t, const cl_workgroup_qcom*, cl_uint, const cl_event*, cl_event*);
|
|
using clEnqueueRecordingSVMQCOMFunc = cl_int (CL_API_CALL *)(cl_command_queue, cl_recording_qcom, size_t, const cl_array_arg_qcom*, size_t, const cl_array_arg_qcom*,
|
|
size_t, const cl_offset_qcom*, size_t, const cl_workgroup_qcom*, size_t, const cl_workgroup_qcom*,
|
|
size_t, const cl_array_kernel_exec_info_qcom*, cl_uint, const cl_event*, cl_event*);
|
|
|
|
using clGetExtensionFunctionAddressFunc = void *(CL_API_CALL *)(const char *);
|
|
using clGetExtensionFunctionAddressForPlatformFunc = void *(CL_API_CALL *)(cl_platform_id, const char *);
|
|
using clImportMemoryARMFunc = cl_mem (CL_API_CALL *)(cl_context, cl_mem_flags, const cl_import_properties_arm*, void*, size_t, cl_int*);
|
|
|
|
#ifdef __ANDROID__
|
|
// use android ahardwarebuffer
|
|
using AHardwareBuffer_describeFunc = void (*)(const AHardwareBuffer* buffer, AHardwareBuffer_Desc* outDesc);
|
|
#endif
|
|
|
|
|
|
#define MNN_CL_DEFINE_FUNC_PTR(func) func##Func func = nullptr
|
|
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetPlatformIDs);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetPlatformInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clBuildProgram);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueNDRangeKernel);
|
|
MNN_CL_DEFINE_FUNC_PTR(clSetKernelArg);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseKernel);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateProgramWithSource);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateBuffer);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateImage2D);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainKernel);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateKernel);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetProgramInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clFlush);
|
|
MNN_CL_DEFINE_FUNC_PTR(clFinish);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseProgram);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainContext);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetContextInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateProgramWithBinary);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateCommandQueue);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseCommandQueue);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueCopyBuffer);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueMapBuffer);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueMapImage);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueCopyImage);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainProgram);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetProgramBuildInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueReadBuffer);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueWriteBuffer);
|
|
MNN_CL_DEFINE_FUNC_PTR(clWaitForEvents);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseEvent);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateContext);
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateContextFromType);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseContext);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainCommandQueue);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueUnmapMemObject);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainMemObject);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseMemObject);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetDeviceInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetDeviceIDs);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainEvent);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetKernelWorkGroupInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetEventInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetEventProfilingInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetMemObjectInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetImageInfo);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueReadImage);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueWriteImage);
|
|
|
|
MNN_CL_DEFINE_FUNC_PTR(clCreateCommandQueueWithProperties);
|
|
MNN_CL_DEFINE_FUNC_PTR(clSVMAlloc);
|
|
MNN_CL_DEFINE_FUNC_PTR(clSVMFree);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueSVMMap);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueSVMUnmap);
|
|
MNN_CL_DEFINE_FUNC_PTR(clSetKernelArgSVMPointer);
|
|
|
|
MNN_CL_DEFINE_FUNC_PTR(clNewRecordingQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEndRecordingQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clReleaseRecordingQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clRetainRecordingQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueRecordingQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clEnqueueRecordingSVMQCOM);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetExtensionFunctionAddress);
|
|
MNN_CL_DEFINE_FUNC_PTR(clGetExtensionFunctionAddressForPlatform);
|
|
MNN_CL_DEFINE_FUNC_PTR(clImportMemoryARM);
|
|
|
|
#ifdef __ANDROID__
|
|
MNN_CL_DEFINE_FUNC_PTR(AHardwareBuffer_describe);
|
|
#endif
|
|
|
|
#undef MNN_CL_DEFINE_FUNC_PTR
|
|
|
|
private:
|
|
bool LoadLibraryFromPath(const std::string &path);
|
|
#if defined(_WIN32)
|
|
HMODULE handle_ = nullptr;
|
|
#else
|
|
void *handle_ = nullptr;
|
|
#endif
|
|
void *ahardwarebuffer_handle_ = nullptr;
|
|
bool mIsError{false};
|
|
bool mSvmError{false};
|
|
bool mPropError{false};
|
|
bool mQcomError{false};
|
|
bool mCL_12Error{false};
|
|
bool mIsSupportAhardwareBuffer{false};
|
|
};
|
|
|
|
class OpenCLSymbolsOperator {
|
|
public:
|
|
static OpenCLSymbolsOperator *createOpenCLSymbolsOperatorSingleInstance();
|
|
|
|
static OpenCLSymbols *getOpenclSymbolsPtr();
|
|
OpenCLSymbolsOperator();
|
|
~OpenCLSymbolsOperator();
|
|
|
|
private:
|
|
OpenCLSymbolsOperator(const OpenCLSymbolsOperator &) = delete;
|
|
OpenCLSymbolsOperator &operator=(const OpenCLSymbolsOperator &) = delete;
|
|
|
|
static std::shared_ptr<OpenCLSymbols> gOpenclSymbols;
|
|
};
|
|
#ifdef __ANDROID__
|
|
void MNNAHardwareBuffer_describe(const AHardwareBuffer* buffer, AHardwareBuffer_Desc* outDesc);
|
|
#endif
|
|
} // namespace MNN
|
|
#endif
|
|
#endif /* OpenCLWrapper_hpp */
|