1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from cl.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // entry_points_cl_autogen.cpp:
9 // Defines the CL entry points.
10
11 #include "libGLESv2/entry_points_cl_autogen.h"
12
13 #include "libANGLE/validationCL_autogen.h"
14 #include "libGLESv2/cl_stubs_autogen.h"
15 #include "libGLESv2/entry_points_cl_utils.h"
16
17 namespace cl
18 {
19
20 // CL 1.0
clGetPlatformIDs(cl_uint num_entries,cl_platform_id * platforms,cl_uint * num_platforms)21 cl_int CL_API_CALL clGetPlatformIDs(cl_uint num_entries,
22 cl_platform_id *platforms,
23 cl_uint *num_platforms)
24 {
25 InitBackEnds(false);
26
27 CL_EVENT(GetPlatformIDs,
28 "num_entries = %u, platforms = 0x%016" PRIxPTR ", num_platforms = 0x%016" PRIxPTR "",
29 num_entries, (uintptr_t)platforms, (uintptr_t)num_platforms);
30
31 ANGLE_CL_VALIDATE_ERROR(GetPlatformIDs, num_entries, platforms, num_platforms);
32
33 cl::gClErrorTls = CL_SUCCESS;
34 return GetPlatformIDs(num_entries, platforms, num_platforms);
35 }
36
clGetPlatformInfo(cl_platform_id platform,cl_platform_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)37 cl_int CL_API_CALL clGetPlatformInfo(cl_platform_id platform,
38 cl_platform_info param_name,
39 size_t param_value_size,
40 void *param_value,
41 size_t *param_value_size_ret)
42 {
43 InitBackEnds(false);
44
45 CL_EVENT(GetPlatformInfo,
46 "platform = 0x%016" PRIxPTR
47 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
48 ", param_value_size_ret = 0x%016" PRIxPTR "",
49 (uintptr_t)platform, param_name, param_value_size, (uintptr_t)param_value,
50 (uintptr_t)param_value_size_ret);
51
52 PlatformInfo param_namePacked = PackParam<PlatformInfo>(param_name);
53
54 ANGLE_CL_VALIDATE_ERROR(GetPlatformInfo, platform, param_namePacked, param_value_size,
55 param_value, param_value_size_ret);
56
57 cl::gClErrorTls = CL_SUCCESS;
58 return GetPlatformInfo(platform, param_namePacked, param_value_size, param_value,
59 param_value_size_ret);
60 }
61
clGetDeviceIDs(cl_platform_id platform,cl_device_type device_type,cl_uint num_entries,cl_device_id * devices,cl_uint * num_devices)62 cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform,
63 cl_device_type device_type,
64 cl_uint num_entries,
65 cl_device_id *devices,
66 cl_uint *num_devices)
67 {
68 InitBackEnds(false);
69
70 CL_EVENT(GetDeviceIDs,
71 "platform = 0x%016" PRIxPTR
72 ", device_type = %llu, num_entries = %u, devices = 0x%016" PRIxPTR
73 ", num_devices = 0x%016" PRIxPTR "",
74 (uintptr_t)platform, static_cast<unsigned long long>(device_type), num_entries,
75 (uintptr_t)devices, (uintptr_t)num_devices);
76
77 DeviceType device_typePacked = PackParam<DeviceType>(device_type);
78
79 ANGLE_CL_VALIDATE_ERROR(GetDeviceIDs, platform, device_typePacked, num_entries, devices,
80 num_devices);
81
82 cl::gClErrorTls = CL_SUCCESS;
83 return GetDeviceIDs(platform, device_typePacked, num_entries, devices, num_devices);
84 }
85
clGetDeviceInfo(cl_device_id device,cl_device_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)86 cl_int CL_API_CALL clGetDeviceInfo(cl_device_id device,
87 cl_device_info param_name,
88 size_t param_value_size,
89 void *param_value,
90 size_t *param_value_size_ret)
91 {
92 CL_EVENT(GetDeviceInfo,
93 "device = 0x%016" PRIxPTR
94 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
95 ", param_value_size_ret = 0x%016" PRIxPTR "",
96 (uintptr_t)device, param_name, param_value_size, (uintptr_t)param_value,
97 (uintptr_t)param_value_size_ret);
98
99 DeviceInfo param_namePacked = PackParam<DeviceInfo>(param_name);
100
101 ANGLE_CL_VALIDATE_ERROR(GetDeviceInfo, device, param_namePacked, param_value_size, param_value,
102 param_value_size_ret);
103
104 cl::gClErrorTls = CL_SUCCESS;
105 return GetDeviceInfo(device, param_namePacked, param_value_size, param_value,
106 param_value_size_ret);
107 }
108
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)109 cl_context CL_API_CALL clCreateContext(const cl_context_properties *properties,
110 cl_uint num_devices,
111 const cl_device_id *devices,
112 void(CL_CALLBACK *pfn_notify)(const char *errinfo,
113 const void *private_info,
114 size_t cb,
115 void *user_data),
116 void *user_data,
117 cl_int *errcode_ret)
118 {
119 InitBackEnds(false);
120
121 CL_EVENT(CreateContext,
122 "properties = 0x%016" PRIxPTR ", num_devices = %u, devices = 0x%016" PRIxPTR
123 ", pfn_notify = 0x%016" PRIxPTR ", user_data = 0x%016" PRIxPTR
124 ", errcode_ret = 0x%016" PRIxPTR "",
125 (uintptr_t)properties, num_devices, (uintptr_t)devices, (uintptr_t)pfn_notify,
126 (uintptr_t)user_data, (uintptr_t)errcode_ret);
127
128 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateContext, properties, num_devices, devices, pfn_notify,
129 user_data);
130
131 cl::gClErrorTls = CL_SUCCESS;
132 cl_context object = CreateContext(properties, num_devices, devices, pfn_notify, user_data);
133
134 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
135 if (errcode_ret != nullptr)
136 {
137 *errcode_ret = cl::gClErrorTls;
138 }
139 return object;
140 }
141
142 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)143 clCreateContextFromType(const cl_context_properties *properties,
144 cl_device_type device_type,
145 void(CL_CALLBACK *pfn_notify)(const char *errinfo,
146 const void *private_info,
147 size_t cb,
148 void *user_data),
149 void *user_data,
150 cl_int *errcode_ret)
151 {
152 InitBackEnds(false);
153
154 CL_EVENT(CreateContextFromType,
155 "properties = 0x%016" PRIxPTR ", device_type = %llu, pfn_notify = 0x%016" PRIxPTR
156 ", user_data = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
157 (uintptr_t)properties, static_cast<unsigned long long>(device_type),
158 (uintptr_t)pfn_notify, (uintptr_t)user_data, (uintptr_t)errcode_ret);
159
160 DeviceType device_typePacked = PackParam<DeviceType>(device_type);
161
162 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateContextFromType, properties, device_typePacked, pfn_notify,
163 user_data);
164
165 cl::gClErrorTls = CL_SUCCESS;
166 cl_context object = CreateContextFromType(properties, device_typePacked, pfn_notify, user_data);
167
168 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
169 if (errcode_ret != nullptr)
170 {
171 *errcode_ret = cl::gClErrorTls;
172 }
173 return object;
174 }
175
clRetainContext(cl_context context)176 cl_int CL_API_CALL clRetainContext(cl_context context)
177 {
178 CL_EVENT(RetainContext, "context = 0x%016" PRIxPTR "", (uintptr_t)context);
179
180 ANGLE_CL_VALIDATE_ERROR(RetainContext, context);
181
182 cl::gClErrorTls = CL_SUCCESS;
183 return RetainContext(context);
184 }
185
clReleaseContext(cl_context context)186 cl_int CL_API_CALL clReleaseContext(cl_context context)
187 {
188 CL_EVENT(ReleaseContext, "context = 0x%016" PRIxPTR "", (uintptr_t)context);
189
190 ANGLE_CL_VALIDATE_ERROR(ReleaseContext, context);
191
192 cl::gClErrorTls = CL_SUCCESS;
193 return ReleaseContext(context);
194 }
195
clGetContextInfo(cl_context context,cl_context_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)196 cl_int CL_API_CALL clGetContextInfo(cl_context context,
197 cl_context_info param_name,
198 size_t param_value_size,
199 void *param_value,
200 size_t *param_value_size_ret)
201 {
202 CL_EVENT(GetContextInfo,
203 "context = 0x%016" PRIxPTR
204 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
205 ", param_value_size_ret = 0x%016" PRIxPTR "",
206 (uintptr_t)context, param_name, param_value_size, (uintptr_t)param_value,
207 (uintptr_t)param_value_size_ret);
208
209 ContextInfo param_namePacked = PackParam<ContextInfo>(param_name);
210
211 ANGLE_CL_VALIDATE_ERROR(GetContextInfo, context, param_namePacked, param_value_size,
212 param_value, param_value_size_ret);
213
214 cl::gClErrorTls = CL_SUCCESS;
215 return GetContextInfo(context, param_namePacked, param_value_size, param_value,
216 param_value_size_ret);
217 }
218
clRetainCommandQueue(cl_command_queue command_queue)219 cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue command_queue)
220 {
221 CL_EVENT(RetainCommandQueue, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);
222
223 ANGLE_CL_VALIDATE_ERROR(RetainCommandQueue, command_queue);
224
225 cl::gClErrorTls = CL_SUCCESS;
226 return RetainCommandQueue(command_queue);
227 }
228
clReleaseCommandQueue(cl_command_queue command_queue)229 cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue command_queue)
230 {
231 CL_EVENT(ReleaseCommandQueue, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);
232
233 ANGLE_CL_VALIDATE_ERROR(ReleaseCommandQueue, command_queue);
234
235 cl::gClErrorTls = CL_SUCCESS;
236 return ReleaseCommandQueue(command_queue);
237 }
238
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)239 cl_int CL_API_CALL clGetCommandQueueInfo(cl_command_queue command_queue,
240 cl_command_queue_info param_name,
241 size_t param_value_size,
242 void *param_value,
243 size_t *param_value_size_ret)
244 {
245 CL_EVENT(GetCommandQueueInfo,
246 "command_queue = 0x%016" PRIxPTR
247 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
248 ", param_value_size_ret = 0x%016" PRIxPTR "",
249 (uintptr_t)command_queue, param_name, param_value_size, (uintptr_t)param_value,
250 (uintptr_t)param_value_size_ret);
251
252 CommandQueueInfo param_namePacked = PackParam<CommandQueueInfo>(param_name);
253
254 ANGLE_CL_VALIDATE_ERROR(GetCommandQueueInfo, command_queue, param_namePacked, param_value_size,
255 param_value, param_value_size_ret);
256
257 cl::gClErrorTls = CL_SUCCESS;
258 return GetCommandQueueInfo(command_queue, param_namePacked, param_value_size, param_value,
259 param_value_size_ret);
260 }
261
clCreateBuffer(cl_context context,cl_mem_flags flags,size_t size,void * host_ptr,cl_int * errcode_ret)262 cl_mem CL_API_CALL clCreateBuffer(cl_context context,
263 cl_mem_flags flags,
264 size_t size,
265 void *host_ptr,
266 cl_int *errcode_ret)
267 {
268 CL_EVENT(CreateBuffer,
269 "context = 0x%016" PRIxPTR ", flags = %llu, size = %zu, host_ptr = 0x%016" PRIxPTR
270 ", errcode_ret = 0x%016" PRIxPTR "",
271 (uintptr_t)context, static_cast<unsigned long long>(flags), size, (uintptr_t)host_ptr,
272 (uintptr_t)errcode_ret);
273
274 MemFlags flagsPacked = PackParam<MemFlags>(flags);
275
276 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateBuffer, context, flagsPacked, size, host_ptr);
277
278 cl::gClErrorTls = CL_SUCCESS;
279 cl_mem object = CreateBuffer(context, flagsPacked, size, host_ptr);
280
281 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
282 if (errcode_ret != nullptr)
283 {
284 *errcode_ret = cl::gClErrorTls;
285 }
286 return object;
287 }
288
clRetainMemObject(cl_mem memobj)289 cl_int CL_API_CALL clRetainMemObject(cl_mem memobj)
290 {
291 CL_EVENT(RetainMemObject, "memobj = 0x%016" PRIxPTR "", (uintptr_t)memobj);
292
293 ANGLE_CL_VALIDATE_ERROR(RetainMemObject, memobj);
294
295 cl::gClErrorTls = CL_SUCCESS;
296 return RetainMemObject(memobj);
297 }
298
clReleaseMemObject(cl_mem memobj)299 cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj)
300 {
301 CL_EVENT(ReleaseMemObject, "memobj = 0x%016" PRIxPTR "", (uintptr_t)memobj);
302
303 ANGLE_CL_VALIDATE_ERROR(ReleaseMemObject, memobj);
304
305 cl::gClErrorTls = CL_SUCCESS;
306 return ReleaseMemObject(memobj);
307 }
308
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)309 cl_int CL_API_CALL clGetSupportedImageFormats(cl_context context,
310 cl_mem_flags flags,
311 cl_mem_object_type image_type,
312 cl_uint num_entries,
313 cl_image_format *image_formats,
314 cl_uint *num_image_formats)
315 {
316 CL_EVENT(GetSupportedImageFormats,
317 "context = 0x%016" PRIxPTR
318 ", flags = %llu, image_type = %u, num_entries = %u, image_formats = 0x%016" PRIxPTR
319 ", num_image_formats = 0x%016" PRIxPTR "",
320 (uintptr_t)context, static_cast<unsigned long long>(flags), image_type, num_entries,
321 (uintptr_t)image_formats, (uintptr_t)num_image_formats);
322
323 MemFlags flagsPacked = PackParam<MemFlags>(flags);
324 MemObjectType image_typePacked = PackParam<MemObjectType>(image_type);
325
326 ANGLE_CL_VALIDATE_ERROR(GetSupportedImageFormats, context, flagsPacked, image_typePacked,
327 num_entries, image_formats, num_image_formats);
328
329 cl::gClErrorTls = CL_SUCCESS;
330 return GetSupportedImageFormats(context, flagsPacked, image_typePacked, num_entries,
331 image_formats, num_image_formats);
332 }
333
clGetMemObjectInfo(cl_mem memobj,cl_mem_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)334 cl_int CL_API_CALL clGetMemObjectInfo(cl_mem memobj,
335 cl_mem_info param_name,
336 size_t param_value_size,
337 void *param_value,
338 size_t *param_value_size_ret)
339 {
340 CL_EVENT(GetMemObjectInfo,
341 "memobj = 0x%016" PRIxPTR
342 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
343 ", param_value_size_ret = 0x%016" PRIxPTR "",
344 (uintptr_t)memobj, param_name, param_value_size, (uintptr_t)param_value,
345 (uintptr_t)param_value_size_ret);
346
347 MemInfo param_namePacked = PackParam<MemInfo>(param_name);
348
349 ANGLE_CL_VALIDATE_ERROR(GetMemObjectInfo, memobj, param_namePacked, param_value_size,
350 param_value, param_value_size_ret);
351
352 cl::gClErrorTls = CL_SUCCESS;
353 return GetMemObjectInfo(memobj, param_namePacked, param_value_size, param_value,
354 param_value_size_ret);
355 }
356
clGetImageInfo(cl_mem image,cl_image_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)357 cl_int CL_API_CALL clGetImageInfo(cl_mem image,
358 cl_image_info param_name,
359 size_t param_value_size,
360 void *param_value,
361 size_t *param_value_size_ret)
362 {
363 CL_EVENT(GetImageInfo,
364 "image = 0x%016" PRIxPTR
365 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
366 ", param_value_size_ret = 0x%016" PRIxPTR "",
367 (uintptr_t)image, param_name, param_value_size, (uintptr_t)param_value,
368 (uintptr_t)param_value_size_ret);
369
370 ImageInfo param_namePacked = PackParam<ImageInfo>(param_name);
371
372 ANGLE_CL_VALIDATE_ERROR(GetImageInfo, image, param_namePacked, param_value_size, param_value,
373 param_value_size_ret);
374
375 cl::gClErrorTls = CL_SUCCESS;
376 return GetImageInfo(image, param_namePacked, param_value_size, param_value,
377 param_value_size_ret);
378 }
379
clRetainSampler(cl_sampler sampler)380 cl_int CL_API_CALL clRetainSampler(cl_sampler sampler)
381 {
382 CL_EVENT(RetainSampler, "sampler = 0x%016" PRIxPTR "", (uintptr_t)sampler);
383
384 ANGLE_CL_VALIDATE_ERROR(RetainSampler, sampler);
385
386 cl::gClErrorTls = CL_SUCCESS;
387 return RetainSampler(sampler);
388 }
389
clReleaseSampler(cl_sampler sampler)390 cl_int CL_API_CALL clReleaseSampler(cl_sampler sampler)
391 {
392 CL_EVENT(ReleaseSampler, "sampler = 0x%016" PRIxPTR "", (uintptr_t)sampler);
393
394 ANGLE_CL_VALIDATE_ERROR(ReleaseSampler, sampler);
395
396 cl::gClErrorTls = CL_SUCCESS;
397 return ReleaseSampler(sampler);
398 }
399
clGetSamplerInfo(cl_sampler sampler,cl_sampler_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)400 cl_int CL_API_CALL clGetSamplerInfo(cl_sampler sampler,
401 cl_sampler_info param_name,
402 size_t param_value_size,
403 void *param_value,
404 size_t *param_value_size_ret)
405 {
406 CL_EVENT(GetSamplerInfo,
407 "sampler = 0x%016" PRIxPTR
408 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
409 ", param_value_size_ret = 0x%016" PRIxPTR "",
410 (uintptr_t)sampler, param_name, param_value_size, (uintptr_t)param_value,
411 (uintptr_t)param_value_size_ret);
412
413 SamplerInfo param_namePacked = PackParam<SamplerInfo>(param_name);
414
415 ANGLE_CL_VALIDATE_ERROR(GetSamplerInfo, sampler, param_namePacked, param_value_size,
416 param_value, param_value_size_ret);
417
418 cl::gClErrorTls = CL_SUCCESS;
419 return GetSamplerInfo(sampler, param_namePacked, param_value_size, param_value,
420 param_value_size_ret);
421 }
422
clCreateProgramWithSource(cl_context context,cl_uint count,const char ** strings,const size_t * lengths,cl_int * errcode_ret)423 cl_program CL_API_CALL clCreateProgramWithSource(cl_context context,
424 cl_uint count,
425 const char **strings,
426 const size_t *lengths,
427 cl_int *errcode_ret)
428 {
429 CL_EVENT(CreateProgramWithSource,
430 "context = 0x%016" PRIxPTR ", count = %u, strings = 0x%016" PRIxPTR
431 ", lengths = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
432 (uintptr_t)context, count, (uintptr_t)strings, (uintptr_t)lengths,
433 (uintptr_t)errcode_ret);
434
435 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateProgramWithSource, context, count, strings, lengths);
436
437 cl::gClErrorTls = CL_SUCCESS;
438 cl_program object = CreateProgramWithSource(context, count, strings, lengths);
439
440 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
441 if (errcode_ret != nullptr)
442 {
443 *errcode_ret = cl::gClErrorTls;
444 }
445 return object;
446 }
447
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)448 cl_program CL_API_CALL clCreateProgramWithBinary(cl_context context,
449 cl_uint num_devices,
450 const cl_device_id *device_list,
451 const size_t *lengths,
452 const unsigned char **binaries,
453 cl_int *binary_status,
454 cl_int *errcode_ret)
455 {
456 CL_EVENT(CreateProgramWithBinary,
457 "context = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
458 ", lengths = 0x%016" PRIxPTR ", binaries = 0x%016" PRIxPTR
459 ", binary_status = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
460 (uintptr_t)context, num_devices, (uintptr_t)device_list, (uintptr_t)lengths,
461 (uintptr_t)binaries, (uintptr_t)binary_status, (uintptr_t)errcode_ret);
462
463 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateProgramWithBinary, context, num_devices, device_list,
464 lengths, binaries, binary_status);
465
466 cl::gClErrorTls = CL_SUCCESS;
467 cl_program object = CreateProgramWithBinary(context, num_devices, device_list, lengths,
468 binaries, binary_status);
469
470 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
471 if (errcode_ret != nullptr)
472 {
473 *errcode_ret = cl::gClErrorTls;
474 }
475 return object;
476 }
477
clRetainProgram(cl_program program)478 cl_int CL_API_CALL clRetainProgram(cl_program program)
479 {
480 CL_EVENT(RetainProgram, "program = 0x%016" PRIxPTR "", (uintptr_t)program);
481
482 ANGLE_CL_VALIDATE_ERROR(RetainProgram, program);
483
484 cl::gClErrorTls = CL_SUCCESS;
485 return RetainProgram(program);
486 }
487
clReleaseProgram(cl_program program)488 cl_int CL_API_CALL clReleaseProgram(cl_program program)
489 {
490 CL_EVENT(ReleaseProgram, "program = 0x%016" PRIxPTR "", (uintptr_t)program);
491
492 ANGLE_CL_VALIDATE_ERROR(ReleaseProgram, program);
493
494 cl::gClErrorTls = CL_SUCCESS;
495 return ReleaseProgram(program);
496 }
497
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)498 cl_int CL_API_CALL clBuildProgram(cl_program program,
499 cl_uint num_devices,
500 const cl_device_id *device_list,
501 const char *options,
502 void(CL_CALLBACK *pfn_notify)(cl_program program,
503 void *user_data),
504 void *user_data)
505 {
506 CL_EVENT(BuildProgram,
507 "program = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
508 ", options = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
509 ", user_data = 0x%016" PRIxPTR "",
510 (uintptr_t)program, num_devices, (uintptr_t)device_list, (uintptr_t)options,
511 (uintptr_t)pfn_notify, (uintptr_t)user_data);
512
513 ANGLE_CL_VALIDATE_ERROR(BuildProgram, program, num_devices, device_list, options, pfn_notify,
514 user_data);
515
516 cl::gClErrorTls = CL_SUCCESS;
517 return BuildProgram(program, num_devices, device_list, options, pfn_notify, user_data);
518 }
519
clGetProgramInfo(cl_program program,cl_program_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)520 cl_int CL_API_CALL clGetProgramInfo(cl_program program,
521 cl_program_info param_name,
522 size_t param_value_size,
523 void *param_value,
524 size_t *param_value_size_ret)
525 {
526 CL_EVENT(GetProgramInfo,
527 "program = 0x%016" PRIxPTR
528 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
529 ", param_value_size_ret = 0x%016" PRIxPTR "",
530 (uintptr_t)program, param_name, param_value_size, (uintptr_t)param_value,
531 (uintptr_t)param_value_size_ret);
532
533 ProgramInfo param_namePacked = PackParam<ProgramInfo>(param_name);
534
535 ANGLE_CL_VALIDATE_ERROR(GetProgramInfo, program, param_namePacked, param_value_size,
536 param_value, param_value_size_ret);
537
538 cl::gClErrorTls = CL_SUCCESS;
539 return GetProgramInfo(program, param_namePacked, param_value_size, param_value,
540 param_value_size_ret);
541 }
542
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)543 cl_int CL_API_CALL clGetProgramBuildInfo(cl_program program,
544 cl_device_id device,
545 cl_program_build_info param_name,
546 size_t param_value_size,
547 void *param_value,
548 size_t *param_value_size_ret)
549 {
550 CL_EVENT(GetProgramBuildInfo,
551 "program = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
552 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
553 ", param_value_size_ret = 0x%016" PRIxPTR "",
554 (uintptr_t)program, (uintptr_t)device, param_name, param_value_size,
555 (uintptr_t)param_value, (uintptr_t)param_value_size_ret);
556
557 ProgramBuildInfo param_namePacked = PackParam<ProgramBuildInfo>(param_name);
558
559 ANGLE_CL_VALIDATE_ERROR(GetProgramBuildInfo, program, device, param_namePacked,
560 param_value_size, param_value, param_value_size_ret);
561
562 cl::gClErrorTls = CL_SUCCESS;
563 return GetProgramBuildInfo(program, device, param_namePacked, param_value_size, param_value,
564 param_value_size_ret);
565 }
566
clCreateKernel(cl_program program,const char * kernel_name,cl_int * errcode_ret)567 cl_kernel CL_API_CALL clCreateKernel(cl_program program,
568 const char *kernel_name,
569 cl_int *errcode_ret)
570 {
571 CL_EVENT(CreateKernel,
572 "program = 0x%016" PRIxPTR ", kernel_name = 0x%016" PRIxPTR
573 ", errcode_ret = 0x%016" PRIxPTR "",
574 (uintptr_t)program, (uintptr_t)kernel_name, (uintptr_t)errcode_ret);
575
576 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateKernel, program, kernel_name);
577
578 cl::gClErrorTls = CL_SUCCESS;
579 cl_kernel object = CreateKernel(program, kernel_name);
580
581 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
582 if (errcode_ret != nullptr)
583 {
584 *errcode_ret = cl::gClErrorTls;
585 }
586 return object;
587 }
588
clCreateKernelsInProgram(cl_program program,cl_uint num_kernels,cl_kernel * kernels,cl_uint * num_kernels_ret)589 cl_int CL_API_CALL clCreateKernelsInProgram(cl_program program,
590 cl_uint num_kernels,
591 cl_kernel *kernels,
592 cl_uint *num_kernels_ret)
593 {
594 CL_EVENT(CreateKernelsInProgram,
595 "program = 0x%016" PRIxPTR ", num_kernels = %u, kernels = 0x%016" PRIxPTR
596 ", num_kernels_ret = 0x%016" PRIxPTR "",
597 (uintptr_t)program, num_kernels, (uintptr_t)kernels, (uintptr_t)num_kernels_ret);
598
599 ANGLE_CL_VALIDATE_ERROR(CreateKernelsInProgram, program, num_kernels, kernels, num_kernels_ret);
600
601 cl::gClErrorTls = CL_SUCCESS;
602 return CreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
603 }
604
clRetainKernel(cl_kernel kernel)605 cl_int CL_API_CALL clRetainKernel(cl_kernel kernel)
606 {
607 CL_EVENT(RetainKernel, "kernel = 0x%016" PRIxPTR "", (uintptr_t)kernel);
608
609 ANGLE_CL_VALIDATE_ERROR(RetainKernel, kernel);
610
611 cl::gClErrorTls = CL_SUCCESS;
612 return RetainKernel(kernel);
613 }
614
clReleaseKernel(cl_kernel kernel)615 cl_int CL_API_CALL clReleaseKernel(cl_kernel kernel)
616 {
617 CL_EVENT(ReleaseKernel, "kernel = 0x%016" PRIxPTR "", (uintptr_t)kernel);
618
619 ANGLE_CL_VALIDATE_ERROR(ReleaseKernel, kernel);
620
621 cl::gClErrorTls = CL_SUCCESS;
622 return ReleaseKernel(kernel);
623 }
624
clSetKernelArg(cl_kernel kernel,cl_uint arg_index,size_t arg_size,const void * arg_value)625 cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel,
626 cl_uint arg_index,
627 size_t arg_size,
628 const void *arg_value)
629 {
630 CL_EVENT(SetKernelArg,
631 "kernel = 0x%016" PRIxPTR
632 ", arg_index = %u, arg_size = %zu, arg_value = 0x%016" PRIxPTR "",
633 (uintptr_t)kernel, arg_index, arg_size, (uintptr_t)arg_value);
634
635 ANGLE_CL_VALIDATE_ERROR(SetKernelArg, kernel, arg_index, arg_size, arg_value);
636
637 cl::gClErrorTls = CL_SUCCESS;
638 return SetKernelArg(kernel, arg_index, arg_size, arg_value);
639 }
640
clGetKernelInfo(cl_kernel kernel,cl_kernel_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)641 cl_int CL_API_CALL clGetKernelInfo(cl_kernel kernel,
642 cl_kernel_info param_name,
643 size_t param_value_size,
644 void *param_value,
645 size_t *param_value_size_ret)
646 {
647 CL_EVENT(GetKernelInfo,
648 "kernel = 0x%016" PRIxPTR
649 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
650 ", param_value_size_ret = 0x%016" PRIxPTR "",
651 (uintptr_t)kernel, param_name, param_value_size, (uintptr_t)param_value,
652 (uintptr_t)param_value_size_ret);
653
654 KernelInfo param_namePacked = PackParam<KernelInfo>(param_name);
655
656 ANGLE_CL_VALIDATE_ERROR(GetKernelInfo, kernel, param_namePacked, param_value_size, param_value,
657 param_value_size_ret);
658
659 cl::gClErrorTls = CL_SUCCESS;
660 return GetKernelInfo(kernel, param_namePacked, param_value_size, param_value,
661 param_value_size_ret);
662 }
663
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)664 cl_int CL_API_CALL clGetKernelWorkGroupInfo(cl_kernel kernel,
665 cl_device_id device,
666 cl_kernel_work_group_info param_name,
667 size_t param_value_size,
668 void *param_value,
669 size_t *param_value_size_ret)
670 {
671 CL_EVENT(GetKernelWorkGroupInfo,
672 "kernel = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
673 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
674 ", param_value_size_ret = 0x%016" PRIxPTR "",
675 (uintptr_t)kernel, (uintptr_t)device, param_name, param_value_size,
676 (uintptr_t)param_value, (uintptr_t)param_value_size_ret);
677
678 KernelWorkGroupInfo param_namePacked = PackParam<KernelWorkGroupInfo>(param_name);
679
680 ANGLE_CL_VALIDATE_ERROR(GetKernelWorkGroupInfo, kernel, device, param_namePacked,
681 param_value_size, param_value, param_value_size_ret);
682
683 cl::gClErrorTls = CL_SUCCESS;
684 return GetKernelWorkGroupInfo(kernel, device, param_namePacked, param_value_size, param_value,
685 param_value_size_ret);
686 }
687
clWaitForEvents(cl_uint num_events,const cl_event * event_list)688 cl_int CL_API_CALL clWaitForEvents(cl_uint num_events, const cl_event *event_list)
689 {
690 CL_EVENT(WaitForEvents, "num_events = %u, event_list = 0x%016" PRIxPTR "", num_events,
691 (uintptr_t)event_list);
692
693 ANGLE_CL_VALIDATE_ERROR(WaitForEvents, num_events, event_list);
694
695 cl::gClErrorTls = CL_SUCCESS;
696 return WaitForEvents(num_events, event_list);
697 }
698
clGetEventInfo(cl_event event,cl_event_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)699 cl_int CL_API_CALL clGetEventInfo(cl_event event,
700 cl_event_info param_name,
701 size_t param_value_size,
702 void *param_value,
703 size_t *param_value_size_ret)
704 {
705 CL_EVENT(GetEventInfo,
706 "event = 0x%016" PRIxPTR
707 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
708 ", param_value_size_ret = 0x%016" PRIxPTR "",
709 (uintptr_t)event, param_name, param_value_size, (uintptr_t)param_value,
710 (uintptr_t)param_value_size_ret);
711
712 EventInfo param_namePacked = PackParam<EventInfo>(param_name);
713
714 ANGLE_CL_VALIDATE_ERROR(GetEventInfo, event, param_namePacked, param_value_size, param_value,
715 param_value_size_ret);
716
717 cl::gClErrorTls = CL_SUCCESS;
718 return GetEventInfo(event, param_namePacked, param_value_size, param_value,
719 param_value_size_ret);
720 }
721
clRetainEvent(cl_event event)722 cl_int CL_API_CALL clRetainEvent(cl_event event)
723 {
724 CL_EVENT(RetainEvent, "event = 0x%016" PRIxPTR "", (uintptr_t)event);
725
726 ANGLE_CL_VALIDATE_ERROR(RetainEvent, event);
727
728 cl::gClErrorTls = CL_SUCCESS;
729 return RetainEvent(event);
730 }
731
clReleaseEvent(cl_event event)732 cl_int CL_API_CALL clReleaseEvent(cl_event event)
733 {
734 CL_EVENT(ReleaseEvent, "event = 0x%016" PRIxPTR "", (uintptr_t)event);
735
736 ANGLE_CL_VALIDATE_ERROR(ReleaseEvent, event);
737
738 cl::gClErrorTls = CL_SUCCESS;
739 return ReleaseEvent(event);
740 }
741
clGetEventProfilingInfo(cl_event event,cl_profiling_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)742 cl_int CL_API_CALL clGetEventProfilingInfo(cl_event event,
743 cl_profiling_info param_name,
744 size_t param_value_size,
745 void *param_value,
746 size_t *param_value_size_ret)
747 {
748 CL_EVENT(GetEventProfilingInfo,
749 "event = 0x%016" PRIxPTR
750 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
751 ", param_value_size_ret = 0x%016" PRIxPTR "",
752 (uintptr_t)event, param_name, param_value_size, (uintptr_t)param_value,
753 (uintptr_t)param_value_size_ret);
754
755 ProfilingInfo param_namePacked = PackParam<ProfilingInfo>(param_name);
756
757 ANGLE_CL_VALIDATE_ERROR(GetEventProfilingInfo, event, param_namePacked, param_value_size,
758 param_value, param_value_size_ret);
759
760 cl::gClErrorTls = CL_SUCCESS;
761 return GetEventProfilingInfo(event, param_namePacked, param_value_size, param_value,
762 param_value_size_ret);
763 }
764
clFlush(cl_command_queue command_queue)765 cl_int CL_API_CALL clFlush(cl_command_queue command_queue)
766 {
767 CL_EVENT(Flush, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);
768
769 ANGLE_CL_VALIDATE_ERROR(Flush, command_queue);
770
771 cl::gClErrorTls = CL_SUCCESS;
772 return Flush(command_queue);
773 }
774
clFinish(cl_command_queue command_queue)775 cl_int CL_API_CALL clFinish(cl_command_queue command_queue)
776 {
777 CL_EVENT(Finish, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);
778
779 ANGLE_CL_VALIDATE_ERROR(Finish, command_queue);
780
781 cl::gClErrorTls = CL_SUCCESS;
782 return Finish(command_queue);
783 }
784
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)785 cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue command_queue,
786 cl_mem buffer,
787 cl_bool blocking_read,
788 size_t offset,
789 size_t size,
790 void *ptr,
791 cl_uint num_events_in_wait_list,
792 const cl_event *event_wait_list,
793 cl_event *event)
794 {
795 CL_EVENT(EnqueueReadBuffer,
796 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
797 ", blocking_read = %u, offset = %zu, size = %zu, ptr = 0x%016" PRIxPTR
798 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
799 ", event = 0x%016" PRIxPTR "",
800 (uintptr_t)command_queue, (uintptr_t)buffer, blocking_read, offset, size,
801 (uintptr_t)ptr, num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
802
803 ANGLE_CL_VALIDATE_ERROR(EnqueueReadBuffer, command_queue, buffer, blocking_read, offset, size,
804 ptr, num_events_in_wait_list, event_wait_list, event);
805
806 cl::gClErrorTls = CL_SUCCESS;
807 return EnqueueReadBuffer(command_queue, buffer, blocking_read, offset, size, ptr,
808 num_events_in_wait_list, event_wait_list, event);
809 }
810
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)811 cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue command_queue,
812 cl_mem buffer,
813 cl_bool blocking_write,
814 size_t offset,
815 size_t size,
816 const void *ptr,
817 cl_uint num_events_in_wait_list,
818 const cl_event *event_wait_list,
819 cl_event *event)
820 {
821 CL_EVENT(EnqueueWriteBuffer,
822 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
823 ", blocking_write = %u, offset = %zu, size = %zu, ptr = 0x%016" PRIxPTR
824 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
825 ", event = 0x%016" PRIxPTR "",
826 (uintptr_t)command_queue, (uintptr_t)buffer, blocking_write, offset, size,
827 (uintptr_t)ptr, num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
828
829 ANGLE_CL_VALIDATE_ERROR(EnqueueWriteBuffer, command_queue, buffer, blocking_write, offset, size,
830 ptr, num_events_in_wait_list, event_wait_list, event);
831
832 cl::gClErrorTls = CL_SUCCESS;
833 return EnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, size, ptr,
834 num_events_in_wait_list, event_wait_list, event);
835 }
836
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)837 cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue command_queue,
838 cl_mem src_buffer,
839 cl_mem dst_buffer,
840 size_t src_offset,
841 size_t dst_offset,
842 size_t size,
843 cl_uint num_events_in_wait_list,
844 const cl_event *event_wait_list,
845 cl_event *event)
846 {
847 CL_EVENT(EnqueueCopyBuffer,
848 "command_queue = 0x%016" PRIxPTR ", src_buffer = 0x%016" PRIxPTR
849 ", dst_buffer = 0x%016" PRIxPTR
850 ", src_offset = %zu, dst_offset = %zu, size = %zu, num_events_in_wait_list = %u, "
851 "event_wait_list = 0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
852 (uintptr_t)command_queue, (uintptr_t)src_buffer, (uintptr_t)dst_buffer, src_offset,
853 dst_offset, size, num_events_in_wait_list, (uintptr_t)event_wait_list,
854 (uintptr_t)event);
855
856 ANGLE_CL_VALIDATE_ERROR(EnqueueCopyBuffer, command_queue, src_buffer, dst_buffer, src_offset,
857 dst_offset, size, num_events_in_wait_list, event_wait_list, event);
858
859 cl::gClErrorTls = CL_SUCCESS;
860 return EnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size,
861 num_events_in_wait_list, event_wait_list, event);
862 }
863
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)864 cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue command_queue,
865 cl_mem image,
866 cl_bool blocking_read,
867 const size_t *origin,
868 const size_t *region,
869 size_t row_pitch,
870 size_t slice_pitch,
871 void *ptr,
872 cl_uint num_events_in_wait_list,
873 const cl_event *event_wait_list,
874 cl_event *event)
875 {
876 CL_EVENT(EnqueueReadImage,
877 "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
878 ", blocking_read = %u, origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
879 ", row_pitch = %zu, slice_pitch = %zu, ptr = 0x%016" PRIxPTR
880 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
881 ", event = 0x%016" PRIxPTR "",
882 (uintptr_t)command_queue, (uintptr_t)image, blocking_read, (uintptr_t)origin,
883 (uintptr_t)region, row_pitch, slice_pitch, (uintptr_t)ptr, num_events_in_wait_list,
884 (uintptr_t)event_wait_list, (uintptr_t)event);
885
886 ANGLE_CL_VALIDATE_ERROR(EnqueueReadImage, command_queue, image, blocking_read, origin, region,
887 row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list,
888 event);
889
890 cl::gClErrorTls = CL_SUCCESS;
891 return EnqueueReadImage(command_queue, image, blocking_read, origin, region, row_pitch,
892 slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
893 }
894
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)895 cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue command_queue,
896 cl_mem image,
897 cl_bool blocking_write,
898 const size_t *origin,
899 const size_t *region,
900 size_t input_row_pitch,
901 size_t input_slice_pitch,
902 const void *ptr,
903 cl_uint num_events_in_wait_list,
904 const cl_event *event_wait_list,
905 cl_event *event)
906 {
907 CL_EVENT(EnqueueWriteImage,
908 "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
909 ", blocking_write = %u, origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
910 ", input_row_pitch = %zu, input_slice_pitch = %zu, ptr = 0x%016" PRIxPTR
911 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
912 ", event = 0x%016" PRIxPTR "",
913 (uintptr_t)command_queue, (uintptr_t)image, blocking_write, (uintptr_t)origin,
914 (uintptr_t)region, input_row_pitch, input_slice_pitch, (uintptr_t)ptr,
915 num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
916
917 ANGLE_CL_VALIDATE_ERROR(EnqueueWriteImage, command_queue, image, blocking_write, origin, region,
918 input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list,
919 event_wait_list, event);
920
921 cl::gClErrorTls = CL_SUCCESS;
922 return EnqueueWriteImage(command_queue, image, blocking_write, origin, region, input_row_pitch,
923 input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list,
924 event);
925 }
926
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)927 cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue command_queue,
928 cl_mem src_image,
929 cl_mem dst_image,
930 const size_t *src_origin,
931 const size_t *dst_origin,
932 const size_t *region,
933 cl_uint num_events_in_wait_list,
934 const cl_event *event_wait_list,
935 cl_event *event)
936 {
937 CL_EVENT(EnqueueCopyImage,
938 "command_queue = 0x%016" PRIxPTR ", src_image = 0x%016" PRIxPTR
939 ", dst_image = 0x%016" PRIxPTR ", src_origin = 0x%016" PRIxPTR
940 ", dst_origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
941 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
942 ", event = 0x%016" PRIxPTR "",
943 (uintptr_t)command_queue, (uintptr_t)src_image, (uintptr_t)dst_image,
944 (uintptr_t)src_origin, (uintptr_t)dst_origin, (uintptr_t)region,
945 num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
946
947 ANGLE_CL_VALIDATE_ERROR(EnqueueCopyImage, command_queue, src_image, dst_image, src_origin,
948 dst_origin, region, num_events_in_wait_list, event_wait_list, event);
949
950 cl::gClErrorTls = CL_SUCCESS;
951 return EnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin, region,
952 num_events_in_wait_list, event_wait_list, event);
953 }
954
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)955 cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
956 cl_mem src_image,
957 cl_mem dst_buffer,
958 const size_t *src_origin,
959 const size_t *region,
960 size_t dst_offset,
961 cl_uint num_events_in_wait_list,
962 const cl_event *event_wait_list,
963 cl_event *event)
964 {
965 CL_EVENT(EnqueueCopyImageToBuffer,
966 "command_queue = 0x%016" PRIxPTR ", src_image = 0x%016" PRIxPTR
967 ", dst_buffer = 0x%016" PRIxPTR ", src_origin = 0x%016" PRIxPTR
968 ", region = 0x%016" PRIxPTR
969 ", dst_offset = %zu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
970 ", event = 0x%016" PRIxPTR "",
971 (uintptr_t)command_queue, (uintptr_t)src_image, (uintptr_t)dst_buffer,
972 (uintptr_t)src_origin, (uintptr_t)region, dst_offset, num_events_in_wait_list,
973 (uintptr_t)event_wait_list, (uintptr_t)event);
974
975 ANGLE_CL_VALIDATE_ERROR(EnqueueCopyImageToBuffer, command_queue, src_image, dst_buffer,
976 src_origin, region, dst_offset, num_events_in_wait_list,
977 event_wait_list, event);
978
979 cl::gClErrorTls = CL_SUCCESS;
980 return EnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin, region,
981 dst_offset, num_events_in_wait_list, event_wait_list, event);
982 }
983
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)984 cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue command_queue,
985 cl_mem src_buffer,
986 cl_mem dst_image,
987 size_t src_offset,
988 const size_t *dst_origin,
989 const size_t *region,
990 cl_uint num_events_in_wait_list,
991 const cl_event *event_wait_list,
992 cl_event *event)
993 {
994 CL_EVENT(EnqueueCopyBufferToImage,
995 "command_queue = 0x%016" PRIxPTR ", src_buffer = 0x%016" PRIxPTR
996 ", dst_image = 0x%016" PRIxPTR ", src_offset = %zu, dst_origin = 0x%016" PRIxPTR
997 ", region = 0x%016" PRIxPTR
998 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
999 ", event = 0x%016" PRIxPTR "",
1000 (uintptr_t)command_queue, (uintptr_t)src_buffer, (uintptr_t)dst_image, src_offset,
1001 (uintptr_t)dst_origin, (uintptr_t)region, num_events_in_wait_list,
1002 (uintptr_t)event_wait_list, (uintptr_t)event);
1003
1004 ANGLE_CL_VALIDATE_ERROR(EnqueueCopyBufferToImage, command_queue, src_buffer, dst_image,
1005 src_offset, dst_origin, region, num_events_in_wait_list,
1006 event_wait_list, event);
1007
1008 cl::gClErrorTls = CL_SUCCESS;
1009 return EnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset, dst_origin,
1010 region, num_events_in_wait_list, event_wait_list, event);
1011 }
1012
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)1013 void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue command_queue,
1014 cl_mem buffer,
1015 cl_bool blocking_map,
1016 cl_map_flags map_flags,
1017 size_t offset,
1018 size_t size,
1019 cl_uint num_events_in_wait_list,
1020 const cl_event *event_wait_list,
1021 cl_event *event,
1022 cl_int *errcode_ret)
1023 {
1024 CL_EVENT(EnqueueMapBuffer,
1025 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
1026 ", blocking_map = %u, map_flags = %llu, offset = %zu, size = %zu, "
1027 "num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1028 ", event = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
1029 (uintptr_t)command_queue, (uintptr_t)buffer, blocking_map,
1030 static_cast<unsigned long long>(map_flags), offset, size, num_events_in_wait_list,
1031 (uintptr_t)event_wait_list, (uintptr_t)event, (uintptr_t)errcode_ret);
1032
1033 MapFlags map_flagsPacked = PackParam<MapFlags>(map_flags);
1034
1035 ANGLE_CL_VALIDATE_ERRCODE_RET(EnqueueMapBuffer, command_queue, buffer, blocking_map,
1036 map_flagsPacked, offset, size, num_events_in_wait_list,
1037 event_wait_list, event);
1038
1039 cl::gClErrorTls = CL_SUCCESS;
1040 void *object = EnqueueMapBuffer(command_queue, buffer, blocking_map, map_flagsPacked, offset,
1041 size, num_events_in_wait_list, event_wait_list, event);
1042
1043 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1044 if (errcode_ret != nullptr)
1045 {
1046 *errcode_ret = cl::gClErrorTls;
1047 }
1048 return object;
1049 }
1050
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)1051 void *CL_API_CALL clEnqueueMapImage(cl_command_queue command_queue,
1052 cl_mem image,
1053 cl_bool blocking_map,
1054 cl_map_flags map_flags,
1055 const size_t *origin,
1056 const size_t *region,
1057 size_t *image_row_pitch,
1058 size_t *image_slice_pitch,
1059 cl_uint num_events_in_wait_list,
1060 const cl_event *event_wait_list,
1061 cl_event *event,
1062 cl_int *errcode_ret)
1063 {
1064 CL_EVENT(EnqueueMapImage,
1065 "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
1066 ", blocking_map = %u, map_flags = %llu, origin = 0x%016" PRIxPTR
1067 ", region = 0x%016" PRIxPTR ", image_row_pitch = 0x%016" PRIxPTR
1068 ", image_slice_pitch = 0x%016" PRIxPTR
1069 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1070 ", event = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
1071 (uintptr_t)command_queue, (uintptr_t)image, blocking_map,
1072 static_cast<unsigned long long>(map_flags), (uintptr_t)origin, (uintptr_t)region,
1073 (uintptr_t)image_row_pitch, (uintptr_t)image_slice_pitch, num_events_in_wait_list,
1074 (uintptr_t)event_wait_list, (uintptr_t)event, (uintptr_t)errcode_ret);
1075
1076 MapFlags map_flagsPacked = PackParam<MapFlags>(map_flags);
1077
1078 ANGLE_CL_VALIDATE_ERRCODE_RET(
1079 EnqueueMapImage, command_queue, image, blocking_map, map_flagsPacked, origin, region,
1080 image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event);
1081
1082 cl::gClErrorTls = CL_SUCCESS;
1083 void *object = EnqueueMapImage(command_queue, image, blocking_map, map_flagsPacked, origin,
1084 region, image_row_pitch, image_slice_pitch,
1085 num_events_in_wait_list, event_wait_list, event);
1086
1087 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1088 if (errcode_ret != nullptr)
1089 {
1090 *errcode_ret = cl::gClErrorTls;
1091 }
1092 return object;
1093 }
1094
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)1095 cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue command_queue,
1096 cl_mem memobj,
1097 void *mapped_ptr,
1098 cl_uint num_events_in_wait_list,
1099 const cl_event *event_wait_list,
1100 cl_event *event)
1101 {
1102 CL_EVENT(EnqueueUnmapMemObject,
1103 "command_queue = 0x%016" PRIxPTR ", memobj = 0x%016" PRIxPTR
1104 ", mapped_ptr = 0x%016" PRIxPTR
1105 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1106 ", event = 0x%016" PRIxPTR "",
1107 (uintptr_t)command_queue, (uintptr_t)memobj, (uintptr_t)mapped_ptr,
1108 num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
1109
1110 ANGLE_CL_VALIDATE_ERROR(EnqueueUnmapMemObject, command_queue, memobj, mapped_ptr,
1111 num_events_in_wait_list, event_wait_list, event);
1112
1113 cl::gClErrorTls = CL_SUCCESS;
1114 return EnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, num_events_in_wait_list,
1115 event_wait_list, event);
1116 }
1117
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)1118 cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue command_queue,
1119 cl_kernel kernel,
1120 cl_uint work_dim,
1121 const size_t *global_work_offset,
1122 const size_t *global_work_size,
1123 const size_t *local_work_size,
1124 cl_uint num_events_in_wait_list,
1125 const cl_event *event_wait_list,
1126 cl_event *event)
1127 {
1128 CL_EVENT(EnqueueNDRangeKernel,
1129 "command_queue = 0x%016" PRIxPTR ", kernel = 0x%016" PRIxPTR
1130 ", work_dim = %u, global_work_offset = 0x%016" PRIxPTR
1131 ", global_work_size = 0x%016" PRIxPTR ", local_work_size = 0x%016" PRIxPTR
1132 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1133 ", event = 0x%016" PRIxPTR "",
1134 (uintptr_t)command_queue, (uintptr_t)kernel, work_dim, (uintptr_t)global_work_offset,
1135 (uintptr_t)global_work_size, (uintptr_t)local_work_size, num_events_in_wait_list,
1136 (uintptr_t)event_wait_list, (uintptr_t)event);
1137
1138 ANGLE_CL_VALIDATE_ERROR(EnqueueNDRangeKernel, command_queue, kernel, work_dim,
1139 global_work_offset, global_work_size, local_work_size,
1140 num_events_in_wait_list, event_wait_list, event);
1141
1142 cl::gClErrorTls = CL_SUCCESS;
1143 return EnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset,
1144 global_work_size, local_work_size, num_events_in_wait_list,
1145 event_wait_list, event);
1146 }
1147
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)1148 cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue command_queue,
1149 void(CL_CALLBACK *user_func)(void *),
1150 void *args,
1151 size_t cb_args,
1152 cl_uint num_mem_objects,
1153 const cl_mem *mem_list,
1154 const void **args_mem_loc,
1155 cl_uint num_events_in_wait_list,
1156 const cl_event *event_wait_list,
1157 cl_event *event)
1158 {
1159 CL_EVENT(EnqueueNativeKernel,
1160 "command_queue = 0x%016" PRIxPTR ", user_func = 0x%016" PRIxPTR
1161 ", args = 0x%016" PRIxPTR
1162 ", cb_args = %zu, num_mem_objects = %u, mem_list = 0x%016" PRIxPTR
1163 ", args_mem_loc = 0x%016" PRIxPTR
1164 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1165 ", event = 0x%016" PRIxPTR "",
1166 (uintptr_t)command_queue, (uintptr_t)user_func, (uintptr_t)args, cb_args,
1167 num_mem_objects, (uintptr_t)mem_list, (uintptr_t)args_mem_loc, num_events_in_wait_list,
1168 (uintptr_t)event_wait_list, (uintptr_t)event);
1169
1170 ANGLE_CL_VALIDATE_ERROR(EnqueueNativeKernel, command_queue, user_func, args, cb_args,
1171 num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list,
1172 event_wait_list, event);
1173
1174 cl::gClErrorTls = CL_SUCCESS;
1175 return EnqueueNativeKernel(command_queue, user_func, args, cb_args, num_mem_objects, mem_list,
1176 args_mem_loc, num_events_in_wait_list, event_wait_list, event);
1177 }
1178
clSetCommandQueueProperty(cl_command_queue command_queue,cl_command_queue_properties properties,cl_bool enable,cl_command_queue_properties * old_properties)1179 cl_int CL_API_CALL clSetCommandQueueProperty(cl_command_queue command_queue,
1180 cl_command_queue_properties properties,
1181 cl_bool enable,
1182 cl_command_queue_properties *old_properties)
1183 {
1184 CL_EVENT(SetCommandQueueProperty,
1185 "command_queue = 0x%016" PRIxPTR
1186 ", properties = %llu, enable = %u, old_properties = 0x%016" PRIxPTR "",
1187 (uintptr_t)command_queue, static_cast<unsigned long long>(properties), enable,
1188 (uintptr_t)old_properties);
1189
1190 CommandQueueProperties propertiesPacked = PackParam<CommandQueueProperties>(properties);
1191
1192 ANGLE_CL_VALIDATE_ERROR(SetCommandQueueProperty, command_queue, propertiesPacked, enable,
1193 old_properties);
1194
1195 cl::gClErrorTls = CL_SUCCESS;
1196 return SetCommandQueueProperty(command_queue, propertiesPacked, enable, old_properties);
1197 }
1198
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)1199 cl_mem CL_API_CALL clCreateImage2D(cl_context context,
1200 cl_mem_flags flags,
1201 const cl_image_format *image_format,
1202 size_t image_width,
1203 size_t image_height,
1204 size_t image_row_pitch,
1205 void *host_ptr,
1206 cl_int *errcode_ret)
1207 {
1208 CL_EVENT(
1209 CreateImage2D,
1210 "context = 0x%016" PRIxPTR ", flags = %llu, image_format = 0x%016" PRIxPTR
1211 ", image_width = %zu, image_height = %zu, image_row_pitch = %zu, host_ptr = 0x%016" PRIxPTR
1212 ", errcode_ret = 0x%016" PRIxPTR "",
1213 (uintptr_t)context, static_cast<unsigned long long>(flags), (uintptr_t)image_format,
1214 image_width, image_height, image_row_pitch, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);
1215
1216 MemFlags flagsPacked = PackParam<MemFlags>(flags);
1217
1218 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateImage2D, context, flagsPacked, image_format, image_width,
1219 image_height, image_row_pitch, host_ptr);
1220
1221 cl::gClErrorTls = CL_SUCCESS;
1222 cl_mem object = CreateImage2D(context, flagsPacked, image_format, image_width, image_height,
1223 image_row_pitch, host_ptr);
1224
1225 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1226 if (errcode_ret != nullptr)
1227 {
1228 *errcode_ret = cl::gClErrorTls;
1229 }
1230 return object;
1231 }
1232
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)1233 cl_mem CL_API_CALL clCreateImage3D(cl_context context,
1234 cl_mem_flags flags,
1235 const cl_image_format *image_format,
1236 size_t image_width,
1237 size_t image_height,
1238 size_t image_depth,
1239 size_t image_row_pitch,
1240 size_t image_slice_pitch,
1241 void *host_ptr,
1242 cl_int *errcode_ret)
1243 {
1244 CL_EVENT(CreateImage3D,
1245 "context = 0x%016" PRIxPTR ", flags = %llu, image_format = 0x%016" PRIxPTR
1246 ", image_width = %zu, image_height = %zu, image_depth = %zu, image_row_pitch = %zu, "
1247 "image_slice_pitch = %zu, host_ptr = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR
1248 "",
1249 (uintptr_t)context, static_cast<unsigned long long>(flags), (uintptr_t)image_format,
1250 image_width, image_height, image_depth, image_row_pitch, image_slice_pitch,
1251 (uintptr_t)host_ptr, (uintptr_t)errcode_ret);
1252
1253 MemFlags flagsPacked = PackParam<MemFlags>(flags);
1254
1255 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateImage3D, context, flagsPacked, image_format, image_width,
1256 image_height, image_depth, image_row_pitch, image_slice_pitch,
1257 host_ptr);
1258
1259 cl::gClErrorTls = CL_SUCCESS;
1260 cl_mem object = CreateImage3D(context, flagsPacked, image_format, image_width, image_height,
1261 image_depth, image_row_pitch, image_slice_pitch, host_ptr);
1262
1263 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1264 if (errcode_ret != nullptr)
1265 {
1266 *errcode_ret = cl::gClErrorTls;
1267 }
1268 return object;
1269 }
1270
clEnqueueMarker(cl_command_queue command_queue,cl_event * event)1271 cl_int CL_API_CALL clEnqueueMarker(cl_command_queue command_queue, cl_event *event)
1272 {
1273 CL_EVENT(EnqueueMarker, "command_queue = 0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
1274 (uintptr_t)command_queue, (uintptr_t)event);
1275
1276 ANGLE_CL_VALIDATE_ERROR(EnqueueMarker, command_queue, event);
1277
1278 cl::gClErrorTls = CL_SUCCESS;
1279 return EnqueueMarker(command_queue, event);
1280 }
1281
clEnqueueWaitForEvents(cl_command_queue command_queue,cl_uint num_events,const cl_event * event_list)1282 cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue command_queue,
1283 cl_uint num_events,
1284 const cl_event *event_list)
1285 {
1286 CL_EVENT(EnqueueWaitForEvents,
1287 "command_queue = 0x%016" PRIxPTR ", num_events = %u, event_list = 0x%016" PRIxPTR "",
1288 (uintptr_t)command_queue, num_events, (uintptr_t)event_list);
1289
1290 ANGLE_CL_VALIDATE_ERROR(EnqueueWaitForEvents, command_queue, num_events, event_list);
1291
1292 cl::gClErrorTls = CL_SUCCESS;
1293 return EnqueueWaitForEvents(command_queue, num_events, event_list);
1294 }
1295
clEnqueueBarrier(cl_command_queue command_queue)1296 cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue command_queue)
1297 {
1298 CL_EVENT(EnqueueBarrier, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);
1299
1300 ANGLE_CL_VALIDATE_ERROR(EnqueueBarrier, command_queue);
1301
1302 cl::gClErrorTls = CL_SUCCESS;
1303 return EnqueueBarrier(command_queue);
1304 }
1305
clUnloadCompiler()1306 cl_int CL_API_CALL clUnloadCompiler()
1307 {
1308 CL_EVENT(UnloadCompiler, "");
1309
1310 ANGLE_CL_VALIDATE_ERROR(UnloadCompiler);
1311
1312 cl::gClErrorTls = CL_SUCCESS;
1313 return UnloadCompiler();
1314 }
1315
clGetExtensionFunctionAddress(const char * func_name)1316 void *CL_API_CALL clGetExtensionFunctionAddress(const char *func_name)
1317 {
1318 CL_EVENT(GetExtensionFunctionAddress, "func_name = 0x%016" PRIxPTR "", (uintptr_t)func_name);
1319
1320 cl::gClErrorTls = CL_SUCCESS;
1321 ANGLE_CL_VALIDATE_POINTER(GetExtensionFunctionAddress, func_name);
1322
1323 return GetExtensionFunctionAddress(func_name);
1324 }
1325
clCreateCommandQueue(cl_context context,cl_device_id device,cl_command_queue_properties properties,cl_int * errcode_ret)1326 cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context,
1327 cl_device_id device,
1328 cl_command_queue_properties properties,
1329 cl_int *errcode_ret)
1330 {
1331 CL_EVENT(CreateCommandQueue,
1332 "context = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
1333 ", properties = %llu, errcode_ret = 0x%016" PRIxPTR "",
1334 (uintptr_t)context, (uintptr_t)device, static_cast<unsigned long long>(properties),
1335 (uintptr_t)errcode_ret);
1336
1337 CommandQueueProperties propertiesPacked = PackParam<CommandQueueProperties>(properties);
1338
1339 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateCommandQueue, context, device, propertiesPacked);
1340
1341 cl::gClErrorTls = CL_SUCCESS;
1342 cl_command_queue object = CreateCommandQueue(context, device, propertiesPacked);
1343
1344 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1345 if (errcode_ret != nullptr)
1346 {
1347 *errcode_ret = cl::gClErrorTls;
1348 }
1349 return object;
1350 }
1351
clCreateSampler(cl_context context,cl_bool normalized_coords,cl_addressing_mode addressing_mode,cl_filter_mode filter_mode,cl_int * errcode_ret)1352 cl_sampler CL_API_CALL clCreateSampler(cl_context context,
1353 cl_bool normalized_coords,
1354 cl_addressing_mode addressing_mode,
1355 cl_filter_mode filter_mode,
1356 cl_int *errcode_ret)
1357 {
1358 CL_EVENT(CreateSampler,
1359 "context = 0x%016" PRIxPTR
1360 ", normalized_coords = %u, addressing_mode = %u, filter_mode = %u, errcode_ret = "
1361 "0x%016" PRIxPTR "",
1362 (uintptr_t)context, normalized_coords, addressing_mode, filter_mode,
1363 (uintptr_t)errcode_ret);
1364
1365 AddressingMode addressing_modePacked = PackParam<AddressingMode>(addressing_mode);
1366 FilterMode filter_modePacked = PackParam<FilterMode>(filter_mode);
1367
1368 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateSampler, context, normalized_coords, addressing_modePacked,
1369 filter_modePacked);
1370
1371 cl::gClErrorTls = CL_SUCCESS;
1372 cl_sampler object =
1373 CreateSampler(context, normalized_coords, addressing_modePacked, filter_modePacked);
1374
1375 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1376 if (errcode_ret != nullptr)
1377 {
1378 *errcode_ret = cl::gClErrorTls;
1379 }
1380 return object;
1381 }
1382
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)1383 cl_int CL_API_CALL clEnqueueTask(cl_command_queue command_queue,
1384 cl_kernel kernel,
1385 cl_uint num_events_in_wait_list,
1386 const cl_event *event_wait_list,
1387 cl_event *event)
1388 {
1389 CL_EVENT(EnqueueTask,
1390 "command_queue = 0x%016" PRIxPTR ", kernel = 0x%016" PRIxPTR
1391 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1392 ", event = 0x%016" PRIxPTR "",
1393 (uintptr_t)command_queue, (uintptr_t)kernel, num_events_in_wait_list,
1394 (uintptr_t)event_wait_list, (uintptr_t)event);
1395
1396 ANGLE_CL_VALIDATE_ERROR(EnqueueTask, command_queue, kernel, num_events_in_wait_list,
1397 event_wait_list, event);
1398
1399 cl::gClErrorTls = CL_SUCCESS;
1400 return EnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
1401 }
1402
1403 // CL 1.1
clCreateSubBuffer(cl_mem buffer,cl_mem_flags flags,cl_buffer_create_type buffer_create_type,const void * buffer_create_info,cl_int * errcode_ret)1404 cl_mem CL_API_CALL clCreateSubBuffer(cl_mem buffer,
1405 cl_mem_flags flags,
1406 cl_buffer_create_type buffer_create_type,
1407 const void *buffer_create_info,
1408 cl_int *errcode_ret)
1409 {
1410 CL_EVENT(CreateSubBuffer,
1411 "buffer = 0x%016" PRIxPTR
1412 ", flags = %llu, buffer_create_type = %u, buffer_create_info = 0x%016" PRIxPTR
1413 ", errcode_ret = 0x%016" PRIxPTR "",
1414 (uintptr_t)buffer, static_cast<unsigned long long>(flags), buffer_create_type,
1415 (uintptr_t)buffer_create_info, (uintptr_t)errcode_ret);
1416
1417 MemFlags flagsPacked = PackParam<MemFlags>(flags);
1418
1419 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateSubBuffer, buffer, flagsPacked, buffer_create_type,
1420 buffer_create_info);
1421
1422 cl::gClErrorTls = CL_SUCCESS;
1423 cl_mem object = CreateSubBuffer(buffer, flagsPacked, buffer_create_type, buffer_create_info);
1424
1425 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1426 if (errcode_ret != nullptr)
1427 {
1428 *errcode_ret = cl::gClErrorTls;
1429 }
1430 return object;
1431 }
1432
clSetMemObjectDestructorCallback(cl_mem memobj,void (CL_CALLBACK * pfn_notify)(cl_mem memobj,void * user_data),void * user_data)1433 cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem memobj,
1434 void(CL_CALLBACK *pfn_notify)(cl_mem memobj,
1435 void *user_data),
1436 void *user_data)
1437 {
1438 CL_EVENT(SetMemObjectDestructorCallback,
1439 "memobj = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
1440 ", user_data = 0x%016" PRIxPTR "",
1441 (uintptr_t)memobj, (uintptr_t)pfn_notify, (uintptr_t)user_data);
1442
1443 ANGLE_CL_VALIDATE_ERROR(SetMemObjectDestructorCallback, memobj, pfn_notify, user_data);
1444
1445 cl::gClErrorTls = CL_SUCCESS;
1446 return SetMemObjectDestructorCallback(memobj, pfn_notify, user_data);
1447 }
1448
clCreateUserEvent(cl_context context,cl_int * errcode_ret)1449 cl_event CL_API_CALL clCreateUserEvent(cl_context context, cl_int *errcode_ret)
1450 {
1451 CL_EVENT(CreateUserEvent, "context = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
1452 (uintptr_t)context, (uintptr_t)errcode_ret);
1453
1454 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateUserEvent, context);
1455
1456 cl::gClErrorTls = CL_SUCCESS;
1457 cl_event object = CreateUserEvent(context);
1458
1459 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1460 if (errcode_ret != nullptr)
1461 {
1462 *errcode_ret = cl::gClErrorTls;
1463 }
1464 return object;
1465 }
1466
clSetUserEventStatus(cl_event event,cl_int execution_status)1467 cl_int CL_API_CALL clSetUserEventStatus(cl_event event, cl_int execution_status)
1468 {
1469 CL_EVENT(SetUserEventStatus, "event = 0x%016" PRIxPTR ", execution_status = %d",
1470 (uintptr_t)event, execution_status);
1471
1472 ANGLE_CL_VALIDATE_ERROR(SetUserEventStatus, event, execution_status);
1473
1474 cl::gClErrorTls = CL_SUCCESS;
1475 return SetUserEventStatus(event, execution_status);
1476 }
1477
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)1478 cl_int CL_API_CALL clSetEventCallback(cl_event event,
1479 cl_int command_exec_callback_type,
1480 void(CL_CALLBACK *pfn_notify)(cl_event event,
1481 cl_int event_command_status,
1482 void *user_data),
1483 void *user_data)
1484 {
1485 CL_EVENT(
1486 SetEventCallback,
1487 "event = 0x%016" PRIxPTR ", command_exec_callback_type = %d, pfn_notify = 0x%016" PRIxPTR
1488 ", user_data = 0x%016" PRIxPTR "",
1489 (uintptr_t)event, command_exec_callback_type, (uintptr_t)pfn_notify, (uintptr_t)user_data);
1490
1491 ANGLE_CL_VALIDATE_ERROR(SetEventCallback, event, command_exec_callback_type, pfn_notify,
1492 user_data);
1493
1494 cl::gClErrorTls = CL_SUCCESS;
1495 return SetEventCallback(event, command_exec_callback_type, pfn_notify, user_data);
1496 }
1497
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)1498 cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue command_queue,
1499 cl_mem buffer,
1500 cl_bool blocking_read,
1501 const size_t *buffer_origin,
1502 const size_t *host_origin,
1503 const size_t *region,
1504 size_t buffer_row_pitch,
1505 size_t buffer_slice_pitch,
1506 size_t host_row_pitch,
1507 size_t host_slice_pitch,
1508 void *ptr,
1509 cl_uint num_events_in_wait_list,
1510 const cl_event *event_wait_list,
1511 cl_event *event)
1512 {
1513 CL_EVENT(EnqueueReadBufferRect,
1514 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
1515 ", blocking_read = %u, buffer_origin = 0x%016" PRIxPTR ", host_origin = 0x%016" PRIxPTR
1516 ", region = 0x%016" PRIxPTR
1517 ", buffer_row_pitch = %zu, buffer_slice_pitch = %zu, host_row_pitch = %zu, "
1518 "host_slice_pitch = %zu, ptr = 0x%016" PRIxPTR
1519 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1520 ", event = 0x%016" PRIxPTR "",
1521 (uintptr_t)command_queue, (uintptr_t)buffer, blocking_read, (uintptr_t)buffer_origin,
1522 (uintptr_t)host_origin, (uintptr_t)region, buffer_row_pitch, buffer_slice_pitch,
1523 host_row_pitch, host_slice_pitch, (uintptr_t)ptr, num_events_in_wait_list,
1524 (uintptr_t)event_wait_list, (uintptr_t)event);
1525
1526 ANGLE_CL_VALIDATE_ERROR(EnqueueReadBufferRect, command_queue, buffer, blocking_read,
1527 buffer_origin, host_origin, region, buffer_row_pitch,
1528 buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr,
1529 num_events_in_wait_list, event_wait_list, event);
1530
1531 cl::gClErrorTls = CL_SUCCESS;
1532 return EnqueueReadBufferRect(command_queue, buffer, blocking_read, buffer_origin, host_origin,
1533 region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch,
1534 host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list,
1535 event);
1536 }
1537
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)1538 cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue command_queue,
1539 cl_mem buffer,
1540 cl_bool blocking_write,
1541 const size_t *buffer_origin,
1542 const size_t *host_origin,
1543 const size_t *region,
1544 size_t buffer_row_pitch,
1545 size_t buffer_slice_pitch,
1546 size_t host_row_pitch,
1547 size_t host_slice_pitch,
1548 const void *ptr,
1549 cl_uint num_events_in_wait_list,
1550 const cl_event *event_wait_list,
1551 cl_event *event)
1552 {
1553 CL_EVENT(EnqueueWriteBufferRect,
1554 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
1555 ", blocking_write = %u, buffer_origin = 0x%016" PRIxPTR
1556 ", host_origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
1557 ", buffer_row_pitch = %zu, buffer_slice_pitch = %zu, host_row_pitch = %zu, "
1558 "host_slice_pitch = %zu, ptr = 0x%016" PRIxPTR
1559 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1560 ", event = 0x%016" PRIxPTR "",
1561 (uintptr_t)command_queue, (uintptr_t)buffer, blocking_write, (uintptr_t)buffer_origin,
1562 (uintptr_t)host_origin, (uintptr_t)region, buffer_row_pitch, buffer_slice_pitch,
1563 host_row_pitch, host_slice_pitch, (uintptr_t)ptr, num_events_in_wait_list,
1564 (uintptr_t)event_wait_list, (uintptr_t)event);
1565
1566 ANGLE_CL_VALIDATE_ERROR(EnqueueWriteBufferRect, command_queue, buffer, blocking_write,
1567 buffer_origin, host_origin, region, buffer_row_pitch,
1568 buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr,
1569 num_events_in_wait_list, event_wait_list, event);
1570
1571 cl::gClErrorTls = CL_SUCCESS;
1572 return EnqueueWriteBufferRect(command_queue, buffer, blocking_write, buffer_origin, host_origin,
1573 region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch,
1574 host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list,
1575 event);
1576 }
1577
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)1578 cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue command_queue,
1579 cl_mem src_buffer,
1580 cl_mem dst_buffer,
1581 const size_t *src_origin,
1582 const size_t *dst_origin,
1583 const size_t *region,
1584 size_t src_row_pitch,
1585 size_t src_slice_pitch,
1586 size_t dst_row_pitch,
1587 size_t dst_slice_pitch,
1588 cl_uint num_events_in_wait_list,
1589 const cl_event *event_wait_list,
1590 cl_event *event)
1591 {
1592 CL_EVENT(EnqueueCopyBufferRect,
1593 "command_queue = 0x%016" PRIxPTR ", src_buffer = 0x%016" PRIxPTR
1594 ", dst_buffer = 0x%016" PRIxPTR ", src_origin = 0x%016" PRIxPTR
1595 ", dst_origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
1596 ", src_row_pitch = %zu, src_slice_pitch = %zu, dst_row_pitch = %zu, dst_slice_pitch = "
1597 "%zu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1598 ", event = 0x%016" PRIxPTR "",
1599 (uintptr_t)command_queue, (uintptr_t)src_buffer, (uintptr_t)dst_buffer,
1600 (uintptr_t)src_origin, (uintptr_t)dst_origin, (uintptr_t)region, src_row_pitch,
1601 src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list,
1602 (uintptr_t)event_wait_list, (uintptr_t)event);
1603
1604 ANGLE_CL_VALIDATE_ERROR(EnqueueCopyBufferRect, command_queue, src_buffer, dst_buffer,
1605 src_origin, dst_origin, region, src_row_pitch, src_slice_pitch,
1606 dst_row_pitch, dst_slice_pitch, num_events_in_wait_list,
1607 event_wait_list, event);
1608
1609 cl::gClErrorTls = CL_SUCCESS;
1610 return EnqueueCopyBufferRect(command_queue, src_buffer, dst_buffer, src_origin, dst_origin,
1611 region, src_row_pitch, src_slice_pitch, dst_row_pitch,
1612 dst_slice_pitch, num_events_in_wait_list, event_wait_list, event);
1613 }
1614
1615 // CL 1.2
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)1616 cl_int CL_API_CALL clCreateSubDevices(cl_device_id in_device,
1617 const cl_device_partition_property *properties,
1618 cl_uint num_devices,
1619 cl_device_id *out_devices,
1620 cl_uint *num_devices_ret)
1621 {
1622 CL_EVENT(CreateSubDevices,
1623 "in_device = 0x%016" PRIxPTR ", properties = 0x%016" PRIxPTR
1624 ", num_devices = %u, out_devices = 0x%016" PRIxPTR ", num_devices_ret = 0x%016" PRIxPTR
1625 "",
1626 (uintptr_t)in_device, (uintptr_t)properties, num_devices, (uintptr_t)out_devices,
1627 (uintptr_t)num_devices_ret);
1628
1629 ANGLE_CL_VALIDATE_ERROR(CreateSubDevices, in_device, properties, num_devices, out_devices,
1630 num_devices_ret);
1631
1632 cl::gClErrorTls = CL_SUCCESS;
1633 return CreateSubDevices(in_device, properties, num_devices, out_devices, num_devices_ret);
1634 }
1635
clRetainDevice(cl_device_id device)1636 cl_int CL_API_CALL clRetainDevice(cl_device_id device)
1637 {
1638 CL_EVENT(RetainDevice, "device = 0x%016" PRIxPTR "", (uintptr_t)device);
1639
1640 ANGLE_CL_VALIDATE_ERROR(RetainDevice, device);
1641
1642 cl::gClErrorTls = CL_SUCCESS;
1643 return RetainDevice(device);
1644 }
1645
clReleaseDevice(cl_device_id device)1646 cl_int CL_API_CALL clReleaseDevice(cl_device_id device)
1647 {
1648 CL_EVENT(ReleaseDevice, "device = 0x%016" PRIxPTR "", (uintptr_t)device);
1649
1650 ANGLE_CL_VALIDATE_ERROR(ReleaseDevice, device);
1651
1652 cl::gClErrorTls = CL_SUCCESS;
1653 return ReleaseDevice(device);
1654 }
1655
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)1656 cl_mem CL_API_CALL clCreateImage(cl_context context,
1657 cl_mem_flags flags,
1658 const cl_image_format *image_format,
1659 const cl_image_desc *image_desc,
1660 void *host_ptr,
1661 cl_int *errcode_ret)
1662 {
1663 CL_EVENT(CreateImage,
1664 "context = 0x%016" PRIxPTR ", flags = %llu, image_format = 0x%016" PRIxPTR
1665 ", image_desc = 0x%016" PRIxPTR ", host_ptr = 0x%016" PRIxPTR
1666 ", errcode_ret = 0x%016" PRIxPTR "",
1667 (uintptr_t)context, static_cast<unsigned long long>(flags), (uintptr_t)image_format,
1668 (uintptr_t)image_desc, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);
1669
1670 MemFlags flagsPacked = PackParam<MemFlags>(flags);
1671
1672 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateImage, context, flagsPacked, image_format, image_desc,
1673 host_ptr);
1674
1675 cl::gClErrorTls = CL_SUCCESS;
1676 cl_mem object = CreateImage(context, flagsPacked, image_format, image_desc, host_ptr);
1677
1678 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1679 if (errcode_ret != nullptr)
1680 {
1681 *errcode_ret = cl::gClErrorTls;
1682 }
1683 return object;
1684 }
1685
clCreateProgramWithBuiltInKernels(cl_context context,cl_uint num_devices,const cl_device_id * device_list,const char * kernel_names,cl_int * errcode_ret)1686 cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context context,
1687 cl_uint num_devices,
1688 const cl_device_id *device_list,
1689 const char *kernel_names,
1690 cl_int *errcode_ret)
1691 {
1692 CL_EVENT(CreateProgramWithBuiltInKernels,
1693 "context = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
1694 ", kernel_names = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
1695 (uintptr_t)context, num_devices, (uintptr_t)device_list, (uintptr_t)kernel_names,
1696 (uintptr_t)errcode_ret);
1697
1698 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateProgramWithBuiltInKernels, context, num_devices,
1699 device_list, kernel_names);
1700
1701 cl::gClErrorTls = CL_SUCCESS;
1702 cl_program object =
1703 CreateProgramWithBuiltInKernels(context, num_devices, device_list, kernel_names);
1704
1705 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1706 if (errcode_ret != nullptr)
1707 {
1708 *errcode_ret = cl::gClErrorTls;
1709 }
1710 return object;
1711 }
1712
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)1713 cl_int CL_API_CALL clCompileProgram(cl_program program,
1714 cl_uint num_devices,
1715 const cl_device_id *device_list,
1716 const char *options,
1717 cl_uint num_input_headers,
1718 const cl_program *input_headers,
1719 const char **header_include_names,
1720 void(CL_CALLBACK *pfn_notify)(cl_program program,
1721 void *user_data),
1722 void *user_data)
1723 {
1724 CL_EVENT(CompileProgram,
1725 "program = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
1726 ", options = 0x%016" PRIxPTR ", num_input_headers = %u, input_headers = 0x%016" PRIxPTR
1727 ", header_include_names = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
1728 ", user_data = 0x%016" PRIxPTR "",
1729 (uintptr_t)program, num_devices, (uintptr_t)device_list, (uintptr_t)options,
1730 num_input_headers, (uintptr_t)input_headers, (uintptr_t)header_include_names,
1731 (uintptr_t)pfn_notify, (uintptr_t)user_data);
1732
1733 ANGLE_CL_VALIDATE_ERROR(CompileProgram, program, num_devices, device_list, options,
1734 num_input_headers, input_headers, header_include_names, pfn_notify,
1735 user_data);
1736
1737 cl::gClErrorTls = CL_SUCCESS;
1738 return CompileProgram(program, num_devices, device_list, options, num_input_headers,
1739 input_headers, header_include_names, pfn_notify, user_data);
1740 }
1741
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)1742 cl_program CL_API_CALL clLinkProgram(cl_context context,
1743 cl_uint num_devices,
1744 const cl_device_id *device_list,
1745 const char *options,
1746 cl_uint num_input_programs,
1747 const cl_program *input_programs,
1748 void(CL_CALLBACK *pfn_notify)(cl_program program,
1749 void *user_data),
1750 void *user_data,
1751 cl_int *errcode_ret)
1752 {
1753 CL_EVENT(LinkProgram,
1754 "context = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
1755 ", options = 0x%016" PRIxPTR
1756 ", num_input_programs = %u, input_programs = 0x%016" PRIxPTR
1757 ", pfn_notify = 0x%016" PRIxPTR ", user_data = 0x%016" PRIxPTR
1758 ", errcode_ret = 0x%016" PRIxPTR "",
1759 (uintptr_t)context, num_devices, (uintptr_t)device_list, (uintptr_t)options,
1760 num_input_programs, (uintptr_t)input_programs, (uintptr_t)pfn_notify,
1761 (uintptr_t)user_data, (uintptr_t)errcode_ret);
1762
1763 ANGLE_CL_VALIDATE_ERRCODE_RET(LinkProgram, context, num_devices, device_list, options,
1764 num_input_programs, input_programs, pfn_notify, user_data);
1765
1766 cl::gClErrorTls = CL_SUCCESS;
1767 cl_program object = LinkProgram(context, num_devices, device_list, options, num_input_programs,
1768 input_programs, pfn_notify, user_data);
1769
1770 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1771 if (errcode_ret != nullptr)
1772 {
1773 *errcode_ret = cl::gClErrorTls;
1774 }
1775 return object;
1776 }
1777
clUnloadPlatformCompiler(cl_platform_id platform)1778 cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id platform)
1779 {
1780 CL_EVENT(UnloadPlatformCompiler, "platform = 0x%016" PRIxPTR "", (uintptr_t)platform);
1781
1782 ANGLE_CL_VALIDATE_ERROR(UnloadPlatformCompiler, platform);
1783
1784 cl::gClErrorTls = CL_SUCCESS;
1785 return UnloadPlatformCompiler(platform);
1786 }
1787
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)1788 cl_int CL_API_CALL clGetKernelArgInfo(cl_kernel kernel,
1789 cl_uint arg_index,
1790 cl_kernel_arg_info param_name,
1791 size_t param_value_size,
1792 void *param_value,
1793 size_t *param_value_size_ret)
1794 {
1795 CL_EVENT(
1796 GetKernelArgInfo,
1797 "kernel = 0x%016" PRIxPTR
1798 ", arg_index = %u, param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
1799 ", param_value_size_ret = 0x%016" PRIxPTR "",
1800 (uintptr_t)kernel, arg_index, param_name, param_value_size, (uintptr_t)param_value,
1801 (uintptr_t)param_value_size_ret);
1802
1803 KernelArgInfo param_namePacked = PackParam<KernelArgInfo>(param_name);
1804
1805 ANGLE_CL_VALIDATE_ERROR(GetKernelArgInfo, kernel, arg_index, param_namePacked, param_value_size,
1806 param_value, param_value_size_ret);
1807
1808 cl::gClErrorTls = CL_SUCCESS;
1809 return GetKernelArgInfo(kernel, arg_index, param_namePacked, param_value_size, param_value,
1810 param_value_size_ret);
1811 }
1812
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)1813 cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue command_queue,
1814 cl_mem buffer,
1815 const void *pattern,
1816 size_t pattern_size,
1817 size_t offset,
1818 size_t size,
1819 cl_uint num_events_in_wait_list,
1820 const cl_event *event_wait_list,
1821 cl_event *event)
1822 {
1823 CL_EVENT(EnqueueFillBuffer,
1824 "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
1825 ", pattern = 0x%016" PRIxPTR
1826 ", pattern_size = %zu, offset = %zu, size = %zu, num_events_in_wait_list = %u, "
1827 "event_wait_list = 0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
1828 (uintptr_t)command_queue, (uintptr_t)buffer, (uintptr_t)pattern, pattern_size, offset,
1829 size, num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
1830
1831 ANGLE_CL_VALIDATE_ERROR(EnqueueFillBuffer, command_queue, buffer, pattern, pattern_size, offset,
1832 size, num_events_in_wait_list, event_wait_list, event);
1833
1834 cl::gClErrorTls = CL_SUCCESS;
1835 return EnqueueFillBuffer(command_queue, buffer, pattern, pattern_size, offset, size,
1836 num_events_in_wait_list, event_wait_list, event);
1837 }
1838
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)1839 cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue command_queue,
1840 cl_mem image,
1841 const void *fill_color,
1842 const size_t *origin,
1843 const size_t *region,
1844 cl_uint num_events_in_wait_list,
1845 const cl_event *event_wait_list,
1846 cl_event *event)
1847 {
1848 CL_EVENT(EnqueueFillImage,
1849 "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
1850 ", fill_color = 0x%016" PRIxPTR ", origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
1851 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1852 ", event = 0x%016" PRIxPTR "",
1853 (uintptr_t)command_queue, (uintptr_t)image, (uintptr_t)fill_color, (uintptr_t)origin,
1854 (uintptr_t)region, num_events_in_wait_list, (uintptr_t)event_wait_list,
1855 (uintptr_t)event);
1856
1857 ANGLE_CL_VALIDATE_ERROR(EnqueueFillImage, command_queue, image, fill_color, origin, region,
1858 num_events_in_wait_list, event_wait_list, event);
1859
1860 cl::gClErrorTls = CL_SUCCESS;
1861 return EnqueueFillImage(command_queue, image, fill_color, origin, region,
1862 num_events_in_wait_list, event_wait_list, event);
1863 }
1864
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)1865 cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue command_queue,
1866 cl_uint num_mem_objects,
1867 const cl_mem *mem_objects,
1868 cl_mem_migration_flags flags,
1869 cl_uint num_events_in_wait_list,
1870 const cl_event *event_wait_list,
1871 cl_event *event)
1872 {
1873 CL_EVENT(EnqueueMigrateMemObjects,
1874 "command_queue = 0x%016" PRIxPTR ", num_mem_objects = %u, mem_objects = 0x%016" PRIxPTR
1875 ", flags = %llu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1876 ", event = 0x%016" PRIxPTR "",
1877 (uintptr_t)command_queue, num_mem_objects, (uintptr_t)mem_objects,
1878 static_cast<unsigned long long>(flags), num_events_in_wait_list,
1879 (uintptr_t)event_wait_list, (uintptr_t)event);
1880
1881 MemMigrationFlags flagsPacked = PackParam<MemMigrationFlags>(flags);
1882
1883 ANGLE_CL_VALIDATE_ERROR(EnqueueMigrateMemObjects, command_queue, num_mem_objects, mem_objects,
1884 flagsPacked, num_events_in_wait_list, event_wait_list, event);
1885
1886 cl::gClErrorTls = CL_SUCCESS;
1887 return EnqueueMigrateMemObjects(command_queue, num_mem_objects, mem_objects, flagsPacked,
1888 num_events_in_wait_list, event_wait_list, event);
1889 }
1890
clEnqueueMarkerWithWaitList(cl_command_queue command_queue,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event)1891 cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue command_queue,
1892 cl_uint num_events_in_wait_list,
1893 const cl_event *event_wait_list,
1894 cl_event *event)
1895 {
1896 CL_EVENT(EnqueueMarkerWithWaitList,
1897 "command_queue = 0x%016" PRIxPTR
1898 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1899 ", event = 0x%016" PRIxPTR "",
1900 (uintptr_t)command_queue, num_events_in_wait_list, (uintptr_t)event_wait_list,
1901 (uintptr_t)event);
1902
1903 ANGLE_CL_VALIDATE_ERROR(EnqueueMarkerWithWaitList, command_queue, num_events_in_wait_list,
1904 event_wait_list, event);
1905
1906 cl::gClErrorTls = CL_SUCCESS;
1907 return EnqueueMarkerWithWaitList(command_queue, num_events_in_wait_list, event_wait_list,
1908 event);
1909 }
1910
clEnqueueBarrierWithWaitList(cl_command_queue command_queue,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event)1911 cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue command_queue,
1912 cl_uint num_events_in_wait_list,
1913 const cl_event *event_wait_list,
1914 cl_event *event)
1915 {
1916 CL_EVENT(EnqueueBarrierWithWaitList,
1917 "command_queue = 0x%016" PRIxPTR
1918 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
1919 ", event = 0x%016" PRIxPTR "",
1920 (uintptr_t)command_queue, num_events_in_wait_list, (uintptr_t)event_wait_list,
1921 (uintptr_t)event);
1922
1923 ANGLE_CL_VALIDATE_ERROR(EnqueueBarrierWithWaitList, command_queue, num_events_in_wait_list,
1924 event_wait_list, event);
1925
1926 cl::gClErrorTls = CL_SUCCESS;
1927 return EnqueueBarrierWithWaitList(command_queue, num_events_in_wait_list, event_wait_list,
1928 event);
1929 }
1930
clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,const char * func_name)1931 void *CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
1932 const char *func_name)
1933 {
1934 CL_EVENT(GetExtensionFunctionAddressForPlatform,
1935 "platform = 0x%016" PRIxPTR ", func_name = 0x%016" PRIxPTR "", (uintptr_t)platform,
1936 (uintptr_t)func_name);
1937
1938 cl::gClErrorTls = CL_SUCCESS;
1939 ANGLE_CL_VALIDATE_POINTER(GetExtensionFunctionAddressForPlatform, platform, func_name);
1940
1941 return GetExtensionFunctionAddressForPlatform(platform, func_name);
1942 }
1943
1944 // CL 2.0
1945 cl_command_queue CL_API_CALL
clCreateCommandQueueWithProperties(cl_context context,cl_device_id device,const cl_queue_properties * properties,cl_int * errcode_ret)1946 clCreateCommandQueueWithProperties(cl_context context,
1947 cl_device_id device,
1948 const cl_queue_properties *properties,
1949 cl_int *errcode_ret)
1950 {
1951 CL_EVENT(CreateCommandQueueWithProperties,
1952 "context = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR ", properties = 0x%016" PRIxPTR
1953 ", errcode_ret = 0x%016" PRIxPTR "",
1954 (uintptr_t)context, (uintptr_t)device, (uintptr_t)properties, (uintptr_t)errcode_ret);
1955
1956 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateCommandQueueWithProperties, context, device, properties);
1957
1958 cl::gClErrorTls = CL_SUCCESS;
1959 cl_command_queue object = CreateCommandQueueWithProperties(context, device, properties);
1960
1961 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1962 if (errcode_ret != nullptr)
1963 {
1964 *errcode_ret = cl::gClErrorTls;
1965 }
1966 return object;
1967 }
1968
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)1969 cl_mem CL_API_CALL clCreatePipe(cl_context context,
1970 cl_mem_flags flags,
1971 cl_uint pipe_packet_size,
1972 cl_uint pipe_max_packets,
1973 const cl_pipe_properties *properties,
1974 cl_int *errcode_ret)
1975 {
1976 CL_EVENT(
1977 CreatePipe,
1978 "context = 0x%016" PRIxPTR
1979 ", flags = %llu, pipe_packet_size = %u, pipe_max_packets = %u, properties = 0x%016" PRIxPTR
1980 ", errcode_ret = 0x%016" PRIxPTR "",
1981 (uintptr_t)context, static_cast<unsigned long long>(flags), pipe_packet_size,
1982 pipe_max_packets, (uintptr_t)properties, (uintptr_t)errcode_ret);
1983
1984 MemFlags flagsPacked = PackParam<MemFlags>(flags);
1985
1986 ANGLE_CL_VALIDATE_ERRCODE_RET(CreatePipe, context, flagsPacked, pipe_packet_size,
1987 pipe_max_packets, properties);
1988
1989 cl::gClErrorTls = CL_SUCCESS;
1990 cl_mem object =
1991 CreatePipe(context, flagsPacked, pipe_packet_size, pipe_max_packets, properties);
1992
1993 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
1994 if (errcode_ret != nullptr)
1995 {
1996 *errcode_ret = cl::gClErrorTls;
1997 }
1998 return object;
1999 }
2000
clGetPipeInfo(cl_mem pipe,cl_pipe_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret)2001 cl_int CL_API_CALL clGetPipeInfo(cl_mem pipe,
2002 cl_pipe_info param_name,
2003 size_t param_value_size,
2004 void *param_value,
2005 size_t *param_value_size_ret)
2006 {
2007 CL_EVENT(GetPipeInfo,
2008 "pipe = 0x%016" PRIxPTR
2009 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
2010 ", param_value_size_ret = 0x%016" PRIxPTR "",
2011 (uintptr_t)pipe, param_name, param_value_size, (uintptr_t)param_value,
2012 (uintptr_t)param_value_size_ret);
2013
2014 PipeInfo param_namePacked = PackParam<PipeInfo>(param_name);
2015
2016 ANGLE_CL_VALIDATE_ERROR(GetPipeInfo, pipe, param_namePacked, param_value_size, param_value,
2017 param_value_size_ret);
2018
2019 cl::gClErrorTls = CL_SUCCESS;
2020 return GetPipeInfo(pipe, param_namePacked, param_value_size, param_value, param_value_size_ret);
2021 }
2022
clSVMAlloc(cl_context context,cl_svm_mem_flags flags,size_t size,cl_uint alignment)2023 void *CL_API_CALL clSVMAlloc(cl_context context,
2024 cl_svm_mem_flags flags,
2025 size_t size,
2026 cl_uint alignment)
2027 {
2028 CL_EVENT(SVMAlloc, "context = 0x%016" PRIxPTR ", flags = %llu, size = %zu, alignment = %u",
2029 (uintptr_t)context, static_cast<unsigned long long>(flags), size, alignment);
2030
2031 SVM_MemFlags flagsPacked = PackParam<SVM_MemFlags>(flags);
2032
2033 cl::gClErrorTls = CL_SUCCESS;
2034 ANGLE_CL_VALIDATE_POINTER(SVMAlloc, context, flagsPacked, size, alignment);
2035
2036 return SVMAlloc(context, flagsPacked, size, alignment);
2037 }
2038
clSVMFree(cl_context context,void * svm_pointer)2039 void CL_API_CALL clSVMFree(cl_context context, void *svm_pointer)
2040 {
2041 CL_EVENT(SVMFree, "context = 0x%016" PRIxPTR ", svm_pointer = 0x%016" PRIxPTR "",
2042 (uintptr_t)context, (uintptr_t)svm_pointer);
2043
2044 ANGLE_CL_VALIDATE_VOID(SVMFree, context, svm_pointer);
2045
2046 cl::gClErrorTls = CL_SUCCESS;
2047 SVMFree(context, svm_pointer);
2048 }
2049
2050 cl_sampler CL_API_CALL
clCreateSamplerWithProperties(cl_context context,const cl_sampler_properties * sampler_properties,cl_int * errcode_ret)2051 clCreateSamplerWithProperties(cl_context context,
2052 const cl_sampler_properties *sampler_properties,
2053 cl_int *errcode_ret)
2054 {
2055 CL_EVENT(CreateSamplerWithProperties,
2056 "context = 0x%016" PRIxPTR ", sampler_properties = 0x%016" PRIxPTR
2057 ", errcode_ret = 0x%016" PRIxPTR "",
2058 (uintptr_t)context, (uintptr_t)sampler_properties, (uintptr_t)errcode_ret);
2059
2060 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateSamplerWithProperties, context, sampler_properties);
2061
2062 cl::gClErrorTls = CL_SUCCESS;
2063 cl_sampler object = CreateSamplerWithProperties(context, sampler_properties);
2064
2065 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
2066 if (errcode_ret != nullptr)
2067 {
2068 *errcode_ret = cl::gClErrorTls;
2069 }
2070 return object;
2071 }
2072
clSetKernelArgSVMPointer(cl_kernel kernel,cl_uint arg_index,const void * arg_value)2073 cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel,
2074 cl_uint arg_index,
2075 const void *arg_value)
2076 {
2077 CL_EVENT(SetKernelArgSVMPointer,
2078 "kernel = 0x%016" PRIxPTR ", arg_index = %u, arg_value = 0x%016" PRIxPTR "",
2079 (uintptr_t)kernel, arg_index, (uintptr_t)arg_value);
2080
2081 ANGLE_CL_VALIDATE_ERROR(SetKernelArgSVMPointer, kernel, arg_index, arg_value);
2082
2083 cl::gClErrorTls = CL_SUCCESS;
2084 return SetKernelArgSVMPointer(kernel, arg_index, arg_value);
2085 }
2086
clSetKernelExecInfo(cl_kernel kernel,cl_kernel_exec_info param_name,size_t param_value_size,const void * param_value)2087 cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel,
2088 cl_kernel_exec_info param_name,
2089 size_t param_value_size,
2090 const void *param_value)
2091 {
2092 CL_EVENT(SetKernelExecInfo,
2093 "kernel = 0x%016" PRIxPTR
2094 ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR "",
2095 (uintptr_t)kernel, param_name, param_value_size, (uintptr_t)param_value);
2096
2097 KernelExecInfo param_namePacked = PackParam<KernelExecInfo>(param_name);
2098
2099 ANGLE_CL_VALIDATE_ERROR(SetKernelExecInfo, kernel, param_namePacked, param_value_size,
2100 param_value);
2101
2102 cl::gClErrorTls = CL_SUCCESS;
2103 return SetKernelExecInfo(kernel, param_namePacked, param_value_size, param_value);
2104 }
2105
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)2106 cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue command_queue,
2107 cl_uint num_svm_pointers,
2108 void *svm_pointers[],
2109 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue,
2110 cl_uint num_svm_pointers,
2111 void *svm_pointers[],
2112 void *user_data),
2113 void *user_data,
2114 cl_uint num_events_in_wait_list,
2115 const cl_event *event_wait_list,
2116 cl_event *event)
2117 {
2118 CL_EVENT(EnqueueSVMFree,
2119 "command_queue = 0x%016" PRIxPTR
2120 ", num_svm_pointers = %u, svm_pointers = 0x%016" PRIxPTR
2121 ", pfn_free_func = 0x%016" PRIxPTR ", user_data = 0x%016" PRIxPTR
2122 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
2123 ", event = 0x%016" PRIxPTR "",
2124 (uintptr_t)command_queue, num_svm_pointers, (uintptr_t)svm_pointers,
2125 (uintptr_t)pfn_free_func, (uintptr_t)user_data, num_events_in_wait_list,
2126 (uintptr_t)event_wait_list, (uintptr_t)event);
2127
2128 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMFree, command_queue, num_svm_pointers, svm_pointers,
2129 pfn_free_func, user_data, num_events_in_wait_list, event_wait_list,
2130 event);
2131
2132 cl::gClErrorTls = CL_SUCCESS;
2133 return EnqueueSVMFree(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data,
2134 num_events_in_wait_list, event_wait_list, event);
2135 }
2136
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)2137 cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue command_queue,
2138 cl_bool blocking_copy,
2139 void *dst_ptr,
2140 const void *src_ptr,
2141 size_t size,
2142 cl_uint num_events_in_wait_list,
2143 const cl_event *event_wait_list,
2144 cl_event *event)
2145 {
2146 CL_EVENT(EnqueueSVMMemcpy,
2147 "command_queue = 0x%016" PRIxPTR ", blocking_copy = %u, dst_ptr = 0x%016" PRIxPTR
2148 ", src_ptr = 0x%016" PRIxPTR
2149 ", size = %zu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
2150 ", event = 0x%016" PRIxPTR "",
2151 (uintptr_t)command_queue, blocking_copy, (uintptr_t)dst_ptr, (uintptr_t)src_ptr, size,
2152 num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
2153
2154 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMMemcpy, command_queue, blocking_copy, dst_ptr, src_ptr, size,
2155 num_events_in_wait_list, event_wait_list, event);
2156
2157 cl::gClErrorTls = CL_SUCCESS;
2158 return EnqueueSVMMemcpy(command_queue, blocking_copy, dst_ptr, src_ptr, size,
2159 num_events_in_wait_list, event_wait_list, event);
2160 }
2161
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)2162 cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue command_queue,
2163 void *svm_ptr,
2164 const void *pattern,
2165 size_t pattern_size,
2166 size_t size,
2167 cl_uint num_events_in_wait_list,
2168 const cl_event *event_wait_list,
2169 cl_event *event)
2170 {
2171 CL_EVENT(EnqueueSVMMemFill,
2172 "command_queue = 0x%016" PRIxPTR ", svm_ptr = 0x%016" PRIxPTR
2173 ", pattern = 0x%016" PRIxPTR
2174 ", pattern_size = %zu, size = %zu, num_events_in_wait_list = %u, event_wait_list = "
2175 "0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
2176 (uintptr_t)command_queue, (uintptr_t)svm_ptr, (uintptr_t)pattern, pattern_size, size,
2177 num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);
2178
2179 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMMemFill, command_queue, svm_ptr, pattern, pattern_size, size,
2180 num_events_in_wait_list, event_wait_list, event);
2181
2182 cl::gClErrorTls = CL_SUCCESS;
2183 return EnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size, size,
2184 num_events_in_wait_list, event_wait_list, event);
2185 }
2186
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)2187 cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue command_queue,
2188 cl_bool blocking_map,
2189 cl_map_flags flags,
2190 void *svm_ptr,
2191 size_t size,
2192 cl_uint num_events_in_wait_list,
2193 const cl_event *event_wait_list,
2194 cl_event *event)
2195 {
2196 CL_EVENT(EnqueueSVMMap,
2197 "command_queue = 0x%016" PRIxPTR
2198 ", blocking_map = %u, flags = %llu, svm_ptr = 0x%016" PRIxPTR
2199 ", size = %zu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
2200 ", event = 0x%016" PRIxPTR "",
2201 (uintptr_t)command_queue, blocking_map, static_cast<unsigned long long>(flags),
2202 (uintptr_t)svm_ptr, size, num_events_in_wait_list, (uintptr_t)event_wait_list,
2203 (uintptr_t)event);
2204
2205 MapFlags flagsPacked = PackParam<MapFlags>(flags);
2206
2207 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMMap, command_queue, blocking_map, flagsPacked, svm_ptr, size,
2208 num_events_in_wait_list, event_wait_list, event);
2209
2210 cl::gClErrorTls = CL_SUCCESS;
2211 return EnqueueSVMMap(command_queue, blocking_map, flagsPacked, svm_ptr, size,
2212 num_events_in_wait_list, event_wait_list, event);
2213 }
2214
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)2215 cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue command_queue,
2216 void *svm_ptr,
2217 cl_uint num_events_in_wait_list,
2218 const cl_event *event_wait_list,
2219 cl_event *event)
2220 {
2221 CL_EVENT(EnqueueSVMUnmap,
2222 "command_queue = 0x%016" PRIxPTR ", svm_ptr = 0x%016" PRIxPTR
2223 ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
2224 ", event = 0x%016" PRIxPTR "",
2225 (uintptr_t)command_queue, (uintptr_t)svm_ptr, num_events_in_wait_list,
2226 (uintptr_t)event_wait_list, (uintptr_t)event);
2227
2228 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMUnmap, command_queue, svm_ptr, num_events_in_wait_list,
2229 event_wait_list, event);
2230
2231 cl::gClErrorTls = CL_SUCCESS;
2232 return EnqueueSVMUnmap(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, event);
2233 }
2234
2235 // CL 2.1
clSetDefaultDeviceCommandQueue(cl_context context,cl_device_id device,cl_command_queue command_queue)2236 cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context,
2237 cl_device_id device,
2238 cl_command_queue command_queue)
2239 {
2240 CL_EVENT(SetDefaultDeviceCommandQueue,
2241 "context = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
2242 ", command_queue = 0x%016" PRIxPTR "",
2243 (uintptr_t)context, (uintptr_t)device, (uintptr_t)command_queue);
2244
2245 ANGLE_CL_VALIDATE_ERROR(SetDefaultDeviceCommandQueue, context, device, command_queue);
2246
2247 cl::gClErrorTls = CL_SUCCESS;
2248 return SetDefaultDeviceCommandQueue(context, device, command_queue);
2249 }
2250
clGetDeviceAndHostTimer(cl_device_id device,cl_ulong * device_timestamp,cl_ulong * host_timestamp)2251 cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device,
2252 cl_ulong *device_timestamp,
2253 cl_ulong *host_timestamp)
2254 {
2255 CL_EVENT(GetDeviceAndHostTimer,
2256 "device = 0x%016" PRIxPTR ", device_timestamp = 0x%016" PRIxPTR
2257 ", host_timestamp = 0x%016" PRIxPTR "",
2258 (uintptr_t)device, (uintptr_t)device_timestamp, (uintptr_t)host_timestamp);
2259
2260 ANGLE_CL_VALIDATE_ERROR(GetDeviceAndHostTimer, device, device_timestamp, host_timestamp);
2261
2262 cl::gClErrorTls = CL_SUCCESS;
2263 return GetDeviceAndHostTimer(device, device_timestamp, host_timestamp);
2264 }
2265
clGetHostTimer(cl_device_id device,cl_ulong * host_timestamp)2266 cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong *host_timestamp)
2267 {
2268 CL_EVENT(GetHostTimer, "device = 0x%016" PRIxPTR ", host_timestamp = 0x%016" PRIxPTR "",
2269 (uintptr_t)device, (uintptr_t)host_timestamp);
2270
2271 ANGLE_CL_VALIDATE_ERROR(GetHostTimer, device, host_timestamp);
2272
2273 cl::gClErrorTls = CL_SUCCESS;
2274 return GetHostTimer(device, host_timestamp);
2275 }
2276
clCreateProgramWithIL(cl_context context,const void * il,size_t length,cl_int * errcode_ret)2277 cl_program CL_API_CALL clCreateProgramWithIL(cl_context context,
2278 const void *il,
2279 size_t length,
2280 cl_int *errcode_ret)
2281 {
2282 CL_EVENT(CreateProgramWithIL,
2283 "context = 0x%016" PRIxPTR ", il = 0x%016" PRIxPTR
2284 ", length = %zu, errcode_ret = 0x%016" PRIxPTR "",
2285 (uintptr_t)context, (uintptr_t)il, length, (uintptr_t)errcode_ret);
2286
2287 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateProgramWithIL, context, il, length);
2288
2289 cl::gClErrorTls = CL_SUCCESS;
2290 cl_program object = CreateProgramWithIL(context, il, length);
2291
2292 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
2293 if (errcode_ret != nullptr)
2294 {
2295 *errcode_ret = cl::gClErrorTls;
2296 }
2297 return object;
2298 }
2299
clCloneKernel(cl_kernel source_kernel,cl_int * errcode_ret)2300 cl_kernel CL_API_CALL clCloneKernel(cl_kernel source_kernel, cl_int *errcode_ret)
2301 {
2302 CL_EVENT(CloneKernel, "source_kernel = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
2303 (uintptr_t)source_kernel, (uintptr_t)errcode_ret);
2304
2305 ANGLE_CL_VALIDATE_ERRCODE_RET(CloneKernel, source_kernel);
2306
2307 cl::gClErrorTls = CL_SUCCESS;
2308 cl_kernel object = CloneKernel(source_kernel);
2309
2310 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
2311 if (errcode_ret != nullptr)
2312 {
2313 *errcode_ret = cl::gClErrorTls;
2314 }
2315 return object;
2316 }
2317
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)2318 cl_int CL_API_CALL clGetKernelSubGroupInfo(cl_kernel kernel,
2319 cl_device_id device,
2320 cl_kernel_sub_group_info param_name,
2321 size_t input_value_size,
2322 const void *input_value,
2323 size_t param_value_size,
2324 void *param_value,
2325 size_t *param_value_size_ret)
2326 {
2327 CL_EVENT(GetKernelSubGroupInfo,
2328 "kernel = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
2329 ", param_name = %u, input_value_size = %zu, input_value = 0x%016" PRIxPTR
2330 ", param_value_size = %zu, param_value = 0x%016" PRIxPTR
2331 ", param_value_size_ret = 0x%016" PRIxPTR "",
2332 (uintptr_t)kernel, (uintptr_t)device, param_name, input_value_size,
2333 (uintptr_t)input_value, param_value_size, (uintptr_t)param_value,
2334 (uintptr_t)param_value_size_ret);
2335
2336 KernelSubGroupInfo param_namePacked = PackParam<KernelSubGroupInfo>(param_name);
2337
2338 ANGLE_CL_VALIDATE_ERROR(GetKernelSubGroupInfo, kernel, device, param_namePacked,
2339 input_value_size, input_value, param_value_size, param_value,
2340 param_value_size_ret);
2341
2342 cl::gClErrorTls = CL_SUCCESS;
2343 return GetKernelSubGroupInfo(kernel, device, param_namePacked, input_value_size, input_value,
2344 param_value_size, param_value, param_value_size_ret);
2345 }
2346
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)2347 cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue command_queue,
2348 cl_uint num_svm_pointers,
2349 const void **svm_pointers,
2350 const size_t *sizes,
2351 cl_mem_migration_flags flags,
2352 cl_uint num_events_in_wait_list,
2353 const cl_event *event_wait_list,
2354 cl_event *event)
2355 {
2356 CL_EVENT(EnqueueSVMMigrateMem,
2357 "command_queue = 0x%016" PRIxPTR
2358 ", num_svm_pointers = %u, svm_pointers = 0x%016" PRIxPTR ", sizes = 0x%016" PRIxPTR
2359 ", flags = %llu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
2360 ", event = 0x%016" PRIxPTR "",
2361 (uintptr_t)command_queue, num_svm_pointers, (uintptr_t)svm_pointers, (uintptr_t)sizes,
2362 static_cast<unsigned long long>(flags), num_events_in_wait_list,
2363 (uintptr_t)event_wait_list, (uintptr_t)event);
2364
2365 MemMigrationFlags flagsPacked = PackParam<MemMigrationFlags>(flags);
2366
2367 ANGLE_CL_VALIDATE_ERROR(EnqueueSVMMigrateMem, command_queue, num_svm_pointers, svm_pointers,
2368 sizes, flagsPacked, num_events_in_wait_list, event_wait_list, event);
2369
2370 cl::gClErrorTls = CL_SUCCESS;
2371 return EnqueueSVMMigrateMem(command_queue, num_svm_pointers, svm_pointers, sizes, flagsPacked,
2372 num_events_in_wait_list, event_wait_list, event);
2373 }
2374
2375 // CL 2.2
clSetProgramReleaseCallback(cl_program program,void (CL_CALLBACK * pfn_notify)(cl_program program,void * user_data),void * user_data)2376 cl_int CL_API_CALL clSetProgramReleaseCallback(cl_program program,
2377 void(CL_CALLBACK *pfn_notify)(cl_program program,
2378 void *user_data),
2379 void *user_data)
2380 {
2381 CL_EVENT(SetProgramReleaseCallback,
2382 "program = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
2383 ", user_data = 0x%016" PRIxPTR "",
2384 (uintptr_t)program, (uintptr_t)pfn_notify, (uintptr_t)user_data);
2385
2386 ANGLE_CL_VALIDATE_ERROR(SetProgramReleaseCallback, program, pfn_notify, user_data);
2387
2388 cl::gClErrorTls = CL_SUCCESS;
2389 return SetProgramReleaseCallback(program, pfn_notify, user_data);
2390 }
2391
clSetProgramSpecializationConstant(cl_program program,cl_uint spec_id,size_t spec_size,const void * spec_value)2392 cl_int CL_API_CALL clSetProgramSpecializationConstant(cl_program program,
2393 cl_uint spec_id,
2394 size_t spec_size,
2395 const void *spec_value)
2396 {
2397 CL_EVENT(SetProgramSpecializationConstant,
2398 "program = 0x%016" PRIxPTR
2399 ", spec_id = %u, spec_size = %zu, spec_value = 0x%016" PRIxPTR "",
2400 (uintptr_t)program, spec_id, spec_size, (uintptr_t)spec_value);
2401
2402 ANGLE_CL_VALIDATE_ERROR(SetProgramSpecializationConstant, program, spec_id, spec_size,
2403 spec_value);
2404
2405 cl::gClErrorTls = CL_SUCCESS;
2406 return SetProgramSpecializationConstant(program, spec_id, spec_size, spec_value);
2407 }
2408
2409 // CL 3.0
clSetContextDestructorCallback(cl_context context,void (CL_CALLBACK * pfn_notify)(cl_context context,void * user_data),void * user_data)2410 cl_int CL_API_CALL clSetContextDestructorCallback(cl_context context,
2411 void(CL_CALLBACK *pfn_notify)(cl_context context,
2412 void *user_data),
2413 void *user_data)
2414 {
2415 CL_EVENT(SetContextDestructorCallback,
2416 "context = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
2417 ", user_data = 0x%016" PRIxPTR "",
2418 (uintptr_t)context, (uintptr_t)pfn_notify, (uintptr_t)user_data);
2419
2420 ANGLE_CL_VALIDATE_ERROR(SetContextDestructorCallback, context, pfn_notify, user_data);
2421
2422 cl::gClErrorTls = CL_SUCCESS;
2423 return SetContextDestructorCallback(context, pfn_notify, user_data);
2424 }
2425
clCreateBufferWithProperties(cl_context context,const cl_mem_properties * properties,cl_mem_flags flags,size_t size,void * host_ptr,cl_int * errcode_ret)2426 cl_mem CL_API_CALL clCreateBufferWithProperties(cl_context context,
2427 const cl_mem_properties *properties,
2428 cl_mem_flags flags,
2429 size_t size,
2430 void *host_ptr,
2431 cl_int *errcode_ret)
2432 {
2433 CL_EVENT(CreateBufferWithProperties,
2434 "context = 0x%016" PRIxPTR ", properties = 0x%016" PRIxPTR
2435 ", flags = %llu, size = %zu, host_ptr = 0x%016" PRIxPTR
2436 ", errcode_ret = 0x%016" PRIxPTR "",
2437 (uintptr_t)context, (uintptr_t)properties, static_cast<unsigned long long>(flags),
2438 size, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);
2439
2440 MemFlags flagsPacked = PackParam<MemFlags>(flags);
2441
2442 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateBufferWithProperties, context, properties, flagsPacked,
2443 size, host_ptr);
2444
2445 cl::gClErrorTls = CL_SUCCESS;
2446 cl_mem object = CreateBufferWithProperties(context, properties, flagsPacked, size, host_ptr);
2447
2448 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
2449 if (errcode_ret != nullptr)
2450 {
2451 *errcode_ret = cl::gClErrorTls;
2452 }
2453 return object;
2454 }
2455
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)2456 cl_mem CL_API_CALL clCreateImageWithProperties(cl_context context,
2457 const cl_mem_properties *properties,
2458 cl_mem_flags flags,
2459 const cl_image_format *image_format,
2460 const cl_image_desc *image_desc,
2461 void *host_ptr,
2462 cl_int *errcode_ret)
2463 {
2464 CL_EVENT(CreateImageWithProperties,
2465 "context = 0x%016" PRIxPTR ", properties = 0x%016" PRIxPTR
2466 ", flags = %llu, image_format = 0x%016" PRIxPTR ", image_desc = 0x%016" PRIxPTR
2467 ", host_ptr = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
2468 (uintptr_t)context, (uintptr_t)properties, static_cast<unsigned long long>(flags),
2469 (uintptr_t)image_format, (uintptr_t)image_desc, (uintptr_t)host_ptr,
2470 (uintptr_t)errcode_ret);
2471
2472 MemFlags flagsPacked = PackParam<MemFlags>(flags);
2473
2474 ANGLE_CL_VALIDATE_ERRCODE_RET(CreateImageWithProperties, context, properties, flagsPacked,
2475 image_format, image_desc, host_ptr);
2476
2477 cl::gClErrorTls = CL_SUCCESS;
2478 cl_mem object = CreateImageWithProperties(context, properties, flagsPacked, image_format,
2479 image_desc, host_ptr);
2480
2481 ASSERT((cl::gClErrorTls == CL_SUCCESS) == (object != nullptr));
2482 if (errcode_ret != nullptr)
2483 {
2484 *errcode_ret = cl::gClErrorTls;
2485 }
2486 return object;
2487 }
2488
2489 // cl_khr_icd
clIcdGetPlatformIDsKHR(cl_uint num_entries,cl_platform_id * platforms,cl_uint * num_platforms)2490 cl_int CL_API_CALL clIcdGetPlatformIDsKHR(cl_uint num_entries,
2491 cl_platform_id *platforms,
2492 cl_uint *num_platforms)
2493 {
2494 InitBackEnds(true);
2495
2496 CL_EVENT(IcdGetPlatformIDsKHR,
2497 "num_entries = %u, platforms = 0x%016" PRIxPTR ", num_platforms = 0x%016" PRIxPTR "",
2498 num_entries, (uintptr_t)platforms, (uintptr_t)num_platforms);
2499
2500 ANGLE_CL_VALIDATE_ERROR(IcdGetPlatformIDsKHR, num_entries, platforms, num_platforms);
2501
2502 cl::gClErrorTls = CL_SUCCESS;
2503 return IcdGetPlatformIDsKHR(num_entries, platforms, num_platforms);
2504 }
2505
2506 } // namespace cl
2507