Class for loading OpenCL symbols. More...

#include <OpenCL.h>

Public Member Functions
	CLSymbols () noexcept(false)
	Default Constructor. More...

void	load_symbols (void *handle)
	Load OpenCL symbols from handle. More...

bool	load (const std::vector< std::string > &libraries_filenames, bool use_loader=false)
	This method attempts to load the OpenCL symbols from the first available library from the provided OpenCL libraries. More...

bool	load_default ()
	Load symbols from any of the default OpenCL library names. More...

Static Public Member Functions
static CLSymbols &	get ()
	Get the static instance of CLSymbols. More...

Data Fields
std::function< decltype(clCreateContext)>	clCreateContext_ptr = nullptr

std::function< decltype(clCreateContextFromType)>	clCreateContextFromType_ptr = nullptr

std::function< decltype(clCreateCommandQueue)>	clCreateCommandQueue_ptr = nullptr

std::function< decltype(clCreateCommandQueueWithProperties)>	clCreateCommandQueueWithProperties_ptr = nullptr

std::function< decltype(clGetContextInfo)>	clGetContextInfo_ptr = nullptr

std::function< decltype(clBuildProgram)>	clBuildProgram_ptr = nullptr

std::function< decltype(clEnqueueNDRangeKernel)>	clEnqueueNDRangeKernel_ptr = nullptr

std::function< decltype(clSetKernelArg)>	clSetKernelArg_ptr = nullptr

std::function< decltype(clReleaseKernel)>	clReleaseKernel_ptr = nullptr

std::function< decltype(clCreateProgramWithSource)>	clCreateProgramWithSource_ptr = nullptr

std::function< decltype(clCreateBuffer)>	clCreateBuffer_ptr = nullptr

std::function< decltype(clRetainKernel)>	clRetainKernel_ptr = nullptr

std::function< decltype(clCreateKernel)>	clCreateKernel_ptr = nullptr

std::function< decltype(clGetProgramInfo)>	clGetProgramInfo_ptr = nullptr

std::function< decltype(clFlush)>	clFlush_ptr = nullptr

std::function< decltype(clFinish)>	clFinish_ptr = nullptr

std::function< decltype(clReleaseProgram)>	clReleaseProgram_ptr = nullptr

std::function< decltype(clRetainContext)>	clRetainContext_ptr = nullptr

std::function< decltype(clCreateProgramWithBinary)>	clCreateProgramWithBinary_ptr = nullptr

std::function< decltype(clReleaseCommandQueue)>	clReleaseCommandQueue_ptr = nullptr

std::function< decltype(clEnqueueMapBuffer)>	clEnqueueMapBuffer_ptr = nullptr

std::function< decltype(clRetainProgram)>	clRetainProgram_ptr = nullptr

std::function< decltype(clGetProgramBuildInfo)>	clGetProgramBuildInfo_ptr = nullptr

std::function< decltype(clEnqueueReadBuffer)>	clEnqueueReadBuffer_ptr = nullptr

std::function< decltype(clEnqueueWriteBuffer)>	clEnqueueWriteBuffer_ptr = nullptr

std::function< decltype(clReleaseEvent)>	clReleaseEvent_ptr = nullptr

std::function< decltype(clReleaseContext)>	clReleaseContext_ptr = nullptr

std::function< decltype(clRetainCommandQueue)>	clRetainCommandQueue_ptr = nullptr

std::function< decltype(clEnqueueUnmapMemObject)>	clEnqueueUnmapMemObject_ptr = nullptr

std::function< decltype(clRetainMemObject)>	clRetainMemObject_ptr = nullptr

std::function< decltype(clReleaseMemObject)>	clReleaseMemObject_ptr = nullptr

std::function< decltype(clGetDeviceInfo)>	clGetDeviceInfo_ptr = nullptr

std::function< decltype(clGetDeviceIDs)>	clGetDeviceIDs_ptr = nullptr

std::function< decltype(clGetMemObjectInfo)>	clGetMemObjectInfo_ptr = nullptr

std::function< decltype(clRetainEvent)>	clRetainEvent_ptr = nullptr

std::function< decltype(clGetPlatformInfo)>	clGetPlatformInfo_ptr = nullptr

std::function< decltype(clGetPlatformIDs)>	clGetPlatformIDs_ptr = nullptr

std::function< decltype(clGetKernelWorkGroupInfo)>	clGetKernelWorkGroupInfo_ptr = nullptr

std::function< decltype(clGetCommandQueueInfo)>	clGetCommandQueueInfo_ptr = nullptr

std::function< decltype(clGetKernelInfo)>	clGetKernelInfo_ptr = nullptr

std::function< decltype(clGetEventProfilingInfo)>	clGetEventProfilingInfo_ptr = nullptr

std::function< decltype(clSVMAlloc)>	clSVMAlloc_ptr = nullptr

std::function< decltype(clSVMFree)>	clSVMFree_ptr = nullptr

std::function< decltype(clEnqueueSVMMap)>	clEnqueueSVMMap_ptr = nullptr

std::function< decltype(clEnqueueSVMUnmap)>	clEnqueueSVMUnmap_ptr = nullptr

std::function< decltype(clEnqueueMarker)>	clEnqueueMarker_ptr = nullptr

std::function< decltype(clWaitForEvents)>	clWaitForEvents_ptr = nullptr

std::function< decltype(clCreateImage)>	clCreateImage_ptr = nullptr

std::function< decltype(clSetKernelExecInfo)>	clSetKernelExecInfo_ptr = nullptr

std::function< decltype(clImportMemoryARM)>	clImportMemoryARM_ptr = nullptr

Detailed Description

Class for loading OpenCL symbols.

Definition at line 61 of file OpenCL.h.

Constructor & Destructor Documentation

◆ CLSymbols()

CLSymbols ( )

noexcept

Default Constructor.

Definition at line 39 of file OpenCL.cpp.

     : _loaded(
 {
     false, false
 })
 {
 }

Member Function Documentation

◆ get()

CLSymbols & get ( )

static

Get the static instance of CLSymbols.

Returns: The static instance of CLSymbols.

Definition at line 47 of file OpenCL.cpp.

 {
     static CLSymbols symbols;
     return symbols;
 }

Referenced by clBuildProgram(), clCreateBuffer(), clCreateCommandQueue(), clCreateCommandQueueWithProperties(), clCreateContext(), clCreateContextFromType(), clCreateImage(), clCreateKernel(), clCreateProgramWithBinary(), clCreateProgramWithSource(), clEnqueueMapBuffer(), clEnqueueMarker(), clEnqueueNDRangeKernel(), clEnqueueReadBuffer(), clEnqueueSVMMap(), clEnqueueSVMUnmap(), clEnqueueUnmapMemObject(), clEnqueueWriteBuffer(), clFinish(), clFlush(), clGetCommandQueueInfo(), clGetContextInfo(), clGetDeviceIDs(), clGetDeviceInfo(), clGetEventProfilingInfo(), clGetKernelInfo(), clGetKernelWorkGroupInfo(), clGetMemObjectInfo(), clGetPlatformIDs(), clGetPlatformInfo(), clGetProgramBuildInfo(), clGetProgramInfo(), clImportMemoryARM(), clReleaseCommandQueue(), clReleaseContext(), clReleaseEvent(), clReleaseKernel(), clReleaseMemObject(), clReleaseProgram(), clRetainCommandQueue(), clRetainContext(), clRetainEvent(), clRetainKernel(), clRetainMemObject(), clRetainProgram(), clSetKernelArg(), clSetKernelExecInfo(), clSVMAlloc(), clSVMFree(), clWaitForEvents(), arm_compute::opencl_is_available(), OpenCLMemoryUsage::test_start(), OpenCLClock< output_timestamps >::test_start(), OpenCLMemoryUsage::test_stop(), and OpenCLClock< output_timestamps >::test_stop().

◆ load()

bool load	(	const std::vector< std::string > &	libraries_filenames,
		bool	use_loader = `false`
	)

This method attempts to load the OpenCL symbols from the first available library from the provided OpenCL libraries.

Parameters

[in]	libraries_filenames	Vector containing the filenames of the libraries to be loaded.
[in]	use_loader	Use symbol loader function loadOpenCLPointer.

Returns: True if loading the library is successful. False if all the provided libraries could not be loaded.

Definition at line 98 of file OpenCL.cpp.

 {
     void        *handle = nullptr;
     unsigned int index  = 0;
     for(index = 0; index < libraries_filenames.size(); ++index)
     {
         handle = dlopen(libraries_filenames[index].c_str(), RTLD_LAZY | RTLD_LOCAL);
         if(handle != nullptr)
         {
             break;
         }
     }
     if(index == libraries_filenames.size())
     {
         // Set status of loading to failed
         _loaded.second = false;
         return false;
     }
  
 #ifdef __ANDROID__
     typedef void* (*loadOpenCLPointer_t)(const char* name);
     loadOpenCLPointer_t loadOpenCLPointer;
     if (use_loader) {
         typedef void (*enableOpenCL_t)();
         enableOpenCL_t enableOpenCL =
             reinterpret_cast<enableOpenCL_t>(dlsym(handle, "enableOpenCL"));
         enableOpenCL();
  
         loadOpenCLPointer = reinterpret_cast<loadOpenCLPointer_t>(
             dlsym(handle, "loadOpenCLPointer"));
     } else {
         loadOpenCLPointer = nullptr;
     }
 #define LOAD_FUNCTION_PTR(func_name, _handle) \
     func_name##_ptr = reinterpret_cast<decltype(func_name) *>( use_loader ? \
         loadOpenCLPointer(#func_name) : dlsym(handle, #func_name));
 #else /* __ANDROID__ */
     (void)use_loader; // Avoid unused warning
 #define LOAD_FUNCTION_PTR(func_name, handle) \
     func_name##_ptr = reinterpret_cast<decltype(func_name) *>(dlsym(handle, #func_name));
 #endif /* __ANDROID__ */
  
     LOAD_FUNCTION_PTR(clCreateContext, handle);
     LOAD_FUNCTION_PTR(clCreateContextFromType, handle);
     LOAD_FUNCTION_PTR(clCreateCommandQueue, handle);
     LOAD_FUNCTION_PTR(clCreateCommandQueueWithProperties, handle);
     LOAD_FUNCTION_PTR(clGetContextInfo, 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(clGetMemObjectInfo, handle);
     LOAD_FUNCTION_PTR(clRetainEvent, handle);
     LOAD_FUNCTION_PTR(clGetPlatformInfo, handle);
     LOAD_FUNCTION_PTR(clGetPlatformIDs, handle);
     LOAD_FUNCTION_PTR(clGetKernelWorkGroupInfo, handle);
     LOAD_FUNCTION_PTR(clGetCommandQueueInfo, handle);
     LOAD_FUNCTION_PTR(clGetKernelInfo, handle);
     LOAD_FUNCTION_PTR(clGetEventProfilingInfo, handle);
     LOAD_FUNCTION_PTR(clSVMAlloc, handle);
     LOAD_FUNCTION_PTR(clSVMFree, handle);
     LOAD_FUNCTION_PTR(clEnqueueSVMMap, handle);
     LOAD_FUNCTION_PTR(clEnqueueSVMUnmap, handle);
     LOAD_FUNCTION_PTR(clEnqueueMarker, handle);
     LOAD_FUNCTION_PTR(clWaitForEvents, handle);
     LOAD_FUNCTION_PTR(clCreateImage, handle);
     LOAD_FUNCTION_PTR(clSetKernelExecInfo, handle);
  
     // Third-party extensions
     LOAD_FUNCTION_PTR(clImportMemoryARM, handle);
  
 #undef LOAD_FUNCTION_PTR
  
     //Don't call dlclose(handle) or all the symbols will be unloaded !
  
     // Disable default loading and set status to successful
     _loaded = std::make_pair(true, true);
  
     return true;
 }

References clBuildProgram(), clCreateBuffer(), clCreateCommandQueue(), clCreateCommandQueueWithProperties(), clCreateContext(), clCreateContextFromType(), clCreateImage(), clCreateKernel(), clCreateProgramWithBinary(), clCreateProgramWithSource(), clEnqueueMapBuffer(), clEnqueueMarker(), clEnqueueNDRangeKernel(), clEnqueueReadBuffer(), clEnqueueSVMMap(), clEnqueueSVMUnmap(), clEnqueueUnmapMemObject(), clEnqueueWriteBuffer(), clFinish(), clFlush(), clGetCommandQueueInfo(), clGetContextInfo(), clGetDeviceIDs(), clGetDeviceInfo(), clGetEventProfilingInfo(), clGetKernelInfo(), clGetKernelWorkGroupInfo(), clGetMemObjectInfo(), clGetPlatformIDs(), clGetPlatformInfo(), clGetProgramBuildInfo(), clGetProgramInfo(), clImportMemoryARM(), clReleaseCommandQueue(), clReleaseContext(), clReleaseEvent(), clReleaseKernel(), clReleaseMemObject(), clReleaseProgram(), clRetainCommandQueue(), clRetainContext(), clRetainEvent(), clRetainKernel(), clRetainMemObject(), clRetainProgram(), clSetKernelArg(), clSetKernelExecInfo(), clSVMAlloc(), clSVMFree(), clWaitForEvents(), LOAD_FUNCTION_PTR, and name.

Referenced by CLSymbols::load_default().

◆ load_default()

bool load_default ( )

Load symbols from any of the default OpenCL library names.

If all the default libraries could not be loaded, this method will print a warning message and return false.

Returns: True if loading any library is successful.

Definition at line 53 of file OpenCL.cpp.

 {
     static const std::vector<std::string> libraries_filenames{ "libOpenCL.so", "libGLES_mali.so", "libmali.so" };
  
     if(_loaded.first)
     {
         return _loaded.second;
     }
  
     // Indicate that default loading has been tried
     _loaded.first = true;
  
     if(load(libraries_filenames, /* use_loader */ false))
     {
         ARM_COMPUTE_ERROR_ON_MSG(this->clBuildProgram_ptr == nullptr, "Failed to load OpenCL symbols from shared library");
         return true;
     }
  
 #ifdef __ANDROID__
     // When running in NDK environment, the above libraries are not accessible.
     static const std::vector<std::string> android_libraries_filenames{ "libOpenCL-pixel.so", "libOpenCL-car.so" };
  
     if(load(android_libraries_filenames, /* use_loader */ true))
     {
         ARM_COMPUTE_ERROR_ON_MSG(this->clBuildProgram_ptr == nullptr, "Failed to load OpenCL symbols from android shared library");
         return true;
     }
 #endif // __ANDROID__
  
     // If not returned till here then libraries not found
     std::stringstream ss;
     std::for_each(libraries_filenames.begin(), libraries_filenames.end(), [&ss](const std::string & s)
     {
         ss << s << " ";
     });
 #ifdef __ANDROID__
     std::for_each(android_libraries_filenames.begin(), android_libraries_filenames.end(), [&ss](const std::string & s)
     {
         ss << s << " ";
     });
 #endif // __ANDROID__
     std::cerr << "Couldn't find any of the following OpenCL library: " << ss.str() << std::endl;
     return false;
 }