2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
8 #include <ext_OpenCL.h>
10 const char *val2cstr_cl (cl_int CL_err
)
12 #define CLERR(a) case a: return #a
16 CLERR (CL_BUILD_PROGRAM_FAILURE
);
17 CLERR (CL_COMPILER_NOT_AVAILABLE
);
18 CLERR (CL_DEVICE_NOT_FOUND
);
19 CLERR (CL_INVALID_ARG_INDEX
);
20 CLERR (CL_INVALID_ARG_SIZE
);
21 CLERR (CL_INVALID_ARG_VALUE
);
22 CLERR (CL_INVALID_BINARY
);
23 CLERR (CL_INVALID_BUFFER_SIZE
);
24 CLERR (CL_INVALID_BUILD_OPTIONS
);
25 CLERR (CL_INVALID_COMMAND_QUEUE
);
26 CLERR (CL_INVALID_CONTEXT
);
27 CLERR (CL_INVALID_DEVICE
);
28 CLERR (CL_INVALID_DEVICE_TYPE
);
29 CLERR (CL_INVALID_EVENT
);
30 CLERR (CL_INVALID_EVENT_WAIT_LIST
);
31 CLERR (CL_INVALID_GLOBAL_OFFSET
);
32 CLERR (CL_INVALID_HOST_PTR
);
33 CLERR (CL_INVALID_KERNEL
);
34 CLERR (CL_INVALID_KERNEL_ARGS
);
35 CLERR (CL_INVALID_KERNEL_DEFINITION
);
36 CLERR (CL_INVALID_KERNEL_NAME
);
37 CLERR (CL_INVALID_MEM_OBJECT
);
38 CLERR (CL_INVALID_OPERATION
);
39 CLERR (CL_INVALID_PLATFORM
);
40 CLERR (CL_INVALID_PROGRAM
);
41 CLERR (CL_INVALID_PROGRAM_EXECUTABLE
);
42 CLERR (CL_INVALID_QUEUE_PROPERTIES
);
43 CLERR (CL_INVALID_SAMPLER
);
44 CLERR (CL_INVALID_VALUE
);
45 CLERR (CL_INVALID_WORK_DIMENSION
);
46 CLERR (CL_INVALID_WORK_GROUP_SIZE
);
47 CLERR (CL_INVALID_WORK_ITEM_SIZE
);
48 CLERR (CL_MISALIGNED_SUB_BUFFER_OFFSET
);
49 CLERR (CL_MAP_FAILURE
);
50 CLERR (CL_MEM_COPY_OVERLAP
);
51 CLERR (CL_MEM_OBJECT_ALLOCATION_FAILURE
);
52 CLERR (CL_OUT_OF_HOST_MEMORY
);
53 CLERR (CL_OUT_OF_RESOURCES
);
56 return "CL_UNKNOWN_ERROR";
59 int ocl_init (OCL_PTR
*ocl
)
63 log_error ("ERROR: opencl library ptr is null");
68 memset (ocl
, 0, sizeof (hc_opencl_lib_t
));
71 ocl
->lib
= hc_dlopen ("OpenCL");
73 ocl
->lib
= hc_dlopen ("/System/Library/Frameworks/OpenCL.framework/OpenCL", RTLD_NOW
);
75 ocl
->lib
= hc_dlopen ("libOpenCL.so", RTLD_NOW
);
77 if (ocl
->lib
== NULL
) ocl
->lib
= hc_dlopen ("libOpenCL.so.1", RTLD_NOW
);
82 log_error ("ERROR: cannot load opencl library");
87 HC_LOAD_FUNC(ocl
, clBuildProgram
, OCL_CLBUILDPROGRAM
, OpenCL
, 1)
88 HC_LOAD_FUNC(ocl
, clCreateBuffer
, OCL_CLCREATEBUFFER
, OpenCL
, 1)
89 HC_LOAD_FUNC(ocl
, clCreateCommandQueue
, OCL_CLCREATECOMMANDQUEUE
, OpenCL
, 1)
90 HC_LOAD_FUNC(ocl
, clCreateContext
, OCL_CLCREATECONTEXT
, OpenCL
, 1)
91 HC_LOAD_FUNC(ocl
, clCreateKernel
, OCL_CLCREATEKERNEL
, OpenCL
, 1)
92 HC_LOAD_FUNC(ocl
, clCreateProgramWithBinary
, OCL_CLCREATEPROGRAMWITHBINARY
, OpenCL
, 1)
93 HC_LOAD_FUNC(ocl
, clCreateProgramWithSource
, OCL_CLCREATEPROGRAMWITHSOURCE
, OpenCL
, 1)
94 HC_LOAD_FUNC(ocl
, clEnqueueCopyBuffer
, OCL_CLENQUEUECOPYBUFFER
, OpenCL
, 1)
95 HC_LOAD_FUNC(ocl
, clEnqueueFillBuffer
, OCL_CLENQUEUEFILLBUFFER
, OpenCL
, -1)
96 HC_LOAD_FUNC(ocl
, clEnqueueMapBuffer
, OCL_CLENQUEUEMAPBUFFER
, OpenCL
, 1)
97 HC_LOAD_FUNC(ocl
, clEnqueueNDRangeKernel
, OCL_CLENQUEUENDRANGEKERNEL
, OpenCL
, 1)
98 HC_LOAD_FUNC(ocl
, clEnqueueReadBuffer
, OCL_CLENQUEUEREADBUFFER
, OpenCL
, 1)
99 HC_LOAD_FUNC(ocl
, clEnqueueUnmapMemObject
, OCL_CLENQUEUEUNMAPMEMOBJECT
, OpenCL
, 1)
100 HC_LOAD_FUNC(ocl
, clEnqueueWriteBuffer
, OCL_CLENQUEUEWRITEBUFFER
, OpenCL
, 1)
101 HC_LOAD_FUNC(ocl
, clFinish
, OCL_CLFINISH
, OpenCL
, 1)
102 HC_LOAD_FUNC(ocl
, clFlush
, OCL_CLFLUSH
, OpenCL
, 1)
103 HC_LOAD_FUNC(ocl
, clGetDeviceIDs
, OCL_CLGETDEVICEIDS
, OpenCL
, 1)
104 HC_LOAD_FUNC(ocl
, clGetDeviceInfo
, OCL_CLGETDEVICEINFO
, OpenCL
, 1)
105 HC_LOAD_FUNC(ocl
, clGetEventInfo
, OCL_CLGETEVENTINFO
, OpenCL
, 1)
106 HC_LOAD_FUNC(ocl
, clGetKernelWorkGroupInfo
, OCL_CLGETKERNELWORKGROUPINFO
, OpenCL
, 1)
107 HC_LOAD_FUNC(ocl
, clGetPlatformIDs
, OCL_CLGETPLATFORMIDS
, OpenCL
, 1)
108 HC_LOAD_FUNC(ocl
, clGetPlatformInfo
, OCL_CLGETPLATFORMINFO
, OpenCL
, 1)
109 HC_LOAD_FUNC(ocl
, clGetProgramBuildInfo
, OCL_CLGETPROGRAMBUILDINFO
, OpenCL
, 1)
110 HC_LOAD_FUNC(ocl
, clGetProgramInfo
, OCL_CLGETPROGRAMINFO
, OpenCL
, 1)
111 HC_LOAD_FUNC(ocl
, clReleaseCommandQueue
, OCL_CLRELEASECOMMANDQUEUE
, OpenCL
, 1)
112 HC_LOAD_FUNC(ocl
, clReleaseContext
, OCL_CLRELEASECONTEXT
, OpenCL
, 1)
113 HC_LOAD_FUNC(ocl
, clReleaseKernel
, OCL_CLRELEASEKERNEL
, OpenCL
, 1)
114 HC_LOAD_FUNC(ocl
, clReleaseMemObject
, OCL_CLRELEASEMEMOBJECT
, OpenCL
, 1)
115 HC_LOAD_FUNC(ocl
, clReleaseProgram
, OCL_CLRELEASEPROGRAM
, OpenCL
, 1)
116 HC_LOAD_FUNC(ocl
, clSetKernelArg
, OCL_CLSETKERNELARG
, OpenCL
, 1)
117 HC_LOAD_FUNC(ocl
, clWaitForEvents
, OCL_CLWAITFOREVENTS
, OpenCL
, 1)
118 HC_LOAD_FUNC(ocl
, clGetEventProfilingInfo
, OCL_CLGETEVENTPROFILINGINFO
, OpenCL
, 1)
119 HC_LOAD_FUNC(ocl
, clReleaseEvent
, CLRELEASEEVENT
, OpenCL
, 1)
124 void ocl_close (OCL_PTR
*ocl
)
129 hc_dlclose (ocl
->lib
);
135 void hc_clEnqueueNDRangeKernel (OCL_PTR
*ocl
, 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
)
137 cl_int CL_err
= ocl
->clEnqueueNDRangeKernel (command_queue
, kernel
, work_dim
, global_work_offset
, global_work_size
, local_work_size
, num_events_in_wait_list
, event_wait_list
, event
);
139 if (CL_err
!= CL_SUCCESS
)
141 log_error ("ERROR: %s : %d : %s\n", "clEnqueueNDRangeKernel()", CL_err
, val2cstr_cl (CL_err
));
147 void hc_clGetEventInfo (OCL_PTR
*ocl
, cl_event event
, cl_event_info param_name
, size_t param_value_size
, void *param_value
, size_t *param_value_size_ret
)
149 cl_int CL_err
= ocl
->clGetEventInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
151 if (CL_err
!= CL_SUCCESS
)
153 log_error ("ERROR: %s : %d : %s\n", "clGetEventInfo()", CL_err
, val2cstr_cl (CL_err
));
159 void hc_clFlush (OCL_PTR
*ocl
, cl_command_queue command_queue
)
161 cl_int CL_err
= ocl
->clFlush (command_queue
);
163 if (CL_err
!= CL_SUCCESS
)
165 log_error ("ERROR: %s : %d : %s\n", "clFlush()", CL_err
, val2cstr_cl (CL_err
));
171 void hc_clFinish (OCL_PTR
*ocl
, cl_command_queue command_queue
)
173 cl_int CL_err
= ocl
->clFinish (command_queue
);
175 if (CL_err
!= CL_SUCCESS
)
177 log_error ("ERROR: %s : %d : %s\n", "clFinish()", CL_err
, val2cstr_cl (CL_err
));
183 void hc_clSetKernelArg (OCL_PTR
*ocl
, cl_kernel kernel
, cl_uint arg_index
, size_t arg_size
, const void *arg_value
)
185 cl_int CL_err
= ocl
->clSetKernelArg (kernel
, arg_index
, arg_size
, arg_value
);
187 if (CL_err
!= CL_SUCCESS
)
189 log_error ("ERROR: %s : %d : %s\n", "clSetKernelArg()", CL_err
, val2cstr_cl (CL_err
));
195 void hc_clEnqueueWriteBuffer (OCL_PTR
*ocl
, cl_command_queue command_queue
, cl_mem buffer
, cl_bool blocking_write
, size_t offset
, size_t cb
, const void *ptr
, cl_uint num_events_in_wait_list
, const cl_event
*event_wait_list
, cl_event
*event
)
197 cl_int CL_err
= ocl
->clEnqueueWriteBuffer (command_queue
, buffer
, blocking_write
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
199 if (CL_err
!= CL_SUCCESS
)
201 log_error ("ERROR: %s : %d : %s\n", "clEnqueueWriteBuffer()", CL_err
, val2cstr_cl (CL_err
));
207 void hc_clEnqueueCopyBuffer (OCL_PTR
*ocl
, cl_command_queue command_queue
, cl_mem src_buffer
, cl_mem dst_buffer
, size_t src_offset
, size_t dst_offset
, size_t cb
, cl_uint num_events_in_wait_list
, const cl_event
*event_wait_list
, cl_event
*event
)
209 cl_int CL_err
= ocl
->clEnqueueCopyBuffer (command_queue
, src_buffer
, dst_buffer
, src_offset
, dst_offset
, cb
, num_events_in_wait_list
, event_wait_list
, event
);
211 if (CL_err
!= CL_SUCCESS
)
213 log_error ("ERROR: %s : %d : %s\n", "clEnqueueCopyBuffer()", CL_err
, val2cstr_cl (CL_err
));
219 void hc_clEnqueueReadBuffer (OCL_PTR
*ocl
, cl_command_queue command_queue
, cl_mem buffer
, cl_bool blocking_read
, size_t offset
, size_t cb
, void *ptr
, cl_uint num_events_in_wait_list
, const cl_event
*event_wait_list
, cl_event
*event
)
221 cl_int CL_err
= ocl
->clEnqueueReadBuffer (command_queue
, buffer
, blocking_read
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
223 if (CL_err
!= CL_SUCCESS
)
225 log_error ("ERROR: %s : %d : %s\n", "clEnqueueReadBuffer()", CL_err
, val2cstr_cl (CL_err
));
231 void hc_clGetPlatformIDs (OCL_PTR
*ocl
, cl_uint num_entries
, cl_platform_id
*platforms
, cl_uint
*num_platforms
)
233 cl_int CL_err
= ocl
->clGetPlatformIDs (num_entries
, platforms
, num_platforms
);
235 if (CL_err
!= CL_SUCCESS
)
237 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformIDs()", CL_err
, val2cstr_cl (CL_err
));
243 void hc_clGetPlatformInfo (OCL_PTR
*ocl
, cl_platform_id platform
, cl_platform_info param_name
, size_t param_value_size
, void *param_value
, size_t *param_value_size_ret
)
245 cl_int CL_err
= ocl
->clGetPlatformInfo (platform
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
247 if (CL_err
!= CL_SUCCESS
)
249 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformInfo()", CL_err
, val2cstr_cl (CL_err
));
255 void hc_clGetDeviceIDs (OCL_PTR
*ocl
, cl_platform_id platform
, cl_device_type device_type
, cl_uint num_entries
, cl_device_id
*devices
, cl_uint
*num_devices
)
257 cl_int CL_err
= ocl
->clGetDeviceIDs (platform
, device_type
, num_entries
, devices
, num_devices
);
259 if (CL_err
!= CL_SUCCESS
)
261 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceIDs()", CL_err
, val2cstr_cl (CL_err
));
267 void hc_clGetDeviceInfo (OCL_PTR
*ocl
, cl_device_id device
, cl_device_info param_name
, size_t param_value_size
, void *param_value
, size_t *param_value_size_ret
)
269 cl_int CL_err
= ocl
->clGetDeviceInfo (device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
271 if (CL_err
!= CL_SUCCESS
)
273 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceInfo()", CL_err
, val2cstr_cl (CL_err
));
279 cl_context
hc_clCreateContext (OCL_PTR
*ocl
, cl_context_properties
*properties
, cl_uint num_devices
, const cl_device_id
*devices
, void (CL_CALLBACK
*pfn_notify
) (const char *, const void *, size_t, void *), void *user_data
)
283 cl_context context
= ocl
->clCreateContext (properties
, num_devices
, devices
, pfn_notify
, user_data
, &CL_err
);
285 if (CL_err
!= CL_SUCCESS
)
287 log_error ("ERROR: %s : %d : %s\n", "clCreateContext()", CL_err
, val2cstr_cl (CL_err
));
295 cl_command_queue
hc_clCreateCommandQueue (OCL_PTR
*ocl
, cl_context context
, cl_device_id device
, cl_command_queue_properties properties
)
299 cl_command_queue command_queue
= ocl
->clCreateCommandQueue (context
, device
, properties
, &CL_err
);
301 if (CL_err
!= CL_SUCCESS
)
303 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
308 return (command_queue
);
312 cl_command_queue hc_clCreateCommandQueueWithProperties (cl_context context, cl_device_id device, const cl_queue_properties *properties)
316 cl_command_queue command_queue = clCreateCommandQueueWithProperties (context, device, properties, &CL_err);
318 if (CL_err != CL_SUCCESS)
320 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueueWithProperties()", CL_err, val2cstr_cl (CL_err));
325 return (command_queue);
329 cl_mem
hc_clCreateBuffer (OCL_PTR
*ocl
, cl_context context
, cl_mem_flags flags
, size_t size
, void *host_ptr
)
333 cl_mem mem
= ocl
->clCreateBuffer (context
, flags
, size
, host_ptr
, &CL_err
);
335 if (CL_err
!= CL_SUCCESS
)
337 log_error ("ERROR: %s : %d : %s\n", "clCreateBuffer()", CL_err
, val2cstr_cl (CL_err
));
345 cl_program
hc_clCreateProgramWithSource (OCL_PTR
*ocl
, cl_context context
, cl_uint count
, const char **strings
, const size_t *lengths
)
349 cl_program program
= ocl
->clCreateProgramWithSource (context
, count
, strings
, lengths
, &CL_err
);
351 if (CL_err
!= CL_SUCCESS
)
353 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithSource()", CL_err
, val2cstr_cl (CL_err
));
361 cl_program
hc_clCreateProgramWithBinary (OCL_PTR
*ocl
, 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
)
365 cl_program program
= ocl
->clCreateProgramWithBinary (context
, num_devices
, device_list
, lengths
, binaries
, binary_status
, &CL_err
);
367 if (CL_err
!= CL_SUCCESS
)
369 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithBinary()", CL_err
, val2cstr_cl (CL_err
));
377 cl_int
hc_clBuildProgram (OCL_PTR
*ocl
, 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
, bool exitOnFail
)
379 cl_int CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options
, pfn_notify
, user_data
);
381 if (CL_err
!= CL_SUCCESS
)
383 size_t len
= strlen (options
) + 1 + 15;
385 char *options_update
= (char *) mymalloc (len
+ 1);
387 options_update
= strncat (options_update
, options
, len
- 1 - 15);
388 options_update
= strncat (options_update
, " -cl-opt-disable", 1 + 15);
390 if (data
.quiet
== 0) log_error ("\n=== Build failed, retry with optimization disabled ===\n");
392 CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options_update
, pfn_notify
, user_data
);
394 myfree (options_update
);
396 if (CL_err
!= CL_SUCCESS
)
398 log_error ("ERROR: %s : %d : %s\n", "clBuildProgram()", CL_err
, val2cstr_cl (CL_err
));
400 log_error ("\n=== Build Options : %s ===\n", options
);
404 cl_int err
= hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, 0, NULL
, &len
);
406 if (err
== CL_SUCCESS
&& len
> 0)
408 char *buf
= (char *) mymalloc (len
+ 1);
410 if (hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, len
, buf
, NULL
) == CL_SUCCESS
)
412 fprintf (stderr
, "\n=== Build Log (start) ===\n%s\n=== Build Log (end) ===\n", buf
);
418 if (exitOnFail
) exit (-1);
427 cl_kernel
hc_clCreateKernel (OCL_PTR
*ocl
, cl_program program
, const char *kernel_name
)
431 cl_kernel kernel
= ocl
->clCreateKernel (program
, kernel_name
, &CL_err
);
433 if (CL_err
!= CL_SUCCESS
)
435 log_error ("ERROR: %s %d - %s\n", "clCreateKernel()", CL_err
, kernel_name
);
443 void hc_clReleaseMemObject (OCL_PTR
*ocl
, cl_mem mem
)
445 cl_int CL_err
= ocl
->clReleaseMemObject (mem
);
447 if (CL_err
!= CL_SUCCESS
)
449 log_error ("ERROR: %s : %d : %s\n", "clReleaseMemObject()", CL_err
, val2cstr_cl (CL_err
));
455 void hc_clReleaseKernel (OCL_PTR
*ocl
, cl_kernel kernel
)
457 cl_int CL_err
= ocl
->clReleaseKernel (kernel
);
459 if (CL_err
!= CL_SUCCESS
)
461 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
467 void hc_clReleaseProgram (OCL_PTR
*ocl
, cl_program program
)
469 cl_int CL_err
= ocl
->clReleaseProgram (program
);
471 if (CL_err
!= CL_SUCCESS
)
473 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
479 void hc_clReleaseCommandQueue (OCL_PTR
*ocl
, cl_command_queue command_queue
)
481 cl_int CL_err
= ocl
->clReleaseCommandQueue (command_queue
);
483 if (CL_err
!= CL_SUCCESS
)
485 log_error ("ERROR: %s : %d : %s\n", "clReleaseCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
491 void hc_clReleaseContext (OCL_PTR
*ocl
, cl_context context
)
493 cl_int CL_err
= ocl
->clReleaseContext (context
);
495 if (CL_err
!= CL_SUCCESS
)
497 log_error ("ERROR: %s : %d : %s\n", "clReleaseContext()", CL_err
, val2cstr_cl (CL_err
));
503 void *hc_clEnqueueMapBuffer (OCL_PTR
*ocl
, cl_command_queue command_queue
, cl_mem buffer
, cl_bool blocking_read
, cl_map_flags map_flags
, size_t offset
, size_t cb
, cl_uint num_events_in_wait_list
, const cl_event
*event_wait_list
, cl_event
*event
)
507 void *buf
= ocl
->clEnqueueMapBuffer (command_queue
, buffer
, blocking_read
, map_flags
, offset
, cb
, num_events_in_wait_list
, event_wait_list
, event
, &CL_err
);
509 if (CL_err
!= CL_SUCCESS
)
511 log_error ("ERROR: %s : %d : %s\n", "clEnqueueMapBuffer()", CL_err
, val2cstr_cl (CL_err
));
519 void hc_clEnqueueUnmapMemObject (OCL_PTR
*ocl
, 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
)
521 cl_int CL_err
= ocl
->clEnqueueUnmapMemObject (command_queue
, memobj
, mapped_ptr
, num_events_in_wait_list
, event_wait_list
, event
);
523 if (CL_err
!= CL_SUCCESS
)
525 log_error ("ERROR: %s : %d : %s\n", "clEnqueueUnmapMemObject()", CL_err
, val2cstr_cl (CL_err
));
531 cl_int
hc_clEnqueueFillBuffer (OCL_PTR
*ocl
, 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
)
535 if (ocl
->clEnqueueFillBuffer
)
537 CL_err
= ocl
->clEnqueueFillBuffer (command_queue
, buffer
, pattern
, pattern_size
, offset
, size
, num_events_in_wait_list
, event_wait_list
, event
);
539 if (CL_err
!= CL_SUCCESS
&& data
.quiet
== 0)
540 log_error ("WARNING: %s : %d : %s\n", "clEnqueueFillBuffer()", CL_err
, val2cstr_cl (CL_err
));
546 void hc_clGetKernelWorkGroupInfo (OCL_PTR
*ocl
, 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
)
548 cl_int CL_err
= ocl
->clGetKernelWorkGroupInfo (kernel
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
550 if (CL_err
!= CL_SUCCESS
)
552 log_error ("ERROR: %s : %d : %s\n", "clGetKernelWorkGroupInfo()", CL_err
, val2cstr_cl (CL_err
));
558 cl_int
hc_clGetProgramBuildInfo (OCL_PTR
*ocl
, 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
)
560 cl_int CL_err
= ocl
->clGetProgramBuildInfo (program
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
562 if (CL_err
!= CL_SUCCESS
)
564 log_error ("ERROR: %s : %d : %s\n", "clGetProgramBuildInfo()", CL_err
, val2cstr_cl (CL_err
));
572 void hc_clGetProgramInfo (OCL_PTR
*ocl
, cl_program program
, cl_program_info param_name
, size_t param_value_size
, void *param_value
, size_t *param_value_size_ret
)
574 cl_int CL_err
= ocl
->clGetProgramInfo (program
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
576 if (CL_err
!= CL_SUCCESS
)
578 log_error ("ERROR: %s : %d : %s\n", "clGetProgramInfo()", CL_err
, val2cstr_cl (CL_err
));
584 void hc_clWaitForEvents (OCL_PTR
*ocl
, cl_uint num_events
, const cl_event
*event_list
)
586 cl_int CL_err
= ocl
->clWaitForEvents (num_events
, event_list
);
588 if (CL_err
!= CL_SUCCESS
)
590 log_error ("ERROR: %s : %d : %s\n", "clWaitForEvents()", CL_err
, val2cstr_cl (CL_err
));
596 void hc_clGetEventProfilingInfo (OCL_PTR
*ocl
, cl_event event
, cl_profiling_info param_name
, size_t param_value_size
, void *param_value
, size_t *param_value_size_ret
)
598 cl_int CL_err
= ocl
->clGetEventProfilingInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
600 if (CL_err
!= CL_SUCCESS
)
602 log_error ("ERROR: %s : %d : %s\n", "clGetEventProfilingInfo()", CL_err
, val2cstr_cl (CL_err
));
608 void hc_clReleaseEvent (OCL_PTR
*ocl
, cl_event event
)
610 cl_int CL_err
= ocl
->clReleaseEvent (event
);
612 if (CL_err
!= CL_SUCCESS
)
614 log_error ("ERROR: %s : %d : %s\n", "clReleaseEvent()", CL_err
, val2cstr_cl (CL_err
));