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
);
80 log_error ("ERROR: cannot load opencl library");
85 HC_LOAD_FUNC(ocl
, clBuildProgram
, OCL_CLBUILDPROGRAM
, OpenCL
, 1)
86 HC_LOAD_FUNC(ocl
, clCreateBuffer
, OCL_CLCREATEBUFFER
, OpenCL
, 1)
87 HC_LOAD_FUNC(ocl
, clCreateCommandQueue
, OCL_CLCREATECOMMANDQUEUE
, OpenCL
, 1)
88 HC_LOAD_FUNC(ocl
, clCreateContext
, OCL_CLCREATECONTEXT
, OpenCL
, 1)
89 HC_LOAD_FUNC(ocl
, clCreateKernel
, OCL_CLCREATEKERNEL
, OpenCL
, 1)
90 HC_LOAD_FUNC(ocl
, clCreateProgramWithBinary
, OCL_CLCREATEPROGRAMWITHBINARY
, OpenCL
, 1)
91 HC_LOAD_FUNC(ocl
, clCreateProgramWithSource
, OCL_CLCREATEPROGRAMWITHSOURCE
, OpenCL
, 1)
92 HC_LOAD_FUNC(ocl
, clEnqueueCopyBuffer
, OCL_CLENQUEUECOPYBUFFER
, OpenCL
, 1)
93 HC_LOAD_FUNC(ocl
, clEnqueueFillBuffer
, OCL_CLENQUEUEFILLBUFFER
, OpenCL
, -1)
94 HC_LOAD_FUNC(ocl
, clEnqueueMapBuffer
, OCL_CLENQUEUEMAPBUFFER
, OpenCL
, 1)
95 HC_LOAD_FUNC(ocl
, clEnqueueNDRangeKernel
, OCL_CLENQUEUENDRANGEKERNEL
, OpenCL
, 1)
96 HC_LOAD_FUNC(ocl
, clEnqueueReadBuffer
, OCL_CLENQUEUEREADBUFFER
, OpenCL
, 1)
97 HC_LOAD_FUNC(ocl
, clEnqueueUnmapMemObject
, OCL_CLENQUEUEUNMAPMEMOBJECT
, OpenCL
, 1)
98 HC_LOAD_FUNC(ocl
, clEnqueueWriteBuffer
, OCL_CLENQUEUEWRITEBUFFER
, OpenCL
, 1)
99 HC_LOAD_FUNC(ocl
, clFinish
, OCL_CLFINISH
, OpenCL
, 1)
100 HC_LOAD_FUNC(ocl
, clFlush
, OCL_CLFLUSH
, OpenCL
, 1)
101 HC_LOAD_FUNC(ocl
, clGetDeviceIDs
, OCL_CLGETDEVICEIDS
, OpenCL
, 1)
102 HC_LOAD_FUNC(ocl
, clGetDeviceInfo
, OCL_CLGETDEVICEINFO
, OpenCL
, 1)
103 HC_LOAD_FUNC(ocl
, clGetEventInfo
, OCL_CLGETEVENTINFO
, OpenCL
, 1)
104 HC_LOAD_FUNC(ocl
, clGetKernelWorkGroupInfo
, OCL_CLGETKERNELWORKGROUPINFO
, OpenCL
, 1)
105 HC_LOAD_FUNC(ocl
, clGetPlatformIDs
, OCL_CLGETPLATFORMIDS
, OpenCL
, 1)
106 HC_LOAD_FUNC(ocl
, clGetPlatformInfo
, OCL_CLGETPLATFORMINFO
, OpenCL
, 1)
107 HC_LOAD_FUNC(ocl
, clGetProgramBuildInfo
, OCL_CLGETPROGRAMBUILDINFO
, OpenCL
, 1)
108 HC_LOAD_FUNC(ocl
, clGetProgramInfo
, OCL_CLGETPROGRAMINFO
, OpenCL
, 1)
109 HC_LOAD_FUNC(ocl
, clReleaseCommandQueue
, OCL_CLRELEASECOMMANDQUEUE
, OpenCL
, 1)
110 HC_LOAD_FUNC(ocl
, clReleaseContext
, OCL_CLRELEASECONTEXT
, OpenCL
, 1)
111 HC_LOAD_FUNC(ocl
, clReleaseKernel
, OCL_CLRELEASEKERNEL
, OpenCL
, 1)
112 HC_LOAD_FUNC(ocl
, clReleaseMemObject
, OCL_CLRELEASEMEMOBJECT
, OpenCL
, 1)
113 HC_LOAD_FUNC(ocl
, clReleaseProgram
, OCL_CLRELEASEPROGRAM
, OpenCL
, 1)
114 HC_LOAD_FUNC(ocl
, clSetKernelArg
, OCL_CLSETKERNELARG
, OpenCL
, 1)
115 HC_LOAD_FUNC(ocl
, clWaitForEvents
, OCL_CLWAITFOREVENTS
, OpenCL
, 1)
116 HC_LOAD_FUNC(ocl
, clGetEventProfilingInfo
, OCL_CLGETEVENTPROFILINGINFO
, OpenCL
, 1)
117 HC_LOAD_FUNC(ocl
, clReleaseEvent
, CLRELEASEEVENT
, OpenCL
, 1)
122 void ocl_close (OCL_PTR
*ocl
)
127 hc_dlclose (ocl
->lib
);
133 cl_int
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
, bool exitOnFail
)
135 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
);
137 if (CL_err
!= CL_SUCCESS
)
141 log_error ("ERROR: %s : %d : %s\n", "clEnqueueNDRangeKernel()", CL_err
, val2cstr_cl (CL_err
));
152 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
)
154 cl_int CL_err
= ocl
->clGetEventInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
156 if (CL_err
!= CL_SUCCESS
)
158 log_error ("ERROR: %s : %d : %s\n", "clGetEventInfo()", CL_err
, val2cstr_cl (CL_err
));
164 void hc_clFlush (OCL_PTR
*ocl
, cl_command_queue command_queue
)
166 cl_int CL_err
= ocl
->clFlush (command_queue
);
168 if (CL_err
!= CL_SUCCESS
)
170 log_error ("ERROR: %s : %d : %s\n", "clFlush()", CL_err
, val2cstr_cl (CL_err
));
176 void hc_clFinish (OCL_PTR
*ocl
, cl_command_queue command_queue
)
178 cl_int CL_err
= ocl
->clFinish (command_queue
);
180 if (CL_err
!= CL_SUCCESS
)
182 log_error ("ERROR: %s : %d : %s\n", "clFinish()", CL_err
, val2cstr_cl (CL_err
));
188 void hc_clSetKernelArg (OCL_PTR
*ocl
, cl_kernel kernel
, cl_uint arg_index
, size_t arg_size
, const void *arg_value
)
190 cl_int CL_err
= ocl
->clSetKernelArg (kernel
, arg_index
, arg_size
, arg_value
);
192 if (CL_err
!= CL_SUCCESS
)
194 log_error ("ERROR: %s : %d : %s\n", "clSetKernelArg()", CL_err
, val2cstr_cl (CL_err
));
200 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
)
202 cl_int CL_err
= ocl
->clEnqueueWriteBuffer (command_queue
, buffer
, blocking_write
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
204 if (CL_err
!= CL_SUCCESS
)
206 log_error ("ERROR: %s : %d : %s\n", "clEnqueueWriteBuffer()", CL_err
, val2cstr_cl (CL_err
));
212 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
)
214 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
);
216 if (CL_err
!= CL_SUCCESS
)
218 log_error ("ERROR: %s : %d : %s\n", "clEnqueueCopyBuffer()", CL_err
, val2cstr_cl (CL_err
));
224 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
)
226 cl_int CL_err
= ocl
->clEnqueueReadBuffer (command_queue
, buffer
, blocking_read
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
228 if (CL_err
!= CL_SUCCESS
)
230 log_error ("ERROR: %s : %d : %s\n", "clEnqueueReadBuffer()", CL_err
, val2cstr_cl (CL_err
));
236 void hc_clGetPlatformIDs (OCL_PTR
*ocl
, cl_uint num_entries
, cl_platform_id
*platforms
, cl_uint
*num_platforms
)
238 cl_int CL_err
= ocl
->clGetPlatformIDs (num_entries
, platforms
, num_platforms
);
240 if (CL_err
!= CL_SUCCESS
)
242 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformIDs()", CL_err
, val2cstr_cl (CL_err
));
248 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
)
250 cl_int CL_err
= ocl
->clGetPlatformInfo (platform
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
252 if (CL_err
!= CL_SUCCESS
)
254 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformInfo()", CL_err
, val2cstr_cl (CL_err
));
260 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
)
262 cl_int CL_err
= ocl
->clGetDeviceIDs (platform
, device_type
, num_entries
, devices
, num_devices
);
264 if (CL_err
!= CL_SUCCESS
)
266 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceIDs()", CL_err
, val2cstr_cl (CL_err
));
272 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
)
274 cl_int CL_err
= ocl
->clGetDeviceInfo (device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
276 if (CL_err
!= CL_SUCCESS
)
278 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceInfo()", CL_err
, val2cstr_cl (CL_err
));
284 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
)
288 cl_context context
= ocl
->clCreateContext (properties
, num_devices
, devices
, pfn_notify
, user_data
, &CL_err
);
290 if (CL_err
!= CL_SUCCESS
)
292 log_error ("ERROR: %s : %d : %s\n", "clCreateContext()", CL_err
, val2cstr_cl (CL_err
));
300 cl_command_queue
hc_clCreateCommandQueue (OCL_PTR
*ocl
, cl_context context
, cl_device_id device
, cl_command_queue_properties properties
)
304 cl_command_queue command_queue
= ocl
->clCreateCommandQueue (context
, device
, properties
, &CL_err
);
306 if (CL_err
!= CL_SUCCESS
)
308 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
313 return (command_queue
);
317 cl_command_queue hc_clCreateCommandQueueWithProperties (cl_context context, cl_device_id device, const cl_queue_properties *properties)
321 cl_command_queue command_queue = clCreateCommandQueueWithProperties (context, device, properties, &CL_err);
323 if (CL_err != CL_SUCCESS)
325 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueueWithProperties()", CL_err, val2cstr_cl (CL_err));
330 return (command_queue);
334 cl_mem
hc_clCreateBuffer (OCL_PTR
*ocl
, cl_context context
, cl_mem_flags flags
, size_t size
, void *host_ptr
)
338 cl_mem mem
= ocl
->clCreateBuffer (context
, flags
, size
, host_ptr
, &CL_err
);
340 if (CL_err
!= CL_SUCCESS
)
342 log_error ("ERROR: %s : %d : %s\n", "clCreateBuffer()", CL_err
, val2cstr_cl (CL_err
));
350 cl_program
hc_clCreateProgramWithSource (OCL_PTR
*ocl
, cl_context context
, cl_uint count
, const char **strings
, const size_t *lengths
)
354 cl_program program
= ocl
->clCreateProgramWithSource (context
, count
, strings
, lengths
, &CL_err
);
356 if (CL_err
!= CL_SUCCESS
)
358 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithSource()", CL_err
, val2cstr_cl (CL_err
));
366 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
)
370 cl_program program
= ocl
->clCreateProgramWithBinary (context
, num_devices
, device_list
, lengths
, binaries
, binary_status
, &CL_err
);
372 if (CL_err
!= CL_SUCCESS
)
374 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithBinary()", CL_err
, val2cstr_cl (CL_err
));
382 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
)
384 cl_int CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options
, pfn_notify
, user_data
);
386 if (CL_err
!= CL_SUCCESS
)
388 size_t len
= strlen (options
) + 1 + 15;
390 char *options_update
= (char *) mymalloc (len
+ 1);
392 options_update
= strncat (options_update
, options
, len
- 1 - 15);
393 options_update
= strncat (options_update
, " -cl-opt-disable", 1 + 15);
395 if (data
.quiet
== 0) log_error ("\n=== Build failed, retry with optimization disabled ===\n");
397 CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options_update
, pfn_notify
, user_data
);
399 myfree (options_update
);
401 if (CL_err
!= CL_SUCCESS
)
403 log_error ("ERROR: %s : %d : %s\n", "clBuildProgram()", CL_err
, val2cstr_cl (CL_err
));
405 log_error ("\n=== Build Options : %s ===\n", options
);
409 cl_int err
= hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, 0, NULL
, &len
);
411 if (err
== CL_SUCCESS
&& len
> 0)
413 char *buf
= (char *) mymalloc (len
+ 1);
415 if (hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, len
, buf
, NULL
) == CL_SUCCESS
)
417 fprintf (stderr
, "\n=== Build Log (start) ===\n%s\n=== Build Log (end) ===\n", buf
);
423 if (exitOnFail
) exit (-1);
432 cl_kernel
hc_clCreateKernel (OCL_PTR
*ocl
, cl_program program
, const char *kernel_name
)
436 cl_kernel kernel
= ocl
->clCreateKernel (program
, kernel_name
, &CL_err
);
438 if (CL_err
!= CL_SUCCESS
)
440 log_error ("ERROR: %s %d - %s\n", "clCreateKernel()", CL_err
, kernel_name
);
448 void hc_clReleaseMemObject (OCL_PTR
*ocl
, cl_mem mem
)
450 cl_int CL_err
= ocl
->clReleaseMemObject (mem
);
452 if (CL_err
!= CL_SUCCESS
)
454 log_error ("ERROR: %s : %d : %s\n", "clReleaseMemObject()", CL_err
, val2cstr_cl (CL_err
));
460 void hc_clReleaseKernel (OCL_PTR
*ocl
, cl_kernel kernel
)
462 cl_int CL_err
= ocl
->clReleaseKernel (kernel
);
464 if (CL_err
!= CL_SUCCESS
)
466 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
472 void hc_clReleaseProgram (OCL_PTR
*ocl
, cl_program program
)
474 cl_int CL_err
= ocl
->clReleaseProgram (program
);
476 if (CL_err
!= CL_SUCCESS
)
478 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
484 void hc_clReleaseCommandQueue (OCL_PTR
*ocl
, cl_command_queue command_queue
)
486 cl_int CL_err
= ocl
->clReleaseCommandQueue (command_queue
);
488 if (CL_err
!= CL_SUCCESS
)
490 log_error ("ERROR: %s : %d : %s\n", "clReleaseCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
496 void hc_clReleaseContext (OCL_PTR
*ocl
, cl_context context
)
498 cl_int CL_err
= ocl
->clReleaseContext (context
);
500 if (CL_err
!= CL_SUCCESS
)
502 log_error ("ERROR: %s : %d : %s\n", "clReleaseContext()", CL_err
, val2cstr_cl (CL_err
));
508 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
)
512 void *buf
= ocl
->clEnqueueMapBuffer (command_queue
, buffer
, blocking_read
, map_flags
, offset
, cb
, num_events_in_wait_list
, event_wait_list
, event
, &CL_err
);
514 if (CL_err
!= CL_SUCCESS
)
516 log_error ("ERROR: %s : %d : %s\n", "clEnqueueMapBuffer()", CL_err
, val2cstr_cl (CL_err
));
524 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
)
526 cl_int CL_err
= ocl
->clEnqueueUnmapMemObject (command_queue
, memobj
, mapped_ptr
, num_events_in_wait_list
, event_wait_list
, event
);
528 if (CL_err
!= CL_SUCCESS
)
530 log_error ("ERROR: %s : %d : %s\n", "clEnqueueUnmapMemObject()", CL_err
, val2cstr_cl (CL_err
));
536 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
)
540 if (ocl
->clEnqueueFillBuffer
)
542 CL_err
= ocl
->clEnqueueFillBuffer (command_queue
, buffer
, pattern
, pattern_size
, offset
, size
, num_events_in_wait_list
, event_wait_list
, event
);
544 if (CL_err
!= CL_SUCCESS
&& data
.quiet
== 0)
545 log_error ("WARNING: %s : %d : %s\n", "clEnqueueFillBuffer()", CL_err
, val2cstr_cl (CL_err
));
551 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
)
553 cl_int CL_err
= ocl
->clGetKernelWorkGroupInfo (kernel
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
555 if (CL_err
!= CL_SUCCESS
)
557 log_error ("ERROR: %s : %d : %s\n", "clGetKernelWorkGroupInfo()", CL_err
, val2cstr_cl (CL_err
));
563 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
)
565 cl_int CL_err
= ocl
->clGetProgramBuildInfo (program
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
567 if (CL_err
!= CL_SUCCESS
)
569 log_error ("ERROR: %s : %d : %s\n", "clGetProgramBuildInfo()", CL_err
, val2cstr_cl (CL_err
));
577 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
)
579 cl_int CL_err
= ocl
->clGetProgramInfo (program
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
581 if (CL_err
!= CL_SUCCESS
)
583 log_error ("ERROR: %s : %d : %s\n", "clGetProgramInfo()", CL_err
, val2cstr_cl (CL_err
));
589 void hc_clWaitForEvents (OCL_PTR
*ocl
, cl_uint num_events
, const cl_event
*event_list
)
591 cl_int CL_err
= ocl
->clWaitForEvents (num_events
, event_list
);
593 if (CL_err
!= CL_SUCCESS
)
595 log_error ("ERROR: %s : %d : %s\n", "clWaitForEvents()", CL_err
, val2cstr_cl (CL_err
));
601 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
)
603 cl_int CL_err
= ocl
->clGetEventProfilingInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
605 if (CL_err
!= CL_SUCCESS
)
607 log_error ("ERROR: %s : %d : %s\n", "clGetEventProfilingInfo()", CL_err
, val2cstr_cl (CL_err
));
613 void hc_clReleaseEvent (OCL_PTR
*ocl
, cl_event event
)
615 cl_int CL_err
= ocl
->clReleaseEvent (event
);
617 if (CL_err
!= CL_SUCCESS
)
619 log_error ("ERROR: %s : %d : %s\n", "clReleaseEvent()", CL_err
, val2cstr_cl (CL_err
));