From 58c4ff1ddd2db5eb9977d99708e5722951c34526 Mon Sep 17 00:00:00 2001 From: Anthony Barbier Date: Thu, 9 Nov 2017 09:15:32 +0000 Subject: COMPMID-663: Updated CLSymbols to use std::function This will allow us to use it as an interceptor for some instruments in the benchmark infrastructure Change-Id: Iccde638c8db6312a74d343ad9f6e369e05230736 Reviewed-on: http://mpd-gerrit.cambridge.arm.com/95014 Tested-by: Kaizen Reviewed-by: Georgios Pinitas --- arm_compute/core/CL/OpenCL.h | 97 ++++++++++++------------------- src/core/CL/OpenCL.cpp | 133 +++++++++++++++++++++++-------------------- 2 files changed, 105 insertions(+), 125 deletions(-) diff --git a/arm_compute/core/CL/OpenCL.h b/arm_compute/core/CL/OpenCL.h index 6780e23c2d..8a2d30bb83 100644 --- a/arm_compute/core/CL/OpenCL.h +++ b/arm_compute/core/CL/OpenCL.h @@ -54,69 +54,42 @@ public: bool load(const std::string &library); bool load_default(); - using clBuildProgram_func = cl_int (*)(cl_program, cl_uint, const cl_device_id *, const char *, void (*pfn_notify)(cl_program, void *), void *); - using clEnqueueNDRangeKernel_func = 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 clSetKernelArg_func = cl_int (*)(cl_kernel, cl_uint, size_t, const void *); - using clRetainMemObject_func = cl_int (*)(cl_mem); - using clReleaseMemObject_func = cl_int (*)(cl_mem); - using clEnqueueUnmapMemObject_func = cl_int (*)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *, cl_event *); - using clRetainCommandQueue_func = cl_int (*)(cl_command_queue command_queue); - using clReleaseContext_func = cl_int (*)(cl_context); - using clReleaseEvent_func = cl_int (*)(cl_event); - using clEnqueueWriteBuffer_func = cl_int (*)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *); - using clEnqueueReadBuffer_func = cl_int (*)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *); - using clGetProgramBuildInfo_func = cl_int (*)(cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *); - using clRetainProgram_func = cl_int (*)(cl_program program); - using clEnqueueMapBuffer_func = 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 clReleaseCommandQueue_func = cl_int (*)(cl_command_queue); - using clCreateProgramWithBinary_func = cl_program (*)(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int *); - using clRetainContext_func = cl_int (*)(cl_context context); - using clReleaseProgram_func = cl_int (*)(cl_program program); - using clFlush_func = cl_int (*)(cl_command_queue command_queue); - using clFinish_func = cl_int (*)(cl_command_queue command_queue); - using clGetProgramInfo_func = cl_int (*)(cl_program, cl_program_info, size_t, void *, size_t *); - using clCreateKernel_func = cl_kernel (*)(cl_program, const char *, cl_int *); - using clRetainKernel_func = cl_int (*)(cl_kernel kernel); - using clCreateBuffer_func = cl_mem (*)(cl_context, cl_mem_flags, size_t, void *, cl_int *); - using clCreateProgramWithSource_func = cl_program (*)(cl_context, cl_uint, const char **, const size_t *, cl_int *); - using clReleaseKernel_func = cl_int (*)(cl_kernel kernel); - using clGetDeviceInfo_func = cl_int (*)(cl_device_id, cl_device_info, size_t, void *, size_t *); - using clGetDeviceIDs_func = cl_int (*)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *); - using clRetainEvent_func = cl_int (*)(cl_event); - using clGetPlatformIDs_func = cl_int (*)(cl_uint, cl_platform_id *, cl_uint *); - using clGetKernelWorkGroupInfo_func = cl_int (*)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *, size_t *); +#define DECLARE_FUNCTION_PTR(func_name) \ + std::function func_name##_ptr = nullptr - clBuildProgram_func clBuildProgram = nullptr; - clEnqueueNDRangeKernel_func clEnqueueNDRangeKernel = nullptr; - clSetKernelArg_func clSetKernelArg = nullptr; - clReleaseKernel_func clReleaseKernel = nullptr; - clCreateProgramWithSource_func clCreateProgramWithSource = nullptr; - clCreateBuffer_func clCreateBuffer = nullptr; - clRetainKernel_func clRetainKernel = nullptr; - clCreateKernel_func clCreateKernel = nullptr; - clGetProgramInfo_func clGetProgramInfo = nullptr; - clFlush_func clFlush = nullptr; - clFinish_func clFinish = nullptr; - clReleaseProgram_func clReleaseProgram = nullptr; - clRetainContext_func clRetainContext = nullptr; - clCreateProgramWithBinary_func clCreateProgramWithBinary = nullptr; - clReleaseCommandQueue_func clReleaseCommandQueue = nullptr; - clEnqueueMapBuffer_func clEnqueueMapBuffer = nullptr; - clRetainProgram_func clRetainProgram = nullptr; - clGetProgramBuildInfo_func clGetProgramBuildInfo = nullptr; - clEnqueueReadBuffer_func clEnqueueReadBuffer = nullptr; - clEnqueueWriteBuffer_func clEnqueueWriteBuffer = nullptr; - clReleaseEvent_func clReleaseEvent = nullptr; - clReleaseContext_func clReleaseContext = nullptr; - clRetainCommandQueue_func clRetainCommandQueue = nullptr; - clEnqueueUnmapMemObject_func clEnqueueUnmapMemObject = nullptr; - clRetainMemObject_func clRetainMemObject = nullptr; - clReleaseMemObject_func clReleaseMemObject = nullptr; - clGetDeviceInfo_func clGetDeviceInfo = nullptr; - clGetDeviceIDs_func clGetDeviceIDs = nullptr; - clRetainEvent_func clRetainEvent = nullptr; - clGetPlatformIDs_func clGetPlatformIDs = nullptr; - clGetKernelWorkGroupInfo_func clGetKernelWorkGroupInfo = nullptr; + DECLARE_FUNCTION_PTR(clBuildProgram); + DECLARE_FUNCTION_PTR(clEnqueueNDRangeKernel); + DECLARE_FUNCTION_PTR(clSetKernelArg); + DECLARE_FUNCTION_PTR(clReleaseKernel); + DECLARE_FUNCTION_PTR(clCreateProgramWithSource); + DECLARE_FUNCTION_PTR(clCreateBuffer); + DECLARE_FUNCTION_PTR(clRetainKernel); + DECLARE_FUNCTION_PTR(clCreateKernel); + DECLARE_FUNCTION_PTR(clGetProgramInfo); + DECLARE_FUNCTION_PTR(clFlush); + DECLARE_FUNCTION_PTR(clFinish); + DECLARE_FUNCTION_PTR(clReleaseProgram); + DECLARE_FUNCTION_PTR(clRetainContext); + DECLARE_FUNCTION_PTR(clCreateProgramWithBinary); + DECLARE_FUNCTION_PTR(clReleaseCommandQueue); + DECLARE_FUNCTION_PTR(clEnqueueMapBuffer); + DECLARE_FUNCTION_PTR(clRetainProgram); + DECLARE_FUNCTION_PTR(clGetProgramBuildInfo); + DECLARE_FUNCTION_PTR(clEnqueueReadBuffer); + DECLARE_FUNCTION_PTR(clEnqueueWriteBuffer); + DECLARE_FUNCTION_PTR(clReleaseEvent); + DECLARE_FUNCTION_PTR(clReleaseContext); + DECLARE_FUNCTION_PTR(clRetainCommandQueue); + DECLARE_FUNCTION_PTR(clEnqueueUnmapMemObject); + DECLARE_FUNCTION_PTR(clRetainMemObject); + DECLARE_FUNCTION_PTR(clReleaseMemObject); + DECLARE_FUNCTION_PTR(clGetDeviceInfo); + DECLARE_FUNCTION_PTR(clGetDeviceIDs); + DECLARE_FUNCTION_PTR(clRetainEvent); + DECLARE_FUNCTION_PTR(clGetPlatformIDs); + DECLARE_FUNCTION_PTR(clGetKernelWorkGroupInfo); + +#undef DECLARE_FUNCTION_PTR private: std::pair _loaded{ false, false }; diff --git a/src/core/CL/OpenCL.cpp b/src/core/CL/OpenCL.cpp index 287c5e2f5a..3a145e0ab3 100644 --- a/src/core/CL/OpenCL.cpp +++ b/src/core/CL/OpenCL.cpp @@ -71,37 +71,44 @@ bool CLSymbols::load(const std::string &library) return false; } - clBuildProgram = reinterpret_cast(dlsym(handle, "clBuildProgram")); - clEnqueueNDRangeKernel = reinterpret_cast(dlsym(handle, "clEnqueueNDRangeKernel")); - clSetKernelArg = reinterpret_cast(dlsym(handle, "clSetKernelArg")); - clReleaseKernel = reinterpret_cast(dlsym(handle, "clReleaseKernel")); - clCreateProgramWithSource = reinterpret_cast(dlsym(handle, "clCreateProgramWithSource")); - clCreateBuffer = reinterpret_cast(dlsym(handle, "clCreateBuffer")); - clRetainKernel = reinterpret_cast(dlsym(handle, "clRetainKernel")); - clCreateKernel = reinterpret_cast(dlsym(handle, "clCreateKernel")); - clGetProgramInfo = reinterpret_cast(dlsym(handle, "clGetProgramInfo")); - clFlush = reinterpret_cast(dlsym(handle, "clFlush")); - clFinish = reinterpret_cast(dlsym(handle, "clFinish")); - clReleaseProgram = reinterpret_cast(dlsym(handle, "clReleaseProgram")); - clRetainContext = reinterpret_cast(dlsym(handle, "clRetainContext")); - clCreateProgramWithBinary = reinterpret_cast(dlsym(handle, "clCreateProgramWithBinary")); - clReleaseCommandQueue = reinterpret_cast(dlsym(handle, "clReleaseCommandQueue")); - clEnqueueMapBuffer = reinterpret_cast(dlsym(handle, "clEnqueueMapBuffer")); - clRetainProgram = reinterpret_cast(dlsym(handle, "clRetainProgram")); - clGetProgramBuildInfo = reinterpret_cast(dlsym(handle, "clGetProgramBuildInfo")); - clEnqueueReadBuffer = reinterpret_cast(dlsym(handle, "clEnqueueReadBuffer")); - clEnqueueWriteBuffer = reinterpret_cast(dlsym(handle, "clEnqueueWriteBuffer")); - clReleaseEvent = reinterpret_cast(dlsym(handle, "clReleaseEvent")); - clReleaseContext = reinterpret_cast(dlsym(handle, "clReleaseContext")); - clRetainCommandQueue = reinterpret_cast(dlsym(handle, "clRetainCommandQueue")); - clEnqueueUnmapMemObject = reinterpret_cast(dlsym(handle, "clEnqueueUnmapMemObject")); - clRetainMemObject = reinterpret_cast(dlsym(handle, "clRetainMemObject")); - clReleaseMemObject = reinterpret_cast(dlsym(handle, "clReleaseMemObject")); - clGetDeviceInfo = reinterpret_cast(dlsym(handle, "clGetDeviceInfo")); - clGetDeviceIDs = reinterpret_cast(dlsym(handle, "clGetDeviceIDs")); - clRetainEvent = reinterpret_cast(dlsym(handle, "clRetainEvent")); - clGetPlatformIDs = reinterpret_cast(dlsym(handle, "clGetPlatformIDs")); - clGetKernelWorkGroupInfo = reinterpret_cast(dlsym(handle, "clGetKernelWorkGroupInfo")); +#define LOAD_FUNCTION_PTR(func_name, handle) \ + func_name##_ptr = reinterpret_cast(dlsym(handle, #func_name)); + + LOAD_FUNCTION_PTR(clBuildProgram, handle); + LOAD_FUNCTION_PTR(clEnqueueNDRangeKernel, handle); + LOAD_FUNCTION_PTR(clBuildProgram, handle); + LOAD_FUNCTION_PTR(clEnqueueNDRangeKernel, handle); + LOAD_FUNCTION_PTR(clSetKernelArg, handle); + LOAD_FUNCTION_PTR(clReleaseKernel, handle); + LOAD_FUNCTION_PTR(clCreateProgramWithSource, handle); + LOAD_FUNCTION_PTR(clCreateBuffer, handle); + LOAD_FUNCTION_PTR(clRetainKernel, handle); + LOAD_FUNCTION_PTR(clCreateKernel, handle); + LOAD_FUNCTION_PTR(clGetProgramInfo, handle); + LOAD_FUNCTION_PTR(clFlush, handle); + LOAD_FUNCTION_PTR(clFinish, handle); + LOAD_FUNCTION_PTR(clReleaseProgram, handle); + LOAD_FUNCTION_PTR(clRetainContext, handle); + LOAD_FUNCTION_PTR(clCreateProgramWithBinary, handle); + LOAD_FUNCTION_PTR(clReleaseCommandQueue, handle); + LOAD_FUNCTION_PTR(clEnqueueMapBuffer, handle); + LOAD_FUNCTION_PTR(clRetainProgram, handle); + LOAD_FUNCTION_PTR(clGetProgramBuildInfo, handle); + LOAD_FUNCTION_PTR(clEnqueueReadBuffer, handle); + LOAD_FUNCTION_PTR(clEnqueueWriteBuffer, handle); + LOAD_FUNCTION_PTR(clReleaseEvent, handle); + LOAD_FUNCTION_PTR(clReleaseContext, handle); + LOAD_FUNCTION_PTR(clRetainCommandQueue, handle); + LOAD_FUNCTION_PTR(clEnqueueUnmapMemObject, handle); + LOAD_FUNCTION_PTR(clRetainMemObject, handle); + LOAD_FUNCTION_PTR(clReleaseMemObject, handle); + LOAD_FUNCTION_PTR(clGetDeviceInfo, handle); + LOAD_FUNCTION_PTR(clGetDeviceIDs, handle); + LOAD_FUNCTION_PTR(clRetainEvent, handle); + LOAD_FUNCTION_PTR(clGetPlatformIDs, handle); + LOAD_FUNCTION_PTR(clGetKernelWorkGroupInfo, handle); + +#undef LOAD_FUNCTION_PTR dlclose(handle); @@ -114,7 +121,7 @@ bool CLSymbols::load(const std::string &library) bool opencl_is_available() { CLSymbols::get().load_default(); - return CLSymbols::get().clBuildProgram != nullptr; + return CLSymbols::get().clBuildProgram_ptr != nullptr; } } // namespace arm_compute @@ -127,7 +134,7 @@ cl_int clBuildProgram( void *user_data) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clBuildProgram; + auto func = arm_compute::CLSymbols::get().clBuildProgram_ptr; if(func != nullptr) { return func(program, num_devices, device_list, options, pfn_notify, user_data); @@ -150,7 +157,7 @@ cl_int clEnqueueNDRangeKernel( cl_event *event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clEnqueueNDRangeKernel; + auto func = arm_compute::CLSymbols::get().clEnqueueNDRangeKernel_ptr; 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); @@ -168,7 +175,7 @@ cl_int clSetKernelArg( const void *arg_value) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clSetKernelArg; + auto func = arm_compute::CLSymbols::get().clSetKernelArg_ptr; if(func != nullptr) { return func(kernel, arg_index, arg_size, arg_value); @@ -182,7 +189,7 @@ cl_int clSetKernelArg( cl_int clRetainMemObject(cl_mem memobj) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainMemObject; + auto func = arm_compute::CLSymbols::get().clRetainMemObject_ptr; if(func != nullptr) { return func(memobj); @@ -196,7 +203,7 @@ cl_int clRetainMemObject(cl_mem memobj) cl_int clReleaseMemObject(cl_mem memobj) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseMemObject; + auto func = arm_compute::CLSymbols::get().clReleaseMemObject_ptr; if(func != nullptr) { return func(memobj); @@ -216,7 +223,7 @@ cl_int clEnqueueUnmapMemObject( cl_event *event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clEnqueueUnmapMemObject; + auto func = arm_compute::CLSymbols::get().clEnqueueUnmapMemObject_ptr; if(func != nullptr) { return func(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event); @@ -230,7 +237,7 @@ cl_int clEnqueueUnmapMemObject( cl_int clRetainCommandQueue(cl_command_queue command_queue) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainCommandQueue; + auto func = arm_compute::CLSymbols::get().clRetainCommandQueue_ptr; if(func != nullptr) { return func(command_queue); @@ -244,7 +251,7 @@ cl_int clRetainCommandQueue(cl_command_queue command_queue) cl_int clReleaseContext(cl_context context) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseContext; + auto func = arm_compute::CLSymbols::get().clReleaseContext_ptr; if(func != nullptr) { return func(context); @@ -257,7 +264,7 @@ cl_int clReleaseContext(cl_context context) cl_int clReleaseEvent(cl_event event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseEvent; + auto func = arm_compute::CLSymbols::get().clReleaseEvent_ptr; if(func != nullptr) { return func(event); @@ -280,7 +287,7 @@ cl_int clEnqueueWriteBuffer( cl_event *event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clEnqueueWriteBuffer; + auto func = arm_compute::CLSymbols::get().clEnqueueWriteBuffer_ptr; if(func != nullptr) { return func(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); @@ -303,7 +310,7 @@ cl_int clEnqueueReadBuffer( cl_event *event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clEnqueueReadBuffer; + auto func = arm_compute::CLSymbols::get().clEnqueueReadBuffer_ptr; if(func != nullptr) { return func(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); @@ -323,7 +330,7 @@ cl_int clGetProgramBuildInfo( size_t *param_value_size_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetProgramBuildInfo; + auto func = arm_compute::CLSymbols::get().clGetProgramBuildInfo_ptr; if(func != nullptr) { return func(program, device, param_name, param_value_size, param_value, param_value_size_ret); @@ -337,7 +344,7 @@ cl_int clGetProgramBuildInfo( cl_int clRetainProgram(cl_program program) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainProgram; + auto func = arm_compute::CLSymbols::get().clRetainProgram_ptr; if(func != nullptr) { return func(program); @@ -361,7 +368,7 @@ void *clEnqueueMapBuffer( cl_int *errcode_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clEnqueueMapBuffer; + auto func = arm_compute::CLSymbols::get().clEnqueueMapBuffer_ptr; 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); @@ -379,7 +386,7 @@ void *clEnqueueMapBuffer( cl_int clReleaseCommandQueue(cl_command_queue command_queue) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseCommandQueue; + auto func = arm_compute::CLSymbols::get().clReleaseCommandQueue_ptr; if(func != nullptr) { return func(command_queue); @@ -400,7 +407,7 @@ cl_program clCreateProgramWithBinary( cl_int *errcode_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clCreateProgramWithBinary; + auto func = arm_compute::CLSymbols::get().clCreateProgramWithBinary_ptr; if(func != nullptr) { return func(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret); @@ -418,7 +425,7 @@ cl_program clCreateProgramWithBinary( cl_int clRetainContext(cl_context context) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainContext; + auto func = arm_compute::CLSymbols::get().clRetainContext_ptr; if(func != nullptr) { return func(context); @@ -432,7 +439,7 @@ cl_int clRetainContext(cl_context context) cl_int clReleaseProgram(cl_program program) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseProgram; + auto func = arm_compute::CLSymbols::get().clReleaseProgram_ptr; if(func != nullptr) { return func(program); @@ -446,7 +453,7 @@ cl_int clReleaseProgram(cl_program program) cl_int clFlush(cl_command_queue command_queue) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clFlush; + auto func = arm_compute::CLSymbols::get().clFlush_ptr; if(func != nullptr) { return func(command_queue); @@ -460,7 +467,7 @@ cl_int clFlush(cl_command_queue command_queue) cl_int clFinish(cl_command_queue command_queue) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clFinish; + auto func = arm_compute::CLSymbols::get().clFinish_ptr; if(func != nullptr) { return func(command_queue); @@ -479,7 +486,7 @@ cl_int clGetProgramInfo( size_t *param_value_size_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetProgramInfo; + auto func = arm_compute::CLSymbols::get().clGetProgramInfo_ptr; if(func != nullptr) { return func(program, param_name, param_value_size, param_value, param_value_size_ret); @@ -496,7 +503,7 @@ cl_kernel clCreateKernel( cl_int *errcode_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clCreateKernel; + auto func = arm_compute::CLSymbols::get().clCreateKernel_ptr; if(func != nullptr) { return func(program, kernel_name, errcode_ret); @@ -514,7 +521,7 @@ cl_kernel clCreateKernel( cl_int clRetainKernel(cl_kernel kernel) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainKernel; + auto func = arm_compute::CLSymbols::get().clRetainKernel_ptr; if(func != nullptr) { return func(kernel); @@ -533,7 +540,7 @@ cl_mem clCreateBuffer( cl_int *errcode_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clCreateBuffer; + auto func = arm_compute::CLSymbols::get().clCreateBuffer_ptr; if(func != nullptr) { return func(context, flags, size, host_ptr, errcode_ret); @@ -556,7 +563,7 @@ cl_program clCreateProgramWithSource( cl_int *errcode_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clCreateProgramWithSource; + auto func = arm_compute::CLSymbols::get().clCreateProgramWithSource_ptr; if(func != nullptr) { return func(context, count, strings, lengths, errcode_ret); @@ -574,7 +581,7 @@ cl_program clCreateProgramWithSource( cl_int clReleaseKernel(cl_kernel kernel) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clReleaseKernel; + auto func = arm_compute::CLSymbols::get().clReleaseKernel_ptr; if(func != nullptr) { return func(kernel); @@ -592,7 +599,7 @@ cl_int clGetDeviceIDs(cl_platform_id platform, cl_uint *num_devices) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetDeviceIDs; + auto func = arm_compute::CLSymbols::get().clGetDeviceIDs_ptr; if(func != nullptr) { return func(platform, device_type, num_entries, devices, num_devices); @@ -610,7 +617,7 @@ cl_int clGetDeviceInfo(cl_device_id device, size_t *param_value_size_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetDeviceInfo; + auto func = arm_compute::CLSymbols::get().clGetDeviceInfo_ptr; if(func != nullptr) { return func(device, param_name, param_value_size, param_value, param_value_size_ret); @@ -624,7 +631,7 @@ cl_int clGetDeviceInfo(cl_device_id device, cl_int clRetainEvent(cl_event event) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clRetainEvent; + auto func = arm_compute::CLSymbols::get().clRetainEvent_ptr; if(func != nullptr) { return func(event); @@ -638,7 +645,7 @@ cl_int clRetainEvent(cl_event event) cl_int clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetPlatformIDs; + auto func = arm_compute::CLSymbols::get().clGetPlatformIDs_ptr; if(func != nullptr) { return func(num_entries, platforms, num_platforms); @@ -658,7 +665,7 @@ clGetKernelWorkGroupInfo(cl_kernel kernel, size_t *param_value_size_ret) { arm_compute::CLSymbols::get().load_default(); - auto func = arm_compute::CLSymbols::get().clGetKernelWorkGroupInfo; + auto func = arm_compute::CLSymbols::get().clGetKernelWorkGroupInfo_ptr; if(func != nullptr) { return func(kernel, device, param_name, param_value_size, param_value, param_value_size_ret); -- cgit v1.2.1