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
);
83 log_info ("ATTENTION! Can't find OpenCL ICD loader library");
86 log_info ("You're probably missing the \"ocl-icd-libopencl1\" package (Debian/Ubuntu)");
87 log_info (" sudo apt-get install ocl-icd-libopencl1");
90 log_info ("You're probably missing the OpenCL runtime installation");
91 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
92 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
93 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
100 HC_LOAD_FUNC(ocl
, clBuildProgram
, OCL_CLBUILDPROGRAM
, OpenCL
, 1)
101 HC_LOAD_FUNC(ocl
, clCreateBuffer
, OCL_CLCREATEBUFFER
, OpenCL
, 1)
102 HC_LOAD_FUNC(ocl
, clCreateCommandQueue
, OCL_CLCREATECOMMANDQUEUE
, OpenCL
, 1)
103 HC_LOAD_FUNC(ocl
, clCreateContext
, OCL_CLCREATECONTEXT
, OpenCL
, 1)
104 HC_LOAD_FUNC(ocl
, clCreateKernel
, OCL_CLCREATEKERNEL
, OpenCL
, 1)
105 HC_LOAD_FUNC(ocl
, clCreateProgramWithBinary
, OCL_CLCREATEPROGRAMWITHBINARY
, OpenCL
, 1)
106 HC_LOAD_FUNC(ocl
, clCreateProgramWithSource
, OCL_CLCREATEPROGRAMWITHSOURCE
, OpenCL
, 1)
107 HC_LOAD_FUNC(ocl
, clEnqueueCopyBuffer
, OCL_CLENQUEUECOPYBUFFER
, OpenCL
, 1)
108 HC_LOAD_FUNC(ocl
, clEnqueueFillBuffer
, OCL_CLENQUEUEFILLBUFFER
, OpenCL
, -1)
109 HC_LOAD_FUNC(ocl
, clEnqueueMapBuffer
, OCL_CLENQUEUEMAPBUFFER
, OpenCL
, 1)
110 HC_LOAD_FUNC(ocl
, clEnqueueNDRangeKernel
, OCL_CLENQUEUENDRANGEKERNEL
, OpenCL
, 1)
111 HC_LOAD_FUNC(ocl
, clEnqueueReadBuffer
, OCL_CLENQUEUEREADBUFFER
, OpenCL
, 1)
112 HC_LOAD_FUNC(ocl
, clEnqueueUnmapMemObject
, OCL_CLENQUEUEUNMAPMEMOBJECT
, OpenCL
, 1)
113 HC_LOAD_FUNC(ocl
, clEnqueueWriteBuffer
, OCL_CLENQUEUEWRITEBUFFER
, OpenCL
, 1)
114 HC_LOAD_FUNC(ocl
, clFinish
, OCL_CLFINISH
, OpenCL
, 1)
115 HC_LOAD_FUNC(ocl
, clFlush
, OCL_CLFLUSH
, OpenCL
, 1)
116 HC_LOAD_FUNC(ocl
, clGetDeviceIDs
, OCL_CLGETDEVICEIDS
, OpenCL
, 1)
117 HC_LOAD_FUNC(ocl
, clGetDeviceInfo
, OCL_CLGETDEVICEINFO
, OpenCL
, 1)
118 HC_LOAD_FUNC(ocl
, clGetEventInfo
, OCL_CLGETEVENTINFO
, OpenCL
, 1)
119 HC_LOAD_FUNC(ocl
, clGetKernelWorkGroupInfo
, OCL_CLGETKERNELWORKGROUPINFO
, OpenCL
, 1)
120 HC_LOAD_FUNC(ocl
, clGetPlatformIDs
, OCL_CLGETPLATFORMIDS
, OpenCL
, 1)
121 HC_LOAD_FUNC(ocl
, clGetPlatformInfo
, OCL_CLGETPLATFORMINFO
, OpenCL
, 1)
122 HC_LOAD_FUNC(ocl
, clGetProgramBuildInfo
, OCL_CLGETPROGRAMBUILDINFO
, OpenCL
, 1)
123 HC_LOAD_FUNC(ocl
, clGetProgramInfo
, OCL_CLGETPROGRAMINFO
, OpenCL
, 1)
124 HC_LOAD_FUNC(ocl
, clReleaseCommandQueue
, OCL_CLRELEASECOMMANDQUEUE
, OpenCL
, 1)
125 HC_LOAD_FUNC(ocl
, clReleaseContext
, OCL_CLRELEASECONTEXT
, OpenCL
, 1)
126 HC_LOAD_FUNC(ocl
, clReleaseKernel
, OCL_CLRELEASEKERNEL
, OpenCL
, 1)
127 HC_LOAD_FUNC(ocl
, clReleaseMemObject
, OCL_CLRELEASEMEMOBJECT
, OpenCL
, 1)
128 HC_LOAD_FUNC(ocl
, clReleaseProgram
, OCL_CLRELEASEPROGRAM
, OpenCL
, 1)
129 HC_LOAD_FUNC(ocl
, clSetKernelArg
, OCL_CLSETKERNELARG
, OpenCL
, 1)
130 HC_LOAD_FUNC(ocl
, clWaitForEvents
, OCL_CLWAITFOREVENTS
, OpenCL
, 1)
131 HC_LOAD_FUNC(ocl
, clGetEventProfilingInfo
, OCL_CLGETEVENTPROFILINGINFO
, OpenCL
, 1)
132 HC_LOAD_FUNC(ocl
, clReleaseEvent
, CLRELEASEEVENT
, OpenCL
, 1)
137 void ocl_close (OCL_PTR
*ocl
)
142 hc_dlclose (ocl
->lib
);
148 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
)
150 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
);
152 if (CL_err
!= CL_SUCCESS
)
154 log_error ("ERROR: %s : %d : %s\n", "clEnqueueNDRangeKernel()", CL_err
, val2cstr_cl (CL_err
));
160 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
)
162 cl_int CL_err
= ocl
->clGetEventInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
164 if (CL_err
!= CL_SUCCESS
)
166 log_error ("ERROR: %s : %d : %s\n", "clGetEventInfo()", CL_err
, val2cstr_cl (CL_err
));
172 void hc_clFlush (OCL_PTR
*ocl
, cl_command_queue command_queue
)
174 cl_int CL_err
= ocl
->clFlush (command_queue
);
176 if (CL_err
!= CL_SUCCESS
)
178 log_error ("ERROR: %s : %d : %s\n", "clFlush()", CL_err
, val2cstr_cl (CL_err
));
184 void hc_clFinish (OCL_PTR
*ocl
, cl_command_queue command_queue
)
186 cl_int CL_err
= ocl
->clFinish (command_queue
);
188 if (CL_err
!= CL_SUCCESS
)
190 log_error ("ERROR: %s : %d : %s\n", "clFinish()", CL_err
, val2cstr_cl (CL_err
));
196 void hc_clSetKernelArg (OCL_PTR
*ocl
, cl_kernel kernel
, cl_uint arg_index
, size_t arg_size
, const void *arg_value
)
198 cl_int CL_err
= ocl
->clSetKernelArg (kernel
, arg_index
, arg_size
, arg_value
);
200 if (CL_err
!= CL_SUCCESS
)
202 log_error ("ERROR: %s : %d : %s\n", "clSetKernelArg()", CL_err
, val2cstr_cl (CL_err
));
208 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
)
210 cl_int CL_err
= ocl
->clEnqueueWriteBuffer (command_queue
, buffer
, blocking_write
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
212 if (CL_err
!= CL_SUCCESS
)
214 log_error ("ERROR: %s : %d : %s\n", "clEnqueueWriteBuffer()", CL_err
, val2cstr_cl (CL_err
));
220 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
)
222 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
);
224 if (CL_err
!= CL_SUCCESS
)
226 log_error ("ERROR: %s : %d : %s\n", "clEnqueueCopyBuffer()", CL_err
, val2cstr_cl (CL_err
));
232 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
)
234 cl_int CL_err
= ocl
->clEnqueueReadBuffer (command_queue
, buffer
, blocking_read
, offset
, cb
, ptr
, num_events_in_wait_list
, event_wait_list
, event
);
236 if (CL_err
!= CL_SUCCESS
)
238 log_error ("ERROR: %s : %d : %s\n", "clEnqueueReadBuffer()", CL_err
, val2cstr_cl (CL_err
));
244 void hc_clGetPlatformIDs (OCL_PTR
*ocl
, cl_uint num_entries
, cl_platform_id
*platforms
, cl_uint
*num_platforms
)
246 cl_int CL_err
= ocl
->clGetPlatformIDs (num_entries
, platforms
, num_platforms
);
248 if (CL_err
!= CL_SUCCESS
)
250 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformIDs()", CL_err
, val2cstr_cl (CL_err
));
256 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
)
258 cl_int CL_err
= ocl
->clGetPlatformInfo (platform
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
260 if (CL_err
!= CL_SUCCESS
)
262 log_error ("ERROR: %s : %d : %s\n", "clGetPlatformInfo()", CL_err
, val2cstr_cl (CL_err
));
268 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
)
270 cl_int CL_err
= ocl
->clGetDeviceIDs (platform
, device_type
, num_entries
, devices
, num_devices
);
272 if (CL_err
!= CL_SUCCESS
)
274 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceIDs()", CL_err
, val2cstr_cl (CL_err
));
280 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
)
282 cl_int CL_err
= ocl
->clGetDeviceInfo (device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
284 if (CL_err
!= CL_SUCCESS
)
286 log_error ("ERROR: %s : %d : %s\n", "clGetDeviceInfo()", CL_err
, val2cstr_cl (CL_err
));
292 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
)
296 cl_context context
= ocl
->clCreateContext (properties
, num_devices
, devices
, pfn_notify
, user_data
, &CL_err
);
298 if (CL_err
!= CL_SUCCESS
)
300 log_error ("ERROR: %s : %d : %s\n", "clCreateContext()", CL_err
, val2cstr_cl (CL_err
));
308 cl_command_queue
hc_clCreateCommandQueue (OCL_PTR
*ocl
, cl_context context
, cl_device_id device
, cl_command_queue_properties properties
)
312 cl_command_queue command_queue
= ocl
->clCreateCommandQueue (context
, device
, properties
, &CL_err
);
314 if (CL_err
!= CL_SUCCESS
)
316 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
321 return (command_queue
);
325 cl_command_queue hc_clCreateCommandQueueWithProperties (cl_context context, cl_device_id device, const cl_queue_properties *properties)
329 cl_command_queue command_queue = clCreateCommandQueueWithProperties (context, device, properties, &CL_err);
331 if (CL_err != CL_SUCCESS)
333 log_error ("ERROR: %s : %d : %s\n", "clCreateCommandQueueWithProperties()", CL_err, val2cstr_cl (CL_err));
338 return (command_queue);
342 cl_mem
hc_clCreateBuffer (OCL_PTR
*ocl
, cl_context context
, cl_mem_flags flags
, size_t size
, void *host_ptr
)
346 cl_mem mem
= ocl
->clCreateBuffer (context
, flags
, size
, host_ptr
, &CL_err
);
348 if (CL_err
!= CL_SUCCESS
)
350 log_error ("ERROR: %s : %d : %s\n", "clCreateBuffer()", CL_err
, val2cstr_cl (CL_err
));
358 cl_program
hc_clCreateProgramWithSource (OCL_PTR
*ocl
, cl_context context
, cl_uint count
, const char **strings
, const size_t *lengths
)
362 cl_program program
= ocl
->clCreateProgramWithSource (context
, count
, strings
, lengths
, &CL_err
);
364 if (CL_err
!= CL_SUCCESS
)
366 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithSource()", CL_err
, val2cstr_cl (CL_err
));
374 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
)
378 cl_program program
= ocl
->clCreateProgramWithBinary (context
, num_devices
, device_list
, lengths
, binaries
, binary_status
, &CL_err
);
380 if (CL_err
!= CL_SUCCESS
)
382 log_error ("ERROR: %s : %d : %s\n", "clCreateProgramWithBinary()", CL_err
, val2cstr_cl (CL_err
));
390 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
)
392 cl_int CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options
, pfn_notify
, user_data
);
394 if (CL_err
!= CL_SUCCESS
)
396 size_t len
= strlen (options
) + 1 + 15;
398 char *options_update
= (char *) mymalloc (len
+ 1);
400 options_update
= strncat (options_update
, options
, len
- 1 - 15);
401 options_update
= strncat (options_update
, " -cl-opt-disable", 1 + 15);
403 if (data
.quiet
== 0) log_error ("\n=== Build failed, retry with optimization disabled ===\n");
405 CL_err
= ocl
->clBuildProgram (program
, num_devices
, device_list
, options_update
, pfn_notify
, user_data
);
407 myfree (options_update
);
409 if (CL_err
!= CL_SUCCESS
)
411 log_error ("ERROR: %s : %d : %s\n", "clBuildProgram()", CL_err
, val2cstr_cl (CL_err
));
413 log_error ("\n=== Build Options : %s ===\n", options
);
417 cl_int err
= hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, 0, NULL
, &len
);
419 if (err
== CL_SUCCESS
&& len
> 0)
421 char *buf
= (char *) mymalloc (len
+ 1);
423 if (hc_clGetProgramBuildInfo (ocl
, program
, *device_list
, CL_PROGRAM_BUILD_LOG
, len
, buf
, NULL
) == CL_SUCCESS
)
425 fprintf (stderr
, "\n=== Build Log (start) ===\n%s\n=== Build Log (end) ===\n", buf
);
431 if (exitOnFail
) exit (-1);
440 cl_kernel
hc_clCreateKernel (OCL_PTR
*ocl
, cl_program program
, const char *kernel_name
)
444 cl_kernel kernel
= ocl
->clCreateKernel (program
, kernel_name
, &CL_err
);
446 if (CL_err
!= CL_SUCCESS
)
448 log_error ("ERROR: %s %d - %s\n", "clCreateKernel()", CL_err
, kernel_name
);
456 void hc_clReleaseMemObject (OCL_PTR
*ocl
, cl_mem mem
)
458 cl_int CL_err
= ocl
->clReleaseMemObject (mem
);
460 if (CL_err
!= CL_SUCCESS
)
462 log_error ("ERROR: %s : %d : %s\n", "clReleaseMemObject()", CL_err
, val2cstr_cl (CL_err
));
468 void hc_clReleaseKernel (OCL_PTR
*ocl
, cl_kernel kernel
)
470 cl_int CL_err
= ocl
->clReleaseKernel (kernel
);
472 if (CL_err
!= CL_SUCCESS
)
474 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
480 void hc_clReleaseProgram (OCL_PTR
*ocl
, cl_program program
)
482 cl_int CL_err
= ocl
->clReleaseProgram (program
);
484 if (CL_err
!= CL_SUCCESS
)
486 log_error ("ERROR: %s : %d : %s\n", "clReleaseProgram()", CL_err
, val2cstr_cl (CL_err
));
492 void hc_clReleaseCommandQueue (OCL_PTR
*ocl
, cl_command_queue command_queue
)
494 cl_int CL_err
= ocl
->clReleaseCommandQueue (command_queue
);
496 if (CL_err
!= CL_SUCCESS
)
498 log_error ("ERROR: %s : %d : %s\n", "clReleaseCommandQueue()", CL_err
, val2cstr_cl (CL_err
));
504 void hc_clReleaseContext (OCL_PTR
*ocl
, cl_context context
)
506 cl_int CL_err
= ocl
->clReleaseContext (context
);
508 if (CL_err
!= CL_SUCCESS
)
510 log_error ("ERROR: %s : %d : %s\n", "clReleaseContext()", CL_err
, val2cstr_cl (CL_err
));
516 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
)
520 void *buf
= ocl
->clEnqueueMapBuffer (command_queue
, buffer
, blocking_read
, map_flags
, offset
, cb
, num_events_in_wait_list
, event_wait_list
, event
, &CL_err
);
522 if (CL_err
!= CL_SUCCESS
)
524 log_error ("ERROR: %s : %d : %s\n", "clEnqueueMapBuffer()", CL_err
, val2cstr_cl (CL_err
));
532 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
)
534 cl_int CL_err
= ocl
->clEnqueueUnmapMemObject (command_queue
, memobj
, mapped_ptr
, num_events_in_wait_list
, event_wait_list
, event
);
536 if (CL_err
!= CL_SUCCESS
)
538 log_error ("ERROR: %s : %d : %s\n", "clEnqueueUnmapMemObject()", CL_err
, val2cstr_cl (CL_err
));
544 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
)
548 if (ocl
->clEnqueueFillBuffer
)
550 CL_err
= ocl
->clEnqueueFillBuffer (command_queue
, buffer
, pattern
, pattern_size
, offset
, size
, num_events_in_wait_list
, event_wait_list
, event
);
552 if (CL_err
!= CL_SUCCESS
&& data
.quiet
== 0)
553 log_error ("WARNING: %s : %d : %s\n", "clEnqueueFillBuffer()", CL_err
, val2cstr_cl (CL_err
));
559 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
)
561 cl_int CL_err
= ocl
->clGetKernelWorkGroupInfo (kernel
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
563 if (CL_err
!= CL_SUCCESS
)
565 log_error ("ERROR: %s : %d : %s\n", "clGetKernelWorkGroupInfo()", CL_err
, val2cstr_cl (CL_err
));
571 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
)
573 cl_int CL_err
= ocl
->clGetProgramBuildInfo (program
, device
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
575 if (CL_err
!= CL_SUCCESS
)
577 log_error ("ERROR: %s : %d : %s\n", "clGetProgramBuildInfo()", CL_err
, val2cstr_cl (CL_err
));
585 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
)
587 cl_int CL_err
= ocl
->clGetProgramInfo (program
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
589 if (CL_err
!= CL_SUCCESS
)
591 log_error ("ERROR: %s : %d : %s\n", "clGetProgramInfo()", CL_err
, val2cstr_cl (CL_err
));
597 void hc_clWaitForEvents (OCL_PTR
*ocl
, cl_uint num_events
, const cl_event
*event_list
)
599 cl_int CL_err
= ocl
->clWaitForEvents (num_events
, event_list
);
601 if (CL_err
!= CL_SUCCESS
)
603 log_error ("ERROR: %s : %d : %s\n", "clWaitForEvents()", CL_err
, val2cstr_cl (CL_err
));
609 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
)
611 cl_int CL_err
= ocl
->clGetEventProfilingInfo (event
, param_name
, param_value_size
, param_value
, param_value_size_ret
);
613 if (CL_err
!= CL_SUCCESS
)
615 log_error ("ERROR: %s : %d : %s\n", "clGetEventProfilingInfo()", CL_err
, val2cstr_cl (CL_err
));
621 void hc_clReleaseEvent (OCL_PTR
*ocl
, cl_event event
)
623 cl_int CL_err
= ocl
->clReleaseEvent (event
);
625 if (CL_err
!= CL_SUCCESS
)
627 log_error ("ERROR: %s : %d : %s\n", "clReleaseEvent()", CL_err
, val2cstr_cl (CL_err
));