| // 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 "anglebase/no_destructor.h" |
| //#include "common/system_utils.h" |
| |
| #include <iostream> |
| //#include <memory> |
| |
| #include "cl_loader.h" |
| |
| namespace |
| { |
| bool gLoaded = false; |
| |
| /* TODO(jplate): uncomment after entry points moved to GLESV2 lib http://anglebug.com/5759 |
| std::unique_ptr<angle::Library> &EntryPointsLib() |
| { |
| static angle::base::NoDestructor<std::unique_ptr<angle::Library>> sEntryPointsLib; |
| return *sEntryPointsLib; |
| } |
| |
| angle::GenericProc CL_API_ENTRY 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); |
| angle::LoadCL(nullptr); |
| if (!cl_loader.clGetDeviceIDs) |
| { |
| std::cerr << "Error loading CL entry points." << std::endl; |
| } |
| else |
| { |
| gLoaded = true; |
| } |
| } |
| } // anonymous namespace |
| |
| extern "C" { |
| |
| // CL 1.0 |
| ANGLE_EXPORT cl_int CL_API_ENTRY clGetPlatformIDs(cl_uint num_entries, |
| cl_platform_id *platforms, |
| cl_uint *num_platforms) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetPlatformIDs(num_entries, platforms, num_platforms); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetPlatformInfo(platform, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clGetDeviceIDs(cl_platform_id platform, |
| cl_device_type device_type, |
| cl_uint num_entries, |
| cl_device_id *devices, |
| cl_uint *num_devices) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetDeviceInfo(device, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_context CL_API_ENTRY |
| 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) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateContext(properties, num_devices, devices, pfn_notify, user_data, |
| errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_context CL_API_ENTRY |
| 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) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateContextFromType(properties, device_type, pfn_notify, user_data, |
| errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainContext(cl_context context) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainContext(context); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseContext(cl_context context) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseContext(context); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetContextInfo(context, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainCommandQueue(cl_command_queue command_queue) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainCommandQueue(command_queue); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseCommandQueue(cl_command_queue command_queue) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseCommandQueue(command_queue); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_mem CL_API_ENTRY clCreateBuffer(cl_context context, |
| cl_mem_flags flags, |
| size_t size, |
| void *host_ptr, |
| cl_int *errcode_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateBuffer(context, flags, size, host_ptr, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainMemObject(cl_mem memobj) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainMemObject(memobj); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseMemObject(cl_mem memobj) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseMemObject(memobj); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetSupportedImageFormats(context, flags, image_type, num_entries, |
| image_formats, num_image_formats); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clGetMemObjectInfo(cl_mem memobj, |
| cl_mem_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetMemObjectInfo(memobj, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetImageInfo(image, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainSampler(cl_sampler sampler) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainSampler(sampler); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseSampler(cl_sampler sampler) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseSampler(sampler); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clGetSamplerInfo(cl_sampler sampler, |
| cl_sampler_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetSamplerInfo(sampler, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_program CL_API_ENTRY clCreateProgramWithSource(cl_context context, |
| cl_uint count, |
| const char **strings, |
| const size_t *lengths, |
| cl_int *errcode_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithSource(context, count, strings, lengths, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_program CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries, |
| binary_status, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainProgram(cl_program program) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainProgram(program); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseProgram(cl_program program) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseProgram(program); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clBuildProgram(program, num_devices, device_list, options, pfn_notify, |
| user_data); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetProgramInfo(program, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetProgramBuildInfo(program, device, param_name, param_value_size, |
| param_value, param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_kernel CL_API_ENTRY clCreateKernel(cl_program program, |
| const char *kernel_name, |
| cl_int *errcode_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateKernel(program, kernel_name, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clCreateKernelsInProgram(cl_program program, |
| cl_uint num_kernels, |
| cl_kernel *kernels, |
| cl_uint *num_kernels_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainKernel(cl_kernel kernel) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainKernel(kernel); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseKernel(cl_kernel kernel) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseKernel(kernel); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clSetKernelArg(cl_kernel kernel, |
| cl_uint arg_index, |
| size_t arg_size, |
| const void *arg_value) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetKernelArg(kernel, arg_index, arg_size, arg_value); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clGetKernelInfo(cl_kernel kernel, |
| cl_kernel_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelInfo(kernel, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size, |
| param_value, param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clWaitForEvents(cl_uint num_events, |
| const cl_event *event_list) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clWaitForEvents(num_events, event_list); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetEventInfo(event, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clRetainEvent(cl_event event) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clRetainEvent(event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseEvent(cl_event event) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clReleaseEvent(event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetEventProfilingInfo(event, param_name, param_value_size, param_value, |
| param_value_size_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clFlush(cl_command_queue command_queue) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clFlush(command_queue); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clFinish(cl_command_queue command_queue) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clFinish(command_queue); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, size, ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, size, ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT void *CL_API_ENTRY 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_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT void *CL_API_ENTRY 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_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, |
| num_events_in_wait_list, event_wait_list, event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY |
| clSetCommandQueueProperty(cl_command_queue command_queue, |
| cl_command_queue_properties properties, |
| cl_bool enable, |
| cl_command_queue_properties *old_properties) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clSetCommandQueueProperty(command_queue, properties, enable, old_properties); |
| } |
| |
| ANGLE_EXPORT cl_mem CL_API_ENTRY 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_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateImage2D(context, flags, image_format, image_width, image_height, |
| image_row_pitch, host_ptr, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_mem CL_API_ENTRY 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) CL_API_CALL |
| { |
| 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); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueMarker(cl_command_queue command_queue, |
| cl_event *event) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueMarker(command_queue, event); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWaitForEvents(cl_command_queue command_queue, |
| cl_uint num_events, |
| const cl_event *event_list) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueWaitForEvents(command_queue, num_events, event_list); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueBarrier(cl_command_queue command_queue) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueBarrier(command_queue); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY clUnloadCompiler() CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clUnloadCompiler(); |
| } |
| |
| ANGLE_EXPORT void *CL_API_ENTRY clGetExtensionFunctionAddress(const char *func_name) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clGetExtensionFunctionAddress(func_name); |
| } |
| |
| ANGLE_EXPORT cl_command_queue CL_API_ENTRY |
| clCreateCommandQueue(cl_context context, |
| cl_device_id device, |
| cl_command_queue_properties properties, |
| cl_int *errcode_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateCommandQueue(context, device, properties, errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_sampler CL_API_ENTRY clCreateSampler(cl_context context, |
| cl_bool normalized_coords, |
| cl_addressing_mode addressing_mode, |
| cl_filter_mode filter_mode, |
| cl_int *errcode_ret) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clCreateSampler(context, normalized_coords, addressing_mode, filter_mode, |
| errcode_ret); |
| } |
| |
| ANGLE_EXPORT cl_int CL_API_ENTRY 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) CL_API_CALL |
| { |
| EnsureCLLoaded(); |
| return cl_loader.clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, |
| event); |
| } |
| |
| } // extern "C" |
