| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from cl.xml. |
| // |
| // Copyright 2020 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // libOpenCL_autogen.cpp: Implements the exported CL functions. |
| |
| #include "cl_loader.h" |
| |
| #include "anglebase/no_destructor.h" |
| #include "common/system_utils.h" |
| |
| #include <iostream> |
| #include <memory> |
| |
| namespace |
| { |
| bool gLoaded = false; |
| |
| std::unique_ptr<angle::Library> &EntryPointsLib() |
| { |
| static angle::base::NoDestructor<std::unique_ptr<angle::Library>> sEntryPointsLib; |
| return *sEntryPointsLib; |
| } |
| |
| angle::GenericProc CL_API_CALL GlobalLoad(const char *symbol) |
| { |
| return reinterpret_cast<angle::GenericProc>(EntryPointsLib()->getSymbol(symbol)); |
| } |
| |
| void EnsureCLLoaded() |
| { |
| if (gLoaded) |
| { |
| return; |
| } |
| |
| EntryPointsLib().reset( |
| angle::OpenSharedLibrary(ANGLE_GLESV2_LIBRARY_NAME, angle::SearchType::ApplicationDir)); |
| angle::LoadCL(GlobalLoad); |
| if (!cl_loader.clGetDeviceIDs) |
| { |
| std::cerr << "Error loading CL entry points." << std::endl; |
| } |
| else |
| { |
| gLoaded = true; |
| } |
| } |
| } // anonymous namespace |
| |
| extern "C" { |
| |
| // CL 1.0 |
| cl_int CL_API_CALL clGetPlatformIDs(cl_uint num_entries, |
| cl_platform_id *platforms, |
| cl_uint *num_platforms) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetPlatformIDs(num_entries, platforms, num_platforms); |
| } |
| |
| cl_int CL_API_CALL clGetPlatformInfo(cl_platform_id platform, |
| cl_platform_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetPlatformInfo(platform, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform, |
| cl_device_type device_type, |
| cl_uint num_entries, |
| cl_device_id *devices, |
| cl_uint *num_devices) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices); |
| } |
| |
| cl_int CL_API_CALL clGetDeviceInfo(cl_device_id device, |
| cl_device_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetDeviceInfo(device, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_context CL_API_CALL clCreateContext(const cl_context_properties *properties, |
| cl_uint num_devices, |
| const cl_device_id *devices, |
| void(CL_CALLBACK *pfn_notify)(const char *errinfo, |
| const void *private_info, |
| size_t cb, |
| void *user_data), |
| void *user_data, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateContext(properties, num_devices, devices, pfn_notify, user_data, |
| errcode_ret); |
| } |
| |
| cl_context CL_API_CALL |
| clCreateContextFromType(const cl_context_properties *properties, |
| cl_device_type device_type, |
| void(CL_CALLBACK *pfn_notify)(const char *errinfo, |
| const void *private_info, |
| size_t cb, |
| void *user_data), |
| void *user_data, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateContextFromType(properties, device_type, pfn_notify, user_data, |
| errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainContext(cl_context context) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainContext(context); |
| } |
| |
| cl_int CL_API_CALL clReleaseContext(cl_context context) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseContext(context); |
| } |
| |
| cl_int CL_API_CALL clGetContextInfo(cl_context context, |
| cl_context_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetContextInfo(context, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainCommandQueue(command_queue); |
| } |
| |
| cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseCommandQueue(command_queue); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_mem CL_API_CALL clCreateBuffer(cl_context context, |
| cl_mem_flags flags, |
| size_t size, |
| void *host_ptr, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateBuffer(context, flags, size, host_ptr, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainMemObject(memobj); |
| } |
| |
| cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseMemObject(memobj); |
| } |
| |
| cl_int CL_API_CALL clGetSupportedImageFormats(cl_context context, |
| cl_mem_flags flags, |
| cl_mem_object_type image_type, |
| cl_uint num_entries, |
| cl_image_format *image_formats, |
| cl_uint *num_image_formats) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetSupportedImageFormats(context, flags, image_type, num_entries, |
| image_formats, num_image_formats); |
| } |
| |
| cl_int CL_API_CALL clGetMemObjectInfo(cl_mem memobj, |
| cl_mem_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetMemObjectInfo(memobj, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clGetImageInfo(cl_mem image, |
| cl_image_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetImageInfo(image, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainSampler(cl_sampler sampler) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainSampler(sampler); |
| } |
| |
| cl_int CL_API_CALL clReleaseSampler(cl_sampler sampler) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseSampler(sampler); |
| } |
| |
| cl_int CL_API_CALL clGetSamplerInfo(cl_sampler sampler, |
| cl_sampler_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetSamplerInfo(sampler, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_program CL_API_CALL clCreateProgramWithSource(cl_context context, |
| cl_uint count, |
| const char **strings, |
| const size_t *lengths, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithSource(context, count, strings, lengths, errcode_ret); |
| } |
| |
| cl_program CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries, |
| binary_status, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainProgram(cl_program program) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainProgram(program); |
| } |
| |
| cl_int CL_API_CALL clReleaseProgram(cl_program program) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseProgram(program); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clBuildProgram(program, num_devices, device_list, options, pfn_notify, |
| user_data); |
| } |
| |
| cl_int CL_API_CALL clGetProgramInfo(cl_program program, |
| cl_program_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetProgramInfo(program, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetProgramBuildInfo(program, device, param_name, param_value_size, |
| param_value, param_value_size_ret); |
| } |
| |
| cl_kernel CL_API_CALL clCreateKernel(cl_program program, |
| const char *kernel_name, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateKernel(program, kernel_name, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clCreateKernelsInProgram(cl_program program, |
| cl_uint num_kernels, |
| cl_kernel *kernels, |
| cl_uint *num_kernels_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainKernel(cl_kernel kernel) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainKernel(kernel); |
| } |
| |
| cl_int CL_API_CALL clReleaseKernel(cl_kernel kernel) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseKernel(kernel); |
| } |
| |
| cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel, |
| cl_uint arg_index, |
| size_t arg_size, |
| const void *arg_value) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetKernelArg(kernel, arg_index, arg_size, arg_value); |
| } |
| |
| cl_int CL_API_CALL clGetKernelInfo(cl_kernel kernel, |
| cl_kernel_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelInfo(kernel, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size, |
| param_value, param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clWaitForEvents(cl_uint num_events, const cl_event *event_list) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clWaitForEvents(num_events, event_list); |
| } |
| |
| cl_int CL_API_CALL clGetEventInfo(cl_event event, |
| cl_event_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetEventInfo(event, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainEvent(cl_event event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainEvent(event); |
| } |
| |
| cl_int CL_API_CALL clReleaseEvent(cl_event event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseEvent(event); |
| } |
| |
| cl_int CL_API_CALL clGetEventProfilingInfo(cl_event event, |
| cl_profiling_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetEventProfilingInfo(event, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clFlush(cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clFlush(command_queue); |
| } |
| |
| cl_int CL_API_CALL clFinish(cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clFinish(command_queue); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, size, ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, size, ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueCopyBuffer(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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, |
| dst_offset, size, num_events_in_wait_list, event_wait_list, |
| event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueReadImage(command_queue, image, blocking_read, origin, region, |
| row_pitch, slice_pitch, ptr, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWriteImage(command_queue, image, blocking_write, origin, region, |
| input_row_pitch, input_slice_pitch, ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue command_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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin, |
| region, num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin, |
| region, dst_offset, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset, |
| dst_origin, region, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| void *CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset, |
| size, num_events_in_wait_list, event_wait_list, event, |
| errcode_ret); |
| } |
| |
| void *CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMapImage( |
| 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); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset, |
| global_work_size, local_work_size, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue command_queue, |
| void(CL_CALLBACK *user_func)(void *), |
| void *args, |
| size_t cb_args, |
| cl_uint num_mem_objects, |
| const cl_mem *mem_list, |
| const void **args_mem_loc, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueNativeKernel(command_queue, user_func, args, cb_args, num_mem_objects, |
| mem_list, args_mem_loc, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clSetCommandQueueProperty(cl_command_queue command_queue, |
| cl_command_queue_properties properties, |
| cl_bool enable, |
| cl_command_queue_properties *old_properties) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetCommandQueueProperty(command_queue, properties, enable, old_properties); |
| } |
| |
| cl_mem CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateImage2D(context, flags, image_format, image_width, image_height, |
| image_row_pitch, host_ptr, errcode_ret); |
| } |
| |
| cl_mem CL_API_CALL clCreateImage3D(cl_context context, |
| cl_mem_flags flags, |
| const cl_image_format *image_format, |
| size_t image_width, |
| size_t image_height, |
| size_t image_depth, |
| size_t image_row_pitch, |
| size_t image_slice_pitch, |
| void *host_ptr, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateImage3D(context, flags, image_format, image_width, image_height, |
| image_depth, image_row_pitch, image_slice_pitch, host_ptr, |
| errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clEnqueueMarker(cl_command_queue command_queue, cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMarker(command_queue, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue command_queue, |
| cl_uint num_events, |
| const cl_event *event_list) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWaitForEvents(command_queue, num_events, event_list); |
| } |
| |
| cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueBarrier(command_queue); |
| } |
| |
| cl_int CL_API_CALL clUnloadCompiler() |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clUnloadCompiler(); |
| } |
| |
| void *CL_API_CALL clGetExtensionFunctionAddress(const char *func_name) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetExtensionFunctionAddress(func_name); |
| } |
| |
| cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context, |
| cl_device_id device, |
| cl_command_queue_properties properties, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateCommandQueue(context, device, properties, errcode_ret); |
| } |
| |
| cl_sampler CL_API_CALL clCreateSampler(cl_context context, |
| cl_bool normalized_coords, |
| cl_addressing_mode addressing_mode, |
| cl_filter_mode filter_mode, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateSampler(context, normalized_coords, addressing_mode, filter_mode, |
| errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clEnqueueTask(cl_command_queue command_queue, |
| cl_kernel kernel, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, |
| event); |
| } |
| |
| // CL 1.1 |
| cl_mem CL_API_CALL clCreateSubBuffer(cl_mem buffer, |
| cl_mem_flags flags, |
| cl_buffer_create_type buffer_create_type, |
| const void *buffer_create_info, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateSubBuffer(buffer, flags, buffer_create_type, buffer_create_info, |
| errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem memobj, |
| void(CL_CALLBACK *pfn_notify)(cl_mem memobj, |
| void *user_data), |
| void *user_data) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetMemObjectDestructorCallback(memobj, pfn_notify, user_data); |
| } |
| |
| cl_event CL_API_CALL clCreateUserEvent(cl_context context, cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateUserEvent(context, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clSetUserEventStatus(cl_event event, cl_int execution_status) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetUserEventStatus(event, execution_status); |
| } |
| |
| cl_int CL_API_CALL clSetEventCallback(cl_event event, |
| cl_int command_exec_callback_type, |
| void(CL_CALLBACK *pfn_notify)(cl_event event, |
| cl_int event_command_status, |
| void *user_data), |
| void *user_data) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetEventCallback(event, command_exec_callback_type, pfn_notify, user_data); |
| } |
| |
| cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_read, |
| const size_t *buffer_origin, |
| const size_t *host_origin, |
| const size_t *region, |
| size_t buffer_row_pitch, |
| size_t buffer_slice_pitch, |
| size_t host_row_pitch, |
| size_t host_slice_pitch, |
| void *ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueReadBufferRect(command_queue, buffer, blocking_read, buffer_origin, |
| host_origin, region, buffer_row_pitch, |
| buffer_slice_pitch, host_row_pitch, host_slice_pitch, |
| ptr, num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_write, |
| const size_t *buffer_origin, |
| const size_t *host_origin, |
| const size_t *region, |
| size_t buffer_row_pitch, |
| size_t buffer_slice_pitch, |
| size_t host_row_pitch, |
| size_t host_slice_pitch, |
| const void *ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWriteBufferRect(command_queue, buffer, blocking_write, buffer_origin, |
| host_origin, region, buffer_row_pitch, |
| buffer_slice_pitch, host_row_pitch, host_slice_pitch, |
| ptr, num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue command_queue, |
| cl_mem src_buffer, |
| cl_mem dst_buffer, |
| const size_t *src_origin, |
| const size_t *dst_origin, |
| const size_t *region, |
| size_t src_row_pitch, |
| size_t src_slice_pitch, |
| size_t dst_row_pitch, |
| size_t dst_slice_pitch, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueCopyBufferRect(command_queue, src_buffer, dst_buffer, src_origin, |
| dst_origin, region, src_row_pitch, src_slice_pitch, |
| dst_row_pitch, dst_slice_pitch, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| // CL 1.2 |
| cl_int CL_API_CALL clCreateSubDevices(cl_device_id in_device, |
| const cl_device_partition_property *properties, |
| cl_uint num_devices, |
| cl_device_id *out_devices, |
| cl_uint *num_devices_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateSubDevices(in_device, properties, num_devices, out_devices, |
| num_devices_ret); |
| } |
| |
| cl_int CL_API_CALL clRetainDevice(cl_device_id device) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainDevice(device); |
| } |
| |
| cl_int CL_API_CALL clReleaseDevice(cl_device_id device) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseDevice(device); |
| } |
| |
| cl_mem CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateImage(context, flags, image_format, image_desc, host_ptr, errcode_ret); |
| } |
| |
| cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context context, |
| cl_uint num_devices, |
| const cl_device_id *device_list, |
| const char *kernel_names, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithBuiltInKernels(context, num_devices, device_list, |
| kernel_names, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clCompileProgram(cl_program program, |
| cl_uint num_devices, |
| const cl_device_id *device_list, |
| const char *options, |
| cl_uint num_input_headers, |
| const cl_program *input_headers, |
| const char **header_include_names, |
| void(CL_CALLBACK *pfn_notify)(cl_program program, |
| void *user_data), |
| void *user_data) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCompileProgram(program, num_devices, device_list, options, num_input_headers, |
| input_headers, header_include_names, pfn_notify, user_data); |
| } |
| |
| cl_program CL_API_CALL clLinkProgram(cl_context context, |
| cl_uint num_devices, |
| const cl_device_id *device_list, |
| const char *options, |
| cl_uint num_input_programs, |
| const cl_program *input_programs, |
| void(CL_CALLBACK *pfn_notify)(cl_program program, |
| void *user_data), |
| void *user_data, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clLinkProgram(context, num_devices, device_list, options, num_input_programs, |
| input_programs, pfn_notify, user_data, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id platform) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clUnloadPlatformCompiler(platform); |
| } |
| |
| cl_int CL_API_CALL clGetKernelArgInfo(cl_kernel kernel, |
| cl_uint arg_index, |
| cl_kernel_arg_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelArgInfo(kernel, arg_index, param_name, param_value_size, |
| param_value, param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue command_queue, |
| cl_mem buffer, |
| const void *pattern, |
| size_t pattern_size, |
| size_t offset, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueFillBuffer(command_queue, buffer, pattern, pattern_size, offset, size, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL 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) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueFillImage(command_queue, image, fill_color, origin, region, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue command_queue, |
| cl_uint num_mem_objects, |
| const cl_mem *mem_objects, |
| cl_mem_migration_flags flags, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMigrateMemObjects(command_queue, num_mem_objects, mem_objects, flags, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue command_queue, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMarkerWithWaitList(command_queue, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue command_queue, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueBarrierWithWaitList(command_queue, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| void *CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, |
| const char *func_name) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetExtensionFunctionAddressForPlatform(platform, func_name); |
| } |
| |
| // CL 2.0 |
| cl_command_queue CL_API_CALL |
| clCreateCommandQueueWithProperties(cl_context context, |
| cl_device_id device, |
| const cl_queue_properties *properties, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateCommandQueueWithProperties(context, device, properties, errcode_ret); |
| } |
| |
| cl_mem CL_API_CALL clCreatePipe(cl_context context, |
| cl_mem_flags flags, |
| cl_uint pipe_packet_size, |
| cl_uint pipe_max_packets, |
| const cl_pipe_properties *properties, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreatePipe(context, flags, pipe_packet_size, pipe_max_packets, properties, |
| errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clGetPipeInfo(cl_mem pipe, |
| cl_pipe_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetPipeInfo(pipe, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| void *CL_API_CALL clSVMAlloc(cl_context context, |
| cl_svm_mem_flags flags, |
| size_t size, |
| cl_uint alignment) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSVMAlloc(context, flags, size, alignment); |
| } |
| |
| void CL_API_CALL clSVMFree(cl_context context, void *svm_pointer) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSVMFree(context, svm_pointer); |
| } |
| |
| cl_sampler CL_API_CALL |
| clCreateSamplerWithProperties(cl_context context, |
| const cl_sampler_properties *sampler_properties, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateSamplerWithProperties(context, sampler_properties, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, |
| cl_uint arg_index, |
| const void *arg_value) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetKernelArgSVMPointer(kernel, arg_index, arg_value); |
| } |
| |
| cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, |
| cl_kernel_exec_info param_name, |
| size_t param_value_size, |
| const void *param_value) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetKernelExecInfo(kernel, param_name, param_value_size, param_value); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue command_queue, |
| cl_uint num_svm_pointers, |
| void *svm_pointers[], |
| void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, |
| cl_uint num_svm_pointers, |
| void *svm_pointers[], |
| void *user_data), |
| void *user_data, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMFree(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, |
| user_data, num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue command_queue, |
| cl_bool blocking_copy, |
| void *dst_ptr, |
| const void *src_ptr, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMMemcpy(command_queue, blocking_copy, dst_ptr, src_ptr, size, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue command_queue, |
| void *svm_ptr, |
| const void *pattern, |
| size_t pattern_size, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size, size, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue command_queue, |
| cl_bool blocking_map, |
| cl_map_flags flags, |
| void *svm_ptr, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMMap(command_queue, blocking_map, flags, svm_ptr, size, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue command_queue, |
| void *svm_ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMUnmap(command_queue, svm_ptr, num_events_in_wait_list, |
| event_wait_list, event); |
| } |
| |
| // CL 2.1 |
| cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, |
| cl_device_id device, |
| cl_command_queue command_queue) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetDefaultDeviceCommandQueue(context, device, command_queue); |
| } |
| |
| cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device, |
| cl_ulong *device_timestamp, |
| cl_ulong *host_timestamp) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetDeviceAndHostTimer(device, device_timestamp, host_timestamp); |
| } |
| |
| cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong *host_timestamp) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetHostTimer(device, host_timestamp); |
| } |
| |
| cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, |
| const void *il, |
| size_t length, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithIL(context, il, length, errcode_ret); |
| } |
| |
| cl_kernel CL_API_CALL clCloneKernel(cl_kernel source_kernel, cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCloneKernel(source_kernel, errcode_ret); |
| } |
| |
| cl_int CL_API_CALL clGetKernelSubGroupInfo(cl_kernel kernel, |
| cl_device_id device, |
| cl_kernel_sub_group_info param_name, |
| size_t input_value_size, |
| const void *input_value, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelSubGroupInfo(kernel, device, param_name, input_value_size, |
| input_value, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue command_queue, |
| cl_uint num_svm_pointers, |
| const void **svm_pointers, |
| const size_t *sizes, |
| cl_mem_migration_flags flags, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueSVMMigrateMem(command_queue, num_svm_pointers, svm_pointers, sizes, |
| flags, num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| // CL 2.2 |
| cl_int CL_API_CALL clSetProgramReleaseCallback(cl_program program, |
| void(CL_CALLBACK *pfn_notify)(cl_program program, |
| void *user_data), |
| void *user_data) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetProgramReleaseCallback(program, pfn_notify, user_data); |
| } |
| |
| cl_int CL_API_CALL clSetProgramSpecializationConstant(cl_program program, |
| cl_uint spec_id, |
| size_t spec_size, |
| const void *spec_value) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetProgramSpecializationConstant(program, spec_id, spec_size, spec_value); |
| } |
| |
| // CL 3.0 |
| cl_int CL_API_CALL clSetContextDestructorCallback(cl_context context, |
| void(CL_CALLBACK *pfn_notify)(cl_context context, |
| void *user_data), |
| void *user_data) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetContextDestructorCallback(context, pfn_notify, user_data); |
| } |
| |
| cl_mem CL_API_CALL clCreateBufferWithProperties(cl_context context, |
| const cl_mem_properties *properties, |
| cl_mem_flags flags, |
| size_t size, |
| void *host_ptr, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateBufferWithProperties(context, properties, flags, size, host_ptr, |
| errcode_ret); |
| } |
| |
| cl_mem CL_API_CALL clCreateImageWithProperties(cl_context context, |
| const cl_mem_properties *properties, |
| cl_mem_flags flags, |
| const cl_image_format *image_format, |
| const cl_image_desc *image_desc, |
| void *host_ptr, |
| cl_int *errcode_ret) |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateImageWithProperties(context, properties, flags, image_format, |
| image_desc, host_ptr, errcode_ret); |
| } |
| |
| } // extern "C" |
