Debian Codegraph @

opencl/source/tracing/tracing_notify.h

raw
1 /*
2 * Copyright (C) 2019-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #pragma once
9
10 #include "shared/source/utilities/cpuintrinsics.h"
11
12 #include "opencl/source/tracing/tracing_handle.h"
13
14 #include <atomic>
15 #include <thread>
16
17 namespace HostSideTracing {
18
19 #define TRACING_SET_ENABLED_BIT(state) ((state) | (HostSideTracing::tracingStateEnabledBit))
20 #define TRACING_UNSET_ENABLED_BIT(state) ((state) & (~HostSideTracing::tracingStateEnabledBit))
21 #define TRACING_GET_ENABLED_BIT(state) ((state) & (HostSideTracing::tracingStateEnabledBit))
22
23 #define TRACING_SET_LOCKED_BIT(state) ((state) | (HostSideTracing::tracingStateLockedBit))
24 #define TRACING_UNSET_LOCKED_BIT(state) ((state) & (~HostSideTracing::tracingStateLockedBit))
25 #define TRACING_GET_LOCKED_BIT(state) ((state) & (HostSideTracing::tracingStateLockedBit))
26
27 #define TRACING_ZERO_CLIENT_COUNTER(state) ((state) & (HostSideTracing::tracingStateEnabledBit | HostSideTracing::tracingStateLockedBit))
28 #define TRACING_GET_CLIENT_COUNTER(state) ((state) & (~(HostSideTracing::tracingStateEnabledBit | HostSideTracing::tracingStateLockedBit)))
29
30 inline thread_local bool tracingInProgress = false;
31
32 #define TRACING_ENTER(name, ...) \
33 bool isHostSideTracingEnabled_##name = false; \
34 bool currentlyTracedCall = false; \
35 HostSideTracing::name##Tracer tracer_##name; \
36 if (TRACING_GET_ENABLED_BIT(HostSideTracing::tracingState.load(std::memory_order_acquire)) && (false == HostSideTracing::tracingInProgress)) { \
37 HostSideTracing::tracingInProgress = true; \
38 currentlyTracedCall = true; \
39 isHostSideTracingEnabled_##name = HostSideTracing::addTracingClient(); \
40 if (isHostSideTracingEnabled_##name) { \
41 tracer_##name.enter(__VA_ARGS__); \
42 } \
43 }
44
45 #define TRACING_EXIT(name, ...) \
46 if (currentlyTracedCall) { \
47 if (isHostSideTracingEnabled_##name) { \
48 tracer_##name.exit(__VA_ARGS__); \
49 HostSideTracing::removeTracingClient(); \
50 } \
51 HostSideTracing::tracingInProgress = false; \
52 currentlyTracedCall = false; \
53 }
54
55 enum TracingNotifyState {
56 TRACING_NOTIFY_STATE_NOTHING_CALLED = 0,
57 TRACING_NOTIFY_STATE_ENTER_CALLED = 1,
58 TRACING_NOTIFY_STATE_EXIT_CALLED = 2,
59 };
60
61 inline constexpr size_t tracingMaxHandleCount = 16;
62
63 inline constexpr uint32_t tracingStateEnabledBit = 0x80000000u;
64 inline constexpr uint32_t tracingStateLockedBit = 0x40000000u;
65
66 extern std::atomic<uint32_t> tracingState;
67 extern TracingHandle *tracingHandle[tracingMaxHandleCount];
68 extern std::atomic<uint32_t> tracingCorrelationId;
69
70 bool addTracingClient();
71 void removeTracingClient();
72
73 class AtomicBackoff {
74 public:
75 AtomicBackoff() {}
76
77 void pause() {
78 if (count < loopsBeforeYield) {
79 for (uint32_t i = 0; i < count; i++) {
80 NEO::CpuIntrinsics::pause();
81 }
82 count *= 2;
83 } else {
84 std::this_thread::yield();
85 }
86 }
87
88 private:
89 static const uint32_t loopsBeforeYield = 16;
90 uint32_t count = 1;
91 };
92
93 class ClBuildProgramTracer {
94 public:
95 ClBuildProgramTracer() {}
96
97 void enter(cl_program *program,
98 cl_uint *numDevices,
99 const cl_device_id **deviceList,
100 const char **options,
101 void(CL_CALLBACK **funcNotify)(cl_program program, void *userData),
102 void **userData) {
103 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
104
105 params.program = program;
106 params.numDevices = numDevices;
107 params.deviceList = deviceList;
108 params.options = options;
109 params.funcNotify = funcNotify;
110 params.userData = userData;
111
112 data.site = CL_CALLBACK_SITE_ENTER;
113 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
114 data.functionName = "clBuildProgram";
115 data.functionParams = static_cast<const void *>(&params);
116 data.functionReturnValue = nullptr;
117
118 size_t i = 0;
119 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
120 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
121 TracingHandle *handle = tracingHandle[i];
122 DEBUG_BREAK_IF(handle == nullptr);
123 if (handle->getTracingPoint(CL_FUNCTION_clBuildProgram)) {
124 data.correlationData = correlationData + i;
125 handle->call(CL_FUNCTION_clBuildProgram, &data);
126 }
127 ++i;
128 }
129
130 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
131 }
132
133 void exit(cl_int *retVal) {
134 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
135 data.site = CL_CALLBACK_SITE_EXIT;
136 data.functionReturnValue = retVal;
137
138 size_t i = 0;
139 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
140 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
141 TracingHandle *handle = tracingHandle[i];
142 DEBUG_BREAK_IF(handle == nullptr);
143 if (handle->getTracingPoint(CL_FUNCTION_clBuildProgram)) {
144 data.correlationData = correlationData + i;
145 handle->call(CL_FUNCTION_clBuildProgram, &data);
146 }
147 ++i;
148 }
149
150 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
151 }
152
153 ~ClBuildProgramTracer() {
154 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
155 }
156
157 private:
158 cl_params_clBuildProgram params{};
159 cl_callback_data data{};
160 uint64_t correlationData[tracingMaxHandleCount];
161 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
162 };
163
164 class ClCloneKernelTracer {
165 public:
166 ClCloneKernelTracer() {}
167
168 void enter(cl_kernel *sourceKernel,
169 cl_int **errcodeRet) {
170 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
171
172 params.sourceKernel = sourceKernel;
173 params.errcodeRet = errcodeRet;
174
175 data.site = CL_CALLBACK_SITE_ENTER;
176 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
177 data.functionName = "clCloneKernel";
178 data.functionParams = static_cast<const void *>(&params);
179 data.functionReturnValue = nullptr;
180
181 size_t i = 0;
182 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
183 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
184 TracingHandle *handle = tracingHandle[i];
185 DEBUG_BREAK_IF(handle == nullptr);
186 if (handle->getTracingPoint(CL_FUNCTION_clCloneKernel)) {
187 data.correlationData = correlationData + i;
188 handle->call(CL_FUNCTION_clCloneKernel, &data);
189 }
190 ++i;
191 }
192
193 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
194 }
195
196 void exit(cl_kernel *retVal) {
197 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
198 data.site = CL_CALLBACK_SITE_EXIT;
199 data.functionReturnValue = retVal;
200
201 size_t i = 0;
202 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
203 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
204 TracingHandle *handle = tracingHandle[i];
205 DEBUG_BREAK_IF(handle == nullptr);
206 if (handle->getTracingPoint(CL_FUNCTION_clCloneKernel)) {
207 data.correlationData = correlationData + i;
208 handle->call(CL_FUNCTION_clCloneKernel, &data);
209 }
210 ++i;
211 }
212
213 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
214 }
215
216 ~ClCloneKernelTracer() {
217 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
218 }
219
220 private:
221 cl_params_clCloneKernel params{};
222 cl_callback_data data{};
223 uint64_t correlationData[tracingMaxHandleCount];
224 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
225 };
226
227 class ClCompileProgramTracer {
228 public:
229 ClCompileProgramTracer() {}
230
231 void enter(cl_program *program,
232 cl_uint *numDevices,
233 const cl_device_id **deviceList,
234 const char **options,
235 cl_uint *numInputHeaders,
236 const cl_program **inputHeaders,
237 const char ***headerIncludeNames,
238 void(CL_CALLBACK **funcNotify)(cl_program program, void *userData),
239 void **userData) {
240 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
241
242 params.program = program;
243 params.numDevices = numDevices;
244 params.deviceList = deviceList;
245 params.options = options;
246 params.numInputHeaders = numInputHeaders;
247 params.inputHeaders = inputHeaders;
248 params.headerIncludeNames = headerIncludeNames;
249 params.funcNotify = funcNotify;
250 params.userData = userData;
251
252 data.site = CL_CALLBACK_SITE_ENTER;
253 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
254 data.functionName = "clCompileProgram";
255 data.functionParams = static_cast<const void *>(&params);
256 data.functionReturnValue = nullptr;
257
258 size_t i = 0;
259 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
260 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
261 TracingHandle *handle = tracingHandle[i];
262 DEBUG_BREAK_IF(handle == nullptr);
263 if (handle->getTracingPoint(CL_FUNCTION_clCompileProgram)) {
264 data.correlationData = correlationData + i;
265 handle->call(CL_FUNCTION_clCompileProgram, &data);
266 }
267 ++i;
268 }
269
270 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
271 }
272
273 void exit(cl_int *retVal) {
274 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
275 data.site = CL_CALLBACK_SITE_EXIT;
276 data.functionReturnValue = retVal;
277
278 size_t i = 0;
279 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
280 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
281 TracingHandle *handle = tracingHandle[i];
282 DEBUG_BREAK_IF(handle == nullptr);
283 if (handle->getTracingPoint(CL_FUNCTION_clCompileProgram)) {
284 data.correlationData = correlationData + i;
285 handle->call(CL_FUNCTION_clCompileProgram, &data);
286 }
287 ++i;
288 }
289
290 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
291 }
292
293 ~ClCompileProgramTracer() {
294 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
295 }
296
297 private:
298 cl_params_clCompileProgram params{};
299 cl_callback_data data{};
300 uint64_t correlationData[tracingMaxHandleCount];
301 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
302 };
303
304 class ClCreateBufferTracer {
305 public:
306 ClCreateBufferTracer() {}
307
308 void enter(cl_context *context,
309 cl_mem_flags *flags,
310 size_t *size,
311 void **hostPtr,
312 cl_int **errcodeRet) {
313 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
314
315 params.context = context;
316 params.flags = flags;
317 params.size = size;
318 params.hostPtr = hostPtr;
319 params.errcodeRet = errcodeRet;
320
321 data.site = CL_CALLBACK_SITE_ENTER;
322 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
323 data.functionName = "clCreateBuffer";
324 data.functionParams = static_cast<const void *>(&params);
325 data.functionReturnValue = nullptr;
326
327 size_t i = 0;
328 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
329 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
330 TracingHandle *handle = tracingHandle[i];
331 DEBUG_BREAK_IF(handle == nullptr);
332 if (handle->getTracingPoint(CL_FUNCTION_clCreateBuffer)) {
333 data.correlationData = correlationData + i;
334 handle->call(CL_FUNCTION_clCreateBuffer, &data);
335 }
336 ++i;
337 }
338
339 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
340 }
341
342 void exit(cl_mem *retVal) {
343 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
344 data.site = CL_CALLBACK_SITE_EXIT;
345 data.functionReturnValue = retVal;
346
347 size_t i = 0;
348 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
349 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
350 TracingHandle *handle = tracingHandle[i];
351 DEBUG_BREAK_IF(handle == nullptr);
352 if (handle->getTracingPoint(CL_FUNCTION_clCreateBuffer)) {
353 data.correlationData = correlationData + i;
354 handle->call(CL_FUNCTION_clCreateBuffer, &data);
355 }
356 ++i;
357 }
358
359 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
360 }
361
362 ~ClCreateBufferTracer() {
363 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
364 }
365
366 private:
367 cl_params_clCreateBuffer params{};
368 cl_callback_data data{};
369 uint64_t correlationData[tracingMaxHandleCount];
370 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
371 };
372
373 class ClCreateCommandQueueTracer {
374 public:
375 ClCreateCommandQueueTracer() {}
376
377 void enter(cl_context *context,
378 cl_device_id *device,
379 cl_command_queue_properties *properties,
380 cl_int **errcodeRet) {
381 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
382
383 params.context = context;
384 params.device = device;
385 params.properties = properties;
386 params.errcodeRet = errcodeRet;
387
388 data.site = CL_CALLBACK_SITE_ENTER;
389 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
390 data.functionName = "clCreateCommandQueue";
391 data.functionParams = static_cast<const void *>(&params);
392 data.functionReturnValue = nullptr;
393
394 size_t i = 0;
395 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
396 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
397 TracingHandle *handle = tracingHandle[i];
398 DEBUG_BREAK_IF(handle == nullptr);
399 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueue)) {
400 data.correlationData = correlationData + i;
401 handle->call(CL_FUNCTION_clCreateCommandQueue, &data);
402 }
403 ++i;
404 }
405
406 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
407 }
408
409 void exit(cl_command_queue *retVal) {
410 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
411 data.site = CL_CALLBACK_SITE_EXIT;
412 data.functionReturnValue = retVal;
413
414 size_t i = 0;
415 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
416 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
417 TracingHandle *handle = tracingHandle[i];
418 DEBUG_BREAK_IF(handle == nullptr);
419 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueue)) {
420 data.correlationData = correlationData + i;
421 handle->call(CL_FUNCTION_clCreateCommandQueue, &data);
422 }
423 ++i;
424 }
425
426 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
427 }
428
429 ~ClCreateCommandQueueTracer() {
430 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
431 }
432
433 private:
434 cl_params_clCreateCommandQueue params{};
435 cl_callback_data data{};
436 uint64_t correlationData[tracingMaxHandleCount];
437 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
438 };
439
440 class ClCreateCommandQueueWithPropertiesTracer {
441 public:
442 ClCreateCommandQueueWithPropertiesTracer() {}
443
444 void enter(cl_context *context,
445 cl_device_id *device,
446 const cl_queue_properties **properties,
447 cl_int **errcodeRet) {
448 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
449
450 params.context = context;
451 params.device = device;
452 params.properties = properties;
453 params.errcodeRet = errcodeRet;
454
455 data.site = CL_CALLBACK_SITE_ENTER;
456 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
457 data.functionName = "clCreateCommandQueueWithProperties";
458 data.functionParams = static_cast<const void *>(&params);
459 data.functionReturnValue = nullptr;
460
461 size_t i = 0;
462 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
463 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
464 TracingHandle *handle = tracingHandle[i];
465 DEBUG_BREAK_IF(handle == nullptr);
466 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithProperties)) {
467 data.correlationData = correlationData + i;
468 handle->call(CL_FUNCTION_clCreateCommandQueueWithProperties, &data);
469 }
470 ++i;
471 }
472
473 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
474 }
475
476 void exit(cl_command_queue *retVal) {
477 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
478 data.site = CL_CALLBACK_SITE_EXIT;
479 data.functionReturnValue = retVal;
480
481 size_t i = 0;
482 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
483 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
484 TracingHandle *handle = tracingHandle[i];
485 DEBUG_BREAK_IF(handle == nullptr);
486 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithProperties)) {
487 data.correlationData = correlationData + i;
488 handle->call(CL_FUNCTION_clCreateCommandQueueWithProperties, &data);
489 }
490 ++i;
491 }
492
493 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
494 }
495
496 ~ClCreateCommandQueueWithPropertiesTracer() {
497 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
498 }
499
500 private:
501 cl_params_clCreateCommandQueueWithProperties params{};
502 cl_callback_data data{};
503 uint64_t correlationData[tracingMaxHandleCount];
504 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
505 };
506
507 class ClCreateContextTracer {
508 public:
509 ClCreateContextTracer() {}
510
511 void enter(const cl_context_properties **properties,
512 cl_uint *numDevices,
513 const cl_device_id **devices,
514 void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *),
515 void **userData,
516 cl_int **errcodeRet) {
517 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
518
519 params.properties = properties;
520 params.numDevices = numDevices;
521 params.devices = devices;
522 params.funcNotify = funcNotify;
523 params.userData = userData;
524 params.errcodeRet = errcodeRet;
525
526 data.site = CL_CALLBACK_SITE_ENTER;
527 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
528 data.functionName = "clCreateContext";
529 data.functionParams = static_cast<const void *>(&params);
530 data.functionReturnValue = nullptr;
531
532 size_t i = 0;
533 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
534 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
535 TracingHandle *handle = tracingHandle[i];
536 DEBUG_BREAK_IF(handle == nullptr);
537 if (handle->getTracingPoint(CL_FUNCTION_clCreateContext)) {
538 data.correlationData = correlationData + i;
539 handle->call(CL_FUNCTION_clCreateContext, &data);
540 }
541 ++i;
542 }
543
544 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
545 }
546
547 void exit(cl_context *retVal) {
548 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
549 data.site = CL_CALLBACK_SITE_EXIT;
550 data.functionReturnValue = retVal;
551
552 size_t i = 0;
553 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
554 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
555 TracingHandle *handle = tracingHandle[i];
556 DEBUG_BREAK_IF(handle == nullptr);
557 if (handle->getTracingPoint(CL_FUNCTION_clCreateContext)) {
558 data.correlationData = correlationData + i;
559 handle->call(CL_FUNCTION_clCreateContext, &data);
560 }
561 ++i;
562 }
563
564 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
565 }
566
567 ~ClCreateContextTracer() {
568 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
569 }
570
571 private:
572 cl_params_clCreateContext params{};
573 cl_callback_data data{};
574 uint64_t correlationData[tracingMaxHandleCount];
575 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
576 };
577
578 class ClCreateContextFromTypeTracer {
579 public:
580 ClCreateContextFromTypeTracer() {}
581
582 void enter(const cl_context_properties **properties,
583 cl_device_type *deviceType,
584 void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *),
585 void **userData,
586 cl_int **errcodeRet) {
587 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
588
589 params.properties = properties;
590 params.deviceType = deviceType;
591 params.funcNotify = funcNotify;
592 params.userData = userData;
593 params.errcodeRet = errcodeRet;
594
595 data.site = CL_CALLBACK_SITE_ENTER;
596 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
597 data.functionName = "clCreateContextFromType";
598 data.functionParams = static_cast<const void *>(&params);
599 data.functionReturnValue = nullptr;
600
601 size_t i = 0;
602 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
603 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
604 TracingHandle *handle = tracingHandle[i];
605 DEBUG_BREAK_IF(handle == nullptr);
606 if (handle->getTracingPoint(CL_FUNCTION_clCreateContextFromType)) {
607 data.correlationData = correlationData + i;
608 handle->call(CL_FUNCTION_clCreateContextFromType, &data);
609 }
610 ++i;
611 }
612
613 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
614 }
615
616 void exit(cl_context *retVal) {
617 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
618 data.site = CL_CALLBACK_SITE_EXIT;
619 data.functionReturnValue = retVal;
620
621 size_t i = 0;
622 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
623 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
624 TracingHandle *handle = tracingHandle[i];
625 DEBUG_BREAK_IF(handle == nullptr);
626 if (handle->getTracingPoint(CL_FUNCTION_clCreateContextFromType)) {
627 data.correlationData = correlationData + i;
628 handle->call(CL_FUNCTION_clCreateContextFromType, &data);
629 }
630 ++i;
631 }
632
633 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
634 }
635
636 ~ClCreateContextFromTypeTracer() {
637 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
638 }
639
640 private:
641 cl_params_clCreateContextFromType params{};
642 cl_callback_data data{};
643 uint64_t correlationData[tracingMaxHandleCount];
644 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
645 };
646
647 class ClMemFreeINTELTracer {
648 public:
649 ClMemFreeINTELTracer() {}
650
651 void enter(cl_context *context,
652 void **ptr) {
653 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
654
655 params.context = context;
656 params.ptr = ptr;
657
658 data.site = CL_CALLBACK_SITE_ENTER;
659 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
660 data.functionName = "clMemFreeINTEL";
661 data.functionParams = static_cast<const void *>(&params);
662 data.functionReturnValue = nullptr;
663
664 size_t i = 0;
665 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
666 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
667 TracingHandle *handle = tracingHandle[i];
668 DEBUG_BREAK_IF(handle == nullptr);
669 if (handle->getTracingPoint(CL_FUNCTION_clMemFreeINTEL)) {
670 data.correlationData = correlationData + i;
671 handle->call(CL_FUNCTION_clMemFreeINTEL, &data);
672 }
673 ++i;
674 }
675
676 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
677 }
678
679 void exit(cl_int *retVal) {
680 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
681 data.site = CL_CALLBACK_SITE_EXIT;
682 data.functionReturnValue = retVal;
683
684 size_t i = 0;
685 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
686 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
687 TracingHandle *handle = tracingHandle[i];
688 DEBUG_BREAK_IF(handle == nullptr);
689 if (handle->getTracingPoint(CL_FUNCTION_clMemFreeINTEL)) {
690 data.correlationData = correlationData + i;
691 handle->call(CL_FUNCTION_clMemFreeINTEL, &data);
692 }
693 ++i;
694 }
695
696 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
697 }
698
699 ~ClMemFreeINTELTracer() {
700 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
701 }
702
703 private:
704 cl_params_clMemFreeINTEL params{};
705 cl_callback_data data{};
706 uint64_t correlationData[tracingMaxHandleCount];
707 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
708 };
709
710 class ClIcdGetPlatformIDsKHRTracer {
711 public:
712 ClIcdGetPlatformIDsKHRTracer() {}
713
714 void enter(cl_uint *numEntries,
715 cl_platform_id **platforms,
716 cl_uint **numPlatforms) {
717 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
718
719 params.numEntries = numEntries;
720 params.platforms = platforms;
721 params.numPlatforms = numPlatforms;
722
723 data.site = CL_CALLBACK_SITE_ENTER;
724 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
725 data.functionName = "clIcdGetPlatformIDsKHR";
726 data.functionParams = static_cast<const void *>(&params);
727 data.functionReturnValue = nullptr;
728
729 size_t i = 0;
730 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
731 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
732 TracingHandle *handle = tracingHandle[i];
733 DEBUG_BREAK_IF(handle == nullptr);
734 if (handle->getTracingPoint(CL_FUNCTION_clIcdGetPlatformIDsKHR)) {
735 data.correlationData = correlationData + i;
736 handle->call(CL_FUNCTION_clIcdGetPlatformIDsKHR, &data);
737 }
738 ++i;
739 }
740
741 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
742 }
743
744 void exit(cl_int *retVal) {
745 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
746 data.site = CL_CALLBACK_SITE_EXIT;
747 data.functionReturnValue = retVal;
748
749 size_t i = 0;
750 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
751 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
752 TracingHandle *handle = tracingHandle[i];
753 DEBUG_BREAK_IF(handle == nullptr);
754 if (handle->getTracingPoint(CL_FUNCTION_clIcdGetPlatformIDsKHR)) {
755 data.correlationData = correlationData + i;
756 handle->call(CL_FUNCTION_clIcdGetPlatformIDsKHR, &data);
757 }
758 ++i;
759 }
760
761 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
762 }
763
764 ~ClIcdGetPlatformIDsKHRTracer() {
765 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
766 }
767
768 private:
769 cl_params_clIcdGetPlatformIDsKHR params{};
770 cl_callback_data data{};
771 uint64_t correlationData[tracingMaxHandleCount];
772 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
773 };
774
775 class ClCreateBufferWithPropertiesINTELTracer {
776 public:
777 ClCreateBufferWithPropertiesINTELTracer() {}
778
779 void enter(cl_context *context,
780 const cl_mem_properties **properties,
781 cl_mem_flags *flags,
782 size_t *size,
783 void **hostPtr,
784 cl_int **errcodeRet) {
785 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
786
787 params.context = context;
788 params.properties = properties;
789 params.flags = flags;
790 params.size = size;
791 params.hostPtr = hostPtr;
792 params.errcodeRet = errcodeRet;
793
794 data.site = CL_CALLBACK_SITE_ENTER;
795 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
796 data.functionName = "clCreateBufferWithPropertiesINTEL";
797 data.functionParams = static_cast<const void *>(&params);
798 data.functionReturnValue = nullptr;
799
800 size_t i = 0;
801 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
802 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
803 TracingHandle *handle = tracingHandle[i];
804 DEBUG_BREAK_IF(handle == nullptr);
805 if (handle->getTracingPoint(CL_FUNCTION_clCreateBufferWithPropertiesINTEL)) {
806 data.correlationData = correlationData + i;
807 handle->call(CL_FUNCTION_clCreateBufferWithPropertiesINTEL, &data);
808 }
809 ++i;
810 }
811
812 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
813 }
814
815 void exit(cl_mem *retVal) {
816 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
817 data.site = CL_CALLBACK_SITE_EXIT;
818 data.functionReturnValue = retVal;
819
820 size_t i = 0;
821 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
822 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
823 TracingHandle *handle = tracingHandle[i];
824 DEBUG_BREAK_IF(handle == nullptr);
825 if (handle->getTracingPoint(CL_FUNCTION_clCreateBufferWithPropertiesINTEL)) {
826 data.correlationData = correlationData + i;
827 handle->call(CL_FUNCTION_clCreateBufferWithPropertiesINTEL, &data);
828 }
829 ++i;
830 }
831
832 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
833 }
834
835 ~ClCreateBufferWithPropertiesINTELTracer() {
836 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
837 }
838
839 private:
840 cl_params_clCreateBufferWithPropertiesINTEL params{};
841 cl_callback_data data{};
842 uint64_t correlationData[tracingMaxHandleCount];
843 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
844 };
845
846 class ClCreateBufferWithPropertiesTracer {
847 public:
848 ClCreateBufferWithPropertiesTracer() {}
849
850 void enter(cl_context *context,
851 const cl_mem_properties **properties,
852 cl_mem_flags *flags,
853 size_t *size,
854 void **hostPtr,
855 cl_int **errcodeRet) {
856 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
857
858 params.context = context;
859 params.properties = properties;
860 params.flags = flags;
861 params.size = size;
862 params.hostPtr = hostPtr;
863 params.errcodeRet = errcodeRet;
864
865 data.site = CL_CALLBACK_SITE_ENTER;
866 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
867 data.functionName = "clCreateBufferWithProperties";
868 data.functionParams = static_cast<const void *>(&params);
869 data.functionReturnValue = nullptr;
870
871 size_t i = 0;
872 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
873 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
874 TracingHandle *handle = tracingHandle[i];
875 DEBUG_BREAK_IF(handle == nullptr);
876 if (handle->getTracingPoint(CL_FUNCTION_clCreateBufferWithProperties)) {
877 data.correlationData = correlationData + i;
878 handle->call(CL_FUNCTION_clCreateBufferWithProperties, &data);
879 }
880 ++i;
881 }
882
883 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
884 }
885
886 void exit(cl_mem *retVal) {
887 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
888 data.site = CL_CALLBACK_SITE_EXIT;
889 data.functionReturnValue = retVal;
890
891 size_t i = 0;
892 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
893 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
894 TracingHandle *handle = tracingHandle[i];
895 DEBUG_BREAK_IF(handle == nullptr);
896 if (handle->getTracingPoint(CL_FUNCTION_clCreateBufferWithProperties)) {
897 data.correlationData = correlationData + i;
898 handle->call(CL_FUNCTION_clCreateBufferWithProperties, &data);
899 }
900 ++i;
901 }
902
903 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
904 }
905
906 ~ClCreateBufferWithPropertiesTracer() {
907 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
908 }
909
910 private:
911 cl_params_clCreateBufferWithProperties params{};
912 cl_callback_data data{};
913 uint64_t correlationData[tracingMaxHandleCount];
914 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
915 };
916
917 class ClCreateImageWithPropertiesTracer {
918 public:
919 ClCreateImageWithPropertiesTracer() {}
920
921 void enter(cl_context *context,
922 const cl_mem_properties_intel **properties,
923 cl_mem_flags *flags,
924 const cl_image_format **imageFormat,
925 const cl_image_desc **imageDesc,
926 void **hostPtr,
927 cl_int **errcodeRet) {
928 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
929
930 params.context = context;
931 params.properties = properties;
932 params.flags = flags;
933 params.imageFormat = imageFormat;
934 params.imageDesc = imageDesc;
935 params.hostPtr = hostPtr;
936 params.errcodeRet = errcodeRet;
937
938 data.site = CL_CALLBACK_SITE_ENTER;
939 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
940 data.functionName = "clCreateImageWithProperties";
941 data.functionParams = static_cast<const void *>(&params);
942 data.functionReturnValue = nullptr;
943
944 size_t i = 0;
945 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
946 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
947 TracingHandle *handle = tracingHandle[i];
948 DEBUG_BREAK_IF(handle == nullptr);
949 if (handle->getTracingPoint(CL_FUNCTION_clCreateImageWithProperties)) {
950 data.correlationData = correlationData + i;
951 handle->call(CL_FUNCTION_clCreateImageWithProperties, &data);
952 }
953 ++i;
954 }
955
956 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
957 }
958
959 void exit(cl_mem *retVal) {
960 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
961 data.site = CL_CALLBACK_SITE_EXIT;
962 data.functionReturnValue = retVal;
963
964 size_t i = 0;
965 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
966 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
967 TracingHandle *handle = tracingHandle[i];
968 DEBUG_BREAK_IF(handle == nullptr);
969 if (handle->getTracingPoint(CL_FUNCTION_clCreateImageWithProperties)) {
970 data.correlationData = correlationData + i;
971 handle->call(CL_FUNCTION_clCreateImageWithProperties, &data);
972 }
973 ++i;
974 }
975
976 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
977 }
978
979 ~ClCreateImageWithPropertiesTracer() {
980 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
981 }
982
983 private:
984 cl_params_clCreateImageWithProperties params{};
985 cl_callback_data data{};
986 uint64_t correlationData[tracingMaxHandleCount];
987 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
988 };
989
990 class ClCreateImageWithPropertiesINTELTracer {
991 public:
992 ClCreateImageWithPropertiesINTELTracer() {}
993
994 void enter(cl_context *context,
995 const cl_mem_properties_intel **properties,
996 cl_mem_flags *flags,
997 const cl_image_format **imageFormat,
998 const cl_image_desc **imageDesc,
999 void **hostPtr,
1000 cl_int **errcodeRet) {
1001 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1002
1003 params.context = context;
1004 params.properties = properties;
1005 params.flags = flags;
1006 params.imageFormat = imageFormat;
1007 params.imageDesc = imageDesc;
1008 params.hostPtr = hostPtr;
1009 params.errcodeRet = errcodeRet;
1010
1011 data.site = CL_CALLBACK_SITE_ENTER;
1012 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1013 data.functionName = "clCreateImageWithPropertiesINTEL";
1014 data.functionParams = static_cast<const void *>(&params);
1015 data.functionReturnValue = nullptr;
1016
1017 size_t i = 0;
1018 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1019 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1020 TracingHandle *handle = tracingHandle[i];
1021 DEBUG_BREAK_IF(handle == nullptr);
1022 if (handle->getTracingPoint(CL_FUNCTION_clCreateImageWithPropertiesINTEL)) {
1023 data.correlationData = correlationData + i;
1024 handle->call(CL_FUNCTION_clCreateImageWithPropertiesINTEL, &data);
1025 }
1026 ++i;
1027 }
1028
1029 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1030 }
1031
1032 void exit(cl_mem *retVal) {
1033 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1034 data.site = CL_CALLBACK_SITE_EXIT;
1035 data.functionReturnValue = retVal;
1036
1037 size_t i = 0;
1038 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1039 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1040 TracingHandle *handle = tracingHandle[i];
1041 DEBUG_BREAK_IF(handle == nullptr);
1042 if (handle->getTracingPoint(CL_FUNCTION_clCreateImageWithPropertiesINTEL)) {
1043 data.correlationData = correlationData + i;
1044 handle->call(CL_FUNCTION_clCreateImageWithPropertiesINTEL, &data);
1045 }
1046 ++i;
1047 }
1048
1049 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1050 }
1051
1052 ~ClCreateImageWithPropertiesINTELTracer() {
1053 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1054 }
1055
1056 private:
1057 cl_params_clCreateImageWithPropertiesINTEL params{};
1058 cl_callback_data data{};
1059 uint64_t correlationData[tracingMaxHandleCount];
1060 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1061 };
1062
1063 class ClGetImageParamsINTELTracer {
1064 public:
1065 ClGetImageParamsINTELTracer() {}
1066
1067 void enter(cl_context *context,
1068 const cl_image_format **imageFormat,
1069 const cl_image_desc **imageDesc,
1070 size_t **imageRowPitch,
1071 size_t **imageSlicePitch) {
1072 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1073
1074 params.context = context;
1075 params.imageFormat = imageFormat;
1076 params.imageDesc = imageDesc;
1077 params.imageRowPitch = imageRowPitch;
1078 params.imageSlicePitch = imageSlicePitch;
1079
1080 data.site = CL_CALLBACK_SITE_ENTER;
1081 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1082 data.functionName = "clGetImageParamsINTEL";
1083 data.functionParams = static_cast<const void *>(&params);
1084 data.functionReturnValue = nullptr;
1085
1086 size_t i = 0;
1087 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1088 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1089 TracingHandle *handle = tracingHandle[i];
1090 DEBUG_BREAK_IF(handle == nullptr);
1091 if (handle->getTracingPoint(CL_FUNCTION_clGetImageParamsINTEL)) {
1092 data.correlationData = correlationData + i;
1093 handle->call(CL_FUNCTION_clGetImageParamsINTEL, &data);
1094 }
1095 ++i;
1096 }
1097
1098 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1099 }
1100
1101 void exit(cl_int *retVal) {
1102 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1103 data.site = CL_CALLBACK_SITE_EXIT;
1104 data.functionReturnValue = retVal;
1105
1106 size_t i = 0;
1107 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1108 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1109 TracingHandle *handle = tracingHandle[i];
1110 DEBUG_BREAK_IF(handle == nullptr);
1111 if (handle->getTracingPoint(CL_FUNCTION_clGetImageParamsINTEL)) {
1112 data.correlationData = correlationData + i;
1113 handle->call(CL_FUNCTION_clGetImageParamsINTEL, &data);
1114 }
1115 ++i;
1116 }
1117
1118 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1119 }
1120
1121 ~ClGetImageParamsINTELTracer() {
1122 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1123 }
1124
1125 private:
1126 cl_params_clGetImageParamsINTEL params{};
1127 cl_callback_data data{};
1128 uint64_t correlationData[tracingMaxHandleCount];
1129 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1130 };
1131
1132 class ClCreatePerfCountersCommandQueueINTELTracer {
1133 public:
1134 ClCreatePerfCountersCommandQueueINTELTracer() {}
1135
1136 void enter(cl_context *context,
1137 cl_device_id *device,
1138 cl_command_queue_properties *properties,
1139 cl_uint *configuration,
1140 cl_int **errcodeRet) {
1141 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1142
1143 params.context = context;
1144 params.device = device;
1145 params.properties = properties;
1146 params.configuration = configuration;
1147 params.errcodeRet = errcodeRet;
1148
1149 data.site = CL_CALLBACK_SITE_ENTER;
1150 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1151 data.functionName = "clCreatePerfCountersCommandQueueINTEL";
1152 data.functionParams = static_cast<const void *>(&params);
1153 data.functionReturnValue = nullptr;
1154
1155 size_t i = 0;
1156 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1157 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1158 TracingHandle *handle = tracingHandle[i];
1159 DEBUG_BREAK_IF(handle == nullptr);
1160 if (handle->getTracingPoint(CL_FUNCTION_clCreatePerfCountersCommandQueueINTEL)) {
1161 data.correlationData = correlationData + i;
1162 handle->call(CL_FUNCTION_clCreatePerfCountersCommandQueueINTEL, &data);
1163 }
1164 ++i;
1165 }
1166
1167 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1168 }
1169
1170 void exit(cl_command_queue *retVal) {
1171 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1172 data.site = CL_CALLBACK_SITE_EXIT;
1173 data.functionReturnValue = retVal;
1174
1175 size_t i = 0;
1176 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1177 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1178 TracingHandle *handle = tracingHandle[i];
1179 DEBUG_BREAK_IF(handle == nullptr);
1180 if (handle->getTracingPoint(CL_FUNCTION_clCreatePerfCountersCommandQueueINTEL)) {
1181 data.correlationData = correlationData + i;
1182 handle->call(CL_FUNCTION_clCreatePerfCountersCommandQueueINTEL, &data);
1183 }
1184 ++i;
1185 }
1186
1187 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1188 }
1189
1190 ~ClCreatePerfCountersCommandQueueINTELTracer() {
1191 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1192 }
1193
1194 private:
1195 cl_params_clCreatePerfCountersCommandQueueINTEL params{};
1196 cl_callback_data data{};
1197 uint64_t correlationData[tracingMaxHandleCount];
1198 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1199 };
1200
1201 class ClHostMemAllocINTELTracer {
1202 public:
1203 ClHostMemAllocINTELTracer() {}
1204
1205 void enter(cl_context *context,
1206 const cl_mem_properties_intel **properties,
1207 size_t *size,
1208 cl_uint *alignment,
1209 cl_int **errcodeRet) {
1210 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1211
1212 params.context = context;
1213 params.properties = properties;
1214 params.size = size;
1215 params.alignment = alignment;
1216 params.errcodeRet = errcodeRet;
1217
1218 data.site = CL_CALLBACK_SITE_ENTER;
1219 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1220 data.functionName = "clHostMemAllocINTEL";
1221 data.functionParams = static_cast<const void *>(&params);
1222 data.functionReturnValue = nullptr;
1223
1224 size_t i = 0;
1225 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1226 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1227 TracingHandle *handle = tracingHandle[i];
1228 DEBUG_BREAK_IF(handle == nullptr);
1229 if (handle->getTracingPoint(CL_FUNCTION_clHostMemAllocINTEL)) {
1230 data.correlationData = correlationData + i;
1231 handle->call(CL_FUNCTION_clHostMemAllocINTEL, &data);
1232 }
1233 ++i;
1234 }
1235
1236 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1237 }
1238
1239 void exit(void **retVal) {
1240 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1241 data.site = CL_CALLBACK_SITE_EXIT;
1242 data.functionReturnValue = retVal;
1243
1244 size_t i = 0;
1245 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1246 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1247 TracingHandle *handle = tracingHandle[i];
1248 DEBUG_BREAK_IF(handle == nullptr);
1249 if (handle->getTracingPoint(CL_FUNCTION_clHostMemAllocINTEL)) {
1250 data.correlationData = correlationData + i;
1251 handle->call(CL_FUNCTION_clHostMemAllocINTEL, &data);
1252 }
1253 ++i;
1254 }
1255
1256 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1257 }
1258
1259 ~ClHostMemAllocINTELTracer() {
1260 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1261 }
1262
1263 private:
1264 cl_params_clHostMemAllocINTEL params{};
1265 cl_callback_data data{};
1266 uint64_t correlationData[tracingMaxHandleCount];
1267 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1268 };
1269
1270 class ClDeviceMemAllocINTELTracer {
1271 public:
1272 ClDeviceMemAllocINTELTracer() {}
1273
1274 void enter(cl_context *context,
1275 cl_device_id *device,
1276 const cl_mem_properties_intel **properties,
1277 size_t *size,
1278 cl_uint *alignment,
1279 cl_int **errcodeRet) {
1280 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1281
1282 params.context = context;
1283 params.device = device;
1284 params.properties = properties;
1285 params.size = size;
1286 params.alignment = alignment;
1287 params.errcodeRet = errcodeRet;
1288
1289 data.site = CL_CALLBACK_SITE_ENTER;
1290 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1291 data.functionName = "clDeviceMemAllocINTEL";
1292 data.functionParams = static_cast<const void *>(&params);
1293 data.functionReturnValue = nullptr;
1294
1295 size_t i = 0;
1296 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1297 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1298 TracingHandle *handle = tracingHandle[i];
1299 DEBUG_BREAK_IF(handle == nullptr);
1300 if (handle->getTracingPoint(CL_FUNCTION_clDeviceMemAllocINTEL)) {
1301 data.correlationData = correlationData + i;
1302 handle->call(CL_FUNCTION_clDeviceMemAllocINTEL, &data);
1303 }
1304 ++i;
1305 }
1306
1307 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1308 }
1309
1310 void exit(void **retVal) {
1311 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1312 data.site = CL_CALLBACK_SITE_EXIT;
1313 data.functionReturnValue = retVal;
1314
1315 size_t i = 0;
1316 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1317 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1318 TracingHandle *handle = tracingHandle[i];
1319 DEBUG_BREAK_IF(handle == nullptr);
1320 if (handle->getTracingPoint(CL_FUNCTION_clDeviceMemAllocINTEL)) {
1321 data.correlationData = correlationData + i;
1322 handle->call(CL_FUNCTION_clDeviceMemAllocINTEL, &data);
1323 }
1324 ++i;
1325 }
1326
1327 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1328 }
1329
1330 ~ClDeviceMemAllocINTELTracer() {
1331 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1332 }
1333
1334 private:
1335 cl_params_clDeviceMemAllocINTEL params{};
1336 cl_callback_data data{};
1337 uint64_t correlationData[tracingMaxHandleCount];
1338 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1339 };
1340
1341 class ClSharedMemAllocINTELTracer {
1342 public:
1343 ClSharedMemAllocINTELTracer() {}
1344
1345 void enter(cl_context *context,
1346 cl_device_id *device,
1347 const cl_mem_properties_intel **properties,
1348 size_t *size,
1349 cl_uint *alignment,
1350 cl_int **errcodeRet) {
1351 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1352
1353 params.context = context;
1354 params.device = device;
1355 params.properties = properties;
1356 params.size = size;
1357 params.alignment = alignment;
1358 params.errcodeRet = errcodeRet;
1359
1360 data.site = CL_CALLBACK_SITE_ENTER;
1361 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1362 data.functionName = "clSharedMemAllocINTEL";
1363 data.functionParams = static_cast<const void *>(&params);
1364 data.functionReturnValue = nullptr;
1365
1366 size_t i = 0;
1367 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1368 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1369 TracingHandle *handle = tracingHandle[i];
1370 DEBUG_BREAK_IF(handle == nullptr);
1371 if (handle->getTracingPoint(CL_FUNCTION_clSharedMemAllocINTEL)) {
1372 data.correlationData = correlationData + i;
1373 handle->call(CL_FUNCTION_clSharedMemAllocINTEL, &data);
1374 }
1375 ++i;
1376 }
1377
1378 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1379 }
1380
1381 void exit(void **retVal) {
1382 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1383 data.site = CL_CALLBACK_SITE_EXIT;
1384 data.functionReturnValue = retVal;
1385
1386 size_t i = 0;
1387 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1388 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1389 TracingHandle *handle = tracingHandle[i];
1390 DEBUG_BREAK_IF(handle == nullptr);
1391 if (handle->getTracingPoint(CL_FUNCTION_clSharedMemAllocINTEL)) {
1392 data.correlationData = correlationData + i;
1393 handle->call(CL_FUNCTION_clSharedMemAllocINTEL, &data);
1394 }
1395 ++i;
1396 }
1397
1398 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1399 }
1400
1401 ~ClSharedMemAllocINTELTracer() {
1402 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1403 }
1404
1405 private:
1406 cl_params_clSharedMemAllocINTEL params{};
1407 cl_callback_data data{};
1408 uint64_t correlationData[tracingMaxHandleCount];
1409 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1410 };
1411
1412 class ClMemBlockingFreeINTELTracer {
1413 public:
1414 ClMemBlockingFreeINTELTracer() {}
1415
1416 void enter(cl_context *context,
1417 void **ptr) {
1418 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1419
1420 params.context = context;
1421 params.ptr = ptr;
1422
1423 data.site = CL_CALLBACK_SITE_ENTER;
1424 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1425 data.functionName = "clMemBlockingFreeINTEL";
1426 data.functionParams = static_cast<const void *>(&params);
1427 data.functionReturnValue = nullptr;
1428
1429 size_t i = 0;
1430 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1431 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1432 TracingHandle *handle = tracingHandle[i];
1433 DEBUG_BREAK_IF(handle == nullptr);
1434 if (handle->getTracingPoint(CL_FUNCTION_clMemBlockingFreeINTEL)) {
1435 data.correlationData = correlationData + i;
1436 handle->call(CL_FUNCTION_clMemBlockingFreeINTEL, &data);
1437 }
1438 ++i;
1439 }
1440
1441 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1442 }
1443
1444 void exit(cl_int *retVal) {
1445 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1446 data.site = CL_CALLBACK_SITE_EXIT;
1447 data.functionReturnValue = retVal;
1448
1449 size_t i = 0;
1450 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1451 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1452 TracingHandle *handle = tracingHandle[i];
1453 DEBUG_BREAK_IF(handle == nullptr);
1454 if (handle->getTracingPoint(CL_FUNCTION_clMemBlockingFreeINTEL)) {
1455 data.correlationData = correlationData + i;
1456 handle->call(CL_FUNCTION_clMemBlockingFreeINTEL, &data);
1457 }
1458 ++i;
1459 }
1460
1461 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1462 }
1463
1464 ~ClMemBlockingFreeINTELTracer() {
1465 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1466 }
1467
1468 private:
1469 cl_params_clMemBlockingFreeINTEL params{};
1470 cl_callback_data data{};
1471 uint64_t correlationData[tracingMaxHandleCount];
1472 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1473 };
1474
1475 class ClGetMemAllocInfoINTELTracer {
1476 public:
1477 ClGetMemAllocInfoINTELTracer() {}
1478
1479 void enter(cl_context *context,
1480 const void **ptr,
1481 cl_mem_info_intel *paramName,
1482 size_t *paramValueSize,
1483 void **paramValue,
1484 size_t **paramValueSizeRet) {
1485 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1486
1487 params.context = context;
1488 params.ptr = ptr;
1489 params.paramName = paramName;
1490 params.paramValueSize = paramValueSize;
1491 params.paramValue = paramValue;
1492 params.paramValueSizeRet = paramValueSizeRet;
1493
1494 data.site = CL_CALLBACK_SITE_ENTER;
1495 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1496 data.functionName = "clGetMemAllocInfoINTEL";
1497 data.functionParams = static_cast<const void *>(&params);
1498 data.functionReturnValue = nullptr;
1499
1500 size_t i = 0;
1501 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1502 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1503 TracingHandle *handle = tracingHandle[i];
1504 DEBUG_BREAK_IF(handle == nullptr);
1505 if (handle->getTracingPoint(CL_FUNCTION_clGetMemAllocInfoINTEL)) {
1506 data.correlationData = correlationData + i;
1507 handle->call(CL_FUNCTION_clGetMemAllocInfoINTEL, &data);
1508 }
1509 ++i;
1510 }
1511
1512 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1513 }
1514
1515 void exit(cl_int *retVal) {
1516 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1517 data.site = CL_CALLBACK_SITE_EXIT;
1518 data.functionReturnValue = retVal;
1519
1520 size_t i = 0;
1521 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1522 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1523 TracingHandle *handle = tracingHandle[i];
1524 DEBUG_BREAK_IF(handle == nullptr);
1525 if (handle->getTracingPoint(CL_FUNCTION_clGetMemAllocInfoINTEL)) {
1526 data.correlationData = correlationData + i;
1527 handle->call(CL_FUNCTION_clGetMemAllocInfoINTEL, &data);
1528 }
1529 ++i;
1530 }
1531
1532 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1533 }
1534
1535 ~ClGetMemAllocInfoINTELTracer() {
1536 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1537 }
1538
1539 private:
1540 cl_params_clGetMemAllocInfoINTEL params{};
1541 cl_callback_data data{};
1542 uint64_t correlationData[tracingMaxHandleCount];
1543 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1544 };
1545
1546 class ClSetKernelArgMemPointerINTELTracer {
1547 public:
1548 ClSetKernelArgMemPointerINTELTracer() {}
1549
1550 void enter(cl_kernel *kernel,
1551 cl_uint *argIndex,
1552 const void **argValue) {
1553 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1554
1555 params.kernel = kernel;
1556 params.argIndex = argIndex;
1557 params.argValue = argValue;
1558
1559 data.site = CL_CALLBACK_SITE_ENTER;
1560 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1561 data.functionName = "clSetKernelArgMemPointerINTEL";
1562 data.functionParams = static_cast<const void *>(&params);
1563 data.functionReturnValue = nullptr;
1564
1565 size_t i = 0;
1566 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1567 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1568 TracingHandle *handle = tracingHandle[i];
1569 DEBUG_BREAK_IF(handle == nullptr);
1570 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgMemPointerINTEL)) {
1571 data.correlationData = correlationData + i;
1572 handle->call(CL_FUNCTION_clSetKernelArgMemPointerINTEL, &data);
1573 }
1574 ++i;
1575 }
1576
1577 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1578 }
1579
1580 void exit(cl_int *retVal) {
1581 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1582 data.site = CL_CALLBACK_SITE_EXIT;
1583 data.functionReturnValue = retVal;
1584
1585 size_t i = 0;
1586 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1587 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1588 TracingHandle *handle = tracingHandle[i];
1589 DEBUG_BREAK_IF(handle == nullptr);
1590 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgMemPointerINTEL)) {
1591 data.correlationData = correlationData + i;
1592 handle->call(CL_FUNCTION_clSetKernelArgMemPointerINTEL, &data);
1593 }
1594 ++i;
1595 }
1596
1597 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1598 }
1599
1600 ~ClSetKernelArgMemPointerINTELTracer() {
1601 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1602 }
1603
1604 private:
1605 cl_params_clSetKernelArgMemPointerINTEL params{};
1606 cl_callback_data data{};
1607 uint64_t correlationData[tracingMaxHandleCount];
1608 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1609 };
1610
1611 class ClEnqueueMemsetINTELTracer {
1612 public:
1613 ClEnqueueMemsetINTELTracer() {}
1614
1615 void enter(cl_command_queue *commandQueue,
1616 void **dstPtr,
1617 cl_int *value,
1618 size_t *size,
1619 cl_uint *numEventsInWaitList,
1620 const cl_event **eventWaitList,
1621 cl_event **event) {
1622 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1623
1624 params.commandQueue = commandQueue;
1625 params.dstPtr = dstPtr;
1626 params.value = value;
1627 params.size = size;
1628 params.numEventsInWaitList = numEventsInWaitList;
1629 params.eventWaitList = eventWaitList;
1630 params.event = event;
1631
1632 data.site = CL_CALLBACK_SITE_ENTER;
1633 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1634 data.functionName = "clEnqueueMemsetINTEL";
1635 data.functionParams = static_cast<const void *>(&params);
1636 data.functionReturnValue = nullptr;
1637
1638 size_t i = 0;
1639 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1640 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1641 TracingHandle *handle = tracingHandle[i];
1642 DEBUG_BREAK_IF(handle == nullptr);
1643 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemsetINTEL)) {
1644 data.correlationData = correlationData + i;
1645 handle->call(CL_FUNCTION_clEnqueueMemsetINTEL, &data);
1646 }
1647 ++i;
1648 }
1649
1650 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1651 }
1652
1653 void exit(cl_int *retVal) {
1654 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1655 data.site = CL_CALLBACK_SITE_EXIT;
1656 data.functionReturnValue = retVal;
1657
1658 size_t i = 0;
1659 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1660 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1661 TracingHandle *handle = tracingHandle[i];
1662 DEBUG_BREAK_IF(handle == nullptr);
1663 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemsetINTEL)) {
1664 data.correlationData = correlationData + i;
1665 handle->call(CL_FUNCTION_clEnqueueMemsetINTEL, &data);
1666 }
1667 ++i;
1668 }
1669
1670 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1671 }
1672
1673 ~ClEnqueueMemsetINTELTracer() {
1674 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1675 }
1676
1677 private:
1678 cl_params_clEnqueueMemsetINTEL params{};
1679 cl_callback_data data{};
1680 uint64_t correlationData[tracingMaxHandleCount];
1681 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1682 };
1683
1684 class ClEnqueueMemFillINTELTracer {
1685 public:
1686 ClEnqueueMemFillINTELTracer() {}
1687
1688 void enter(cl_command_queue *commandQueue,
1689 void **dstPtr,
1690 const void **pattern,
1691 size_t *patternSize,
1692 size_t *size,
1693 cl_uint *numEventsInWaitList,
1694 const cl_event **eventWaitList,
1695 cl_event **event) {
1696 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1697
1698 params.commandQueue = commandQueue;
1699 params.dstPtr = dstPtr;
1700 params.pattern = pattern;
1701 params.patternSize = patternSize;
1702 params.size = size;
1703 params.numEventsInWaitList = numEventsInWaitList;
1704 params.eventWaitList = eventWaitList;
1705 params.event = event;
1706
1707 data.site = CL_CALLBACK_SITE_ENTER;
1708 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1709 data.functionName = "clEnqueueMemFillINTEL";
1710 data.functionParams = static_cast<const void *>(&params);
1711 data.functionReturnValue = nullptr;
1712
1713 size_t i = 0;
1714 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1715 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1716 TracingHandle *handle = tracingHandle[i];
1717 DEBUG_BREAK_IF(handle == nullptr);
1718 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemFillINTEL)) {
1719 data.correlationData = correlationData + i;
1720 handle->call(CL_FUNCTION_clEnqueueMemFillINTEL, &data);
1721 }
1722 ++i;
1723 }
1724
1725 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1726 }
1727
1728 void exit(cl_int *retVal) {
1729 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1730 data.site = CL_CALLBACK_SITE_EXIT;
1731 data.functionReturnValue = retVal;
1732
1733 size_t i = 0;
1734 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1735 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1736 TracingHandle *handle = tracingHandle[i];
1737 DEBUG_BREAK_IF(handle == nullptr);
1738 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemFillINTEL)) {
1739 data.correlationData = correlationData + i;
1740 handle->call(CL_FUNCTION_clEnqueueMemFillINTEL, &data);
1741 }
1742 ++i;
1743 }
1744
1745 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1746 }
1747
1748 ~ClEnqueueMemFillINTELTracer() {
1749 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1750 }
1751
1752 private:
1753 cl_params_clEnqueueMemFillINTEL params{};
1754 cl_callback_data data{};
1755 uint64_t correlationData[tracingMaxHandleCount];
1756 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1757 };
1758
1759 class ClEnqueueMemcpyINTELTracer {
1760 public:
1761 ClEnqueueMemcpyINTELTracer() {}
1762
1763 void enter(cl_command_queue *commandQueue,
1764 cl_bool *blocking,
1765 void **dstPtr,
1766 const void **srcPtr,
1767 size_t *size,
1768 cl_uint *numEventsInWaitList,
1769 const cl_event **eventWaitList,
1770 cl_event **event) {
1771 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1772
1773 params.commandQueue = commandQueue;
1774 params.blocking = blocking;
1775 params.dstPtr = dstPtr;
1776 params.srcPtr = srcPtr;
1777 params.size = size;
1778 params.numEventsInWaitList = numEventsInWaitList;
1779 params.eventWaitList = eventWaitList;
1780 params.event = event;
1781
1782 data.site = CL_CALLBACK_SITE_ENTER;
1783 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1784 data.functionName = "clEnqueueMemcpyINTEL";
1785 data.functionParams = static_cast<const void *>(&params);
1786 data.functionReturnValue = nullptr;
1787
1788 size_t i = 0;
1789 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1790 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1791 TracingHandle *handle = tracingHandle[i];
1792 DEBUG_BREAK_IF(handle == nullptr);
1793 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemcpyINTEL)) {
1794 data.correlationData = correlationData + i;
1795 handle->call(CL_FUNCTION_clEnqueueMemcpyINTEL, &data);
1796 }
1797 ++i;
1798 }
1799
1800 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1801 }
1802
1803 void exit(cl_int *retVal) {
1804 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1805 data.site = CL_CALLBACK_SITE_EXIT;
1806 data.functionReturnValue = retVal;
1807
1808 size_t i = 0;
1809 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1810 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1811 TracingHandle *handle = tracingHandle[i];
1812 DEBUG_BREAK_IF(handle == nullptr);
1813 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemcpyINTEL)) {
1814 data.correlationData = correlationData + i;
1815 handle->call(CL_FUNCTION_clEnqueueMemcpyINTEL, &data);
1816 }
1817 ++i;
1818 }
1819
1820 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1821 }
1822
1823 ~ClEnqueueMemcpyINTELTracer() {
1824 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1825 }
1826
1827 private:
1828 cl_params_clEnqueueMemcpyINTEL params{};
1829 cl_callback_data data{};
1830 uint64_t correlationData[tracingMaxHandleCount];
1831 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1832 };
1833
1834 class ClEnqueueMigrateMemINTELTracer {
1835 public:
1836 ClEnqueueMigrateMemINTELTracer() {}
1837
1838 void enter(cl_command_queue *commandQueue,
1839 const void **ptr,
1840 size_t *size,
1841 cl_mem_migration_flags *flags,
1842 cl_uint *numEventsInWaitList,
1843 const cl_event **eventWaitList,
1844 cl_event **event) {
1845 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1846
1847 params.commandQueue = commandQueue;
1848 params.ptr = ptr;
1849 params.size = size;
1850 params.flags = flags;
1851 params.numEventsInWaitList = numEventsInWaitList;
1852 params.eventWaitList = eventWaitList;
1853 params.event = event;
1854
1855 data.site = CL_CALLBACK_SITE_ENTER;
1856 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1857 data.functionName = "clEnqueueMigrateMemINTEL";
1858 data.functionParams = static_cast<const void *>(&params);
1859 data.functionReturnValue = nullptr;
1860
1861 size_t i = 0;
1862 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1863 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1864 TracingHandle *handle = tracingHandle[i];
1865 DEBUG_BREAK_IF(handle == nullptr);
1866 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemINTEL)) {
1867 data.correlationData = correlationData + i;
1868 handle->call(CL_FUNCTION_clEnqueueMigrateMemINTEL, &data);
1869 }
1870 ++i;
1871 }
1872
1873 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1874 }
1875
1876 void exit(cl_int *retVal) {
1877 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1878 data.site = CL_CALLBACK_SITE_EXIT;
1879 data.functionReturnValue = retVal;
1880
1881 size_t i = 0;
1882 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1883 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1884 TracingHandle *handle = tracingHandle[i];
1885 DEBUG_BREAK_IF(handle == nullptr);
1886 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemINTEL)) {
1887 data.correlationData = correlationData + i;
1888 handle->call(CL_FUNCTION_clEnqueueMigrateMemINTEL, &data);
1889 }
1890 ++i;
1891 }
1892
1893 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1894 }
1895
1896 ~ClEnqueueMigrateMemINTELTracer() {
1897 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1898 }
1899
1900 private:
1901 cl_params_clEnqueueMigrateMemINTEL params{};
1902 cl_callback_data data{};
1903 uint64_t correlationData[tracingMaxHandleCount];
1904 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1905 };
1906
1907 class ClEnqueueMemAdviseINTELTracer {
1908 public:
1909 ClEnqueueMemAdviseINTELTracer() {}
1910
1911 void enter(cl_command_queue *commandQueue,
1912 const void **ptr,
1913 size_t *size,
1914 cl_mem_advice_intel *advice,
1915 cl_uint *numEventsInWaitList,
1916 const cl_event **eventWaitList,
1917 cl_event **event) {
1918 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1919
1920 params.commandQueue = commandQueue;
1921 params.ptr = ptr;
1922 params.size = size;
1923 params.advice = advice;
1924 params.numEventsInWaitList = numEventsInWaitList;
1925 params.eventWaitList = eventWaitList;
1926 params.event = event;
1927
1928 data.site = CL_CALLBACK_SITE_ENTER;
1929 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1930 data.functionName = "clEnqueueMemAdviseINTEL";
1931 data.functionParams = static_cast<const void *>(&params);
1932 data.functionReturnValue = nullptr;
1933
1934 size_t i = 0;
1935 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1936 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1937 TracingHandle *handle = tracingHandle[i];
1938 DEBUG_BREAK_IF(handle == nullptr);
1939 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemAdviseINTEL)) {
1940 data.correlationData = correlationData + i;
1941 handle->call(CL_FUNCTION_clEnqueueMemAdviseINTEL, &data);
1942 }
1943 ++i;
1944 }
1945
1946 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
1947 }
1948
1949 void exit(cl_int *retVal) {
1950 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
1951 data.site = CL_CALLBACK_SITE_EXIT;
1952 data.functionReturnValue = retVal;
1953
1954 size_t i = 0;
1955 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
1956 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
1957 TracingHandle *handle = tracingHandle[i];
1958 DEBUG_BREAK_IF(handle == nullptr);
1959 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMemAdviseINTEL)) {
1960 data.correlationData = correlationData + i;
1961 handle->call(CL_FUNCTION_clEnqueueMemAdviseINTEL, &data);
1962 }
1963 ++i;
1964 }
1965
1966 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
1967 }
1968
1969 ~ClEnqueueMemAdviseINTELTracer() {
1970 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
1971 }
1972
1973 private:
1974 cl_params_clEnqueueMemAdviseINTEL params{};
1975 cl_callback_data data{};
1976 uint64_t correlationData[tracingMaxHandleCount];
1977 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
1978 };
1979
1980 class ClCreateCommandQueueWithPropertiesKHRTracer {
1981 public:
1982 ClCreateCommandQueueWithPropertiesKHRTracer() {}
1983
1984 void enter(cl_context *context,
1985 cl_device_id *device,
1986 const cl_queue_properties_khr **properties,
1987 cl_int **errcodeRet) {
1988 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
1989
1990 params.context = context;
1991 params.device = device;
1992 params.properties = properties;
1993 params.errcodeRet = errcodeRet;
1994
1995 data.site = CL_CALLBACK_SITE_ENTER;
1996 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
1997 data.functionName = "clCreateCommandQueueWithPropertiesKHR";
1998 data.functionParams = static_cast<const void *>(&params);
1999 data.functionReturnValue = nullptr;
2000
2001 size_t i = 0;
2002 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2003 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2004 TracingHandle *handle = tracingHandle[i];
2005 DEBUG_BREAK_IF(handle == nullptr);
2006 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithPropertiesKHR)) {
2007 data.correlationData = correlationData + i;
2008 handle->call(CL_FUNCTION_clCreateCommandQueueWithPropertiesKHR, &data);
2009 }
2010 ++i;
2011 }
2012
2013 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2014 }
2015
2016 void exit(cl_command_queue *retVal) {
2017 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2018 data.site = CL_CALLBACK_SITE_EXIT;
2019 data.functionReturnValue = retVal;
2020
2021 size_t i = 0;
2022 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2023 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2024 TracingHandle *handle = tracingHandle[i];
2025 DEBUG_BREAK_IF(handle == nullptr);
2026 if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithPropertiesKHR)) {
2027 data.correlationData = correlationData + i;
2028 handle->call(CL_FUNCTION_clCreateCommandQueueWithPropertiesKHR, &data);
2029 }
2030 ++i;
2031 }
2032
2033 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2034 }
2035
2036 ~ClCreateCommandQueueWithPropertiesKHRTracer() {
2037 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2038 }
2039
2040 private:
2041 cl_params_clCreateCommandQueueWithPropertiesKHR params{};
2042 cl_callback_data data{};
2043 uint64_t correlationData[tracingMaxHandleCount];
2044 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2045 };
2046
2047 class ClCreateAcceleratorINTELTracer {
2048 public:
2049 ClCreateAcceleratorINTELTracer() {}
2050
2051 void enter(cl_context *context,
2052 cl_accelerator_type_intel *acceleratorType,
2053 size_t *descriptorSize,
2054 const void **descriptor,
2055 cl_int **errcodeRet) {
2056 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2057
2058 params.context = context;
2059 params.acceleratorType = acceleratorType;
2060 params.descriptorSize = descriptorSize;
2061 params.descriptor = descriptor;
2062 params.errcodeRet = errcodeRet;
2063
2064 data.site = CL_CALLBACK_SITE_ENTER;
2065 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2066 data.functionName = "clCreateAcceleratorINTEL";
2067 data.functionParams = static_cast<const void *>(&params);
2068 data.functionReturnValue = nullptr;
2069
2070 size_t i = 0;
2071 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2072 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2073 TracingHandle *handle = tracingHandle[i];
2074 DEBUG_BREAK_IF(handle == nullptr);
2075 if (handle->getTracingPoint(CL_FUNCTION_clCreateAcceleratorINTEL)) {
2076 data.correlationData = correlationData + i;
2077 handle->call(CL_FUNCTION_clCreateAcceleratorINTEL, &data);
2078 }
2079 ++i;
2080 }
2081
2082 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2083 }
2084
2085 void exit(cl_accelerator_intel *retVal) {
2086 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2087 data.site = CL_CALLBACK_SITE_EXIT;
2088 data.functionReturnValue = retVal;
2089
2090 size_t i = 0;
2091 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2092 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2093 TracingHandle *handle = tracingHandle[i];
2094 DEBUG_BREAK_IF(handle == nullptr);
2095 if (handle->getTracingPoint(CL_FUNCTION_clCreateAcceleratorINTEL)) {
2096 data.correlationData = correlationData + i;
2097 handle->call(CL_FUNCTION_clCreateAcceleratorINTEL, &data);
2098 }
2099 ++i;
2100 }
2101
2102 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2103 }
2104
2105 ~ClCreateAcceleratorINTELTracer() {
2106 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2107 }
2108
2109 private:
2110 cl_params_clCreateAcceleratorINTEL params{};
2111 cl_callback_data data{};
2112 uint64_t correlationData[tracingMaxHandleCount];
2113 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2114 };
2115
2116 class ClRetainAcceleratorINTELTracer {
2117 public:
2118 ClRetainAcceleratorINTELTracer() {}
2119
2120 void enter(cl_accelerator_intel *accelerator) {
2121 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2122
2123 params.accelerator = accelerator;
2124
2125 data.site = CL_CALLBACK_SITE_ENTER;
2126 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2127 data.functionName = "clRetainAcceleratorINTEL";
2128 data.functionParams = static_cast<const void *>(&params);
2129 data.functionReturnValue = nullptr;
2130
2131 size_t i = 0;
2132 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2133 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2134 TracingHandle *handle = tracingHandle[i];
2135 DEBUG_BREAK_IF(handle == nullptr);
2136 if (handle->getTracingPoint(CL_FUNCTION_clRetainAcceleratorINTEL)) {
2137 data.correlationData = correlationData + i;
2138 handle->call(CL_FUNCTION_clRetainAcceleratorINTEL, &data);
2139 }
2140 ++i;
2141 }
2142
2143 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2144 }
2145
2146 void exit(cl_int *retVal) {
2147 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2148 data.site = CL_CALLBACK_SITE_EXIT;
2149 data.functionReturnValue = retVal;
2150
2151 size_t i = 0;
2152 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2153 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2154 TracingHandle *handle = tracingHandle[i];
2155 DEBUG_BREAK_IF(handle == nullptr);
2156 if (handle->getTracingPoint(CL_FUNCTION_clRetainAcceleratorINTEL)) {
2157 data.correlationData = correlationData + i;
2158 handle->call(CL_FUNCTION_clRetainAcceleratorINTEL, &data);
2159 }
2160 ++i;
2161 }
2162
2163 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2164 }
2165
2166 ~ClRetainAcceleratorINTELTracer() {
2167 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2168 }
2169
2170 private:
2171 cl_params_clRetainAcceleratorINTEL params{};
2172 cl_callback_data data{};
2173 uint64_t correlationData[tracingMaxHandleCount];
2174 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2175 };
2176
2177 class ClGetAcceleratorInfoINTELTracer {
2178 public:
2179 ClGetAcceleratorInfoINTELTracer() {}
2180
2181 void enter(cl_accelerator_intel *accelerator,
2182 cl_accelerator_info_intel *paramName,
2183 size_t *paramValueSize,
2184 void **paramValue,
2185 size_t **paramValueSizeRet) {
2186 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2187
2188 params.accelerator = accelerator;
2189 params.paramName = paramName;
2190 params.paramValueSize = paramValueSize;
2191 params.paramValue = paramValue;
2192 params.paramValueSizeRet = paramValueSizeRet;
2193
2194 data.site = CL_CALLBACK_SITE_ENTER;
2195 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2196 data.functionName = "clGetAcceleratorInfoINTEL";
2197 data.functionParams = static_cast<const void *>(&params);
2198 data.functionReturnValue = nullptr;
2199
2200 size_t i = 0;
2201 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2202 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2203 TracingHandle *handle = tracingHandle[i];
2204 DEBUG_BREAK_IF(handle == nullptr);
2205 if (handle->getTracingPoint(CL_FUNCTION_clGetAcceleratorInfoINTEL)) {
2206 data.correlationData = correlationData + i;
2207 handle->call(CL_FUNCTION_clGetAcceleratorInfoINTEL, &data);
2208 }
2209 ++i;
2210 }
2211
2212 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2213 }
2214
2215 void exit(cl_int *retVal) {
2216 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2217 data.site = CL_CALLBACK_SITE_EXIT;
2218 data.functionReturnValue = retVal;
2219
2220 size_t i = 0;
2221 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2222 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2223 TracingHandle *handle = tracingHandle[i];
2224 DEBUG_BREAK_IF(handle == nullptr);
2225 if (handle->getTracingPoint(CL_FUNCTION_clGetAcceleratorInfoINTEL)) {
2226 data.correlationData = correlationData + i;
2227 handle->call(CL_FUNCTION_clGetAcceleratorInfoINTEL, &data);
2228 }
2229 ++i;
2230 }
2231
2232 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2233 }
2234
2235 ~ClGetAcceleratorInfoINTELTracer() {
2236 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2237 }
2238
2239 private:
2240 cl_params_clGetAcceleratorInfoINTEL params{};
2241 cl_callback_data data{};
2242 uint64_t correlationData[tracingMaxHandleCount];
2243 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2244 };
2245
2246 class ClReleaseAcceleratorINTELTracer {
2247 public:
2248 ClReleaseAcceleratorINTELTracer() {}
2249
2250 void enter(cl_accelerator_intel *accelerator) {
2251 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2252
2253 params.accelerator = accelerator;
2254
2255 data.site = CL_CALLBACK_SITE_ENTER;
2256 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2257 data.functionName = "clReleaseAcceleratorINTEL";
2258 data.functionParams = static_cast<const void *>(&params);
2259 data.functionReturnValue = nullptr;
2260
2261 size_t i = 0;
2262 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2263 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2264 TracingHandle *handle = tracingHandle[i];
2265 DEBUG_BREAK_IF(handle == nullptr);
2266 if (handle->getTracingPoint(CL_FUNCTION_clReleaseAcceleratorINTEL)) {
2267 data.correlationData = correlationData + i;
2268 handle->call(CL_FUNCTION_clReleaseAcceleratorINTEL, &data);
2269 }
2270 ++i;
2271 }
2272
2273 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2274 }
2275
2276 void exit(cl_int *retVal) {
2277 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2278 data.site = CL_CALLBACK_SITE_EXIT;
2279 data.functionReturnValue = retVal;
2280
2281 size_t i = 0;
2282 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2283 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2284 TracingHandle *handle = tracingHandle[i];
2285 DEBUG_BREAK_IF(handle == nullptr);
2286 if (handle->getTracingPoint(CL_FUNCTION_clReleaseAcceleratorINTEL)) {
2287 data.correlationData = correlationData + i;
2288 handle->call(CL_FUNCTION_clReleaseAcceleratorINTEL, &data);
2289 }
2290 ++i;
2291 }
2292
2293 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2294 }
2295
2296 ~ClReleaseAcceleratorINTELTracer() {
2297 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2298 }
2299
2300 private:
2301 cl_params_clReleaseAcceleratorINTEL params{};
2302 cl_callback_data data{};
2303 uint64_t correlationData[tracingMaxHandleCount];
2304 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2305 };
2306
2307 class ClCreateProgramWithILKHRTracer {
2308 public:
2309 ClCreateProgramWithILKHRTracer() {}
2310
2311 void enter(cl_context *context,
2312 const void **il,
2313 size_t *length,
2314 cl_int **errcodeRet) {
2315 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2316
2317 params.context = context;
2318 params.il = il;
2319 params.length = length;
2320 params.errcodeRet = errcodeRet;
2321
2322 data.site = CL_CALLBACK_SITE_ENTER;
2323 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2324 data.functionName = "clCreateProgramWithILKHR";
2325 data.functionParams = static_cast<const void *>(&params);
2326 data.functionReturnValue = nullptr;
2327
2328 size_t i = 0;
2329 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2330 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2331 TracingHandle *handle = tracingHandle[i];
2332 DEBUG_BREAK_IF(handle == nullptr);
2333 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithILKHR)) {
2334 data.correlationData = correlationData + i;
2335 handle->call(CL_FUNCTION_clCreateProgramWithILKHR, &data);
2336 }
2337 ++i;
2338 }
2339
2340 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2341 }
2342
2343 void exit(cl_program *retVal) {
2344 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2345 data.site = CL_CALLBACK_SITE_EXIT;
2346 data.functionReturnValue = retVal;
2347
2348 size_t i = 0;
2349 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2350 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2351 TracingHandle *handle = tracingHandle[i];
2352 DEBUG_BREAK_IF(handle == nullptr);
2353 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithILKHR)) {
2354 data.correlationData = correlationData + i;
2355 handle->call(CL_FUNCTION_clCreateProgramWithILKHR, &data);
2356 }
2357 ++i;
2358 }
2359
2360 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2361 }
2362
2363 ~ClCreateProgramWithILKHRTracer() {
2364 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2365 }
2366
2367 private:
2368 cl_params_clCreateProgramWithILKHR params{};
2369 cl_callback_data data{};
2370 uint64_t correlationData[tracingMaxHandleCount];
2371 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2372 };
2373
2374 class ClGetKernelSuggestedLocalWorkSizeKHRTracer {
2375 public:
2376 ClGetKernelSuggestedLocalWorkSizeKHRTracer() {}
2377
2378 void enter(cl_command_queue *commandQueue,
2379 cl_kernel *kernel,
2380 cl_uint *workDim,
2381 const size_t **globalWorkOffset,
2382 const size_t **globalWorkSize,
2383 size_t **suggestedLocalWorkSize) {
2384 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2385
2386 params.commandQueue = commandQueue;
2387 params.kernel = kernel;
2388 params.workDim = workDim;
2389 params.globalWorkOffset = globalWorkOffset;
2390 params.globalWorkSize = globalWorkSize;
2391 params.suggestedLocalWorkSize = suggestedLocalWorkSize;
2392
2393 data.site = CL_CALLBACK_SITE_ENTER;
2394 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2395 data.functionName = "clGetKernelSuggestedLocalWorkSizeKHR";
2396 data.functionParams = static_cast<const void *>(&params);
2397 data.functionReturnValue = nullptr;
2398
2399 size_t i = 0;
2400 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2401 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2402 TracingHandle *handle = tracingHandle[i];
2403 DEBUG_BREAK_IF(handle == nullptr);
2404 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeKHR)) {
2405 data.correlationData = correlationData + i;
2406 handle->call(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeKHR, &data);
2407 }
2408 ++i;
2409 }
2410
2411 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2412 }
2413
2414 void exit(cl_int *retVal) {
2415 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2416 data.site = CL_CALLBACK_SITE_EXIT;
2417 data.functionReturnValue = retVal;
2418
2419 size_t i = 0;
2420 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2421 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2422 TracingHandle *handle = tracingHandle[i];
2423 DEBUG_BREAK_IF(handle == nullptr);
2424 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeKHR)) {
2425 data.correlationData = correlationData + i;
2426 handle->call(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeKHR, &data);
2427 }
2428 ++i;
2429 }
2430
2431 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2432 }
2433
2434 ~ClGetKernelSuggestedLocalWorkSizeKHRTracer() {
2435 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2436 }
2437
2438 private:
2439 cl_params_clGetKernelSuggestedLocalWorkSizeKHR params{};
2440 cl_callback_data data{};
2441 uint64_t correlationData[tracingMaxHandleCount];
2442 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2443 };
2444
2445 class ClGetKernelSubGroupInfoKHRTracer {
2446 public:
2447 ClGetKernelSubGroupInfoKHRTracer() {}
2448
2449 void enter(cl_kernel *kernel,
2450 cl_device_id *device,
2451 cl_kernel_sub_group_info *paramName,
2452 size_t *inputValueSize,
2453 const void **inputValue,
2454 size_t *paramValueSize,
2455 void **paramValue,
2456 size_t **paramValueSizeRet) {
2457 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2458
2459 params.kernel = kernel;
2460 params.device = device;
2461 params.paramName = paramName;
2462 params.inputValueSize = inputValueSize;
2463 params.inputValue = inputValue;
2464 params.paramValueSize = paramValueSize;
2465 params.paramValue = paramValue;
2466 params.paramValueSizeRet = paramValueSizeRet;
2467
2468 data.site = CL_CALLBACK_SITE_ENTER;
2469 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2470 data.functionName = "clGetKernelSubGroupInfoKHR";
2471 data.functionParams = static_cast<const void *>(&params);
2472 data.functionReturnValue = nullptr;
2473
2474 size_t i = 0;
2475 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2476 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2477 TracingHandle *handle = tracingHandle[i];
2478 DEBUG_BREAK_IF(handle == nullptr);
2479 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfoKHR)) {
2480 data.correlationData = correlationData + i;
2481 handle->call(CL_FUNCTION_clGetKernelSubGroupInfoKHR, &data);
2482 }
2483 ++i;
2484 }
2485
2486 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2487 }
2488
2489 void exit(cl_int *retVal) {
2490 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2491 data.site = CL_CALLBACK_SITE_EXIT;
2492 data.functionReturnValue = retVal;
2493
2494 size_t i = 0;
2495 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2496 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2497 TracingHandle *handle = tracingHandle[i];
2498 DEBUG_BREAK_IF(handle == nullptr);
2499 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfoKHR)) {
2500 data.correlationData = correlationData + i;
2501 handle->call(CL_FUNCTION_clGetKernelSubGroupInfoKHR, &data);
2502 }
2503 ++i;
2504 }
2505
2506 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2507 }
2508
2509 ~ClGetKernelSubGroupInfoKHRTracer() {
2510 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2511 }
2512
2513 private:
2514 cl_params_clGetKernelSubGroupInfoKHR params{};
2515 cl_callback_data data{};
2516 uint64_t correlationData[tracingMaxHandleCount];
2517 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2518 };
2519
2520 class ClEnqueueVerifyMemoryINTELTracer {
2521 public:
2522 ClEnqueueVerifyMemoryINTELTracer() {}
2523
2524 void enter(cl_command_queue *commandQueue,
2525 const void **allocationPtr,
2526 const void **expectedData,
2527 size_t *sizeOfComparison,
2528 cl_uint *comparisonMode) {
2529 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2530
2531 params.commandQueue = commandQueue;
2532 params.allocationPtr = allocationPtr;
2533 params.expectedData = expectedData;
2534 params.sizeOfComparison = sizeOfComparison;
2535 params.comparisonMode = comparisonMode;
2536
2537 data.site = CL_CALLBACK_SITE_ENTER;
2538 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2539 data.functionName = "clEnqueueVerifyMemoryINTEL";
2540 data.functionParams = static_cast<const void *>(&params);
2541 data.functionReturnValue = nullptr;
2542
2543 size_t i = 0;
2544 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2545 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2546 TracingHandle *handle = tracingHandle[i];
2547 DEBUG_BREAK_IF(handle == nullptr);
2548 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueVerifyMemoryINTEL)) {
2549 data.correlationData = correlationData + i;
2550 handle->call(CL_FUNCTION_clEnqueueVerifyMemoryINTEL, &data);
2551 }
2552 ++i;
2553 }
2554
2555 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2556 }
2557
2558 void exit(cl_int *retVal) {
2559 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2560 data.site = CL_CALLBACK_SITE_EXIT;
2561 data.functionReturnValue = retVal;
2562
2563 size_t i = 0;
2564 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2565 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2566 TracingHandle *handle = tracingHandle[i];
2567 DEBUG_BREAK_IF(handle == nullptr);
2568 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueVerifyMemoryINTEL)) {
2569 data.correlationData = correlationData + i;
2570 handle->call(CL_FUNCTION_clEnqueueVerifyMemoryINTEL, &data);
2571 }
2572 ++i;
2573 }
2574
2575 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2576 }
2577
2578 ~ClEnqueueVerifyMemoryINTELTracer() {
2579 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2580 }
2581
2582 private:
2583 cl_params_clEnqueueVerifyMemoryINTEL params{};
2584 cl_callback_data data{};
2585 uint64_t correlationData[tracingMaxHandleCount];
2586 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2587 };
2588
2589 class ClAddCommentINTELTracer {
2590 public:
2591 ClAddCommentINTELTracer() {}
2592
2593 void enter(cl_device_id *device,
2594 const char **comment) {
2595 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2596
2597 params.device = device;
2598 params.comment = comment;
2599
2600 data.site = CL_CALLBACK_SITE_ENTER;
2601 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2602 data.functionName = "clAddCommentINTEL";
2603 data.functionParams = static_cast<const void *>(&params);
2604 data.functionReturnValue = nullptr;
2605
2606 size_t i = 0;
2607 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2608 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2609 TracingHandle *handle = tracingHandle[i];
2610 DEBUG_BREAK_IF(handle == nullptr);
2611 if (handle->getTracingPoint(CL_FUNCTION_clAddCommentINTEL)) {
2612 data.correlationData = correlationData + i;
2613 handle->call(CL_FUNCTION_clAddCommentINTEL, &data);
2614 }
2615 ++i;
2616 }
2617
2618 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2619 }
2620
2621 void exit(cl_int *retVal) {
2622 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2623 data.site = CL_CALLBACK_SITE_EXIT;
2624 data.functionReturnValue = retVal;
2625
2626 size_t i = 0;
2627 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2628 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2629 TracingHandle *handle = tracingHandle[i];
2630 DEBUG_BREAK_IF(handle == nullptr);
2631 if (handle->getTracingPoint(CL_FUNCTION_clAddCommentINTEL)) {
2632 data.correlationData = correlationData + i;
2633 handle->call(CL_FUNCTION_clAddCommentINTEL, &data);
2634 }
2635 ++i;
2636 }
2637
2638 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2639 }
2640
2641 ~ClAddCommentINTELTracer() {
2642 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2643 }
2644
2645 private:
2646 cl_params_clAddCommentINTEL params{};
2647 cl_callback_data data{};
2648 uint64_t correlationData[tracingMaxHandleCount];
2649 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2650 };
2651
2652 class ClGetDeviceGlobalVariablePointerINTELTracer {
2653 public:
2654 ClGetDeviceGlobalVariablePointerINTELTracer() {}
2655
2656 void enter(cl_device_id *device,
2657 cl_program *program,
2658 const char **globalVariableName,
2659 size_t **globalVariableSizeRet,
2660 void ***globalVariablePointerRet) {
2661 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2662
2663 params.device = device;
2664 params.program = program;
2665 params.globalVariableName = globalVariableName;
2666 params.globalVariableSizeRet = globalVariableSizeRet;
2667 params.globalVariablePointerRet = globalVariablePointerRet;
2668
2669 data.site = CL_CALLBACK_SITE_ENTER;
2670 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2671 data.functionName = "clGetDeviceGlobalVariablePointerINTEL";
2672 data.functionParams = static_cast<const void *>(&params);
2673 data.functionReturnValue = nullptr;
2674
2675 size_t i = 0;
2676 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2677 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2678 TracingHandle *handle = tracingHandle[i];
2679 DEBUG_BREAK_IF(handle == nullptr);
2680 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceGlobalVariablePointerINTEL)) {
2681 data.correlationData = correlationData + i;
2682 handle->call(CL_FUNCTION_clGetDeviceGlobalVariablePointerINTEL, &data);
2683 }
2684 ++i;
2685 }
2686
2687 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2688 }
2689
2690 void exit(cl_int *retVal) {
2691 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2692 data.site = CL_CALLBACK_SITE_EXIT;
2693 data.functionReturnValue = retVal;
2694
2695 size_t i = 0;
2696 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2697 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2698 TracingHandle *handle = tracingHandle[i];
2699 DEBUG_BREAK_IF(handle == nullptr);
2700 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceGlobalVariablePointerINTEL)) {
2701 data.correlationData = correlationData + i;
2702 handle->call(CL_FUNCTION_clGetDeviceGlobalVariablePointerINTEL, &data);
2703 }
2704 ++i;
2705 }
2706
2707 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2708 }
2709
2710 ~ClGetDeviceGlobalVariablePointerINTELTracer() {
2711 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2712 }
2713
2714 private:
2715 cl_params_clGetDeviceGlobalVariablePointerINTEL params{};
2716 cl_callback_data data{};
2717 uint64_t correlationData[tracingMaxHandleCount];
2718 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2719 };
2720
2721 class ClGetDeviceFunctionPointerINTELTracer {
2722 public:
2723 ClGetDeviceFunctionPointerINTELTracer() {}
2724
2725 void enter(cl_device_id *device,
2726 cl_program *program,
2727 const char **functionName,
2728 cl_ulong **functionPointerRet) {
2729 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2730
2731 params.device = device;
2732 params.program = program;
2733 params.functionName = functionName;
2734 params.functionPointerRet = functionPointerRet;
2735
2736 data.site = CL_CALLBACK_SITE_ENTER;
2737 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2738 data.functionName = "clGetDeviceFunctionPointerINTEL";
2739 data.functionParams = static_cast<const void *>(&params);
2740 data.functionReturnValue = nullptr;
2741
2742 size_t i = 0;
2743 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2744 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2745 TracingHandle *handle = tracingHandle[i];
2746 DEBUG_BREAK_IF(handle == nullptr);
2747 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceFunctionPointerINTEL)) {
2748 data.correlationData = correlationData + i;
2749 handle->call(CL_FUNCTION_clGetDeviceFunctionPointerINTEL, &data);
2750 }
2751 ++i;
2752 }
2753
2754 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2755 }
2756
2757 void exit(cl_int *retVal) {
2758 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2759 data.site = CL_CALLBACK_SITE_EXIT;
2760 data.functionReturnValue = retVal;
2761
2762 size_t i = 0;
2763 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2764 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2765 TracingHandle *handle = tracingHandle[i];
2766 DEBUG_BREAK_IF(handle == nullptr);
2767 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceFunctionPointerINTEL)) {
2768 data.correlationData = correlationData + i;
2769 handle->call(CL_FUNCTION_clGetDeviceFunctionPointerINTEL, &data);
2770 }
2771 ++i;
2772 }
2773
2774 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2775 }
2776
2777 ~ClGetDeviceFunctionPointerINTELTracer() {
2778 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2779 }
2780
2781 private:
2782 cl_params_clGetDeviceFunctionPointerINTEL params{};
2783 cl_callback_data data{};
2784 uint64_t correlationData[tracingMaxHandleCount];
2785 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2786 };
2787
2788 class ClSetProgramReleaseCallbackTracer {
2789 public:
2790 ClSetProgramReleaseCallbackTracer() {}
2791
2792 void enter(cl_program *program,
2793 void(CL_CALLBACK **pfnNotify)(cl_program, void *),
2794 void **userData) {
2795 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2796
2797 params.program = program;
2798 params.pfnNotify = pfnNotify;
2799 params.userData = userData;
2800
2801 data.site = CL_CALLBACK_SITE_ENTER;
2802 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2803 data.functionName = "clSetProgramReleaseCallback";
2804 data.functionParams = static_cast<const void *>(&params);
2805 data.functionReturnValue = nullptr;
2806
2807 size_t i = 0;
2808 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2809 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2810 TracingHandle *handle = tracingHandle[i];
2811 DEBUG_BREAK_IF(handle == nullptr);
2812 if (handle->getTracingPoint(CL_FUNCTION_clSetProgramReleaseCallback)) {
2813 data.correlationData = correlationData + i;
2814 handle->call(CL_FUNCTION_clSetProgramReleaseCallback, &data);
2815 }
2816 ++i;
2817 }
2818
2819 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2820 }
2821
2822 void exit(cl_int *retVal) {
2823 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2824 data.site = CL_CALLBACK_SITE_EXIT;
2825 data.functionReturnValue = retVal;
2826
2827 size_t i = 0;
2828 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2829 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2830 TracingHandle *handle = tracingHandle[i];
2831 DEBUG_BREAK_IF(handle == nullptr);
2832 if (handle->getTracingPoint(CL_FUNCTION_clSetProgramReleaseCallback)) {
2833 data.correlationData = correlationData + i;
2834 handle->call(CL_FUNCTION_clSetProgramReleaseCallback, &data);
2835 }
2836 ++i;
2837 }
2838
2839 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2840 }
2841
2842 ~ClSetProgramReleaseCallbackTracer() {
2843 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2844 }
2845
2846 private:
2847 cl_params_clSetProgramReleaseCallback params{};
2848 cl_callback_data data{};
2849 uint64_t correlationData[tracingMaxHandleCount];
2850 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2851 };
2852
2853 class ClSetProgramSpecializationConstantTracer {
2854 public:
2855 ClSetProgramSpecializationConstantTracer() {}
2856
2857 void enter(cl_program *program,
2858 cl_uint *specId,
2859 size_t *specSize,
2860 const void **specValue) {
2861 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2862
2863 params.program = program;
2864 params.specId = specId;
2865 params.specSize = specSize;
2866 params.specValue = specValue;
2867
2868 data.site = CL_CALLBACK_SITE_ENTER;
2869 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2870 data.functionName = "clSetProgramSpecializationConstant";
2871 data.functionParams = static_cast<const void *>(&params);
2872 data.functionReturnValue = nullptr;
2873
2874 size_t i = 0;
2875 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2876 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2877 TracingHandle *handle = tracingHandle[i];
2878 DEBUG_BREAK_IF(handle == nullptr);
2879 if (handle->getTracingPoint(CL_FUNCTION_clSetProgramSpecializationConstant)) {
2880 data.correlationData = correlationData + i;
2881 handle->call(CL_FUNCTION_clSetProgramSpecializationConstant, &data);
2882 }
2883 ++i;
2884 }
2885
2886 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2887 }
2888
2889 void exit(cl_int *retVal) {
2890 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2891 data.site = CL_CALLBACK_SITE_EXIT;
2892 data.functionReturnValue = retVal;
2893
2894 size_t i = 0;
2895 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2896 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2897 TracingHandle *handle = tracingHandle[i];
2898 DEBUG_BREAK_IF(handle == nullptr);
2899 if (handle->getTracingPoint(CL_FUNCTION_clSetProgramSpecializationConstant)) {
2900 data.correlationData = correlationData + i;
2901 handle->call(CL_FUNCTION_clSetProgramSpecializationConstant, &data);
2902 }
2903 ++i;
2904 }
2905
2906 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2907 }
2908
2909 ~ClSetProgramSpecializationConstantTracer() {
2910 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2911 }
2912
2913 private:
2914 cl_params_clSetProgramSpecializationConstant params{};
2915 cl_callback_data data{};
2916 uint64_t correlationData[tracingMaxHandleCount];
2917 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2918 };
2919
2920 class ClGetKernelSuggestedLocalWorkSizeINTELTracer {
2921 public:
2922 ClGetKernelSuggestedLocalWorkSizeINTELTracer() {}
2923
2924 void enter(cl_command_queue *commandQueue,
2925 cl_kernel *kernel,
2926 cl_uint *workDim,
2927 const size_t **globalWorkOffset,
2928 const size_t **globalWorkSize,
2929 size_t **suggestedLocalWorkSize) {
2930 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
2931
2932 params.commandQueue = commandQueue;
2933 params.kernel = kernel;
2934 params.workDim = workDim;
2935 params.globalWorkOffset = globalWorkOffset;
2936 params.globalWorkSize = globalWorkSize;
2937 params.suggestedLocalWorkSize = suggestedLocalWorkSize;
2938
2939 data.site = CL_CALLBACK_SITE_ENTER;
2940 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
2941 data.functionName = "clGetKernelSuggestedLocalWorkSizeINTEL";
2942 data.functionParams = static_cast<const void *>(&params);
2943 data.functionReturnValue = nullptr;
2944
2945 size_t i = 0;
2946 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2947 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2948 TracingHandle *handle = tracingHandle[i];
2949 DEBUG_BREAK_IF(handle == nullptr);
2950 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeINTEL)) {
2951 data.correlationData = correlationData + i;
2952 handle->call(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeINTEL, &data);
2953 }
2954 ++i;
2955 }
2956
2957 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
2958 }
2959
2960 void exit(cl_int *retVal) {
2961 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
2962 data.site = CL_CALLBACK_SITE_EXIT;
2963 data.functionReturnValue = retVal;
2964
2965 size_t i = 0;
2966 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
2967 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
2968 TracingHandle *handle = tracingHandle[i];
2969 DEBUG_BREAK_IF(handle == nullptr);
2970 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeINTEL)) {
2971 data.correlationData = correlationData + i;
2972 handle->call(CL_FUNCTION_clGetKernelSuggestedLocalWorkSizeINTEL, &data);
2973 }
2974 ++i;
2975 }
2976
2977 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
2978 }
2979
2980 ~ClGetKernelSuggestedLocalWorkSizeINTELTracer() {
2981 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
2982 }
2983
2984 private:
2985 cl_params_clGetKernelSuggestedLocalWorkSizeINTEL params{};
2986 cl_callback_data data{};
2987 uint64_t correlationData[tracingMaxHandleCount];
2988 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
2989 };
2990
2991 class ClGetKernelMaxConcurrentWorkGroupCountINTELTracer {
2992 public:
2993 ClGetKernelMaxConcurrentWorkGroupCountINTELTracer() {}
2994
2995 void enter(cl_command_queue *commandQueue,
2996 cl_kernel *kernel,
2997 cl_uint *workDim,
2998 const size_t **globalWorkOffset,
2999 const size_t **localWorkSize,
3000 size_t **suggestedWorkGroupCount) {
3001 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3002
3003 params.commandQueue = commandQueue;
3004 params.kernel = kernel;
3005 params.workDim = workDim;
3006 params.globalWorkOffset = globalWorkOffset;
3007 params.localWorkSize = localWorkSize;
3008 params.suggestedWorkGroupCount = suggestedWorkGroupCount;
3009
3010 data.site = CL_CALLBACK_SITE_ENTER;
3011 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3012 data.functionName = "clGetKernelMaxConcurrentWorkGroupCountINTEL";
3013 data.functionParams = static_cast<const void *>(&params);
3014 data.functionReturnValue = nullptr;
3015
3016 size_t i = 0;
3017 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3018 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3019 TracingHandle *handle = tracingHandle[i];
3020 DEBUG_BREAK_IF(handle == nullptr);
3021 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelMaxConcurrentWorkGroupCountINTEL)) {
3022 data.correlationData = correlationData + i;
3023 handle->call(CL_FUNCTION_clGetKernelMaxConcurrentWorkGroupCountINTEL, &data);
3024 }
3025 ++i;
3026 }
3027
3028 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3029 }
3030
3031 void exit(cl_int *retVal) {
3032 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3033 data.site = CL_CALLBACK_SITE_EXIT;
3034 data.functionReturnValue = retVal;
3035
3036 size_t i = 0;
3037 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3038 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3039 TracingHandle *handle = tracingHandle[i];
3040 DEBUG_BREAK_IF(handle == nullptr);
3041 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelMaxConcurrentWorkGroupCountINTEL)) {
3042 data.correlationData = correlationData + i;
3043 handle->call(CL_FUNCTION_clGetKernelMaxConcurrentWorkGroupCountINTEL, &data);
3044 }
3045 ++i;
3046 }
3047
3048 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3049 }
3050
3051 ~ClGetKernelMaxConcurrentWorkGroupCountINTELTracer() {
3052 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3053 }
3054
3055 private:
3056 cl_params_clGetKernelMaxConcurrentWorkGroupCountINTEL params{};
3057 cl_callback_data data{};
3058 uint64_t correlationData[tracingMaxHandleCount];
3059 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3060 };
3061
3062 class ClEnqueueNDCountKernelINTELTracer {
3063 public:
3064 ClEnqueueNDCountKernelINTELTracer() {}
3065
3066 void enter(cl_command_queue *commandQueue,
3067 cl_kernel *kernel,
3068 cl_uint *workDim,
3069 const size_t **globalWorkOffset,
3070 const size_t **workgroupCount,
3071 const size_t **localWorkSize,
3072 cl_uint *numEventsInWaitList,
3073 const cl_event **eventWaitList,
3074 cl_event **event) {
3075 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3076
3077 params.commandQueue = commandQueue;
3078 params.kernel = kernel;
3079 params.workDim = workDim;
3080 params.globalWorkOffset = globalWorkOffset;
3081 params.workgroupCount = workgroupCount;
3082 params.localWorkSize = localWorkSize;
3083 params.numEventsInWaitList = numEventsInWaitList;
3084 params.eventWaitList = eventWaitList;
3085 params.event = event;
3086
3087 data.site = CL_CALLBACK_SITE_ENTER;
3088 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3089 data.functionName = "clEnqueueNDCountKernelINTEL";
3090 data.functionParams = static_cast<const void *>(&params);
3091 data.functionReturnValue = nullptr;
3092
3093 size_t i = 0;
3094 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3095 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3096 TracingHandle *handle = tracingHandle[i];
3097 DEBUG_BREAK_IF(handle == nullptr);
3098 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDCountKernelINTEL)) {
3099 data.correlationData = correlationData + i;
3100 handle->call(CL_FUNCTION_clEnqueueNDCountKernelINTEL, &data);
3101 }
3102 ++i;
3103 }
3104
3105 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3106 }
3107
3108 void exit(cl_int *retVal) {
3109 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3110 data.site = CL_CALLBACK_SITE_EXIT;
3111 data.functionReturnValue = retVal;
3112
3113 size_t i = 0;
3114 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3115 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3116 TracingHandle *handle = tracingHandle[i];
3117 DEBUG_BREAK_IF(handle == nullptr);
3118 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDCountKernelINTEL)) {
3119 data.correlationData = correlationData + i;
3120 handle->call(CL_FUNCTION_clEnqueueNDCountKernelINTEL, &data);
3121 }
3122 ++i;
3123 }
3124
3125 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3126 }
3127
3128 ~ClEnqueueNDCountKernelINTELTracer() {
3129 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3130 }
3131
3132 private:
3133 cl_params_clEnqueueNDCountKernelINTEL params{};
3134 cl_callback_data data{};
3135 uint64_t correlationData[tracingMaxHandleCount];
3136 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3137 };
3138
3139 class ClSetContextDestructorCallbackTracer {
3140 public:
3141 ClSetContextDestructorCallbackTracer() {}
3142
3143 void enter(cl_context *context,
3144 void(CL_CALLBACK **pfnNotify)(cl_context, void *),
3145 void **userData) {
3146 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3147
3148 params.context = context;
3149 params.pfnNotify = pfnNotify;
3150 params.userData = userData;
3151
3152 data.site = CL_CALLBACK_SITE_ENTER;
3153 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3154 data.functionName = "clSetContextDestructorCallback";
3155 data.functionParams = static_cast<const void *>(&params);
3156 data.functionReturnValue = nullptr;
3157
3158 size_t i = 0;
3159 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3160 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3161 TracingHandle *handle = tracingHandle[i];
3162 DEBUG_BREAK_IF(handle == nullptr);
3163 if (handle->getTracingPoint(CL_FUNCTION_clSetContextDestructorCallback)) {
3164 data.correlationData = correlationData + i;
3165 handle->call(CL_FUNCTION_clSetContextDestructorCallback, &data);
3166 }
3167 ++i;
3168 }
3169
3170 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3171 }
3172
3173 void exit(cl_int *retVal) {
3174 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3175 data.site = CL_CALLBACK_SITE_EXIT;
3176 data.functionReturnValue = retVal;
3177
3178 size_t i = 0;
3179 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3180 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3181 TracingHandle *handle = tracingHandle[i];
3182 DEBUG_BREAK_IF(handle == nullptr);
3183 if (handle->getTracingPoint(CL_FUNCTION_clSetContextDestructorCallback)) {
3184 data.correlationData = correlationData + i;
3185 handle->call(CL_FUNCTION_clSetContextDestructorCallback, &data);
3186 }
3187 ++i;
3188 }
3189
3190 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3191 }
3192
3193 ~ClSetContextDestructorCallbackTracer() {
3194 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3195 }
3196
3197 private:
3198 cl_params_clSetContextDestructorCallback params{};
3199 cl_callback_data data{};
3200 uint64_t correlationData[tracingMaxHandleCount];
3201 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3202 };
3203
3204 class ClEnqueueExternalMemObjectsKHRTracer {
3205 public:
3206 ClEnqueueExternalMemObjectsKHRTracer() {}
3207
3208 void enter(cl_command_queue *commandQueue,
3209 cl_uint *numMemObjects,
3210 const cl_mem **memObjects,
3211 cl_uint *numEventsInWaitList,
3212 const cl_event **eventWaitList,
3213 cl_event **event) {
3214 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3215
3216 params.commandQueue = commandQueue;
3217 params.numMemObjects = numMemObjects;
3218 params.memObjects = memObjects;
3219 params.numEventsInWaitList = numEventsInWaitList;
3220 params.eventWaitList = eventWaitList;
3221 params.event = event;
3222
3223 data.site = CL_CALLBACK_SITE_ENTER;
3224 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3225 data.functionName = "clEnqueueExternalMemObjectsKHR";
3226 data.functionParams = static_cast<const void *>(&params);
3227 data.functionReturnValue = nullptr;
3228
3229 size_t i = 0;
3230 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3231 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3232 TracingHandle *handle = tracingHandle[i];
3233 DEBUG_BREAK_IF(handle == nullptr);
3234 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueExternalMemObjectsKHR)) {
3235 data.correlationData = correlationData + i;
3236 handle->call(CL_FUNCTION_clEnqueueExternalMemObjectsKHR, &data);
3237 }
3238 ++i;
3239 }
3240
3241 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3242 }
3243
3244 void exit(cl_int *retVal) {
3245 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3246 data.site = CL_CALLBACK_SITE_EXIT;
3247 data.functionReturnValue = retVal;
3248
3249 size_t i = 0;
3250 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3251 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3252 TracingHandle *handle = tracingHandle[i];
3253 DEBUG_BREAK_IF(handle == nullptr);
3254 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueExternalMemObjectsKHR)) {
3255 data.correlationData = correlationData + i;
3256 handle->call(CL_FUNCTION_clEnqueueExternalMemObjectsKHR, &data);
3257 }
3258 ++i;
3259 }
3260
3261 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3262 }
3263
3264 ~ClEnqueueExternalMemObjectsKHRTracer() {
3265 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3266 }
3267
3268 private:
3269 cl_params_clEnqueueExternalMemObjectsKHR params{};
3270 cl_callback_data data{};
3271 uint64_t correlationData[tracingMaxHandleCount];
3272 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3273 };
3274
3275 class ClEnqueueAcquireExternalMemObjectsKHRTracer {
3276 public:
3277 ClEnqueueAcquireExternalMemObjectsKHRTracer() {}
3278
3279 void enter(cl_command_queue *commandQueue,
3280 cl_uint *numMemObjects,
3281 const cl_mem **memObjects,
3282 cl_uint *numEventsInWaitList,
3283 const cl_event **eventWaitList,
3284 cl_event **event) {
3285 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3286
3287 params.commandQueue = commandQueue;
3288 params.numMemObjects = numMemObjects;
3289 params.memObjects = memObjects;
3290 params.numEventsInWaitList = numEventsInWaitList;
3291 params.eventWaitList = eventWaitList;
3292 params.event = event;
3293
3294 data.site = CL_CALLBACK_SITE_ENTER;
3295 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3296 data.functionName = "clEnqueueAcquireExternalMemObjectsKHR";
3297 data.functionParams = static_cast<const void *>(&params);
3298 data.functionReturnValue = nullptr;
3299
3300 size_t i = 0;
3301 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3302 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3303 TracingHandle *handle = tracingHandle[i];
3304 DEBUG_BREAK_IF(handle == nullptr);
3305 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireExternalMemObjectsKHR)) {
3306 data.correlationData = correlationData + i;
3307 handle->call(CL_FUNCTION_clEnqueueAcquireExternalMemObjectsKHR, &data);
3308 }
3309 ++i;
3310 }
3311
3312 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3313 }
3314
3315 void exit(cl_int *retVal) {
3316 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3317 data.site = CL_CALLBACK_SITE_EXIT;
3318 data.functionReturnValue = retVal;
3319
3320 size_t i = 0;
3321 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3322 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3323 TracingHandle *handle = tracingHandle[i];
3324 DEBUG_BREAK_IF(handle == nullptr);
3325 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireExternalMemObjectsKHR)) {
3326 data.correlationData = correlationData + i;
3327 handle->call(CL_FUNCTION_clEnqueueAcquireExternalMemObjectsKHR, &data);
3328 }
3329 ++i;
3330 }
3331
3332 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3333 }
3334
3335 ~ClEnqueueAcquireExternalMemObjectsKHRTracer() {
3336 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3337 }
3338
3339 private:
3340 cl_params_clEnqueueAcquireExternalMemObjectsKHR params{};
3341 cl_callback_data data{};
3342 uint64_t correlationData[tracingMaxHandleCount];
3343 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3344 };
3345
3346 class ClEnqueueReleaseExternalMemObjectsKHRTracer {
3347 public:
3348 ClEnqueueReleaseExternalMemObjectsKHRTracer() {}
3349
3350 void enter(cl_command_queue *commandQueue,
3351 cl_uint *numMemObjects,
3352 const cl_mem **memObjects,
3353 cl_uint *numEventsInWaitList,
3354 const cl_event **eventWaitList,
3355 cl_event **event) {
3356 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3357
3358 params.commandQueue = commandQueue;
3359 params.numMemObjects = numMemObjects;
3360 params.memObjects = memObjects;
3361 params.numEventsInWaitList = numEventsInWaitList;
3362 params.eventWaitList = eventWaitList;
3363 params.event = event;
3364
3365 data.site = CL_CALLBACK_SITE_ENTER;
3366 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3367 data.functionName = "clEnqueueReleaseExternalMemObjectsKHR";
3368 data.functionParams = static_cast<const void *>(&params);
3369 data.functionReturnValue = nullptr;
3370
3371 size_t i = 0;
3372 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3373 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3374 TracingHandle *handle = tracingHandle[i];
3375 DEBUG_BREAK_IF(handle == nullptr);
3376 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseExternalMemObjectsKHR)) {
3377 data.correlationData = correlationData + i;
3378 handle->call(CL_FUNCTION_clEnqueueReleaseExternalMemObjectsKHR, &data);
3379 }
3380 ++i;
3381 }
3382
3383 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3384 }
3385
3386 void exit(cl_int *retVal) {
3387 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3388 data.site = CL_CALLBACK_SITE_EXIT;
3389 data.functionReturnValue = retVal;
3390
3391 size_t i = 0;
3392 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3393 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3394 TracingHandle *handle = tracingHandle[i];
3395 DEBUG_BREAK_IF(handle == nullptr);
3396 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseExternalMemObjectsKHR)) {
3397 data.correlationData = correlationData + i;
3398 handle->call(CL_FUNCTION_clEnqueueReleaseExternalMemObjectsKHR, &data);
3399 }
3400 ++i;
3401 }
3402
3403 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3404 }
3405
3406 ~ClEnqueueReleaseExternalMemObjectsKHRTracer() {
3407 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3408 }
3409
3410 private:
3411 cl_params_clEnqueueReleaseExternalMemObjectsKHR params{};
3412 cl_callback_data data{};
3413 uint64_t correlationData[tracingMaxHandleCount];
3414 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3415 };
3416
3417 class ClCreateImageTracer {
3418 public:
3419 ClCreateImageTracer() {}
3420
3421 void enter(cl_context *context,
3422 cl_mem_flags *flags,
3423 const cl_image_format **imageFormat,
3424 const cl_image_desc **imageDesc,
3425 void **hostPtr,
3426 cl_int **errcodeRet) {
3427 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3428
3429 params.context = context;
3430 params.flags = flags;
3431 params.imageFormat = imageFormat;
3432 params.imageDesc = imageDesc;
3433 params.hostPtr = hostPtr;
3434 params.errcodeRet = errcodeRet;
3435
3436 data.site = CL_CALLBACK_SITE_ENTER;
3437 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3438 data.functionName = "clCreateImage";
3439 data.functionParams = static_cast<const void *>(&params);
3440 data.functionReturnValue = nullptr;
3441
3442 size_t i = 0;
3443 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3444 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3445 TracingHandle *handle = tracingHandle[i];
3446 DEBUG_BREAK_IF(handle == nullptr);
3447 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage)) {
3448 data.correlationData = correlationData + i;
3449 handle->call(CL_FUNCTION_clCreateImage, &data);
3450 }
3451 ++i;
3452 }
3453
3454 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3455 }
3456
3457 void exit(cl_mem *retVal) {
3458 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3459 data.site = CL_CALLBACK_SITE_EXIT;
3460 data.functionReturnValue = retVal;
3461
3462 size_t i = 0;
3463 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3464 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3465 TracingHandle *handle = tracingHandle[i];
3466 DEBUG_BREAK_IF(handle == nullptr);
3467 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage)) {
3468 data.correlationData = correlationData + i;
3469 handle->call(CL_FUNCTION_clCreateImage, &data);
3470 }
3471 ++i;
3472 }
3473
3474 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3475 }
3476
3477 ~ClCreateImageTracer() {
3478 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3479 }
3480
3481 private:
3482 cl_params_clCreateImage params{};
3483 cl_callback_data data{};
3484 uint64_t correlationData[tracingMaxHandleCount];
3485 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3486 };
3487
3488 class ClCreateImage2DTracer {
3489 public:
3490 ClCreateImage2DTracer() {}
3491
3492 void enter(cl_context *context,
3493 cl_mem_flags *flags,
3494 const cl_image_format **imageFormat,
3495 size_t *imageWidth,
3496 size_t *imageHeight,
3497 size_t *imageRowPitch,
3498 void **hostPtr,
3499 cl_int **errcodeRet) {
3500 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3501
3502 params.context = context;
3503 params.flags = flags;
3504 params.imageFormat = imageFormat;
3505 params.imageWidth = imageWidth;
3506 params.imageHeight = imageHeight;
3507 params.imageRowPitch = imageRowPitch;
3508 params.hostPtr = hostPtr;
3509 params.errcodeRet = errcodeRet;
3510
3511 data.site = CL_CALLBACK_SITE_ENTER;
3512 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3513 data.functionName = "clCreateImage2D";
3514 data.functionParams = static_cast<const void *>(&params);
3515 data.functionReturnValue = nullptr;
3516
3517 size_t i = 0;
3518 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3519 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3520 TracingHandle *handle = tracingHandle[i];
3521 DEBUG_BREAK_IF(handle == nullptr);
3522 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage2D)) {
3523 data.correlationData = correlationData + i;
3524 handle->call(CL_FUNCTION_clCreateImage2D, &data);
3525 }
3526 ++i;
3527 }
3528
3529 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3530 }
3531
3532 void exit(cl_mem *retVal) {
3533 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3534 data.site = CL_CALLBACK_SITE_EXIT;
3535 data.functionReturnValue = retVal;
3536
3537 size_t i = 0;
3538 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3539 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3540 TracingHandle *handle = tracingHandle[i];
3541 DEBUG_BREAK_IF(handle == nullptr);
3542 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage2D)) {
3543 data.correlationData = correlationData + i;
3544 handle->call(CL_FUNCTION_clCreateImage2D, &data);
3545 }
3546 ++i;
3547 }
3548
3549 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3550 }
3551
3552 ~ClCreateImage2DTracer() {
3553 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3554 }
3555
3556 private:
3557 cl_params_clCreateImage2D params{};
3558 cl_callback_data data{};
3559 uint64_t correlationData[tracingMaxHandleCount];
3560 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3561 };
3562
3563 class ClCreateImage3DTracer {
3564 public:
3565 ClCreateImage3DTracer() {}
3566
3567 void enter(cl_context *context,
3568 cl_mem_flags *flags,
3569 const cl_image_format **imageFormat,
3570 size_t *imageWidth,
3571 size_t *imageHeight,
3572 size_t *imageDepth,
3573 size_t *imageRowPitch,
3574 size_t *imageSlicePitch,
3575 void **hostPtr,
3576 cl_int **errcodeRet) {
3577 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3578
3579 params.context = context;
3580 params.flags = flags;
3581 params.imageFormat = imageFormat;
3582 params.imageWidth = imageWidth;
3583 params.imageHeight = imageHeight;
3584 params.imageDepth = imageDepth;
3585 params.imageRowPitch = imageRowPitch;
3586 params.imageSlicePitch = imageSlicePitch;
3587 params.hostPtr = hostPtr;
3588 params.errcodeRet = errcodeRet;
3589
3590 data.site = CL_CALLBACK_SITE_ENTER;
3591 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3592 data.functionName = "clCreateImage3D";
3593 data.functionParams = static_cast<const void *>(&params);
3594 data.functionReturnValue = nullptr;
3595
3596 size_t i = 0;
3597 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3598 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3599 TracingHandle *handle = tracingHandle[i];
3600 DEBUG_BREAK_IF(handle == nullptr);
3601 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage3D)) {
3602 data.correlationData = correlationData + i;
3603 handle->call(CL_FUNCTION_clCreateImage3D, &data);
3604 }
3605 ++i;
3606 }
3607
3608 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3609 }
3610
3611 void exit(cl_mem *retVal) {
3612 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3613 data.site = CL_CALLBACK_SITE_EXIT;
3614 data.functionReturnValue = retVal;
3615
3616 size_t i = 0;
3617 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3618 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3619 TracingHandle *handle = tracingHandle[i];
3620 DEBUG_BREAK_IF(handle == nullptr);
3621 if (handle->getTracingPoint(CL_FUNCTION_clCreateImage3D)) {
3622 data.correlationData = correlationData + i;
3623 handle->call(CL_FUNCTION_clCreateImage3D, &data);
3624 }
3625 ++i;
3626 }
3627
3628 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3629 }
3630
3631 ~ClCreateImage3DTracer() {
3632 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3633 }
3634
3635 private:
3636 cl_params_clCreateImage3D params{};
3637 cl_callback_data data{};
3638 uint64_t correlationData[tracingMaxHandleCount];
3639 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3640 };
3641
3642 class ClCreateKernelTracer {
3643 public:
3644 ClCreateKernelTracer() {}
3645
3646 void enter(cl_program *program,
3647 const char **kernelName,
3648 cl_int **errcodeRet) {
3649 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3650
3651 params.program = program;
3652 params.kernelName = kernelName;
3653 params.errcodeRet = errcodeRet;
3654
3655 data.site = CL_CALLBACK_SITE_ENTER;
3656 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3657 data.functionName = "clCreateKernel";
3658 data.functionParams = static_cast<const void *>(&params);
3659 data.functionReturnValue = nullptr;
3660
3661 size_t i = 0;
3662 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3663 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3664 TracingHandle *handle = tracingHandle[i];
3665 DEBUG_BREAK_IF(handle == nullptr);
3666 if (handle->getTracingPoint(CL_FUNCTION_clCreateKernel)) {
3667 data.correlationData = correlationData + i;
3668 handle->call(CL_FUNCTION_clCreateKernel, &data);
3669 }
3670 ++i;
3671 }
3672
3673 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3674 }
3675
3676 void exit(cl_kernel *retVal) {
3677 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3678 data.site = CL_CALLBACK_SITE_EXIT;
3679 data.functionReturnValue = retVal;
3680
3681 size_t i = 0;
3682 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3683 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3684 TracingHandle *handle = tracingHandle[i];
3685 DEBUG_BREAK_IF(handle == nullptr);
3686 if (handle->getTracingPoint(CL_FUNCTION_clCreateKernel)) {
3687 data.correlationData = correlationData + i;
3688 handle->call(CL_FUNCTION_clCreateKernel, &data);
3689 }
3690 ++i;
3691 }
3692
3693 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3694 }
3695
3696 ~ClCreateKernelTracer() {
3697 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3698 }
3699
3700 private:
3701 cl_params_clCreateKernel params{};
3702 cl_callback_data data{};
3703 uint64_t correlationData[tracingMaxHandleCount];
3704 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3705 };
3706
3707 class ClCreateKernelsInProgramTracer {
3708 public:
3709 ClCreateKernelsInProgramTracer() {}
3710
3711 void enter(cl_program *program,
3712 cl_uint *numKernels,
3713 cl_kernel **kernels,
3714 cl_uint **numKernelsRet) {
3715 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3716
3717 params.program = program;
3718 params.numKernels = numKernels;
3719 params.kernels = kernels;
3720 params.numKernelsRet = numKernelsRet;
3721
3722 data.site = CL_CALLBACK_SITE_ENTER;
3723 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3724 data.functionName = "clCreateKernelsInProgram";
3725 data.functionParams = static_cast<const void *>(&params);
3726 data.functionReturnValue = nullptr;
3727
3728 size_t i = 0;
3729 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3730 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3731 TracingHandle *handle = tracingHandle[i];
3732 DEBUG_BREAK_IF(handle == nullptr);
3733 if (handle->getTracingPoint(CL_FUNCTION_clCreateKernelsInProgram)) {
3734 data.correlationData = correlationData + i;
3735 handle->call(CL_FUNCTION_clCreateKernelsInProgram, &data);
3736 }
3737 ++i;
3738 }
3739
3740 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3741 }
3742
3743 void exit(cl_int *retVal) {
3744 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3745 data.site = CL_CALLBACK_SITE_EXIT;
3746 data.functionReturnValue = retVal;
3747
3748 size_t i = 0;
3749 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3750 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3751 TracingHandle *handle = tracingHandle[i];
3752 DEBUG_BREAK_IF(handle == nullptr);
3753 if (handle->getTracingPoint(CL_FUNCTION_clCreateKernelsInProgram)) {
3754 data.correlationData = correlationData + i;
3755 handle->call(CL_FUNCTION_clCreateKernelsInProgram, &data);
3756 }
3757 ++i;
3758 }
3759
3760 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3761 }
3762
3763 ~ClCreateKernelsInProgramTracer() {
3764 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3765 }
3766
3767 private:
3768 cl_params_clCreateKernelsInProgram params{};
3769 cl_callback_data data{};
3770 uint64_t correlationData[tracingMaxHandleCount];
3771 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3772 };
3773
3774 class ClCreateSubDevicesTracer {
3775 public:
3776 ClCreateSubDevicesTracer() {}
3777
3778 void enter(cl_device_id *inDevice,
3779 const cl_device_partition_property **properties,
3780 cl_uint *numDevices,
3781 cl_device_id **outDevices,
3782 cl_uint **numDevicesRet) {
3783 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3784
3785 params.inDevice = inDevice;
3786 params.properties = properties;
3787 params.numDevices = numDevices;
3788 params.outDevices = outDevices;
3789 params.numDevicesRet = numDevicesRet;
3790
3791 data.site = CL_CALLBACK_SITE_ENTER;
3792 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3793 data.functionName = "clCreateSubDevices";
3794 data.functionParams = static_cast<const void *>(&params);
3795 data.functionReturnValue = nullptr;
3796
3797 size_t i = 0;
3798 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3799 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3800 TracingHandle *handle = tracingHandle[i];
3801 DEBUG_BREAK_IF(handle == nullptr);
3802 if (handle->getTracingPoint(CL_FUNCTION_clCreateSubDevices)) {
3803 data.correlationData = correlationData + i;
3804 handle->call(CL_FUNCTION_clCreateSubDevices, &data);
3805 }
3806 ++i;
3807 }
3808
3809 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3810 }
3811
3812 void exit(cl_int *retVal) {
3813 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3814 data.site = CL_CALLBACK_SITE_EXIT;
3815 data.functionReturnValue = retVal;
3816
3817 size_t i = 0;
3818 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3819 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3820 TracingHandle *handle = tracingHandle[i];
3821 DEBUG_BREAK_IF(handle == nullptr);
3822 if (handle->getTracingPoint(CL_FUNCTION_clCreateSubDevices)) {
3823 data.correlationData = correlationData + i;
3824 handle->call(CL_FUNCTION_clCreateSubDevices, &data);
3825 }
3826 ++i;
3827 }
3828
3829 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3830 }
3831
3832 ~ClCreateSubDevicesTracer() {
3833 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3834 }
3835
3836 private:
3837 cl_params_clCreateSubDevices params{};
3838 cl_callback_data data{};
3839 uint64_t correlationData[tracingMaxHandleCount];
3840 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3841 };
3842
3843 class ClCreatePipeTracer {
3844 public:
3845 ClCreatePipeTracer() {}
3846
3847 void enter(cl_context *context,
3848 cl_mem_flags *flags,
3849 cl_uint *pipePacketSize,
3850 cl_uint *pipeMaxPackets,
3851 const cl_pipe_properties **properties,
3852 cl_int **errcodeRet) {
3853 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3854
3855 params.context = context;
3856 params.flags = flags;
3857 params.pipePacketSize = pipePacketSize;
3858 params.pipeMaxPackets = pipeMaxPackets;
3859 params.properties = properties;
3860 params.errcodeRet = errcodeRet;
3861
3862 data.site = CL_CALLBACK_SITE_ENTER;
3863 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3864 data.functionName = "clCreatePipe";
3865 data.functionParams = static_cast<const void *>(&params);
3866 data.functionReturnValue = nullptr;
3867
3868 size_t i = 0;
3869 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3870 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3871 TracingHandle *handle = tracingHandle[i];
3872 DEBUG_BREAK_IF(handle == nullptr);
3873 if (handle->getTracingPoint(CL_FUNCTION_clCreatePipe)) {
3874 data.correlationData = correlationData + i;
3875 handle->call(CL_FUNCTION_clCreatePipe, &data);
3876 }
3877 ++i;
3878 }
3879
3880 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3881 }
3882
3883 void exit(cl_mem *retVal) {
3884 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3885 data.site = CL_CALLBACK_SITE_EXIT;
3886 data.functionReturnValue = retVal;
3887
3888 size_t i = 0;
3889 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3890 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3891 TracingHandle *handle = tracingHandle[i];
3892 DEBUG_BREAK_IF(handle == nullptr);
3893 if (handle->getTracingPoint(CL_FUNCTION_clCreatePipe)) {
3894 data.correlationData = correlationData + i;
3895 handle->call(CL_FUNCTION_clCreatePipe, &data);
3896 }
3897 ++i;
3898 }
3899
3900 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3901 }
3902
3903 ~ClCreatePipeTracer() {
3904 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3905 }
3906
3907 private:
3908 cl_params_clCreatePipe params{};
3909 cl_callback_data data{};
3910 uint64_t correlationData[tracingMaxHandleCount];
3911 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3912 };
3913
3914 class ClCreateProgramWithBinaryTracer {
3915 public:
3916 ClCreateProgramWithBinaryTracer() {}
3917
3918 void enter(cl_context *context,
3919 cl_uint *numDevices,
3920 const cl_device_id **deviceList,
3921 const size_t **lengths,
3922 const unsigned char ***binaries,
3923 cl_int **binaryStatus,
3924 cl_int **errcodeRet) {
3925 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3926
3927 params.context = context;
3928 params.numDevices = numDevices;
3929 params.deviceList = deviceList;
3930 params.lengths = lengths;
3931 params.binaries = binaries;
3932 params.binaryStatus = binaryStatus;
3933 params.errcodeRet = errcodeRet;
3934
3935 data.site = CL_CALLBACK_SITE_ENTER;
3936 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
3937 data.functionName = "clCreateProgramWithBinary";
3938 data.functionParams = static_cast<const void *>(&params);
3939 data.functionReturnValue = nullptr;
3940
3941 size_t i = 0;
3942 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3943 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3944 TracingHandle *handle = tracingHandle[i];
3945 DEBUG_BREAK_IF(handle == nullptr);
3946 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBinary)) {
3947 data.correlationData = correlationData + i;
3948 handle->call(CL_FUNCTION_clCreateProgramWithBinary, &data);
3949 }
3950 ++i;
3951 }
3952
3953 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
3954 }
3955
3956 void exit(cl_program *retVal) {
3957 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
3958 data.site = CL_CALLBACK_SITE_EXIT;
3959 data.functionReturnValue = retVal;
3960
3961 size_t i = 0;
3962 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
3963 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
3964 TracingHandle *handle = tracingHandle[i];
3965 DEBUG_BREAK_IF(handle == nullptr);
3966 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBinary)) {
3967 data.correlationData = correlationData + i;
3968 handle->call(CL_FUNCTION_clCreateProgramWithBinary, &data);
3969 }
3970 ++i;
3971 }
3972
3973 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
3974 }
3975
3976 ~ClCreateProgramWithBinaryTracer() {
3977 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
3978 }
3979
3980 private:
3981 cl_params_clCreateProgramWithBinary params{};
3982 cl_callback_data data{};
3983 uint64_t correlationData[tracingMaxHandleCount];
3984 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
3985 };
3986
3987 class ClCreateProgramWithBuiltInKernelsTracer {
3988 public:
3989 ClCreateProgramWithBuiltInKernelsTracer() {}
3990
3991 void enter(cl_context *context,
3992 cl_uint *numDevices,
3993 const cl_device_id **deviceList,
3994 const char **kernelNames,
3995 cl_int **errcodeRet) {
3996 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
3997
3998 params.context = context;
3999 params.numDevices = numDevices;
4000 params.deviceList = deviceList;
4001 params.kernelNames = kernelNames;
4002 params.errcodeRet = errcodeRet;
4003
4004 data.site = CL_CALLBACK_SITE_ENTER;
4005 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4006 data.functionName = "clCreateProgramWithBuiltInKernels";
4007 data.functionParams = static_cast<const void *>(&params);
4008 data.functionReturnValue = nullptr;
4009
4010 size_t i = 0;
4011 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4012 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4013 TracingHandle *handle = tracingHandle[i];
4014 DEBUG_BREAK_IF(handle == nullptr);
4015 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBuiltInKernels)) {
4016 data.correlationData = correlationData + i;
4017 handle->call(CL_FUNCTION_clCreateProgramWithBuiltInKernels, &data);
4018 }
4019 ++i;
4020 }
4021
4022 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4023 }
4024
4025 void exit(cl_program *retVal) {
4026 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4027 data.site = CL_CALLBACK_SITE_EXIT;
4028 data.functionReturnValue = retVal;
4029
4030 size_t i = 0;
4031 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4032 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4033 TracingHandle *handle = tracingHandle[i];
4034 DEBUG_BREAK_IF(handle == nullptr);
4035 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBuiltInKernels)) {
4036 data.correlationData = correlationData + i;
4037 handle->call(CL_FUNCTION_clCreateProgramWithBuiltInKernels, &data);
4038 }
4039 ++i;
4040 }
4041
4042 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4043 }
4044
4045 ~ClCreateProgramWithBuiltInKernelsTracer() {
4046 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4047 }
4048
4049 private:
4050 cl_params_clCreateProgramWithBuiltInKernels params{};
4051 cl_callback_data data{};
4052 uint64_t correlationData[tracingMaxHandleCount];
4053 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4054 };
4055
4056 class ClCreateProgramWithIlTracer {
4057 public:
4058 ClCreateProgramWithIlTracer() {}
4059
4060 void enter(cl_context *context,
4061 const void **il,
4062 size_t *length,
4063 cl_int **errcodeRet) {
4064 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4065
4066 params.context = context;
4067 params.il = il;
4068 params.length = length;
4069 params.errcodeRet = errcodeRet;
4070
4071 data.site = CL_CALLBACK_SITE_ENTER;
4072 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4073 data.functionName = "clCreateProgramWithIL";
4074 data.functionParams = static_cast<const void *>(&params);
4075 data.functionReturnValue = nullptr;
4076
4077 size_t i = 0;
4078 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4079 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4080 TracingHandle *handle = tracingHandle[i];
4081 DEBUG_BREAK_IF(handle == nullptr);
4082 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithIL)) {
4083 data.correlationData = correlationData + i;
4084 handle->call(CL_FUNCTION_clCreateProgramWithIL, &data);
4085 }
4086 ++i;
4087 }
4088
4089 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4090 }
4091
4092 void exit(cl_program *retVal) {
4093 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4094 data.site = CL_CALLBACK_SITE_EXIT;
4095 data.functionReturnValue = retVal;
4096
4097 size_t i = 0;
4098 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4099 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4100 TracingHandle *handle = tracingHandle[i];
4101 DEBUG_BREAK_IF(handle == nullptr);
4102 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithIL)) {
4103 data.correlationData = correlationData + i;
4104 handle->call(CL_FUNCTION_clCreateProgramWithIL, &data);
4105 }
4106 ++i;
4107 }
4108
4109 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4110 }
4111
4112 ~ClCreateProgramWithIlTracer() {
4113 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4114 }
4115
4116 private:
4117 cl_params_clCreateProgramWithIL params{};
4118 cl_callback_data data{};
4119 uint64_t correlationData[tracingMaxHandleCount];
4120 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4121 };
4122
4123 class ClCreateProgramWithSourceTracer {
4124 public:
4125 ClCreateProgramWithSourceTracer() {}
4126
4127 void enter(cl_context *context,
4128 cl_uint *count,
4129 const char ***strings,
4130 const size_t **lengths,
4131 cl_int **errcodeRet) {
4132 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4133
4134 params.context = context;
4135 params.count = count;
4136 params.strings = strings;
4137 params.lengths = lengths;
4138 params.errcodeRet = errcodeRet;
4139
4140 data.site = CL_CALLBACK_SITE_ENTER;
4141 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4142 data.functionName = "clCreateProgramWithSource";
4143 data.functionParams = static_cast<const void *>(&params);
4144 data.functionReturnValue = nullptr;
4145
4146 size_t i = 0;
4147 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4148 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4149 TracingHandle *handle = tracingHandle[i];
4150 DEBUG_BREAK_IF(handle == nullptr);
4151 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithSource)) {
4152 data.correlationData = correlationData + i;
4153 handle->call(CL_FUNCTION_clCreateProgramWithSource, &data);
4154 }
4155 ++i;
4156 }
4157
4158 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4159 }
4160
4161 void exit(cl_program *retVal) {
4162 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4163 data.site = CL_CALLBACK_SITE_EXIT;
4164 data.functionReturnValue = retVal;
4165
4166 size_t i = 0;
4167 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4168 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4169 TracingHandle *handle = tracingHandle[i];
4170 DEBUG_BREAK_IF(handle == nullptr);
4171 if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithSource)) {
4172 data.correlationData = correlationData + i;
4173 handle->call(CL_FUNCTION_clCreateProgramWithSource, &data);
4174 }
4175 ++i;
4176 }
4177
4178 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4179 }
4180
4181 ~ClCreateProgramWithSourceTracer() {
4182 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4183 }
4184
4185 private:
4186 cl_params_clCreateProgramWithSource params{};
4187 cl_callback_data data{};
4188 uint64_t correlationData[tracingMaxHandleCount];
4189 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4190 };
4191
4192 class ClCreateSamplerTracer {
4193 public:
4194 ClCreateSamplerTracer() {}
4195
4196 void enter(cl_context *context,
4197 cl_bool *normalizedCoords,
4198 cl_addressing_mode *addressingMode,
4199 cl_filter_mode *filterMode,
4200 cl_int **errcodeRet) {
4201 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4202
4203 params.context = context;
4204 params.normalizedCoords = normalizedCoords;
4205 params.addressingMode = addressingMode;
4206 params.filterMode = filterMode;
4207 params.errcodeRet = errcodeRet;
4208
4209 data.site = CL_CALLBACK_SITE_ENTER;
4210 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4211 data.functionName = "clCreateSampler";
4212 data.functionParams = static_cast<const void *>(&params);
4213 data.functionReturnValue = nullptr;
4214
4215 size_t i = 0;
4216 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4217 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4218 TracingHandle *handle = tracingHandle[i];
4219 DEBUG_BREAK_IF(handle == nullptr);
4220 if (handle->getTracingPoint(CL_FUNCTION_clCreateSampler)) {
4221 data.correlationData = correlationData + i;
4222 handle->call(CL_FUNCTION_clCreateSampler, &data);
4223 }
4224 ++i;
4225 }
4226
4227 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4228 }
4229
4230 void exit(cl_sampler *retVal) {
4231 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4232 data.site = CL_CALLBACK_SITE_EXIT;
4233 data.functionReturnValue = retVal;
4234
4235 size_t i = 0;
4236 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4237 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4238 TracingHandle *handle = tracingHandle[i];
4239 DEBUG_BREAK_IF(handle == nullptr);
4240 if (handle->getTracingPoint(CL_FUNCTION_clCreateSampler)) {
4241 data.correlationData = correlationData + i;
4242 handle->call(CL_FUNCTION_clCreateSampler, &data);
4243 }
4244 ++i;
4245 }
4246
4247 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4248 }
4249
4250 ~ClCreateSamplerTracer() {
4251 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4252 }
4253
4254 private:
4255 cl_params_clCreateSampler params{};
4256 cl_callback_data data{};
4257 uint64_t correlationData[tracingMaxHandleCount];
4258 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4259 };
4260
4261 class ClCreateSamplerWithPropertiesTracer {
4262 public:
4263 ClCreateSamplerWithPropertiesTracer() {}
4264
4265 void enter(cl_context *context,
4266 const cl_sampler_properties **samplerProperties,
4267 cl_int **errcodeRet) {
4268 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4269
4270 params.context = context;
4271 params.samplerProperties = samplerProperties;
4272 params.errcodeRet = errcodeRet;
4273
4274 data.site = CL_CALLBACK_SITE_ENTER;
4275 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4276 data.functionName = "clCreateSamplerWithProperties";
4277 data.functionParams = static_cast<const void *>(&params);
4278 data.functionReturnValue = nullptr;
4279
4280 size_t i = 0;
4281 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4282 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4283 TracingHandle *handle = tracingHandle[i];
4284 DEBUG_BREAK_IF(handle == nullptr);
4285 if (handle->getTracingPoint(CL_FUNCTION_clCreateSamplerWithProperties)) {
4286 data.correlationData = correlationData + i;
4287 handle->call(CL_FUNCTION_clCreateSamplerWithProperties, &data);
4288 }
4289 ++i;
4290 }
4291
4292 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4293 }
4294
4295 void exit(cl_sampler *retVal) {
4296 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4297 data.site = CL_CALLBACK_SITE_EXIT;
4298 data.functionReturnValue = retVal;
4299
4300 size_t i = 0;
4301 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4302 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4303 TracingHandle *handle = tracingHandle[i];
4304 DEBUG_BREAK_IF(handle == nullptr);
4305 if (handle->getTracingPoint(CL_FUNCTION_clCreateSamplerWithProperties)) {
4306 data.correlationData = correlationData + i;
4307 handle->call(CL_FUNCTION_clCreateSamplerWithProperties, &data);
4308 }
4309 ++i;
4310 }
4311
4312 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4313 }
4314
4315 ~ClCreateSamplerWithPropertiesTracer() {
4316 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4317 }
4318
4319 private:
4320 cl_params_clCreateSamplerWithProperties params{};
4321 cl_callback_data data{};
4322 uint64_t correlationData[tracingMaxHandleCount];
4323 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4324 };
4325
4326 class ClCreateSubBufferTracer {
4327 public:
4328 ClCreateSubBufferTracer() {}
4329
4330 void enter(cl_mem *buffer,
4331 cl_mem_flags *flags,
4332 cl_buffer_create_type *bufferCreateType,
4333 const void **bufferCreateInfo,
4334 cl_int **errcodeRet) {
4335 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4336
4337 params.buffer = buffer;
4338 params.flags = flags;
4339 params.bufferCreateType = bufferCreateType;
4340 params.bufferCreateInfo = bufferCreateInfo;
4341 params.errcodeRet = errcodeRet;
4342
4343 data.site = CL_CALLBACK_SITE_ENTER;
4344 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4345 data.functionName = "clCreateSubBuffer";
4346 data.functionParams = static_cast<const void *>(&params);
4347 data.functionReturnValue = nullptr;
4348
4349 size_t i = 0;
4350 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4351 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4352 TracingHandle *handle = tracingHandle[i];
4353 DEBUG_BREAK_IF(handle == nullptr);
4354 if (handle->getTracingPoint(CL_FUNCTION_clCreateSubBuffer)) {
4355 data.correlationData = correlationData + i;
4356 handle->call(CL_FUNCTION_clCreateSubBuffer, &data);
4357 }
4358 ++i;
4359 }
4360
4361 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4362 }
4363
4364 void exit(cl_mem *retVal) {
4365 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4366 data.site = CL_CALLBACK_SITE_EXIT;
4367 data.functionReturnValue = retVal;
4368
4369 size_t i = 0;
4370 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4371 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4372 TracingHandle *handle = tracingHandle[i];
4373 DEBUG_BREAK_IF(handle == nullptr);
4374 if (handle->getTracingPoint(CL_FUNCTION_clCreateSubBuffer)) {
4375 data.correlationData = correlationData + i;
4376 handle->call(CL_FUNCTION_clCreateSubBuffer, &data);
4377 }
4378 ++i;
4379 }
4380
4381 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4382 }
4383
4384 ~ClCreateSubBufferTracer() {
4385 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4386 }
4387
4388 private:
4389 cl_params_clCreateSubBuffer params{};
4390 cl_callback_data data{};
4391 uint64_t correlationData[tracingMaxHandleCount];
4392 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4393 };
4394
4395 class ClCreateUserEventTracer {
4396 public:
4397 ClCreateUserEventTracer() {}
4398
4399 void enter(cl_context *context,
4400 cl_int **errcodeRet) {
4401 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4402
4403 params.context = context;
4404 params.errcodeRet = errcodeRet;
4405
4406 data.site = CL_CALLBACK_SITE_ENTER;
4407 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4408 data.functionName = "clCreateUserEvent";
4409 data.functionParams = static_cast<const void *>(&params);
4410 data.functionReturnValue = nullptr;
4411
4412 size_t i = 0;
4413 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4414 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4415 TracingHandle *handle = tracingHandle[i];
4416 DEBUG_BREAK_IF(handle == nullptr);
4417 if (handle->getTracingPoint(CL_FUNCTION_clCreateUserEvent)) {
4418 data.correlationData = correlationData + i;
4419 handle->call(CL_FUNCTION_clCreateUserEvent, &data);
4420 }
4421 ++i;
4422 }
4423
4424 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4425 }
4426
4427 void exit(cl_event *retVal) {
4428 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4429 data.site = CL_CALLBACK_SITE_EXIT;
4430 data.functionReturnValue = retVal;
4431
4432 size_t i = 0;
4433 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4434 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4435 TracingHandle *handle = tracingHandle[i];
4436 DEBUG_BREAK_IF(handle == nullptr);
4437 if (handle->getTracingPoint(CL_FUNCTION_clCreateUserEvent)) {
4438 data.correlationData = correlationData + i;
4439 handle->call(CL_FUNCTION_clCreateUserEvent, &data);
4440 }
4441 ++i;
4442 }
4443
4444 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4445 }
4446
4447 ~ClCreateUserEventTracer() {
4448 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4449 }
4450
4451 private:
4452 cl_params_clCreateUserEvent params{};
4453 cl_callback_data data{};
4454 uint64_t correlationData[tracingMaxHandleCount];
4455 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4456 };
4457
4458 class ClEnqueueBarrierTracer {
4459 public:
4460 ClEnqueueBarrierTracer() {}
4461
4462 void enter(cl_command_queue *commandQueue) {
4463 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4464
4465 params.commandQueue = commandQueue;
4466
4467 data.site = CL_CALLBACK_SITE_ENTER;
4468 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4469 data.functionName = "clEnqueueBarrier";
4470 data.functionParams = static_cast<const void *>(&params);
4471 data.functionReturnValue = nullptr;
4472
4473 size_t i = 0;
4474 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4475 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4476 TracingHandle *handle = tracingHandle[i];
4477 DEBUG_BREAK_IF(handle == nullptr);
4478 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrier)) {
4479 data.correlationData = correlationData + i;
4480 handle->call(CL_FUNCTION_clEnqueueBarrier, &data);
4481 }
4482 ++i;
4483 }
4484
4485 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4486 }
4487
4488 void exit(cl_int *retVal) {
4489 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4490 data.site = CL_CALLBACK_SITE_EXIT;
4491 data.functionReturnValue = retVal;
4492
4493 size_t i = 0;
4494 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4495 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4496 TracingHandle *handle = tracingHandle[i];
4497 DEBUG_BREAK_IF(handle == nullptr);
4498 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrier)) {
4499 data.correlationData = correlationData + i;
4500 handle->call(CL_FUNCTION_clEnqueueBarrier, &data);
4501 }
4502 ++i;
4503 }
4504
4505 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4506 }
4507
4508 ~ClEnqueueBarrierTracer() {
4509 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4510 }
4511
4512 private:
4513 cl_params_clEnqueueBarrier params{};
4514 cl_callback_data data{};
4515 uint64_t correlationData[tracingMaxHandleCount];
4516 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4517 };
4518
4519 class ClEnqueueBarrierWithWaitListTracer {
4520 public:
4521 ClEnqueueBarrierWithWaitListTracer() {}
4522
4523 void enter(cl_command_queue *commandQueue,
4524 cl_uint *numEventsInWaitList,
4525 const cl_event **eventWaitList,
4526 cl_event **event) {
4527 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4528
4529 params.commandQueue = commandQueue;
4530 params.numEventsInWaitList = numEventsInWaitList;
4531 params.eventWaitList = eventWaitList;
4532 params.event = event;
4533
4534 data.site = CL_CALLBACK_SITE_ENTER;
4535 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4536 data.functionName = "clEnqueueBarrierWithWaitList";
4537 data.functionParams = static_cast<const void *>(&params);
4538 data.functionReturnValue = nullptr;
4539
4540 size_t i = 0;
4541 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4542 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4543 TracingHandle *handle = tracingHandle[i];
4544 DEBUG_BREAK_IF(handle == nullptr);
4545 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrierWithWaitList)) {
4546 data.correlationData = correlationData + i;
4547 handle->call(CL_FUNCTION_clEnqueueBarrierWithWaitList, &data);
4548 }
4549 ++i;
4550 }
4551
4552 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4553 }
4554
4555 void exit(cl_int *retVal) {
4556 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4557 data.site = CL_CALLBACK_SITE_EXIT;
4558 data.functionReturnValue = retVal;
4559
4560 size_t i = 0;
4561 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4562 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4563 TracingHandle *handle = tracingHandle[i];
4564 DEBUG_BREAK_IF(handle == nullptr);
4565 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrierWithWaitList)) {
4566 data.correlationData = correlationData + i;
4567 handle->call(CL_FUNCTION_clEnqueueBarrierWithWaitList, &data);
4568 }
4569 ++i;
4570 }
4571
4572 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4573 }
4574
4575 ~ClEnqueueBarrierWithWaitListTracer() {
4576 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4577 }
4578
4579 private:
4580 cl_params_clEnqueueBarrierWithWaitList params{};
4581 cl_callback_data data{};
4582 uint64_t correlationData[tracingMaxHandleCount];
4583 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4584 };
4585
4586 class ClEnqueueCopyBufferTracer {
4587 public:
4588 ClEnqueueCopyBufferTracer() {}
4589
4590 void enter(cl_command_queue *commandQueue,
4591 cl_mem *srcBuffer,
4592 cl_mem *dstBuffer,
4593 size_t *srcOffset,
4594 size_t *dstOffset,
4595 size_t *cb,
4596 cl_uint *numEventsInWaitList,
4597 const cl_event **eventWaitList,
4598 cl_event **event) {
4599 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4600
4601 params.commandQueue = commandQueue;
4602 params.srcBuffer = srcBuffer;
4603 params.dstBuffer = dstBuffer;
4604 params.srcOffset = srcOffset;
4605 params.dstOffset = dstOffset;
4606 params.cb = cb;
4607 params.numEventsInWaitList = numEventsInWaitList;
4608 params.eventWaitList = eventWaitList;
4609 params.event = event;
4610
4611 data.site = CL_CALLBACK_SITE_ENTER;
4612 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4613 data.functionName = "clEnqueueCopyBuffer";
4614 data.functionParams = static_cast<const void *>(&params);
4615 data.functionReturnValue = nullptr;
4616
4617 size_t i = 0;
4618 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4619 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4620 TracingHandle *handle = tracingHandle[i];
4621 DEBUG_BREAK_IF(handle == nullptr);
4622 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBuffer)) {
4623 data.correlationData = correlationData + i;
4624 handle->call(CL_FUNCTION_clEnqueueCopyBuffer, &data);
4625 }
4626 ++i;
4627 }
4628
4629 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4630 }
4631
4632 void exit(cl_int *retVal) {
4633 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4634 data.site = CL_CALLBACK_SITE_EXIT;
4635 data.functionReturnValue = retVal;
4636
4637 size_t i = 0;
4638 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4639 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4640 TracingHandle *handle = tracingHandle[i];
4641 DEBUG_BREAK_IF(handle == nullptr);
4642 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBuffer)) {
4643 data.correlationData = correlationData + i;
4644 handle->call(CL_FUNCTION_clEnqueueCopyBuffer, &data);
4645 }
4646 ++i;
4647 }
4648
4649 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4650 }
4651
4652 ~ClEnqueueCopyBufferTracer() {
4653 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4654 }
4655
4656 private:
4657 cl_params_clEnqueueCopyBuffer params{};
4658 cl_callback_data data{};
4659 uint64_t correlationData[tracingMaxHandleCount];
4660 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4661 };
4662
4663 class ClEnqueueCopyBufferRectTracer {
4664 public:
4665 ClEnqueueCopyBufferRectTracer() {}
4666
4667 void enter(cl_command_queue *commandQueue,
4668 cl_mem *srcBuffer,
4669 cl_mem *dstBuffer,
4670 const size_t **srcOrigin,
4671 const size_t **dstOrigin,
4672 const size_t **region,
4673 size_t *srcRowPitch,
4674 size_t *srcSlicePitch,
4675 size_t *dstRowPitch,
4676 size_t *dstSlicePitch,
4677 cl_uint *numEventsInWaitList,
4678 const cl_event **eventWaitList,
4679 cl_event **event) {
4680 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4681
4682 params.commandQueue = commandQueue;
4683 params.srcBuffer = srcBuffer;
4684 params.dstBuffer = dstBuffer;
4685 params.srcOrigin = srcOrigin;
4686 params.dstOrigin = dstOrigin;
4687 params.region = region;
4688 params.srcRowPitch = srcRowPitch;
4689 params.srcSlicePitch = srcSlicePitch;
4690 params.dstRowPitch = dstRowPitch;
4691 params.dstSlicePitch = dstSlicePitch;
4692 params.numEventsInWaitList = numEventsInWaitList;
4693 params.eventWaitList = eventWaitList;
4694 params.event = event;
4695
4696 data.site = CL_CALLBACK_SITE_ENTER;
4697 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4698 data.functionName = "clEnqueueCopyBufferRect";
4699 data.functionParams = static_cast<const void *>(&params);
4700 data.functionReturnValue = nullptr;
4701
4702 size_t i = 0;
4703 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4704 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4705 TracingHandle *handle = tracingHandle[i];
4706 DEBUG_BREAK_IF(handle == nullptr);
4707 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferRect)) {
4708 data.correlationData = correlationData + i;
4709 handle->call(CL_FUNCTION_clEnqueueCopyBufferRect, &data);
4710 }
4711 ++i;
4712 }
4713
4714 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4715 }
4716
4717 void exit(cl_int *retVal) {
4718 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4719 data.site = CL_CALLBACK_SITE_EXIT;
4720 data.functionReturnValue = retVal;
4721
4722 size_t i = 0;
4723 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4724 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4725 TracingHandle *handle = tracingHandle[i];
4726 DEBUG_BREAK_IF(handle == nullptr);
4727 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferRect)) {
4728 data.correlationData = correlationData + i;
4729 handle->call(CL_FUNCTION_clEnqueueCopyBufferRect, &data);
4730 }
4731 ++i;
4732 }
4733
4734 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4735 }
4736
4737 ~ClEnqueueCopyBufferRectTracer() {
4738 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4739 }
4740
4741 private:
4742 cl_params_clEnqueueCopyBufferRect params{};
4743 cl_callback_data data{};
4744 uint64_t correlationData[tracingMaxHandleCount];
4745 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4746 };
4747
4748 class ClEnqueueCopyBufferToImageTracer {
4749 public:
4750 ClEnqueueCopyBufferToImageTracer() {}
4751
4752 void enter(cl_command_queue *commandQueue,
4753 cl_mem *srcBuffer,
4754 cl_mem *dstImage,
4755 size_t *srcOffset,
4756 const size_t **dstOrigin,
4757 const size_t **region,
4758 cl_uint *numEventsInWaitList,
4759 const cl_event **eventWaitList,
4760 cl_event **event) {
4761 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4762
4763 params.commandQueue = commandQueue;
4764 params.srcBuffer = srcBuffer;
4765 params.dstImage = dstImage;
4766 params.srcOffset = srcOffset;
4767 params.dstOrigin = dstOrigin;
4768 params.region = region;
4769 params.numEventsInWaitList = numEventsInWaitList;
4770 params.eventWaitList = eventWaitList;
4771 params.event = event;
4772
4773 data.site = CL_CALLBACK_SITE_ENTER;
4774 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4775 data.functionName = "clEnqueueCopyBufferToImage";
4776 data.functionParams = static_cast<const void *>(&params);
4777 data.functionReturnValue = nullptr;
4778
4779 size_t i = 0;
4780 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4781 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4782 TracingHandle *handle = tracingHandle[i];
4783 DEBUG_BREAK_IF(handle == nullptr);
4784 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferToImage)) {
4785 data.correlationData = correlationData + i;
4786 handle->call(CL_FUNCTION_clEnqueueCopyBufferToImage, &data);
4787 }
4788 ++i;
4789 }
4790
4791 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4792 }
4793
4794 void exit(cl_int *retVal) {
4795 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4796 data.site = CL_CALLBACK_SITE_EXIT;
4797 data.functionReturnValue = retVal;
4798
4799 size_t i = 0;
4800 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4801 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4802 TracingHandle *handle = tracingHandle[i];
4803 DEBUG_BREAK_IF(handle == nullptr);
4804 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferToImage)) {
4805 data.correlationData = correlationData + i;
4806 handle->call(CL_FUNCTION_clEnqueueCopyBufferToImage, &data);
4807 }
4808 ++i;
4809 }
4810
4811 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4812 }
4813
4814 ~ClEnqueueCopyBufferToImageTracer() {
4815 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4816 }
4817
4818 private:
4819 cl_params_clEnqueueCopyBufferToImage params{};
4820 cl_callback_data data{};
4821 uint64_t correlationData[tracingMaxHandleCount];
4822 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4823 };
4824
4825 class ClEnqueueCopyImageTracer {
4826 public:
4827 ClEnqueueCopyImageTracer() {}
4828
4829 void enter(cl_command_queue *commandQueue,
4830 cl_mem *srcImage,
4831 cl_mem *dstImage,
4832 const size_t **srcOrigin,
4833 const size_t **dstOrigin,
4834 const size_t **region,
4835 cl_uint *numEventsInWaitList,
4836 const cl_event **eventWaitList,
4837 cl_event **event) {
4838 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4839
4840 params.commandQueue = commandQueue;
4841 params.srcImage = srcImage;
4842 params.dstImage = dstImage;
4843 params.srcOrigin = srcOrigin;
4844 params.dstOrigin = dstOrigin;
4845 params.region = region;
4846 params.numEventsInWaitList = numEventsInWaitList;
4847 params.eventWaitList = eventWaitList;
4848 params.event = event;
4849
4850 data.site = CL_CALLBACK_SITE_ENTER;
4851 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4852 data.functionName = "clEnqueueCopyImage";
4853 data.functionParams = static_cast<const void *>(&params);
4854 data.functionReturnValue = nullptr;
4855
4856 size_t i = 0;
4857 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4858 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4859 TracingHandle *handle = tracingHandle[i];
4860 DEBUG_BREAK_IF(handle == nullptr);
4861 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImage)) {
4862 data.correlationData = correlationData + i;
4863 handle->call(CL_FUNCTION_clEnqueueCopyImage, &data);
4864 }
4865 ++i;
4866 }
4867
4868 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4869 }
4870
4871 void exit(cl_int *retVal) {
4872 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4873 data.site = CL_CALLBACK_SITE_EXIT;
4874 data.functionReturnValue = retVal;
4875
4876 size_t i = 0;
4877 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4878 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4879 TracingHandle *handle = tracingHandle[i];
4880 DEBUG_BREAK_IF(handle == nullptr);
4881 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImage)) {
4882 data.correlationData = correlationData + i;
4883 handle->call(CL_FUNCTION_clEnqueueCopyImage, &data);
4884 }
4885 ++i;
4886 }
4887
4888 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4889 }
4890
4891 ~ClEnqueueCopyImageTracer() {
4892 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4893 }
4894
4895 private:
4896 cl_params_clEnqueueCopyImage params{};
4897 cl_callback_data data{};
4898 uint64_t correlationData[tracingMaxHandleCount];
4899 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4900 };
4901
4902 class ClEnqueueCopyImageToBufferTracer {
4903 public:
4904 ClEnqueueCopyImageToBufferTracer() {}
4905
4906 void enter(cl_command_queue *commandQueue,
4907 cl_mem *srcImage,
4908 cl_mem *dstBuffer,
4909 const size_t **srcOrigin,
4910 const size_t **region,
4911 size_t *dstOffset,
4912 cl_uint *numEventsInWaitList,
4913 const cl_event **eventWaitList,
4914 cl_event **event) {
4915 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4916
4917 params.commandQueue = commandQueue;
4918 params.srcImage = srcImage;
4919 params.dstBuffer = dstBuffer;
4920 params.srcOrigin = srcOrigin;
4921 params.region = region;
4922 params.dstOffset = dstOffset;
4923 params.numEventsInWaitList = numEventsInWaitList;
4924 params.eventWaitList = eventWaitList;
4925 params.event = event;
4926
4927 data.site = CL_CALLBACK_SITE_ENTER;
4928 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
4929 data.functionName = "clEnqueueCopyImageToBuffer";
4930 data.functionParams = static_cast<const void *>(&params);
4931 data.functionReturnValue = nullptr;
4932
4933 size_t i = 0;
4934 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4935 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4936 TracingHandle *handle = tracingHandle[i];
4937 DEBUG_BREAK_IF(handle == nullptr);
4938 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImageToBuffer)) {
4939 data.correlationData = correlationData + i;
4940 handle->call(CL_FUNCTION_clEnqueueCopyImageToBuffer, &data);
4941 }
4942 ++i;
4943 }
4944
4945 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
4946 }
4947
4948 void exit(cl_int *retVal) {
4949 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
4950 data.site = CL_CALLBACK_SITE_EXIT;
4951 data.functionReturnValue = retVal;
4952
4953 size_t i = 0;
4954 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
4955 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
4956 TracingHandle *handle = tracingHandle[i];
4957 DEBUG_BREAK_IF(handle == nullptr);
4958 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImageToBuffer)) {
4959 data.correlationData = correlationData + i;
4960 handle->call(CL_FUNCTION_clEnqueueCopyImageToBuffer, &data);
4961 }
4962 ++i;
4963 }
4964
4965 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
4966 }
4967
4968 ~ClEnqueueCopyImageToBufferTracer() {
4969 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
4970 }
4971
4972 private:
4973 cl_params_clEnqueueCopyImageToBuffer params{};
4974 cl_callback_data data{};
4975 uint64_t correlationData[tracingMaxHandleCount];
4976 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
4977 };
4978
4979 class ClEnqueueFillBufferTracer {
4980 public:
4981 ClEnqueueFillBufferTracer() {}
4982
4983 void enter(cl_command_queue *commandQueue,
4984 cl_mem *buffer,
4985 const void **pattern,
4986 size_t *patternSize,
4987 size_t *offset,
4988 size_t *size,
4989 cl_uint *numEventsInWaitList,
4990 const cl_event **eventWaitList,
4991 cl_event **event) {
4992 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
4993
4994 params.commandQueue = commandQueue;
4995 params.buffer = buffer;
4996 params.pattern = pattern;
4997 params.patternSize = patternSize;
4998 params.offset = offset;
4999 params.size = size;
5000 params.numEventsInWaitList = numEventsInWaitList;
5001 params.eventWaitList = eventWaitList;
5002 params.event = event;
5003
5004 data.site = CL_CALLBACK_SITE_ENTER;
5005 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5006 data.functionName = "clEnqueueFillBuffer";
5007 data.functionParams = static_cast<const void *>(&params);
5008 data.functionReturnValue = nullptr;
5009
5010 size_t i = 0;
5011 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5012 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5013 TracingHandle *handle = tracingHandle[i];
5014 DEBUG_BREAK_IF(handle == nullptr);
5015 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillBuffer)) {
5016 data.correlationData = correlationData + i;
5017 handle->call(CL_FUNCTION_clEnqueueFillBuffer, &data);
5018 }
5019 ++i;
5020 }
5021
5022 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5023 }
5024
5025 void exit(cl_int *retVal) {
5026 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5027 data.site = CL_CALLBACK_SITE_EXIT;
5028 data.functionReturnValue = retVal;
5029
5030 size_t i = 0;
5031 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5032 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5033 TracingHandle *handle = tracingHandle[i];
5034 DEBUG_BREAK_IF(handle == nullptr);
5035 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillBuffer)) {
5036 data.correlationData = correlationData + i;
5037 handle->call(CL_FUNCTION_clEnqueueFillBuffer, &data);
5038 }
5039 ++i;
5040 }
5041
5042 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5043 }
5044
5045 ~ClEnqueueFillBufferTracer() {
5046 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5047 }
5048
5049 private:
5050 cl_params_clEnqueueFillBuffer params{};
5051 cl_callback_data data{};
5052 uint64_t correlationData[tracingMaxHandleCount];
5053 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5054 };
5055
5056 class ClEnqueueFillImageTracer {
5057 public:
5058 ClEnqueueFillImageTracer() {}
5059
5060 void enter(cl_command_queue *commandQueue,
5061 cl_mem *image,
5062 const void **fillColor,
5063 const size_t **origin,
5064 const size_t **region,
5065 cl_uint *numEventsInWaitList,
5066 const cl_event **eventWaitList,
5067 cl_event **event) {
5068 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5069
5070 params.commandQueue = commandQueue;
5071 params.image = image;
5072 params.fillColor = fillColor;
5073 params.origin = origin;
5074 params.region = region;
5075 params.numEventsInWaitList = numEventsInWaitList;
5076 params.eventWaitList = eventWaitList;
5077 params.event = event;
5078
5079 data.site = CL_CALLBACK_SITE_ENTER;
5080 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5081 data.functionName = "clEnqueueFillImage";
5082 data.functionParams = static_cast<const void *>(&params);
5083 data.functionReturnValue = nullptr;
5084
5085 size_t i = 0;
5086 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5087 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5088 TracingHandle *handle = tracingHandle[i];
5089 DEBUG_BREAK_IF(handle == nullptr);
5090 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillImage)) {
5091 data.correlationData = correlationData + i;
5092 handle->call(CL_FUNCTION_clEnqueueFillImage, &data);
5093 }
5094 ++i;
5095 }
5096
5097 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5098 }
5099
5100 void exit(cl_int *retVal) {
5101 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5102 data.site = CL_CALLBACK_SITE_EXIT;
5103 data.functionReturnValue = retVal;
5104
5105 size_t i = 0;
5106 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5107 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5108 TracingHandle *handle = tracingHandle[i];
5109 DEBUG_BREAK_IF(handle == nullptr);
5110 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillImage)) {
5111 data.correlationData = correlationData + i;
5112 handle->call(CL_FUNCTION_clEnqueueFillImage, &data);
5113 }
5114 ++i;
5115 }
5116
5117 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5118 }
5119
5120 ~ClEnqueueFillImageTracer() {
5121 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5122 }
5123
5124 private:
5125 cl_params_clEnqueueFillImage params{};
5126 cl_callback_data data{};
5127 uint64_t correlationData[tracingMaxHandleCount];
5128 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5129 };
5130
5131 class ClEnqueueMapBufferTracer {
5132 public:
5133 ClEnqueueMapBufferTracer() {}
5134
5135 void enter(cl_command_queue *commandQueue,
5136 cl_mem *buffer,
5137 cl_bool *blockingMap,
5138 cl_map_flags *mapFlags,
5139 size_t *offset,
5140 size_t *cb,
5141 cl_uint *numEventsInWaitList,
5142 const cl_event **eventWaitList,
5143 cl_event **event,
5144 cl_int **errcodeRet) {
5145 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5146
5147 params.commandQueue = commandQueue;
5148 params.buffer = buffer;
5149 params.blockingMap = blockingMap;
5150 params.mapFlags = mapFlags;
5151 params.offset = offset;
5152 params.cb = cb;
5153 params.numEventsInWaitList = numEventsInWaitList;
5154 params.eventWaitList = eventWaitList;
5155 params.event = event;
5156 params.errcodeRet = errcodeRet;
5157
5158 data.site = CL_CALLBACK_SITE_ENTER;
5159 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5160 data.functionName = "clEnqueueMapBuffer";
5161 data.functionParams = static_cast<const void *>(&params);
5162 data.functionReturnValue = nullptr;
5163
5164 size_t i = 0;
5165 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5166 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5167 TracingHandle *handle = tracingHandle[i];
5168 DEBUG_BREAK_IF(handle == nullptr);
5169 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapBuffer)) {
5170 data.correlationData = correlationData + i;
5171 handle->call(CL_FUNCTION_clEnqueueMapBuffer, &data);
5172 }
5173 ++i;
5174 }
5175
5176 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5177 }
5178
5179 void exit(void **retVal) {
5180 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5181 data.site = CL_CALLBACK_SITE_EXIT;
5182 data.functionReturnValue = retVal;
5183
5184 size_t i = 0;
5185 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5186 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5187 TracingHandle *handle = tracingHandle[i];
5188 DEBUG_BREAK_IF(handle == nullptr);
5189 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapBuffer)) {
5190 data.correlationData = correlationData + i;
5191 handle->call(CL_FUNCTION_clEnqueueMapBuffer, &data);
5192 }
5193 ++i;
5194 }
5195
5196 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5197 }
5198
5199 ~ClEnqueueMapBufferTracer() {
5200 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5201 }
5202
5203 private:
5204 cl_params_clEnqueueMapBuffer params{};
5205 cl_callback_data data{};
5206 uint64_t correlationData[tracingMaxHandleCount];
5207 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5208 };
5209
5210 class ClEnqueueMapImageTracer {
5211 public:
5212 ClEnqueueMapImageTracer() {}
5213
5214 void enter(cl_command_queue *commandQueue,
5215 cl_mem *image,
5216 cl_bool *blockingMap,
5217 cl_map_flags *mapFlags,
5218 const size_t **origin,
5219 const size_t **region,
5220 size_t **imageRowPitch,
5221 size_t **imageSlicePitch,
5222 cl_uint *numEventsInWaitList,
5223 const cl_event **eventWaitList,
5224 cl_event **event,
5225 cl_int **errcodeRet) {
5226 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5227
5228 params.commandQueue = commandQueue;
5229 params.image = image;
5230 params.blockingMap = blockingMap;
5231 params.mapFlags = mapFlags;
5232 params.origin = origin;
5233 params.region = region;
5234 params.imageRowPitch = imageRowPitch;
5235 params.imageSlicePitch = imageSlicePitch;
5236 params.numEventsInWaitList = numEventsInWaitList;
5237 params.eventWaitList = eventWaitList;
5238 params.event = event;
5239 params.errcodeRet = errcodeRet;
5240
5241 data.site = CL_CALLBACK_SITE_ENTER;
5242 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5243 data.functionName = "clEnqueueMapImage";
5244 data.functionParams = static_cast<const void *>(&params);
5245 data.functionReturnValue = nullptr;
5246
5247 size_t i = 0;
5248 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5249 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5250 TracingHandle *handle = tracingHandle[i];
5251 DEBUG_BREAK_IF(handle == nullptr);
5252 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapImage)) {
5253 data.correlationData = correlationData + i;
5254 handle->call(CL_FUNCTION_clEnqueueMapImage, &data);
5255 }
5256 ++i;
5257 }
5258
5259 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5260 }
5261
5262 void exit(void **retVal) {
5263 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5264 data.site = CL_CALLBACK_SITE_EXIT;
5265 data.functionReturnValue = retVal;
5266
5267 size_t i = 0;
5268 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5269 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5270 TracingHandle *handle = tracingHandle[i];
5271 DEBUG_BREAK_IF(handle == nullptr);
5272 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapImage)) {
5273 data.correlationData = correlationData + i;
5274 handle->call(CL_FUNCTION_clEnqueueMapImage, &data);
5275 }
5276 ++i;
5277 }
5278
5279 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5280 }
5281
5282 ~ClEnqueueMapImageTracer() {
5283 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5284 }
5285
5286 private:
5287 cl_params_clEnqueueMapImage params{};
5288 cl_callback_data data{};
5289 uint64_t correlationData[tracingMaxHandleCount];
5290 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5291 };
5292
5293 class ClEnqueueMarkerTracer {
5294 public:
5295 ClEnqueueMarkerTracer() {}
5296
5297 void enter(cl_command_queue *commandQueue,
5298 cl_event **event) {
5299 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5300
5301 params.commandQueue = commandQueue;
5302 params.event = event;
5303
5304 data.site = CL_CALLBACK_SITE_ENTER;
5305 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5306 data.functionName = "clEnqueueMarker";
5307 data.functionParams = static_cast<const void *>(&params);
5308 data.functionReturnValue = nullptr;
5309
5310 size_t i = 0;
5311 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5312 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5313 TracingHandle *handle = tracingHandle[i];
5314 DEBUG_BREAK_IF(handle == nullptr);
5315 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarker)) {
5316 data.correlationData = correlationData + i;
5317 handle->call(CL_FUNCTION_clEnqueueMarker, &data);
5318 }
5319 ++i;
5320 }
5321
5322 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5323 }
5324
5325 void exit(cl_int *retVal) {
5326 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5327 data.site = CL_CALLBACK_SITE_EXIT;
5328 data.functionReturnValue = retVal;
5329
5330 size_t i = 0;
5331 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5332 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5333 TracingHandle *handle = tracingHandle[i];
5334 DEBUG_BREAK_IF(handle == nullptr);
5335 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarker)) {
5336 data.correlationData = correlationData + i;
5337 handle->call(CL_FUNCTION_clEnqueueMarker, &data);
5338 }
5339 ++i;
5340 }
5341
5342 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5343 }
5344
5345 ~ClEnqueueMarkerTracer() {
5346 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5347 }
5348
5349 private:
5350 cl_params_clEnqueueMarker params{};
5351 cl_callback_data data{};
5352 uint64_t correlationData[tracingMaxHandleCount];
5353 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5354 };
5355
5356 class ClEnqueueMarkerWithWaitListTracer {
5357 public:
5358 ClEnqueueMarkerWithWaitListTracer() {}
5359
5360 void enter(cl_command_queue *commandQueue,
5361 cl_uint *numEventsInWaitList,
5362 const cl_event **eventWaitList,
5363 cl_event **event) {
5364 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5365
5366 params.commandQueue = commandQueue;
5367 params.numEventsInWaitList = numEventsInWaitList;
5368 params.eventWaitList = eventWaitList;
5369 params.event = event;
5370
5371 data.site = CL_CALLBACK_SITE_ENTER;
5372 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5373 data.functionName = "clEnqueueMarkerWithWaitList";
5374 data.functionParams = static_cast<const void *>(&params);
5375 data.functionReturnValue = nullptr;
5376
5377 size_t i = 0;
5378 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5379 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5380 TracingHandle *handle = tracingHandle[i];
5381 DEBUG_BREAK_IF(handle == nullptr);
5382 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarkerWithWaitList)) {
5383 data.correlationData = correlationData + i;
5384 handle->call(CL_FUNCTION_clEnqueueMarkerWithWaitList, &data);
5385 }
5386 ++i;
5387 }
5388
5389 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5390 }
5391
5392 void exit(cl_int *retVal) {
5393 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5394 data.site = CL_CALLBACK_SITE_EXIT;
5395 data.functionReturnValue = retVal;
5396
5397 size_t i = 0;
5398 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5399 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5400 TracingHandle *handle = tracingHandle[i];
5401 DEBUG_BREAK_IF(handle == nullptr);
5402 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarkerWithWaitList)) {
5403 data.correlationData = correlationData + i;
5404 handle->call(CL_FUNCTION_clEnqueueMarkerWithWaitList, &data);
5405 }
5406 ++i;
5407 }
5408
5409 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5410 }
5411
5412 ~ClEnqueueMarkerWithWaitListTracer() {
5413 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5414 }
5415
5416 private:
5417 cl_params_clEnqueueMarkerWithWaitList params{};
5418 cl_callback_data data{};
5419 uint64_t correlationData[tracingMaxHandleCount];
5420 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5421 };
5422
5423 class ClEnqueueMigrateMemObjectsTracer {
5424 public:
5425 ClEnqueueMigrateMemObjectsTracer() {}
5426
5427 void enter(cl_command_queue *commandQueue,
5428 cl_uint *numMemObjects,
5429 const cl_mem **memObjects,
5430 cl_mem_migration_flags *flags,
5431 cl_uint *numEventsInWaitList,
5432 const cl_event **eventWaitList,
5433 cl_event **event) {
5434 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5435
5436 params.commandQueue = commandQueue;
5437 params.numMemObjects = numMemObjects;
5438 params.memObjects = memObjects;
5439 params.flags = flags;
5440 params.numEventsInWaitList = numEventsInWaitList;
5441 params.eventWaitList = eventWaitList;
5442 params.event = event;
5443
5444 data.site = CL_CALLBACK_SITE_ENTER;
5445 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5446 data.functionName = "clEnqueueMigrateMemObjects";
5447 data.functionParams = static_cast<const void *>(&params);
5448 data.functionReturnValue = nullptr;
5449
5450 size_t i = 0;
5451 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5452 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5453 TracingHandle *handle = tracingHandle[i];
5454 DEBUG_BREAK_IF(handle == nullptr);
5455 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemObjects)) {
5456 data.correlationData = correlationData + i;
5457 handle->call(CL_FUNCTION_clEnqueueMigrateMemObjects, &data);
5458 }
5459 ++i;
5460 }
5461
5462 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5463 }
5464
5465 void exit(cl_int *retVal) {
5466 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5467 data.site = CL_CALLBACK_SITE_EXIT;
5468 data.functionReturnValue = retVal;
5469
5470 size_t i = 0;
5471 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5472 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5473 TracingHandle *handle = tracingHandle[i];
5474 DEBUG_BREAK_IF(handle == nullptr);
5475 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemObjects)) {
5476 data.correlationData = correlationData + i;
5477 handle->call(CL_FUNCTION_clEnqueueMigrateMemObjects, &data);
5478 }
5479 ++i;
5480 }
5481
5482 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5483 }
5484
5485 ~ClEnqueueMigrateMemObjectsTracer() {
5486 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5487 }
5488
5489 private:
5490 cl_params_clEnqueueMigrateMemObjects params{};
5491 cl_callback_data data{};
5492 uint64_t correlationData[tracingMaxHandleCount];
5493 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5494 };
5495
5496 class ClEnqueueNdRangeKernelTracer {
5497 public:
5498 ClEnqueueNdRangeKernelTracer() {}
5499
5500 void enter(cl_command_queue *commandQueue,
5501 cl_kernel *kernel,
5502 cl_uint *workDim,
5503 const size_t **globalWorkOffset,
5504 const size_t **globalWorkSize,
5505 const size_t **localWorkSize,
5506 cl_uint *numEventsInWaitList,
5507 const cl_event **eventWaitList,
5508 cl_event **event) {
5509 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5510
5511 params.commandQueue = commandQueue;
5512 params.kernel = kernel;
5513 params.workDim = workDim;
5514 params.globalWorkOffset = globalWorkOffset;
5515 params.globalWorkSize = globalWorkSize;
5516 params.localWorkSize = localWorkSize;
5517 params.numEventsInWaitList = numEventsInWaitList;
5518 params.eventWaitList = eventWaitList;
5519 params.event = event;
5520
5521 data.site = CL_CALLBACK_SITE_ENTER;
5522 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5523 data.functionName = "clEnqueueNDRangeKernel";
5524 data.functionParams = static_cast<const void *>(&params);
5525 data.functionReturnValue = nullptr;
5526
5527 size_t i = 0;
5528 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5529 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5530 TracingHandle *handle = tracingHandle[i];
5531 DEBUG_BREAK_IF(handle == nullptr);
5532 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDRangeKernel)) {
5533 data.correlationData = correlationData + i;
5534 handle->call(CL_FUNCTION_clEnqueueNDRangeKernel, &data);
5535 }
5536 ++i;
5537 }
5538
5539 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5540 }
5541
5542 void exit(cl_int *retVal) {
5543 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5544 data.site = CL_CALLBACK_SITE_EXIT;
5545 data.functionReturnValue = retVal;
5546
5547 size_t i = 0;
5548 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5549 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5550 TracingHandle *handle = tracingHandle[i];
5551 DEBUG_BREAK_IF(handle == nullptr);
5552 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDRangeKernel)) {
5553 data.correlationData = correlationData + i;
5554 handle->call(CL_FUNCTION_clEnqueueNDRangeKernel, &data);
5555 }
5556 ++i;
5557 }
5558
5559 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5560 }
5561
5562 ~ClEnqueueNdRangeKernelTracer() {
5563 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5564 }
5565
5566 private:
5567 cl_params_clEnqueueNDRangeKernel params{};
5568 cl_callback_data data{};
5569 uint64_t correlationData[tracingMaxHandleCount];
5570 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5571 };
5572
5573 class ClEnqueueNativeKernelTracer {
5574 public:
5575 ClEnqueueNativeKernelTracer() {}
5576
5577 void enter(cl_command_queue *commandQueue,
5578 void(CL_CALLBACK **userFunc)(void *),
5579 void **args,
5580 size_t *cbArgs,
5581 cl_uint *numMemObjects,
5582 const cl_mem **memList,
5583 const void ***argsMemLoc,
5584 cl_uint *numEventsInWaitList,
5585 const cl_event **eventWaitList,
5586 cl_event **event) {
5587 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5588
5589 params.commandQueue = commandQueue;
5590 params.userFunc = userFunc;
5591 params.args = args;
5592 params.cbArgs = cbArgs;
5593 params.numMemObjects = numMemObjects;
5594 params.memList = memList;
5595 params.argsMemLoc = argsMemLoc;
5596 params.numEventsInWaitList = numEventsInWaitList;
5597 params.eventWaitList = eventWaitList;
5598 params.event = event;
5599
5600 data.site = CL_CALLBACK_SITE_ENTER;
5601 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5602 data.functionName = "clEnqueueNativeKernel";
5603 data.functionParams = static_cast<const void *>(&params);
5604 data.functionReturnValue = nullptr;
5605
5606 size_t i = 0;
5607 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5608 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5609 TracingHandle *handle = tracingHandle[i];
5610 DEBUG_BREAK_IF(handle == nullptr);
5611 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNativeKernel)) {
5612 data.correlationData = correlationData + i;
5613 handle->call(CL_FUNCTION_clEnqueueNativeKernel, &data);
5614 }
5615 ++i;
5616 }
5617
5618 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5619 }
5620
5621 void exit(cl_int *retVal) {
5622 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5623 data.site = CL_CALLBACK_SITE_EXIT;
5624 data.functionReturnValue = retVal;
5625
5626 size_t i = 0;
5627 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5628 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5629 TracingHandle *handle = tracingHandle[i];
5630 DEBUG_BREAK_IF(handle == nullptr);
5631 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNativeKernel)) {
5632 data.correlationData = correlationData + i;
5633 handle->call(CL_FUNCTION_clEnqueueNativeKernel, &data);
5634 }
5635 ++i;
5636 }
5637
5638 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5639 }
5640
5641 ~ClEnqueueNativeKernelTracer() {
5642 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5643 }
5644
5645 private:
5646 cl_params_clEnqueueNativeKernel params{};
5647 cl_callback_data data{};
5648 uint64_t correlationData[tracingMaxHandleCount];
5649 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5650 };
5651
5652 class ClEnqueueReadBufferTracer {
5653 public:
5654 ClEnqueueReadBufferTracer() {}
5655
5656 void enter(cl_command_queue *commandQueue,
5657 cl_mem *buffer,
5658 cl_bool *blockingRead,
5659 size_t *offset,
5660 size_t *cb,
5661 void **ptr,
5662 cl_uint *numEventsInWaitList,
5663 const cl_event **eventWaitList,
5664 cl_event **event) {
5665 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5666
5667 params.commandQueue = commandQueue;
5668 params.buffer = buffer;
5669 params.blockingRead = blockingRead;
5670 params.offset = offset;
5671 params.cb = cb;
5672 params.ptr = ptr;
5673 params.numEventsInWaitList = numEventsInWaitList;
5674 params.eventWaitList = eventWaitList;
5675 params.event = event;
5676
5677 data.site = CL_CALLBACK_SITE_ENTER;
5678 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5679 data.functionName = "clEnqueueReadBuffer";
5680 data.functionParams = static_cast<const void *>(&params);
5681 data.functionReturnValue = nullptr;
5682
5683 size_t i = 0;
5684 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5685 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5686 TracingHandle *handle = tracingHandle[i];
5687 DEBUG_BREAK_IF(handle == nullptr);
5688 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBuffer)) {
5689 data.correlationData = correlationData + i;
5690 handle->call(CL_FUNCTION_clEnqueueReadBuffer, &data);
5691 }
5692 ++i;
5693 }
5694
5695 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5696 }
5697
5698 void exit(cl_int *retVal) {
5699 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5700 data.site = CL_CALLBACK_SITE_EXIT;
5701 data.functionReturnValue = retVal;
5702
5703 size_t i = 0;
5704 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5705 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5706 TracingHandle *handle = tracingHandle[i];
5707 DEBUG_BREAK_IF(handle == nullptr);
5708 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBuffer)) {
5709 data.correlationData = correlationData + i;
5710 handle->call(CL_FUNCTION_clEnqueueReadBuffer, &data);
5711 }
5712 ++i;
5713 }
5714
5715 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5716 }
5717
5718 ~ClEnqueueReadBufferTracer() {
5719 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5720 }
5721
5722 private:
5723 cl_params_clEnqueueReadBuffer params{};
5724 cl_callback_data data{};
5725 uint64_t correlationData[tracingMaxHandleCount];
5726 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5727 };
5728
5729 class ClEnqueueReadBufferRectTracer {
5730 public:
5731 ClEnqueueReadBufferRectTracer() {}
5732
5733 void enter(cl_command_queue *commandQueue,
5734 cl_mem *buffer,
5735 cl_bool *blockingRead,
5736 const size_t **bufferOrigin,
5737 const size_t **hostOrigin,
5738 const size_t **region,
5739 size_t *bufferRowPitch,
5740 size_t *bufferSlicePitch,
5741 size_t *hostRowPitch,
5742 size_t *hostSlicePitch,
5743 void **ptr,
5744 cl_uint *numEventsInWaitList,
5745 const cl_event **eventWaitList,
5746 cl_event **event) {
5747 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5748
5749 params.commandQueue = commandQueue;
5750 params.buffer = buffer;
5751 params.blockingRead = blockingRead;
5752 params.bufferOrigin = bufferOrigin;
5753 params.hostOrigin = hostOrigin;
5754 params.region = region;
5755 params.bufferRowPitch = bufferRowPitch;
5756 params.bufferSlicePitch = bufferSlicePitch;
5757 params.hostRowPitch = hostRowPitch;
5758 params.hostSlicePitch = hostSlicePitch;
5759 params.ptr = ptr;
5760 params.numEventsInWaitList = numEventsInWaitList;
5761 params.eventWaitList = eventWaitList;
5762 params.event = event;
5763
5764 data.site = CL_CALLBACK_SITE_ENTER;
5765 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5766 data.functionName = "clEnqueueReadBufferRect";
5767 data.functionParams = static_cast<const void *>(&params);
5768 data.functionReturnValue = nullptr;
5769
5770 size_t i = 0;
5771 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5772 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5773 TracingHandle *handle = tracingHandle[i];
5774 DEBUG_BREAK_IF(handle == nullptr);
5775 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBufferRect)) {
5776 data.correlationData = correlationData + i;
5777 handle->call(CL_FUNCTION_clEnqueueReadBufferRect, &data);
5778 }
5779 ++i;
5780 }
5781
5782 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5783 }
5784
5785 void exit(cl_int *retVal) {
5786 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5787 data.site = CL_CALLBACK_SITE_EXIT;
5788 data.functionReturnValue = retVal;
5789
5790 size_t i = 0;
5791 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5792 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5793 TracingHandle *handle = tracingHandle[i];
5794 DEBUG_BREAK_IF(handle == nullptr);
5795 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBufferRect)) {
5796 data.correlationData = correlationData + i;
5797 handle->call(CL_FUNCTION_clEnqueueReadBufferRect, &data);
5798 }
5799 ++i;
5800 }
5801
5802 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5803 }
5804
5805 ~ClEnqueueReadBufferRectTracer() {
5806 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5807 }
5808
5809 private:
5810 cl_params_clEnqueueReadBufferRect params{};
5811 cl_callback_data data{};
5812 uint64_t correlationData[tracingMaxHandleCount];
5813 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5814 };
5815
5816 class ClEnqueueReadImageTracer {
5817 public:
5818 ClEnqueueReadImageTracer() {}
5819
5820 void enter(cl_command_queue *commandQueue,
5821 cl_mem *image,
5822 cl_bool *blockingRead,
5823 const size_t **origin,
5824 const size_t **region,
5825 size_t *rowPitch,
5826 size_t *slicePitch,
5827 void **ptr,
5828 cl_uint *numEventsInWaitList,
5829 const cl_event **eventWaitList,
5830 cl_event **event) {
5831 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5832
5833 params.commandQueue = commandQueue;
5834 params.image = image;
5835 params.blockingRead = blockingRead;
5836 params.origin = origin;
5837 params.region = region;
5838 params.rowPitch = rowPitch;
5839 params.slicePitch = slicePitch;
5840 params.ptr = ptr;
5841 params.numEventsInWaitList = numEventsInWaitList;
5842 params.eventWaitList = eventWaitList;
5843 params.event = event;
5844
5845 data.site = CL_CALLBACK_SITE_ENTER;
5846 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5847 data.functionName = "clEnqueueReadImage";
5848 data.functionParams = static_cast<const void *>(&params);
5849 data.functionReturnValue = nullptr;
5850
5851 size_t i = 0;
5852 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5853 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5854 TracingHandle *handle = tracingHandle[i];
5855 DEBUG_BREAK_IF(handle == nullptr);
5856 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadImage)) {
5857 data.correlationData = correlationData + i;
5858 handle->call(CL_FUNCTION_clEnqueueReadImage, &data);
5859 }
5860 ++i;
5861 }
5862
5863 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5864 }
5865
5866 void exit(cl_int *retVal) {
5867 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5868 data.site = CL_CALLBACK_SITE_EXIT;
5869 data.functionReturnValue = retVal;
5870
5871 size_t i = 0;
5872 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5873 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5874 TracingHandle *handle = tracingHandle[i];
5875 DEBUG_BREAK_IF(handle == nullptr);
5876 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadImage)) {
5877 data.correlationData = correlationData + i;
5878 handle->call(CL_FUNCTION_clEnqueueReadImage, &data);
5879 }
5880 ++i;
5881 }
5882
5883 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5884 }
5885
5886 ~ClEnqueueReadImageTracer() {
5887 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5888 }
5889
5890 private:
5891 cl_params_clEnqueueReadImage params{};
5892 cl_callback_data data{};
5893 uint64_t correlationData[tracingMaxHandleCount];
5894 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5895 };
5896
5897 class ClEnqueueSvmFreeTracer {
5898 public:
5899 ClEnqueueSvmFreeTracer() {}
5900
5901 void enter(cl_command_queue *commandQueue,
5902 cl_uint *numSvmPointers,
5903 void ***svmPointers,
5904 void(CL_CALLBACK **pfnFreeFunc)(cl_command_queue queue, cl_uint numSvmPointers, void **svmPointers, void *userData),
5905 void **userData,
5906 cl_uint *numEventsInWaitList,
5907 const cl_event **eventWaitList,
5908 cl_event **event) {
5909 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5910
5911 params.commandQueue = commandQueue;
5912 params.numSvmPointers = numSvmPointers;
5913 params.svmPointers = svmPointers;
5914 params.pfnFreeFunc = pfnFreeFunc;
5915 params.userData = userData;
5916 params.numEventsInWaitList = numEventsInWaitList;
5917 params.eventWaitList = eventWaitList;
5918 params.event = event;
5919
5920 data.site = CL_CALLBACK_SITE_ENTER;
5921 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5922 data.functionName = "clEnqueueSVMFree";
5923 data.functionParams = static_cast<const void *>(&params);
5924 data.functionReturnValue = nullptr;
5925
5926 size_t i = 0;
5927 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5928 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5929 TracingHandle *handle = tracingHandle[i];
5930 DEBUG_BREAK_IF(handle == nullptr);
5931 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMFree)) {
5932 data.correlationData = correlationData + i;
5933 handle->call(CL_FUNCTION_clEnqueueSVMFree, &data);
5934 }
5935 ++i;
5936 }
5937
5938 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
5939 }
5940
5941 void exit(cl_int *retVal) {
5942 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
5943 data.site = CL_CALLBACK_SITE_EXIT;
5944 data.functionReturnValue = retVal;
5945
5946 size_t i = 0;
5947 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
5948 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
5949 TracingHandle *handle = tracingHandle[i];
5950 DEBUG_BREAK_IF(handle == nullptr);
5951 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMFree)) {
5952 data.correlationData = correlationData + i;
5953 handle->call(CL_FUNCTION_clEnqueueSVMFree, &data);
5954 }
5955 ++i;
5956 }
5957
5958 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
5959 }
5960
5961 ~ClEnqueueSvmFreeTracer() {
5962 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
5963 }
5964
5965 private:
5966 cl_params_clEnqueueSVMFree params{};
5967 cl_callback_data data{};
5968 uint64_t correlationData[tracingMaxHandleCount];
5969 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
5970 };
5971
5972 class ClEnqueueSvmMapTracer {
5973 public:
5974 ClEnqueueSvmMapTracer() {}
5975
5976 void enter(cl_command_queue *commandQueue,
5977 cl_bool *blockingMap,
5978 cl_map_flags *mapFlags,
5979 void **svmPtr,
5980 size_t *size,
5981 cl_uint *numEventsInWaitList,
5982 const cl_event **eventWaitList,
5983 cl_event **event) {
5984 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
5985
5986 params.commandQueue = commandQueue;
5987 params.blockingMap = blockingMap;
5988 params.mapFlags = mapFlags;
5989 params.svmPtr = svmPtr;
5990 params.size = size;
5991 params.numEventsInWaitList = numEventsInWaitList;
5992 params.eventWaitList = eventWaitList;
5993 params.event = event;
5994
5995 data.site = CL_CALLBACK_SITE_ENTER;
5996 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
5997 data.functionName = "clEnqueueSVMMap";
5998 data.functionParams = static_cast<const void *>(&params);
5999 data.functionReturnValue = nullptr;
6000
6001 size_t i = 0;
6002 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6003 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6004 TracingHandle *handle = tracingHandle[i];
6005 DEBUG_BREAK_IF(handle == nullptr);
6006 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMap)) {
6007 data.correlationData = correlationData + i;
6008 handle->call(CL_FUNCTION_clEnqueueSVMMap, &data);
6009 }
6010 ++i;
6011 }
6012
6013 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6014 }
6015
6016 void exit(cl_int *retVal) {
6017 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6018 data.site = CL_CALLBACK_SITE_EXIT;
6019 data.functionReturnValue = retVal;
6020
6021 size_t i = 0;
6022 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6023 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6024 TracingHandle *handle = tracingHandle[i];
6025 DEBUG_BREAK_IF(handle == nullptr);
6026 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMap)) {
6027 data.correlationData = correlationData + i;
6028 handle->call(CL_FUNCTION_clEnqueueSVMMap, &data);
6029 }
6030 ++i;
6031 }
6032
6033 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6034 }
6035
6036 ~ClEnqueueSvmMapTracer() {
6037 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6038 }
6039
6040 private:
6041 cl_params_clEnqueueSVMMap params{};
6042 cl_callback_data data{};
6043 uint64_t correlationData[tracingMaxHandleCount];
6044 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6045 };
6046
6047 class ClEnqueueSvmMemFillTracer {
6048 public:
6049 ClEnqueueSvmMemFillTracer() {}
6050
6051 void enter(cl_command_queue *commandQueue,
6052 void **svmPtr,
6053 const void **pattern,
6054 size_t *patternSize,
6055 size_t *size,
6056 cl_uint *numEventsInWaitList,
6057 const cl_event **eventWaitList,
6058 cl_event **event) {
6059 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6060
6061 params.commandQueue = commandQueue;
6062 params.svmPtr = svmPtr;
6063 params.pattern = pattern;
6064 params.patternSize = patternSize;
6065 params.size = size;
6066 params.numEventsInWaitList = numEventsInWaitList;
6067 params.eventWaitList = eventWaitList;
6068 params.event = event;
6069
6070 data.site = CL_CALLBACK_SITE_ENTER;
6071 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6072 data.functionName = "clEnqueueSVMMemFill";
6073 data.functionParams = static_cast<const void *>(&params);
6074 data.functionReturnValue = nullptr;
6075
6076 size_t i = 0;
6077 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6078 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6079 TracingHandle *handle = tracingHandle[i];
6080 DEBUG_BREAK_IF(handle == nullptr);
6081 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemFill)) {
6082 data.correlationData = correlationData + i;
6083 handle->call(CL_FUNCTION_clEnqueueSVMMemFill, &data);
6084 }
6085 ++i;
6086 }
6087
6088 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6089 }
6090
6091 void exit(cl_int *retVal) {
6092 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6093 data.site = CL_CALLBACK_SITE_EXIT;
6094 data.functionReturnValue = retVal;
6095
6096 size_t i = 0;
6097 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6098 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6099 TracingHandle *handle = tracingHandle[i];
6100 DEBUG_BREAK_IF(handle == nullptr);
6101 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemFill)) {
6102 data.correlationData = correlationData + i;
6103 handle->call(CL_FUNCTION_clEnqueueSVMMemFill, &data);
6104 }
6105 ++i;
6106 }
6107
6108 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6109 }
6110
6111 ~ClEnqueueSvmMemFillTracer() {
6112 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6113 }
6114
6115 private:
6116 cl_params_clEnqueueSVMMemFill params{};
6117 cl_callback_data data{};
6118 uint64_t correlationData[tracingMaxHandleCount];
6119 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6120 };
6121
6122 class ClEnqueueSvmMemcpyTracer {
6123 public:
6124 ClEnqueueSvmMemcpyTracer() {}
6125
6126 void enter(cl_command_queue *commandQueue,
6127 cl_bool *blockingCopy,
6128 void **dstPtr,
6129 const void **srcPtr,
6130 size_t *size,
6131 cl_uint *numEventsInWaitList,
6132 const cl_event **eventWaitList,
6133 cl_event **event) {
6134 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6135
6136 params.commandQueue = commandQueue;
6137 params.blockingCopy = blockingCopy;
6138 params.dstPtr = dstPtr;
6139 params.srcPtr = srcPtr;
6140 params.size = size;
6141 params.numEventsInWaitList = numEventsInWaitList;
6142 params.eventWaitList = eventWaitList;
6143 params.event = event;
6144
6145 data.site = CL_CALLBACK_SITE_ENTER;
6146 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6147 data.functionName = "clEnqueueSVMMemcpy";
6148 data.functionParams = static_cast<const void *>(&params);
6149 data.functionReturnValue = nullptr;
6150
6151 size_t i = 0;
6152 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6153 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6154 TracingHandle *handle = tracingHandle[i];
6155 DEBUG_BREAK_IF(handle == nullptr);
6156 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemcpy)) {
6157 data.correlationData = correlationData + i;
6158 handle->call(CL_FUNCTION_clEnqueueSVMMemcpy, &data);
6159 }
6160 ++i;
6161 }
6162
6163 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6164 }
6165
6166 void exit(cl_int *retVal) {
6167 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6168 data.site = CL_CALLBACK_SITE_EXIT;
6169 data.functionReturnValue = retVal;
6170
6171 size_t i = 0;
6172 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6173 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6174 TracingHandle *handle = tracingHandle[i];
6175 DEBUG_BREAK_IF(handle == nullptr);
6176 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemcpy)) {
6177 data.correlationData = correlationData + i;
6178 handle->call(CL_FUNCTION_clEnqueueSVMMemcpy, &data);
6179 }
6180 ++i;
6181 }
6182
6183 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6184 }
6185
6186 ~ClEnqueueSvmMemcpyTracer() {
6187 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6188 }
6189
6190 private:
6191 cl_params_clEnqueueSVMMemcpy params{};
6192 cl_callback_data data{};
6193 uint64_t correlationData[tracingMaxHandleCount];
6194 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6195 };
6196
6197 class ClEnqueueSvmMigrateMemTracer {
6198 public:
6199 ClEnqueueSvmMigrateMemTracer() {}
6200
6201 void enter(cl_command_queue *commandQueue,
6202 cl_uint *numSvmPointers,
6203 const void ***svmPointers,
6204 const size_t **sizes,
6205 const cl_mem_migration_flags *flags,
6206 cl_uint *numEventsInWaitList,
6207 const cl_event **eventWaitList,
6208 cl_event **event) {
6209 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6210
6211 params.commandQueue = commandQueue;
6212 params.numSvmPointers = numSvmPointers;
6213 params.svmPointers = svmPointers;
6214 params.sizes = sizes;
6215 params.flags = flags;
6216 params.numEventsInWaitList = numEventsInWaitList;
6217 params.eventWaitList = eventWaitList;
6218 params.event = event;
6219
6220 data.site = CL_CALLBACK_SITE_ENTER;
6221 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6222 data.functionName = "clEnqueueSVMMigrateMem";
6223 data.functionParams = static_cast<const void *>(&params);
6224 data.functionReturnValue = nullptr;
6225
6226 size_t i = 0;
6227 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6228 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6229 TracingHandle *handle = tracingHandle[i];
6230 DEBUG_BREAK_IF(handle == nullptr);
6231 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMigrateMem)) {
6232 data.correlationData = correlationData + i;
6233 handle->call(CL_FUNCTION_clEnqueueSVMMigrateMem, &data);
6234 }
6235 ++i;
6236 }
6237
6238 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6239 }
6240
6241 void exit(cl_int *retVal) {
6242 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6243 data.site = CL_CALLBACK_SITE_EXIT;
6244 data.functionReturnValue = retVal;
6245
6246 size_t i = 0;
6247 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6248 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6249 TracingHandle *handle = tracingHandle[i];
6250 DEBUG_BREAK_IF(handle == nullptr);
6251 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMigrateMem)) {
6252 data.correlationData = correlationData + i;
6253 handle->call(CL_FUNCTION_clEnqueueSVMMigrateMem, &data);
6254 }
6255 ++i;
6256 }
6257
6258 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6259 }
6260
6261 ~ClEnqueueSvmMigrateMemTracer() {
6262 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6263 }
6264
6265 private:
6266 cl_params_clEnqueueSVMMigrateMem params{};
6267 cl_callback_data data{};
6268 uint64_t correlationData[tracingMaxHandleCount];
6269 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6270 };
6271
6272 class ClEnqueueSvmUnmapTracer {
6273 public:
6274 ClEnqueueSvmUnmapTracer() {}
6275
6276 void enter(cl_command_queue *commandQueue,
6277 void **svmPtr,
6278 cl_uint *numEventsInWaitList,
6279 const cl_event **eventWaitList,
6280 cl_event **event) {
6281 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6282
6283 params.commandQueue = commandQueue;
6284 params.svmPtr = svmPtr;
6285 params.numEventsInWaitList = numEventsInWaitList;
6286 params.eventWaitList = eventWaitList;
6287 params.event = event;
6288
6289 data.site = CL_CALLBACK_SITE_ENTER;
6290 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6291 data.functionName = "clEnqueueSVMUnmap";
6292 data.functionParams = static_cast<const void *>(&params);
6293 data.functionReturnValue = nullptr;
6294
6295 size_t i = 0;
6296 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6297 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6298 TracingHandle *handle = tracingHandle[i];
6299 DEBUG_BREAK_IF(handle == nullptr);
6300 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMUnmap)) {
6301 data.correlationData = correlationData + i;
6302 handle->call(CL_FUNCTION_clEnqueueSVMUnmap, &data);
6303 }
6304 ++i;
6305 }
6306
6307 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6308 }
6309
6310 void exit(cl_int *retVal) {
6311 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6312 data.site = CL_CALLBACK_SITE_EXIT;
6313 data.functionReturnValue = retVal;
6314
6315 size_t i = 0;
6316 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6317 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6318 TracingHandle *handle = tracingHandle[i];
6319 DEBUG_BREAK_IF(handle == nullptr);
6320 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMUnmap)) {
6321 data.correlationData = correlationData + i;
6322 handle->call(CL_FUNCTION_clEnqueueSVMUnmap, &data);
6323 }
6324 ++i;
6325 }
6326
6327 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6328 }
6329
6330 ~ClEnqueueSvmUnmapTracer() {
6331 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6332 }
6333
6334 private:
6335 cl_params_clEnqueueSVMUnmap params{};
6336 cl_callback_data data{};
6337 uint64_t correlationData[tracingMaxHandleCount];
6338 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6339 };
6340
6341 class ClEnqueueTaskTracer {
6342 public:
6343 ClEnqueueTaskTracer() {}
6344
6345 void enter(cl_command_queue *commandQueue,
6346 cl_kernel *kernel,
6347 cl_uint *numEventsInWaitList,
6348 const cl_event **eventWaitList,
6349 cl_event **event) {
6350 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6351
6352 params.commandQueue = commandQueue;
6353 params.kernel = kernel;
6354 params.numEventsInWaitList = numEventsInWaitList;
6355 params.eventWaitList = eventWaitList;
6356 params.event = event;
6357
6358 data.site = CL_CALLBACK_SITE_ENTER;
6359 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6360 data.functionName = "clEnqueueTask";
6361 data.functionParams = static_cast<const void *>(&params);
6362 data.functionReturnValue = nullptr;
6363
6364 size_t i = 0;
6365 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6366 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6367 TracingHandle *handle = tracingHandle[i];
6368 DEBUG_BREAK_IF(handle == nullptr);
6369 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueTask)) {
6370 data.correlationData = correlationData + i;
6371 handle->call(CL_FUNCTION_clEnqueueTask, &data);
6372 }
6373 ++i;
6374 }
6375
6376 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6377 }
6378
6379 void exit(cl_int *retVal) {
6380 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6381 data.site = CL_CALLBACK_SITE_EXIT;
6382 data.functionReturnValue = retVal;
6383
6384 size_t i = 0;
6385 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6386 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6387 TracingHandle *handle = tracingHandle[i];
6388 DEBUG_BREAK_IF(handle == nullptr);
6389 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueTask)) {
6390 data.correlationData = correlationData + i;
6391 handle->call(CL_FUNCTION_clEnqueueTask, &data);
6392 }
6393 ++i;
6394 }
6395
6396 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6397 }
6398
6399 ~ClEnqueueTaskTracer() {
6400 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6401 }
6402
6403 private:
6404 cl_params_clEnqueueTask params{};
6405 cl_callback_data data{};
6406 uint64_t correlationData[tracingMaxHandleCount];
6407 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6408 };
6409
6410 class ClEnqueueUnmapMemObjectTracer {
6411 public:
6412 ClEnqueueUnmapMemObjectTracer() {}
6413
6414 void enter(cl_command_queue *commandQueue,
6415 cl_mem *memobj,
6416 void **mappedPtr,
6417 cl_uint *numEventsInWaitList,
6418 const cl_event **eventWaitList,
6419 cl_event **event) {
6420 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6421
6422 params.commandQueue = commandQueue;
6423 params.memobj = memobj;
6424 params.mappedPtr = mappedPtr;
6425 params.numEventsInWaitList = numEventsInWaitList;
6426 params.eventWaitList = eventWaitList;
6427 params.event = event;
6428
6429 data.site = CL_CALLBACK_SITE_ENTER;
6430 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6431 data.functionName = "clEnqueueUnmapMemObject";
6432 data.functionParams = static_cast<const void *>(&params);
6433 data.functionReturnValue = nullptr;
6434
6435 size_t i = 0;
6436 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6437 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6438 TracingHandle *handle = tracingHandle[i];
6439 DEBUG_BREAK_IF(handle == nullptr);
6440 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueUnmapMemObject)) {
6441 data.correlationData = correlationData + i;
6442 handle->call(CL_FUNCTION_clEnqueueUnmapMemObject, &data);
6443 }
6444 ++i;
6445 }
6446
6447 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6448 }
6449
6450 void exit(cl_int *retVal) {
6451 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6452 data.site = CL_CALLBACK_SITE_EXIT;
6453 data.functionReturnValue = retVal;
6454
6455 size_t i = 0;
6456 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6457 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6458 TracingHandle *handle = tracingHandle[i];
6459 DEBUG_BREAK_IF(handle == nullptr);
6460 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueUnmapMemObject)) {
6461 data.correlationData = correlationData + i;
6462 handle->call(CL_FUNCTION_clEnqueueUnmapMemObject, &data);
6463 }
6464 ++i;
6465 }
6466
6467 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6468 }
6469
6470 ~ClEnqueueUnmapMemObjectTracer() {
6471 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6472 }
6473
6474 private:
6475 cl_params_clEnqueueUnmapMemObject params{};
6476 cl_callback_data data{};
6477 uint64_t correlationData[tracingMaxHandleCount];
6478 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6479 };
6480
6481 class ClEnqueueWaitForEventsTracer {
6482 public:
6483 ClEnqueueWaitForEventsTracer() {}
6484
6485 void enter(cl_command_queue *commandQueue,
6486 cl_uint *numEvents,
6487 const cl_event **eventList) {
6488 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6489
6490 params.commandQueue = commandQueue;
6491 params.numEvents = numEvents;
6492 params.eventList = eventList;
6493
6494 data.site = CL_CALLBACK_SITE_ENTER;
6495 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6496 data.functionName = "clEnqueueWaitForEvents";
6497 data.functionParams = static_cast<const void *>(&params);
6498 data.functionReturnValue = nullptr;
6499
6500 size_t i = 0;
6501 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6502 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6503 TracingHandle *handle = tracingHandle[i];
6504 DEBUG_BREAK_IF(handle == nullptr);
6505 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWaitForEvents)) {
6506 data.correlationData = correlationData + i;
6507 handle->call(CL_FUNCTION_clEnqueueWaitForEvents, &data);
6508 }
6509 ++i;
6510 }
6511
6512 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6513 }
6514
6515 void exit(cl_int *retVal) {
6516 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6517 data.site = CL_CALLBACK_SITE_EXIT;
6518 data.functionReturnValue = retVal;
6519
6520 size_t i = 0;
6521 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6522 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6523 TracingHandle *handle = tracingHandle[i];
6524 DEBUG_BREAK_IF(handle == nullptr);
6525 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWaitForEvents)) {
6526 data.correlationData = correlationData + i;
6527 handle->call(CL_FUNCTION_clEnqueueWaitForEvents, &data);
6528 }
6529 ++i;
6530 }
6531
6532 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6533 }
6534
6535 ~ClEnqueueWaitForEventsTracer() {
6536 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6537 }
6538
6539 private:
6540 cl_params_clEnqueueWaitForEvents params{};
6541 cl_callback_data data{};
6542 uint64_t correlationData[tracingMaxHandleCount];
6543 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6544 };
6545
6546 class ClEnqueueWriteBufferTracer {
6547 public:
6548 ClEnqueueWriteBufferTracer() {}
6549
6550 void enter(cl_command_queue *commandQueue,
6551 cl_mem *buffer,
6552 cl_bool *blockingWrite,
6553 size_t *offset,
6554 size_t *cb,
6555 const void **ptr,
6556 cl_uint *numEventsInWaitList,
6557 const cl_event **eventWaitList,
6558 cl_event **event) {
6559 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6560
6561 params.commandQueue = commandQueue;
6562 params.buffer = buffer;
6563 params.blockingWrite = blockingWrite;
6564 params.offset = offset;
6565 params.cb = cb;
6566 params.ptr = ptr;
6567 params.numEventsInWaitList = numEventsInWaitList;
6568 params.eventWaitList = eventWaitList;
6569 params.event = event;
6570
6571 data.site = CL_CALLBACK_SITE_ENTER;
6572 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6573 data.functionName = "clEnqueueWriteBuffer";
6574 data.functionParams = static_cast<const void *>(&params);
6575 data.functionReturnValue = nullptr;
6576
6577 size_t i = 0;
6578 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6579 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6580 TracingHandle *handle = tracingHandle[i];
6581 DEBUG_BREAK_IF(handle == nullptr);
6582 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBuffer)) {
6583 data.correlationData = correlationData + i;
6584 handle->call(CL_FUNCTION_clEnqueueWriteBuffer, &data);
6585 }
6586 ++i;
6587 }
6588
6589 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6590 }
6591
6592 void exit(cl_int *retVal) {
6593 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6594 data.site = CL_CALLBACK_SITE_EXIT;
6595 data.functionReturnValue = retVal;
6596
6597 size_t i = 0;
6598 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6599 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6600 TracingHandle *handle = tracingHandle[i];
6601 DEBUG_BREAK_IF(handle == nullptr);
6602 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBuffer)) {
6603 data.correlationData = correlationData + i;
6604 handle->call(CL_FUNCTION_clEnqueueWriteBuffer, &data);
6605 }
6606 ++i;
6607 }
6608
6609 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6610 }
6611
6612 ~ClEnqueueWriteBufferTracer() {
6613 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6614 }
6615
6616 private:
6617 cl_params_clEnqueueWriteBuffer params{};
6618 cl_callback_data data{};
6619 uint64_t correlationData[tracingMaxHandleCount];
6620 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6621 };
6622
6623 class ClEnqueueWriteBufferRectTracer {
6624 public:
6625 ClEnqueueWriteBufferRectTracer() {}
6626
6627 void enter(cl_command_queue *commandQueue,
6628 cl_mem *buffer,
6629 cl_bool *blockingWrite,
6630 const size_t **bufferOrigin,
6631 const size_t **hostOrigin,
6632 const size_t **region,
6633 size_t *bufferRowPitch,
6634 size_t *bufferSlicePitch,
6635 size_t *hostRowPitch,
6636 size_t *hostSlicePitch,
6637 const void **ptr,
6638 cl_uint *numEventsInWaitList,
6639 const cl_event **eventWaitList,
6640 cl_event **event) {
6641 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6642
6643 params.commandQueue = commandQueue;
6644 params.buffer = buffer;
6645 params.blockingWrite = blockingWrite;
6646 params.bufferOrigin = bufferOrigin;
6647 params.hostOrigin = hostOrigin;
6648 params.region = region;
6649 params.bufferRowPitch = bufferRowPitch;
6650 params.bufferSlicePitch = bufferSlicePitch;
6651 params.hostRowPitch = hostRowPitch;
6652 params.hostSlicePitch = hostSlicePitch;
6653 params.ptr = ptr;
6654 params.numEventsInWaitList = numEventsInWaitList;
6655 params.eventWaitList = eventWaitList;
6656 params.event = event;
6657
6658 data.site = CL_CALLBACK_SITE_ENTER;
6659 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6660 data.functionName = "clEnqueueWriteBufferRect";
6661 data.functionParams = static_cast<const void *>(&params);
6662 data.functionReturnValue = nullptr;
6663
6664 size_t i = 0;
6665 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6666 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6667 TracingHandle *handle = tracingHandle[i];
6668 DEBUG_BREAK_IF(handle == nullptr);
6669 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBufferRect)) {
6670 data.correlationData = correlationData + i;
6671 handle->call(CL_FUNCTION_clEnqueueWriteBufferRect, &data);
6672 }
6673 ++i;
6674 }
6675
6676 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6677 }
6678
6679 void exit(cl_int *retVal) {
6680 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6681 data.site = CL_CALLBACK_SITE_EXIT;
6682 data.functionReturnValue = retVal;
6683
6684 size_t i = 0;
6685 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6686 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6687 TracingHandle *handle = tracingHandle[i];
6688 DEBUG_BREAK_IF(handle == nullptr);
6689 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBufferRect)) {
6690 data.correlationData = correlationData + i;
6691 handle->call(CL_FUNCTION_clEnqueueWriteBufferRect, &data);
6692 }
6693 ++i;
6694 }
6695
6696 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6697 }
6698
6699 ~ClEnqueueWriteBufferRectTracer() {
6700 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6701 }
6702
6703 private:
6704 cl_params_clEnqueueWriteBufferRect params{};
6705 cl_callback_data data{};
6706 uint64_t correlationData[tracingMaxHandleCount];
6707 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6708 };
6709
6710 class ClEnqueueWriteImageTracer {
6711 public:
6712 ClEnqueueWriteImageTracer() {}
6713
6714 void enter(cl_command_queue *commandQueue,
6715 cl_mem *image,
6716 cl_bool *blockingWrite,
6717 const size_t **origin,
6718 const size_t **region,
6719 size_t *inputRowPitch,
6720 size_t *inputSlicePitch,
6721 const void **ptr,
6722 cl_uint *numEventsInWaitList,
6723 const cl_event **eventWaitList,
6724 cl_event **event) {
6725 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6726
6727 params.commandQueue = commandQueue;
6728 params.image = image;
6729 params.blockingWrite = blockingWrite;
6730 params.origin = origin;
6731 params.region = region;
6732 params.inputRowPitch = inputRowPitch;
6733 params.inputSlicePitch = inputSlicePitch;
6734 params.ptr = ptr;
6735 params.numEventsInWaitList = numEventsInWaitList;
6736 params.eventWaitList = eventWaitList;
6737 params.event = event;
6738
6739 data.site = CL_CALLBACK_SITE_ENTER;
6740 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6741 data.functionName = "clEnqueueWriteImage";
6742 data.functionParams = static_cast<const void *>(&params);
6743 data.functionReturnValue = nullptr;
6744
6745 size_t i = 0;
6746 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6747 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6748 TracingHandle *handle = tracingHandle[i];
6749 DEBUG_BREAK_IF(handle == nullptr);
6750 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteImage)) {
6751 data.correlationData = correlationData + i;
6752 handle->call(CL_FUNCTION_clEnqueueWriteImage, &data);
6753 }
6754 ++i;
6755 }
6756
6757 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6758 }
6759
6760 void exit(cl_int *retVal) {
6761 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6762 data.site = CL_CALLBACK_SITE_EXIT;
6763 data.functionReturnValue = retVal;
6764
6765 size_t i = 0;
6766 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6767 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6768 TracingHandle *handle = tracingHandle[i];
6769 DEBUG_BREAK_IF(handle == nullptr);
6770 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteImage)) {
6771 data.correlationData = correlationData + i;
6772 handle->call(CL_FUNCTION_clEnqueueWriteImage, &data);
6773 }
6774 ++i;
6775 }
6776
6777 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6778 }
6779
6780 ~ClEnqueueWriteImageTracer() {
6781 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6782 }
6783
6784 private:
6785 cl_params_clEnqueueWriteImage params{};
6786 cl_callback_data data{};
6787 uint64_t correlationData[tracingMaxHandleCount];
6788 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6789 };
6790
6791 class ClFinishTracer {
6792 public:
6793 ClFinishTracer() {}
6794
6795 void enter(cl_command_queue *commandQueue) {
6796 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6797
6798 params.commandQueue = commandQueue;
6799
6800 data.site = CL_CALLBACK_SITE_ENTER;
6801 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6802 data.functionName = "clFinish";
6803 data.functionParams = static_cast<const void *>(&params);
6804 data.functionReturnValue = nullptr;
6805
6806 size_t i = 0;
6807 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6808 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6809 TracingHandle *handle = tracingHandle[i];
6810 DEBUG_BREAK_IF(handle == nullptr);
6811 if (handle->getTracingPoint(CL_FUNCTION_clFinish)) {
6812 data.correlationData = correlationData + i;
6813 handle->call(CL_FUNCTION_clFinish, &data);
6814 }
6815 ++i;
6816 }
6817
6818 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6819 }
6820
6821 void exit(cl_int *retVal) {
6822 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6823 data.site = CL_CALLBACK_SITE_EXIT;
6824 data.functionReturnValue = retVal;
6825
6826 size_t i = 0;
6827 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6828 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6829 TracingHandle *handle = tracingHandle[i];
6830 DEBUG_BREAK_IF(handle == nullptr);
6831 if (handle->getTracingPoint(CL_FUNCTION_clFinish)) {
6832 data.correlationData = correlationData + i;
6833 handle->call(CL_FUNCTION_clFinish, &data);
6834 }
6835 ++i;
6836 }
6837
6838 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6839 }
6840
6841 ~ClFinishTracer() {
6842 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6843 }
6844
6845 private:
6846 cl_params_clFinish params{};
6847 cl_callback_data data{};
6848 uint64_t correlationData[tracingMaxHandleCount];
6849 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6850 };
6851
6852 class ClFlushTracer {
6853 public:
6854 ClFlushTracer() {}
6855
6856 void enter(cl_command_queue *commandQueue) {
6857 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6858
6859 params.commandQueue = commandQueue;
6860
6861 data.site = CL_CALLBACK_SITE_ENTER;
6862 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6863 data.functionName = "clFlush";
6864 data.functionParams = static_cast<const void *>(&params);
6865 data.functionReturnValue = nullptr;
6866
6867 size_t i = 0;
6868 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6869 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6870 TracingHandle *handle = tracingHandle[i];
6871 DEBUG_BREAK_IF(handle == nullptr);
6872 if (handle->getTracingPoint(CL_FUNCTION_clFlush)) {
6873 data.correlationData = correlationData + i;
6874 handle->call(CL_FUNCTION_clFlush, &data);
6875 }
6876 ++i;
6877 }
6878
6879 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6880 }
6881
6882 void exit(cl_int *retVal) {
6883 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6884 data.site = CL_CALLBACK_SITE_EXIT;
6885 data.functionReturnValue = retVal;
6886
6887 size_t i = 0;
6888 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6889 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6890 TracingHandle *handle = tracingHandle[i];
6891 DEBUG_BREAK_IF(handle == nullptr);
6892 if (handle->getTracingPoint(CL_FUNCTION_clFlush)) {
6893 data.correlationData = correlationData + i;
6894 handle->call(CL_FUNCTION_clFlush, &data);
6895 }
6896 ++i;
6897 }
6898
6899 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6900 }
6901
6902 ~ClFlushTracer() {
6903 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6904 }
6905
6906 private:
6907 cl_params_clFlush params{};
6908 cl_callback_data data{};
6909 uint64_t correlationData[tracingMaxHandleCount];
6910 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6911 };
6912
6913 class ClGetCommandQueueInfoTracer {
6914 public:
6915 ClGetCommandQueueInfoTracer() {}
6916
6917 void enter(cl_command_queue *commandQueue,
6918 cl_command_queue_info *paramName,
6919 size_t *paramValueSize,
6920 void **paramValue,
6921 size_t **paramValueSizeRet) {
6922 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6923
6924 params.commandQueue = commandQueue;
6925 params.paramName = paramName;
6926 params.paramValueSize = paramValueSize;
6927 params.paramValue = paramValue;
6928 params.paramValueSizeRet = paramValueSizeRet;
6929
6930 data.site = CL_CALLBACK_SITE_ENTER;
6931 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
6932 data.functionName = "clGetCommandQueueInfo";
6933 data.functionParams = static_cast<const void *>(&params);
6934 data.functionReturnValue = nullptr;
6935
6936 size_t i = 0;
6937 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6938 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6939 TracingHandle *handle = tracingHandle[i];
6940 DEBUG_BREAK_IF(handle == nullptr);
6941 if (handle->getTracingPoint(CL_FUNCTION_clGetCommandQueueInfo)) {
6942 data.correlationData = correlationData + i;
6943 handle->call(CL_FUNCTION_clGetCommandQueueInfo, &data);
6944 }
6945 ++i;
6946 }
6947
6948 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
6949 }
6950
6951 void exit(cl_int *retVal) {
6952 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
6953 data.site = CL_CALLBACK_SITE_EXIT;
6954 data.functionReturnValue = retVal;
6955
6956 size_t i = 0;
6957 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
6958 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
6959 TracingHandle *handle = tracingHandle[i];
6960 DEBUG_BREAK_IF(handle == nullptr);
6961 if (handle->getTracingPoint(CL_FUNCTION_clGetCommandQueueInfo)) {
6962 data.correlationData = correlationData + i;
6963 handle->call(CL_FUNCTION_clGetCommandQueueInfo, &data);
6964 }
6965 ++i;
6966 }
6967
6968 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
6969 }
6970
6971 ~ClGetCommandQueueInfoTracer() {
6972 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
6973 }
6974
6975 private:
6976 cl_params_clGetCommandQueueInfo params{};
6977 cl_callback_data data{};
6978 uint64_t correlationData[tracingMaxHandleCount];
6979 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
6980 };
6981
6982 class ClGetContextInfoTracer {
6983 public:
6984 ClGetContextInfoTracer() {}
6985
6986 void enter(cl_context *context,
6987 cl_context_info *paramName,
6988 size_t *paramValueSize,
6989 void **paramValue,
6990 size_t **paramValueSizeRet) {
6991 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
6992
6993 params.context = context;
6994 params.paramName = paramName;
6995 params.paramValueSize = paramValueSize;
6996 params.paramValue = paramValue;
6997 params.paramValueSizeRet = paramValueSizeRet;
6998
6999 data.site = CL_CALLBACK_SITE_ENTER;
7000 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7001 data.functionName = "clGetContextInfo";
7002 data.functionParams = static_cast<const void *>(&params);
7003 data.functionReturnValue = nullptr;
7004
7005 size_t i = 0;
7006 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7007 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7008 TracingHandle *handle = tracingHandle[i];
7009 DEBUG_BREAK_IF(handle == nullptr);
7010 if (handle->getTracingPoint(CL_FUNCTION_clGetContextInfo)) {
7011 data.correlationData = correlationData + i;
7012 handle->call(CL_FUNCTION_clGetContextInfo, &data);
7013 }
7014 ++i;
7015 }
7016
7017 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7018 }
7019
7020 void exit(cl_int *retVal) {
7021 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7022 data.site = CL_CALLBACK_SITE_EXIT;
7023 data.functionReturnValue = retVal;
7024
7025 size_t i = 0;
7026 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7027 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7028 TracingHandle *handle = tracingHandle[i];
7029 DEBUG_BREAK_IF(handle == nullptr);
7030 if (handle->getTracingPoint(CL_FUNCTION_clGetContextInfo)) {
7031 data.correlationData = correlationData + i;
7032 handle->call(CL_FUNCTION_clGetContextInfo, &data);
7033 }
7034 ++i;
7035 }
7036
7037 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7038 }
7039
7040 ~ClGetContextInfoTracer() {
7041 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7042 }
7043
7044 private:
7045 cl_params_clGetContextInfo params{};
7046 cl_callback_data data{};
7047 uint64_t correlationData[tracingMaxHandleCount];
7048 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7049 };
7050
7051 class ClGetDeviceAndHostTimerTracer {
7052 public:
7053 ClGetDeviceAndHostTimerTracer() {}
7054
7055 void enter(cl_device_id *device,
7056 cl_ulong **deviceTimestamp,
7057 cl_ulong **hostTimestamp) {
7058 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7059
7060 params.device = device;
7061 params.deviceTimestamp = deviceTimestamp;
7062 params.hostTimestamp = hostTimestamp;
7063
7064 data.site = CL_CALLBACK_SITE_ENTER;
7065 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7066 data.functionName = "clGetDeviceAndHostTimer";
7067 data.functionParams = static_cast<const void *>(&params);
7068 data.functionReturnValue = nullptr;
7069
7070 size_t i = 0;
7071 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7072 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7073 TracingHandle *handle = tracingHandle[i];
7074 DEBUG_BREAK_IF(handle == nullptr);
7075 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceAndHostTimer)) {
7076 data.correlationData = correlationData + i;
7077 handle->call(CL_FUNCTION_clGetDeviceAndHostTimer, &data);
7078 }
7079 ++i;
7080 }
7081
7082 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7083 }
7084
7085 void exit(cl_int *retVal) {
7086 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7087 data.site = CL_CALLBACK_SITE_EXIT;
7088 data.functionReturnValue = retVal;
7089
7090 size_t i = 0;
7091 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7092 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7093 TracingHandle *handle = tracingHandle[i];
7094 DEBUG_BREAK_IF(handle == nullptr);
7095 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceAndHostTimer)) {
7096 data.correlationData = correlationData + i;
7097 handle->call(CL_FUNCTION_clGetDeviceAndHostTimer, &data);
7098 }
7099 ++i;
7100 }
7101
7102 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7103 }
7104
7105 ~ClGetDeviceAndHostTimerTracer() {
7106 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7107 }
7108
7109 private:
7110 cl_params_clGetDeviceAndHostTimer params{};
7111 cl_callback_data data{};
7112 uint64_t correlationData[tracingMaxHandleCount];
7113 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7114 };
7115
7116 class ClGetDeviceIDsTracer {
7117 public:
7118 ClGetDeviceIDsTracer() {}
7119
7120 void enter(cl_platform_id *platform,
7121 cl_device_type *deviceType,
7122 cl_uint *numEntries,
7123 cl_device_id **devices,
7124 cl_uint **numDevices) {
7125 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7126
7127 params.platform = platform;
7128 params.deviceType = deviceType;
7129 params.numEntries = numEntries;
7130 params.devices = devices;
7131 params.numDevices = numDevices;
7132
7133 data.site = CL_CALLBACK_SITE_ENTER;
7134 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7135 data.functionName = "clGetDeviceIDs";
7136 data.functionParams = static_cast<const void *>(&params);
7137 data.functionReturnValue = nullptr;
7138
7139 size_t i = 0;
7140 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7141 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7142 TracingHandle *handle = tracingHandle[i];
7143 DEBUG_BREAK_IF(handle == nullptr);
7144 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceIDs)) {
7145 data.correlationData = correlationData + i;
7146 handle->call(CL_FUNCTION_clGetDeviceIDs, &data);
7147 }
7148 ++i;
7149 }
7150
7151 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7152 }
7153
7154 void exit(cl_int *retVal) {
7155 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7156 data.site = CL_CALLBACK_SITE_EXIT;
7157 data.functionReturnValue = retVal;
7158
7159 size_t i = 0;
7160 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7161 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7162 TracingHandle *handle = tracingHandle[i];
7163 DEBUG_BREAK_IF(handle == nullptr);
7164 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceIDs)) {
7165 data.correlationData = correlationData + i;
7166 handle->call(CL_FUNCTION_clGetDeviceIDs, &data);
7167 }
7168 ++i;
7169 }
7170
7171 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7172 }
7173
7174 ~ClGetDeviceIDsTracer() {
7175 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7176 }
7177
7178 private:
7179 cl_params_clGetDeviceIDs params{};
7180 cl_callback_data data{};
7181 uint64_t correlationData[tracingMaxHandleCount];
7182 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7183 };
7184
7185 class ClGetDeviceInfoTracer {
7186 public:
7187 ClGetDeviceInfoTracer() {}
7188
7189 void enter(cl_device_id *device,
7190 cl_device_info *paramName,
7191 size_t *paramValueSize,
7192 void **paramValue,
7193 size_t **paramValueSizeRet) {
7194 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7195
7196 params.device = device;
7197 params.paramName = paramName;
7198 params.paramValueSize = paramValueSize;
7199 params.paramValue = paramValue;
7200 params.paramValueSizeRet = paramValueSizeRet;
7201
7202 data.site = CL_CALLBACK_SITE_ENTER;
7203 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7204 data.functionName = "clGetDeviceInfo";
7205 data.functionParams = static_cast<const void *>(&params);
7206 data.functionReturnValue = nullptr;
7207
7208 size_t i = 0;
7209 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7210 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7211 TracingHandle *handle = tracingHandle[i];
7212 DEBUG_BREAK_IF(handle == nullptr);
7213 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceInfo)) {
7214 data.correlationData = correlationData + i;
7215 handle->call(CL_FUNCTION_clGetDeviceInfo, &data);
7216 }
7217 ++i;
7218 }
7219
7220 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7221 }
7222
7223 void exit(cl_int *retVal) {
7224 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7225 data.site = CL_CALLBACK_SITE_EXIT;
7226 data.functionReturnValue = retVal;
7227
7228 size_t i = 0;
7229 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7230 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7231 TracingHandle *handle = tracingHandle[i];
7232 DEBUG_BREAK_IF(handle == nullptr);
7233 if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceInfo)) {
7234 data.correlationData = correlationData + i;
7235 handle->call(CL_FUNCTION_clGetDeviceInfo, &data);
7236 }
7237 ++i;
7238 }
7239
7240 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7241 }
7242
7243 ~ClGetDeviceInfoTracer() {
7244 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7245 }
7246
7247 private:
7248 cl_params_clGetDeviceInfo params{};
7249 cl_callback_data data{};
7250 uint64_t correlationData[tracingMaxHandleCount];
7251 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7252 };
7253
7254 class ClGetEventInfoTracer {
7255 public:
7256 ClGetEventInfoTracer() {}
7257
7258 void enter(cl_event *event,
7259 cl_event_info *paramName,
7260 size_t *paramValueSize,
7261 void **paramValue,
7262 size_t **paramValueSizeRet) {
7263 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7264
7265 params.event = event;
7266 params.paramName = paramName;
7267 params.paramValueSize = paramValueSize;
7268 params.paramValue = paramValue;
7269 params.paramValueSizeRet = paramValueSizeRet;
7270
7271 data.site = CL_CALLBACK_SITE_ENTER;
7272 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7273 data.functionName = "clGetEventInfo";
7274 data.functionParams = static_cast<const void *>(&params);
7275 data.functionReturnValue = nullptr;
7276
7277 size_t i = 0;
7278 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7279 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7280 TracingHandle *handle = tracingHandle[i];
7281 DEBUG_BREAK_IF(handle == nullptr);
7282 if (handle->getTracingPoint(CL_FUNCTION_clGetEventInfo)) {
7283 data.correlationData = correlationData + i;
7284 handle->call(CL_FUNCTION_clGetEventInfo, &data);
7285 }
7286 ++i;
7287 }
7288
7289 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7290 }
7291
7292 void exit(cl_int *retVal) {
7293 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7294 data.site = CL_CALLBACK_SITE_EXIT;
7295 data.functionReturnValue = retVal;
7296
7297 size_t i = 0;
7298 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7299 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7300 TracingHandle *handle = tracingHandle[i];
7301 DEBUG_BREAK_IF(handle == nullptr);
7302 if (handle->getTracingPoint(CL_FUNCTION_clGetEventInfo)) {
7303 data.correlationData = correlationData + i;
7304 handle->call(CL_FUNCTION_clGetEventInfo, &data);
7305 }
7306 ++i;
7307 }
7308
7309 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7310 }
7311
7312 ~ClGetEventInfoTracer() {
7313 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7314 }
7315
7316 private:
7317 cl_params_clGetEventInfo params{};
7318 cl_callback_data data{};
7319 uint64_t correlationData[tracingMaxHandleCount];
7320 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7321 };
7322
7323 class ClGetEventProfilingInfoTracer {
7324 public:
7325 ClGetEventProfilingInfoTracer() {}
7326
7327 void enter(cl_event *event,
7328 cl_profiling_info *paramName,
7329 size_t *paramValueSize,
7330 void **paramValue,
7331 size_t **paramValueSizeRet) {
7332 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7333
7334 params.event = event;
7335 params.paramName = paramName;
7336 params.paramValueSize = paramValueSize;
7337 params.paramValue = paramValue;
7338 params.paramValueSizeRet = paramValueSizeRet;
7339
7340 data.site = CL_CALLBACK_SITE_ENTER;
7341 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7342 data.functionName = "clGetEventProfilingInfo";
7343 data.functionParams = static_cast<const void *>(&params);
7344 data.functionReturnValue = nullptr;
7345
7346 size_t i = 0;
7347 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7348 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7349 TracingHandle *handle = tracingHandle[i];
7350 DEBUG_BREAK_IF(handle == nullptr);
7351 if (handle->getTracingPoint(CL_FUNCTION_clGetEventProfilingInfo)) {
7352 data.correlationData = correlationData + i;
7353 handle->call(CL_FUNCTION_clGetEventProfilingInfo, &data);
7354 }
7355 ++i;
7356 }
7357
7358 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7359 }
7360
7361 void exit(cl_int *retVal) {
7362 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7363 data.site = CL_CALLBACK_SITE_EXIT;
7364 data.functionReturnValue = retVal;
7365
7366 size_t i = 0;
7367 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7368 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7369 TracingHandle *handle = tracingHandle[i];
7370 DEBUG_BREAK_IF(handle == nullptr);
7371 if (handle->getTracingPoint(CL_FUNCTION_clGetEventProfilingInfo)) {
7372 data.correlationData = correlationData + i;
7373 handle->call(CL_FUNCTION_clGetEventProfilingInfo, &data);
7374 }
7375 ++i;
7376 }
7377
7378 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7379 }
7380
7381 ~ClGetEventProfilingInfoTracer() {
7382 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7383 }
7384
7385 private:
7386 cl_params_clGetEventProfilingInfo params{};
7387 cl_callback_data data{};
7388 uint64_t correlationData[tracingMaxHandleCount];
7389 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7390 };
7391
7392 class ClGetExtensionFunctionAddressTracer {
7393 public:
7394 ClGetExtensionFunctionAddressTracer() {}
7395
7396 void enter(const char **funcName) {
7397 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7398
7399 params.funcName = funcName;
7400
7401 data.site = CL_CALLBACK_SITE_ENTER;
7402 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7403 data.functionName = "clGetExtensionFunctionAddress";
7404 data.functionParams = static_cast<const void *>(&params);
7405 data.functionReturnValue = nullptr;
7406
7407 size_t i = 0;
7408 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7409 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7410 TracingHandle *handle = tracingHandle[i];
7411 DEBUG_BREAK_IF(handle == nullptr);
7412 if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddress)) {
7413 data.correlationData = correlationData + i;
7414 handle->call(CL_FUNCTION_clGetExtensionFunctionAddress, &data);
7415 }
7416 ++i;
7417 }
7418
7419 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7420 }
7421
7422 void exit(void **retVal) {
7423 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7424 data.site = CL_CALLBACK_SITE_EXIT;
7425 data.functionReturnValue = retVal;
7426
7427 size_t i = 0;
7428 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7429 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7430 TracingHandle *handle = tracingHandle[i];
7431 DEBUG_BREAK_IF(handle == nullptr);
7432 if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddress)) {
7433 data.correlationData = correlationData + i;
7434 handle->call(CL_FUNCTION_clGetExtensionFunctionAddress, &data);
7435 }
7436 ++i;
7437 }
7438
7439 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7440 }
7441
7442 ~ClGetExtensionFunctionAddressTracer() {
7443 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7444 }
7445
7446 private:
7447 cl_params_clGetExtensionFunctionAddress params{};
7448 cl_callback_data data{};
7449 uint64_t correlationData[tracingMaxHandleCount];
7450 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7451 };
7452
7453 class ClGetExtensionFunctionAddressForPlatformTracer {
7454 public:
7455 ClGetExtensionFunctionAddressForPlatformTracer() {}
7456
7457 void enter(cl_platform_id *platform,
7458 const char **funcName) {
7459 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7460
7461 params.platform = platform;
7462 params.funcName = funcName;
7463
7464 data.site = CL_CALLBACK_SITE_ENTER;
7465 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7466 data.functionName = "clGetExtensionFunctionAddressForPlatform";
7467 data.functionParams = static_cast<const void *>(&params);
7468 data.functionReturnValue = nullptr;
7469
7470 size_t i = 0;
7471 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7472 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7473 TracingHandle *handle = tracingHandle[i];
7474 DEBUG_BREAK_IF(handle == nullptr);
7475 if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform)) {
7476 data.correlationData = correlationData + i;
7477 handle->call(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform, &data);
7478 }
7479 ++i;
7480 }
7481
7482 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7483 }
7484
7485 void exit(void **retVal) {
7486 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7487 data.site = CL_CALLBACK_SITE_EXIT;
7488 data.functionReturnValue = retVal;
7489
7490 size_t i = 0;
7491 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7492 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7493 TracingHandle *handle = tracingHandle[i];
7494 DEBUG_BREAK_IF(handle == nullptr);
7495 if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform)) {
7496 data.correlationData = correlationData + i;
7497 handle->call(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform, &data);
7498 }
7499 ++i;
7500 }
7501
7502 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7503 }
7504
7505 ~ClGetExtensionFunctionAddressForPlatformTracer() {
7506 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7507 }
7508
7509 private:
7510 cl_params_clGetExtensionFunctionAddressForPlatform params{};
7511 cl_callback_data data{};
7512 uint64_t correlationData[tracingMaxHandleCount];
7513 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7514 };
7515
7516 class ClGetHostTimerTracer {
7517 public:
7518 ClGetHostTimerTracer() {}
7519
7520 void enter(cl_device_id *device,
7521 cl_ulong **hostTimestamp) {
7522 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7523
7524 params.device = device;
7525 params.hostTimestamp = hostTimestamp;
7526
7527 data.site = CL_CALLBACK_SITE_ENTER;
7528 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7529 data.functionName = "clGetHostTimer";
7530 data.functionParams = static_cast<const void *>(&params);
7531 data.functionReturnValue = nullptr;
7532
7533 size_t i = 0;
7534 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7535 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7536 TracingHandle *handle = tracingHandle[i];
7537 DEBUG_BREAK_IF(handle == nullptr);
7538 if (handle->getTracingPoint(CL_FUNCTION_clGetHostTimer)) {
7539 data.correlationData = correlationData + i;
7540 handle->call(CL_FUNCTION_clGetHostTimer, &data);
7541 }
7542 ++i;
7543 }
7544
7545 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7546 }
7547
7548 void exit(cl_int *retVal) {
7549 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7550 data.site = CL_CALLBACK_SITE_EXIT;
7551 data.functionReturnValue = retVal;
7552
7553 size_t i = 0;
7554 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7555 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7556 TracingHandle *handle = tracingHandle[i];
7557 DEBUG_BREAK_IF(handle == nullptr);
7558 if (handle->getTracingPoint(CL_FUNCTION_clGetHostTimer)) {
7559 data.correlationData = correlationData + i;
7560 handle->call(CL_FUNCTION_clGetHostTimer, &data);
7561 }
7562 ++i;
7563 }
7564
7565 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7566 }
7567
7568 ~ClGetHostTimerTracer() {
7569 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7570 }
7571
7572 private:
7573 cl_params_clGetHostTimer params{};
7574 cl_callback_data data{};
7575 uint64_t correlationData[tracingMaxHandleCount];
7576 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7577 };
7578
7579 class ClGetImageInfoTracer {
7580 public:
7581 ClGetImageInfoTracer() {}
7582
7583 void enter(cl_mem *image,
7584 cl_image_info *paramName,
7585 size_t *paramValueSize,
7586 void **paramValue,
7587 size_t **paramValueSizeRet) {
7588 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7589
7590 params.image = image;
7591 params.paramName = paramName;
7592 params.paramValueSize = paramValueSize;
7593 params.paramValue = paramValue;
7594 params.paramValueSizeRet = paramValueSizeRet;
7595
7596 data.site = CL_CALLBACK_SITE_ENTER;
7597 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7598 data.functionName = "clGetImageInfo";
7599 data.functionParams = static_cast<const void *>(&params);
7600 data.functionReturnValue = nullptr;
7601
7602 size_t i = 0;
7603 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7604 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7605 TracingHandle *handle = tracingHandle[i];
7606 DEBUG_BREAK_IF(handle == nullptr);
7607 if (handle->getTracingPoint(CL_FUNCTION_clGetImageInfo)) {
7608 data.correlationData = correlationData + i;
7609 handle->call(CL_FUNCTION_clGetImageInfo, &data);
7610 }
7611 ++i;
7612 }
7613
7614 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7615 }
7616
7617 void exit(cl_int *retVal) {
7618 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7619 data.site = CL_CALLBACK_SITE_EXIT;
7620 data.functionReturnValue = retVal;
7621
7622 size_t i = 0;
7623 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7624 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7625 TracingHandle *handle = tracingHandle[i];
7626 DEBUG_BREAK_IF(handle == nullptr);
7627 if (handle->getTracingPoint(CL_FUNCTION_clGetImageInfo)) {
7628 data.correlationData = correlationData + i;
7629 handle->call(CL_FUNCTION_clGetImageInfo, &data);
7630 }
7631 ++i;
7632 }
7633
7634 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7635 }
7636
7637 ~ClGetImageInfoTracer() {
7638 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7639 }
7640
7641 private:
7642 cl_params_clGetImageInfo params{};
7643 cl_callback_data data{};
7644 uint64_t correlationData[tracingMaxHandleCount];
7645 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7646 };
7647
7648 class ClGetKernelArgInfoTracer {
7649 public:
7650 ClGetKernelArgInfoTracer() {}
7651
7652 void enter(cl_kernel *kernel,
7653 cl_uint *argIndx,
7654 cl_kernel_arg_info *paramName,
7655 size_t *paramValueSize,
7656 void **paramValue,
7657 size_t **paramValueSizeRet) {
7658 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7659
7660 params.kernel = kernel;
7661 params.argIndx = argIndx;
7662 params.paramName = paramName;
7663 params.paramValueSize = paramValueSize;
7664 params.paramValue = paramValue;
7665 params.paramValueSizeRet = paramValueSizeRet;
7666
7667 data.site = CL_CALLBACK_SITE_ENTER;
7668 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7669 data.functionName = "clGetKernelArgInfo";
7670 data.functionParams = static_cast<const void *>(&params);
7671 data.functionReturnValue = nullptr;
7672
7673 size_t i = 0;
7674 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7675 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7676 TracingHandle *handle = tracingHandle[i];
7677 DEBUG_BREAK_IF(handle == nullptr);
7678 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelArgInfo)) {
7679 data.correlationData = correlationData + i;
7680 handle->call(CL_FUNCTION_clGetKernelArgInfo, &data);
7681 }
7682 ++i;
7683 }
7684
7685 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7686 }
7687
7688 void exit(cl_int *retVal) {
7689 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7690 data.site = CL_CALLBACK_SITE_EXIT;
7691 data.functionReturnValue = retVal;
7692
7693 size_t i = 0;
7694 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7695 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7696 TracingHandle *handle = tracingHandle[i];
7697 DEBUG_BREAK_IF(handle == nullptr);
7698 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelArgInfo)) {
7699 data.correlationData = correlationData + i;
7700 handle->call(CL_FUNCTION_clGetKernelArgInfo, &data);
7701 }
7702 ++i;
7703 }
7704
7705 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7706 }
7707
7708 ~ClGetKernelArgInfoTracer() {
7709 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7710 }
7711
7712 private:
7713 cl_params_clGetKernelArgInfo params{};
7714 cl_callback_data data{};
7715 uint64_t correlationData[tracingMaxHandleCount];
7716 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7717 };
7718
7719 class ClGetKernelInfoTracer {
7720 public:
7721 ClGetKernelInfoTracer() {}
7722
7723 void enter(cl_kernel *kernel,
7724 cl_kernel_info *paramName,
7725 size_t *paramValueSize,
7726 void **paramValue,
7727 size_t **paramValueSizeRet) {
7728 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7729
7730 params.kernel = kernel;
7731 params.paramName = paramName;
7732 params.paramValueSize = paramValueSize;
7733 params.paramValue = paramValue;
7734 params.paramValueSizeRet = paramValueSizeRet;
7735
7736 data.site = CL_CALLBACK_SITE_ENTER;
7737 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7738 data.functionName = "clGetKernelInfo";
7739 data.functionParams = static_cast<const void *>(&params);
7740 data.functionReturnValue = nullptr;
7741
7742 size_t i = 0;
7743 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7744 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7745 TracingHandle *handle = tracingHandle[i];
7746 DEBUG_BREAK_IF(handle == nullptr);
7747 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelInfo)) {
7748 data.correlationData = correlationData + i;
7749 handle->call(CL_FUNCTION_clGetKernelInfo, &data);
7750 }
7751 ++i;
7752 }
7753
7754 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7755 }
7756
7757 void exit(cl_int *retVal) {
7758 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7759 data.site = CL_CALLBACK_SITE_EXIT;
7760 data.functionReturnValue = retVal;
7761
7762 size_t i = 0;
7763 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7764 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7765 TracingHandle *handle = tracingHandle[i];
7766 DEBUG_BREAK_IF(handle == nullptr);
7767 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelInfo)) {
7768 data.correlationData = correlationData + i;
7769 handle->call(CL_FUNCTION_clGetKernelInfo, &data);
7770 }
7771 ++i;
7772 }
7773
7774 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7775 }
7776
7777 ~ClGetKernelInfoTracer() {
7778 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7779 }
7780
7781 private:
7782 cl_params_clGetKernelInfo params{};
7783 cl_callback_data data{};
7784 uint64_t correlationData[tracingMaxHandleCount];
7785 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7786 };
7787
7788 class ClGetKernelSubGroupInfoTracer {
7789 public:
7790 ClGetKernelSubGroupInfoTracer() {}
7791
7792 void enter(cl_kernel *kernel,
7793 cl_device_id *device,
7794 cl_kernel_sub_group_info *paramName,
7795 size_t *inputValueSize,
7796 const void **inputValue,
7797 size_t *paramValueSize,
7798 void **paramValue,
7799 size_t **paramValueSizeRet) {
7800 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7801
7802 params.kernel = kernel;
7803 params.device = device;
7804 params.paramName = paramName;
7805 params.inputValueSize = inputValueSize;
7806 params.inputValue = inputValue;
7807 params.paramValueSize = paramValueSize;
7808 params.paramValue = paramValue;
7809 params.paramValueSizeRet = paramValueSizeRet;
7810
7811 data.site = CL_CALLBACK_SITE_ENTER;
7812 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7813 data.functionName = "clGetKernelSubGroupInfo";
7814 data.functionParams = static_cast<const void *>(&params);
7815 data.functionReturnValue = nullptr;
7816
7817 size_t i = 0;
7818 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7819 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7820 TracingHandle *handle = tracingHandle[i];
7821 DEBUG_BREAK_IF(handle == nullptr);
7822 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfo)) {
7823 data.correlationData = correlationData + i;
7824 handle->call(CL_FUNCTION_clGetKernelSubGroupInfo, &data);
7825 }
7826 ++i;
7827 }
7828
7829 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7830 }
7831
7832 void exit(cl_int *retVal) {
7833 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7834 data.site = CL_CALLBACK_SITE_EXIT;
7835 data.functionReturnValue = retVal;
7836
7837 size_t i = 0;
7838 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7839 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7840 TracingHandle *handle = tracingHandle[i];
7841 DEBUG_BREAK_IF(handle == nullptr);
7842 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfo)) {
7843 data.correlationData = correlationData + i;
7844 handle->call(CL_FUNCTION_clGetKernelSubGroupInfo, &data);
7845 }
7846 ++i;
7847 }
7848
7849 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7850 }
7851
7852 ~ClGetKernelSubGroupInfoTracer() {
7853 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7854 }
7855
7856 private:
7857 cl_params_clGetKernelSubGroupInfo params{};
7858 cl_callback_data data{};
7859 uint64_t correlationData[tracingMaxHandleCount];
7860 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7861 };
7862
7863 class ClGetKernelWorkGroupInfoTracer {
7864 public:
7865 ClGetKernelWorkGroupInfoTracer() {}
7866
7867 void enter(cl_kernel *kernel,
7868 cl_device_id *device,
7869 cl_kernel_work_group_info *paramName,
7870 size_t *paramValueSize,
7871 void **paramValue,
7872 size_t **paramValueSizeRet) {
7873 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7874
7875 params.kernel = kernel;
7876 params.device = device;
7877 params.paramName = paramName;
7878 params.paramValueSize = paramValueSize;
7879 params.paramValue = paramValue;
7880 params.paramValueSizeRet = paramValueSizeRet;
7881
7882 data.site = CL_CALLBACK_SITE_ENTER;
7883 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7884 data.functionName = "clGetKernelWorkGroupInfo";
7885 data.functionParams = static_cast<const void *>(&params);
7886 data.functionReturnValue = nullptr;
7887
7888 size_t i = 0;
7889 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7890 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7891 TracingHandle *handle = tracingHandle[i];
7892 DEBUG_BREAK_IF(handle == nullptr);
7893 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelWorkGroupInfo)) {
7894 data.correlationData = correlationData + i;
7895 handle->call(CL_FUNCTION_clGetKernelWorkGroupInfo, &data);
7896 }
7897 ++i;
7898 }
7899
7900 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7901 }
7902
7903 void exit(cl_int *retVal) {
7904 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7905 data.site = CL_CALLBACK_SITE_EXIT;
7906 data.functionReturnValue = retVal;
7907
7908 size_t i = 0;
7909 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7910 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7911 TracingHandle *handle = tracingHandle[i];
7912 DEBUG_BREAK_IF(handle == nullptr);
7913 if (handle->getTracingPoint(CL_FUNCTION_clGetKernelWorkGroupInfo)) {
7914 data.correlationData = correlationData + i;
7915 handle->call(CL_FUNCTION_clGetKernelWorkGroupInfo, &data);
7916 }
7917 ++i;
7918 }
7919
7920 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7921 }
7922
7923 ~ClGetKernelWorkGroupInfoTracer() {
7924 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7925 }
7926
7927 private:
7928 cl_params_clGetKernelWorkGroupInfo params{};
7929 cl_callback_data data{};
7930 uint64_t correlationData[tracingMaxHandleCount];
7931 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
7932 };
7933
7934 class ClGetMemObjectInfoTracer {
7935 public:
7936 ClGetMemObjectInfoTracer() {}
7937
7938 void enter(cl_mem *memobj,
7939 cl_mem_info *paramName,
7940 size_t *paramValueSize,
7941 void **paramValue,
7942 size_t **paramValueSizeRet) {
7943 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
7944
7945 params.memobj = memobj;
7946 params.paramName = paramName;
7947 params.paramValueSize = paramValueSize;
7948 params.paramValue = paramValue;
7949 params.paramValueSizeRet = paramValueSizeRet;
7950
7951 data.site = CL_CALLBACK_SITE_ENTER;
7952 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
7953 data.functionName = "clGetMemObjectInfo";
7954 data.functionParams = static_cast<const void *>(&params);
7955 data.functionReturnValue = nullptr;
7956
7957 size_t i = 0;
7958 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7959 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7960 TracingHandle *handle = tracingHandle[i];
7961 DEBUG_BREAK_IF(handle == nullptr);
7962 if (handle->getTracingPoint(CL_FUNCTION_clGetMemObjectInfo)) {
7963 data.correlationData = correlationData + i;
7964 handle->call(CL_FUNCTION_clGetMemObjectInfo, &data);
7965 }
7966 ++i;
7967 }
7968
7969 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
7970 }
7971
7972 void exit(cl_int *retVal) {
7973 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
7974 data.site = CL_CALLBACK_SITE_EXIT;
7975 data.functionReturnValue = retVal;
7976
7977 size_t i = 0;
7978 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
7979 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
7980 TracingHandle *handle = tracingHandle[i];
7981 DEBUG_BREAK_IF(handle == nullptr);
7982 if (handle->getTracingPoint(CL_FUNCTION_clGetMemObjectInfo)) {
7983 data.correlationData = correlationData + i;
7984 handle->call(CL_FUNCTION_clGetMemObjectInfo, &data);
7985 }
7986 ++i;
7987 }
7988
7989 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
7990 }
7991
7992 ~ClGetMemObjectInfoTracer() {
7993 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
7994 }
7995
7996 private:
7997 cl_params_clGetMemObjectInfo params{};
7998 cl_callback_data data{};
7999 uint64_t correlationData[tracingMaxHandleCount];
8000 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8001 };
8002
8003 class ClGetPipeInfoTracer {
8004 public:
8005 ClGetPipeInfoTracer() {}
8006
8007 void enter(cl_mem *pipe,
8008 cl_pipe_info *paramName,
8009 size_t *paramValueSize,
8010 void **paramValue,
8011 size_t **paramValueSizeRet) {
8012 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8013
8014 params.pipe = pipe;
8015 params.paramName = paramName;
8016 params.paramValueSize = paramValueSize;
8017 params.paramValue = paramValue;
8018 params.paramValueSizeRet = paramValueSizeRet;
8019
8020 data.site = CL_CALLBACK_SITE_ENTER;
8021 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8022 data.functionName = "clGetPipeInfo";
8023 data.functionParams = static_cast<const void *>(&params);
8024 data.functionReturnValue = nullptr;
8025
8026 size_t i = 0;
8027 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8028 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8029 TracingHandle *handle = tracingHandle[i];
8030 DEBUG_BREAK_IF(handle == nullptr);
8031 if (handle->getTracingPoint(CL_FUNCTION_clGetPipeInfo)) {
8032 data.correlationData = correlationData + i;
8033 handle->call(CL_FUNCTION_clGetPipeInfo, &data);
8034 }
8035 ++i;
8036 }
8037
8038 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8039 }
8040
8041 void exit(cl_int *retVal) {
8042 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8043 data.site = CL_CALLBACK_SITE_EXIT;
8044 data.functionReturnValue = retVal;
8045
8046 size_t i = 0;
8047 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8048 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8049 TracingHandle *handle = tracingHandle[i];
8050 DEBUG_BREAK_IF(handle == nullptr);
8051 if (handle->getTracingPoint(CL_FUNCTION_clGetPipeInfo)) {
8052 data.correlationData = correlationData + i;
8053 handle->call(CL_FUNCTION_clGetPipeInfo, &data);
8054 }
8055 ++i;
8056 }
8057
8058 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8059 }
8060
8061 ~ClGetPipeInfoTracer() {
8062 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8063 }
8064
8065 private:
8066 cl_params_clGetPipeInfo params{};
8067 cl_callback_data data{};
8068 uint64_t correlationData[tracingMaxHandleCount];
8069 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8070 };
8071
8072 class ClGetPlatformIDsTracer {
8073 public:
8074 ClGetPlatformIDsTracer() {}
8075
8076 void enter(cl_uint *numEntries,
8077 cl_platform_id **platforms,
8078 cl_uint **numPlatforms) {
8079 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8080
8081 params.numEntries = numEntries;
8082 params.platforms = platforms;
8083 params.numPlatforms = numPlatforms;
8084
8085 data.site = CL_CALLBACK_SITE_ENTER;
8086 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8087 data.functionName = "clGetPlatformIDs";
8088 data.functionParams = static_cast<const void *>(&params);
8089 data.functionReturnValue = nullptr;
8090
8091 size_t i = 0;
8092 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8093 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8094 TracingHandle *handle = tracingHandle[i];
8095 DEBUG_BREAK_IF(handle == nullptr);
8096 if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformIDs)) {
8097 data.correlationData = correlationData + i;
8098 handle->call(CL_FUNCTION_clGetPlatformIDs, &data);
8099 }
8100 ++i;
8101 }
8102
8103 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8104 }
8105
8106 void exit(cl_int *retVal) {
8107 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8108 data.site = CL_CALLBACK_SITE_EXIT;
8109 data.functionReturnValue = retVal;
8110
8111 size_t i = 0;
8112 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8113 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8114 TracingHandle *handle = tracingHandle[i];
8115 DEBUG_BREAK_IF(handle == nullptr);
8116 if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformIDs)) {
8117 data.correlationData = correlationData + i;
8118 handle->call(CL_FUNCTION_clGetPlatformIDs, &data);
8119 }
8120 ++i;
8121 }
8122
8123 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8124 }
8125
8126 ~ClGetPlatformIDsTracer() {
8127 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8128 }
8129
8130 private:
8131 cl_params_clGetPlatformIDs params{};
8132 cl_callback_data data{};
8133 uint64_t correlationData[tracingMaxHandleCount];
8134 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8135 };
8136
8137 class ClGetPlatformInfoTracer {
8138 public:
8139 ClGetPlatformInfoTracer() {}
8140
8141 void enter(cl_platform_id *platform,
8142 cl_platform_info *paramName,
8143 size_t *paramValueSize,
8144 void **paramValue,
8145 size_t **paramValueSizeRet) {
8146 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8147
8148 params.platform = platform;
8149 params.paramName = paramName;
8150 params.paramValueSize = paramValueSize;
8151 params.paramValue = paramValue;
8152 params.paramValueSizeRet = paramValueSizeRet;
8153
8154 data.site = CL_CALLBACK_SITE_ENTER;
8155 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8156 data.functionName = "clGetPlatformInfo";
8157 data.functionParams = static_cast<const void *>(&params);
8158 data.functionReturnValue = nullptr;
8159
8160 size_t i = 0;
8161 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8162 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8163 TracingHandle *handle = tracingHandle[i];
8164 DEBUG_BREAK_IF(handle == nullptr);
8165 if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformInfo)) {
8166 data.correlationData = correlationData + i;
8167 handle->call(CL_FUNCTION_clGetPlatformInfo, &data);
8168 }
8169 ++i;
8170 }
8171
8172 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8173 }
8174
8175 void exit(cl_int *retVal) {
8176 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8177 data.site = CL_CALLBACK_SITE_EXIT;
8178 data.functionReturnValue = retVal;
8179
8180 size_t i = 0;
8181 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8182 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8183 TracingHandle *handle = tracingHandle[i];
8184 DEBUG_BREAK_IF(handle == nullptr);
8185 if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformInfo)) {
8186 data.correlationData = correlationData + i;
8187 handle->call(CL_FUNCTION_clGetPlatformInfo, &data);
8188 }
8189 ++i;
8190 }
8191
8192 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8193 }
8194
8195 ~ClGetPlatformInfoTracer() {
8196 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8197 }
8198
8199 private:
8200 cl_params_clGetPlatformInfo params{};
8201 cl_callback_data data{};
8202 uint64_t correlationData[tracingMaxHandleCount];
8203 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8204 };
8205
8206 class ClGetProgramBuildInfoTracer {
8207 public:
8208 ClGetProgramBuildInfoTracer() {}
8209
8210 void enter(cl_program *program,
8211 cl_device_id *device,
8212 cl_program_build_info *paramName,
8213 size_t *paramValueSize,
8214 void **paramValue,
8215 size_t **paramValueSizeRet) {
8216 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8217
8218 params.program = program;
8219 params.device = device;
8220 params.paramName = paramName;
8221 params.paramValueSize = paramValueSize;
8222 params.paramValue = paramValue;
8223 params.paramValueSizeRet = paramValueSizeRet;
8224
8225 data.site = CL_CALLBACK_SITE_ENTER;
8226 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8227 data.functionName = "clGetProgramBuildInfo";
8228 data.functionParams = static_cast<const void *>(&params);
8229 data.functionReturnValue = nullptr;
8230
8231 size_t i = 0;
8232 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8233 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8234 TracingHandle *handle = tracingHandle[i];
8235 DEBUG_BREAK_IF(handle == nullptr);
8236 if (handle->getTracingPoint(CL_FUNCTION_clGetProgramBuildInfo)) {
8237 data.correlationData = correlationData + i;
8238 handle->call(CL_FUNCTION_clGetProgramBuildInfo, &data);
8239 }
8240 ++i;
8241 }
8242
8243 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8244 }
8245
8246 void exit(cl_int *retVal) {
8247 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8248 data.site = CL_CALLBACK_SITE_EXIT;
8249 data.functionReturnValue = retVal;
8250
8251 size_t i = 0;
8252 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8253 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8254 TracingHandle *handle = tracingHandle[i];
8255 DEBUG_BREAK_IF(handle == nullptr);
8256 if (handle->getTracingPoint(CL_FUNCTION_clGetProgramBuildInfo)) {
8257 data.correlationData = correlationData + i;
8258 handle->call(CL_FUNCTION_clGetProgramBuildInfo, &data);
8259 }
8260 ++i;
8261 }
8262
8263 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8264 }
8265
8266 ~ClGetProgramBuildInfoTracer() {
8267 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8268 }
8269
8270 private:
8271 cl_params_clGetProgramBuildInfo params{};
8272 cl_callback_data data{};
8273 uint64_t correlationData[tracingMaxHandleCount];
8274 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8275 };
8276
8277 class ClGetProgramInfoTracer {
8278 public:
8279 ClGetProgramInfoTracer() {}
8280
8281 void enter(cl_program *program,
8282 cl_program_info *paramName,
8283 size_t *paramValueSize,
8284 void **paramValue,
8285 size_t **paramValueSizeRet) {
8286 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8287
8288 params.program = program;
8289 params.paramName = paramName;
8290 params.paramValueSize = paramValueSize;
8291 params.paramValue = paramValue;
8292 params.paramValueSizeRet = paramValueSizeRet;
8293
8294 data.site = CL_CALLBACK_SITE_ENTER;
8295 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8296 data.functionName = "clGetProgramInfo";
8297 data.functionParams = static_cast<const void *>(&params);
8298 data.functionReturnValue = nullptr;
8299
8300 size_t i = 0;
8301 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8302 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8303 TracingHandle *handle = tracingHandle[i];
8304 DEBUG_BREAK_IF(handle == nullptr);
8305 if (handle->getTracingPoint(CL_FUNCTION_clGetProgramInfo)) {
8306 data.correlationData = correlationData + i;
8307 handle->call(CL_FUNCTION_clGetProgramInfo, &data);
8308 }
8309 ++i;
8310 }
8311
8312 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8313 }
8314
8315 void exit(cl_int *retVal) {
8316 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8317 data.site = CL_CALLBACK_SITE_EXIT;
8318 data.functionReturnValue = retVal;
8319
8320 size_t i = 0;
8321 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8322 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8323 TracingHandle *handle = tracingHandle[i];
8324 DEBUG_BREAK_IF(handle == nullptr);
8325 if (handle->getTracingPoint(CL_FUNCTION_clGetProgramInfo)) {
8326 data.correlationData = correlationData + i;
8327 handle->call(CL_FUNCTION_clGetProgramInfo, &data);
8328 }
8329 ++i;
8330 }
8331
8332 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8333 }
8334
8335 ~ClGetProgramInfoTracer() {
8336 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8337 }
8338
8339 private:
8340 cl_params_clGetProgramInfo params{};
8341 cl_callback_data data{};
8342 uint64_t correlationData[tracingMaxHandleCount];
8343 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8344 };
8345
8346 class ClGetSamplerInfoTracer {
8347 public:
8348 ClGetSamplerInfoTracer() {}
8349
8350 void enter(cl_sampler *sampler,
8351 cl_sampler_info *paramName,
8352 size_t *paramValueSize,
8353 void **paramValue,
8354 size_t **paramValueSizeRet) {
8355 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8356
8357 params.sampler = sampler;
8358 params.paramName = paramName;
8359 params.paramValueSize = paramValueSize;
8360 params.paramValue = paramValue;
8361 params.paramValueSizeRet = paramValueSizeRet;
8362
8363 data.site = CL_CALLBACK_SITE_ENTER;
8364 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8365 data.functionName = "clGetSamplerInfo";
8366 data.functionParams = static_cast<const void *>(&params);
8367 data.functionReturnValue = nullptr;
8368
8369 size_t i = 0;
8370 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8371 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8372 TracingHandle *handle = tracingHandle[i];
8373 DEBUG_BREAK_IF(handle == nullptr);
8374 if (handle->getTracingPoint(CL_FUNCTION_clGetSamplerInfo)) {
8375 data.correlationData = correlationData + i;
8376 handle->call(CL_FUNCTION_clGetSamplerInfo, &data);
8377 }
8378 ++i;
8379 }
8380
8381 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8382 }
8383
8384 void exit(cl_int *retVal) {
8385 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8386 data.site = CL_CALLBACK_SITE_EXIT;
8387 data.functionReturnValue = retVal;
8388
8389 size_t i = 0;
8390 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8391 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8392 TracingHandle *handle = tracingHandle[i];
8393 DEBUG_BREAK_IF(handle == nullptr);
8394 if (handle->getTracingPoint(CL_FUNCTION_clGetSamplerInfo)) {
8395 data.correlationData = correlationData + i;
8396 handle->call(CL_FUNCTION_clGetSamplerInfo, &data);
8397 }
8398 ++i;
8399 }
8400
8401 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8402 }
8403
8404 ~ClGetSamplerInfoTracer() {
8405 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8406 }
8407
8408 private:
8409 cl_params_clGetSamplerInfo params{};
8410 cl_callback_data data{};
8411 uint64_t correlationData[tracingMaxHandleCount];
8412 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8413 };
8414
8415 class ClGetSupportedImageFormatsTracer {
8416 public:
8417 ClGetSupportedImageFormatsTracer() {}
8418
8419 void enter(cl_context *context,
8420 cl_mem_flags *flags,
8421 cl_mem_object_type *imageType,
8422 cl_uint *numEntries,
8423 cl_image_format **imageFormats,
8424 cl_uint **numImageFormats) {
8425 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8426
8427 params.context = context;
8428 params.flags = flags;
8429 params.imageType = imageType;
8430 params.numEntries = numEntries;
8431 params.imageFormats = imageFormats;
8432 params.numImageFormats = numImageFormats;
8433
8434 data.site = CL_CALLBACK_SITE_ENTER;
8435 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8436 data.functionName = "clGetSupportedImageFormats";
8437 data.functionParams = static_cast<const void *>(&params);
8438 data.functionReturnValue = nullptr;
8439
8440 size_t i = 0;
8441 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8442 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8443 TracingHandle *handle = tracingHandle[i];
8444 DEBUG_BREAK_IF(handle == nullptr);
8445 if (handle->getTracingPoint(CL_FUNCTION_clGetSupportedImageFormats)) {
8446 data.correlationData = correlationData + i;
8447 handle->call(CL_FUNCTION_clGetSupportedImageFormats, &data);
8448 }
8449 ++i;
8450 }
8451
8452 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8453 }
8454
8455 void exit(cl_int *retVal) {
8456 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8457 data.site = CL_CALLBACK_SITE_EXIT;
8458 data.functionReturnValue = retVal;
8459
8460 size_t i = 0;
8461 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8462 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8463 TracingHandle *handle = tracingHandle[i];
8464 DEBUG_BREAK_IF(handle == nullptr);
8465 if (handle->getTracingPoint(CL_FUNCTION_clGetSupportedImageFormats)) {
8466 data.correlationData = correlationData + i;
8467 handle->call(CL_FUNCTION_clGetSupportedImageFormats, &data);
8468 }
8469 ++i;
8470 }
8471
8472 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8473 }
8474
8475 ~ClGetSupportedImageFormatsTracer() {
8476 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8477 }
8478
8479 private:
8480 cl_params_clGetSupportedImageFormats params{};
8481 cl_callback_data data{};
8482 uint64_t correlationData[tracingMaxHandleCount];
8483 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8484 };
8485
8486 class ClLinkProgramTracer {
8487 public:
8488 ClLinkProgramTracer() {}
8489
8490 void enter(cl_context *context,
8491 cl_uint *numDevices,
8492 const cl_device_id **deviceList,
8493 const char **options,
8494 cl_uint *numInputPrograms,
8495 const cl_program **inputPrograms,
8496 void(CL_CALLBACK **funcNotify)(cl_program program, void *userData),
8497 void **userData,
8498 cl_int **errcodeRet) {
8499 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8500
8501 params.context = context;
8502 params.numDevices = numDevices;
8503 params.deviceList = deviceList;
8504 params.options = options;
8505 params.numInputPrograms = numInputPrograms;
8506 params.inputPrograms = inputPrograms;
8507 params.funcNotify = funcNotify;
8508 params.userData = userData;
8509 params.errcodeRet = errcodeRet;
8510
8511 data.site = CL_CALLBACK_SITE_ENTER;
8512 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8513 data.functionName = "clLinkProgram";
8514 data.functionParams = static_cast<const void *>(&params);
8515 data.functionReturnValue = nullptr;
8516
8517 size_t i = 0;
8518 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8519 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8520 TracingHandle *handle = tracingHandle[i];
8521 DEBUG_BREAK_IF(handle == nullptr);
8522 if (handle->getTracingPoint(CL_FUNCTION_clLinkProgram)) {
8523 data.correlationData = correlationData + i;
8524 handle->call(CL_FUNCTION_clLinkProgram, &data);
8525 }
8526 ++i;
8527 }
8528
8529 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8530 }
8531
8532 void exit(cl_program *retVal) {
8533 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8534 data.site = CL_CALLBACK_SITE_EXIT;
8535 data.functionReturnValue = retVal;
8536
8537 size_t i = 0;
8538 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8539 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8540 TracingHandle *handle = tracingHandle[i];
8541 DEBUG_BREAK_IF(handle == nullptr);
8542 if (handle->getTracingPoint(CL_FUNCTION_clLinkProgram)) {
8543 data.correlationData = correlationData + i;
8544 handle->call(CL_FUNCTION_clLinkProgram, &data);
8545 }
8546 ++i;
8547 }
8548
8549 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8550 }
8551
8552 ~ClLinkProgramTracer() {
8553 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8554 }
8555
8556 private:
8557 cl_params_clLinkProgram params{};
8558 cl_callback_data data{};
8559 uint64_t correlationData[tracingMaxHandleCount];
8560 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8561 };
8562
8563 class ClReleaseCommandQueueTracer {
8564 public:
8565 ClReleaseCommandQueueTracer() {}
8566
8567 void enter(cl_command_queue *commandQueue) {
8568 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8569
8570 params.commandQueue = commandQueue;
8571
8572 data.site = CL_CALLBACK_SITE_ENTER;
8573 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8574 data.functionName = "clReleaseCommandQueue";
8575 data.functionParams = static_cast<const void *>(&params);
8576 data.functionReturnValue = nullptr;
8577
8578 size_t i = 0;
8579 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8580 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8581 TracingHandle *handle = tracingHandle[i];
8582 DEBUG_BREAK_IF(handle == nullptr);
8583 if (handle->getTracingPoint(CL_FUNCTION_clReleaseCommandQueue)) {
8584 data.correlationData = correlationData + i;
8585 handle->call(CL_FUNCTION_clReleaseCommandQueue, &data);
8586 }
8587 ++i;
8588 }
8589
8590 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8591 }
8592
8593 void exit(cl_int *retVal) {
8594 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8595 data.site = CL_CALLBACK_SITE_EXIT;
8596 data.functionReturnValue = retVal;
8597
8598 size_t i = 0;
8599 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8600 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8601 TracingHandle *handle = tracingHandle[i];
8602 DEBUG_BREAK_IF(handle == nullptr);
8603 if (handle->getTracingPoint(CL_FUNCTION_clReleaseCommandQueue)) {
8604 data.correlationData = correlationData + i;
8605 handle->call(CL_FUNCTION_clReleaseCommandQueue, &data);
8606 }
8607 ++i;
8608 }
8609
8610 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8611 }
8612
8613 ~ClReleaseCommandQueueTracer() {
8614 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8615 }
8616
8617 private:
8618 cl_params_clReleaseCommandQueue params{};
8619 cl_callback_data data{};
8620 uint64_t correlationData[tracingMaxHandleCount];
8621 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8622 };
8623
8624 class ClReleaseContextTracer {
8625 public:
8626 ClReleaseContextTracer() {}
8627
8628 void enter(cl_context *context) {
8629 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8630
8631 params.context = context;
8632
8633 data.site = CL_CALLBACK_SITE_ENTER;
8634 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8635 data.functionName = "clReleaseContext";
8636 data.functionParams = static_cast<const void *>(&params);
8637 data.functionReturnValue = nullptr;
8638
8639 size_t i = 0;
8640 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8641 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8642 TracingHandle *handle = tracingHandle[i];
8643 DEBUG_BREAK_IF(handle == nullptr);
8644 if (handle->getTracingPoint(CL_FUNCTION_clReleaseContext)) {
8645 data.correlationData = correlationData + i;
8646 handle->call(CL_FUNCTION_clReleaseContext, &data);
8647 }
8648 ++i;
8649 }
8650
8651 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8652 }
8653
8654 void exit(cl_int *retVal) {
8655 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8656 data.site = CL_CALLBACK_SITE_EXIT;
8657 data.functionReturnValue = retVal;
8658
8659 size_t i = 0;
8660 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8661 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8662 TracingHandle *handle = tracingHandle[i];
8663 DEBUG_BREAK_IF(handle == nullptr);
8664 if (handle->getTracingPoint(CL_FUNCTION_clReleaseContext)) {
8665 data.correlationData = correlationData + i;
8666 handle->call(CL_FUNCTION_clReleaseContext, &data);
8667 }
8668 ++i;
8669 }
8670
8671 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8672 }
8673
8674 ~ClReleaseContextTracer() {
8675 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8676 }
8677
8678 private:
8679 cl_params_clReleaseContext params{};
8680 cl_callback_data data{};
8681 uint64_t correlationData[tracingMaxHandleCount];
8682 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8683 };
8684
8685 class ClReleaseDeviceTracer {
8686 public:
8687 ClReleaseDeviceTracer() {}
8688
8689 void enter(cl_device_id *device) {
8690 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8691
8692 params.device = device;
8693
8694 data.site = CL_CALLBACK_SITE_ENTER;
8695 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8696 data.functionName = "clReleaseDevice";
8697 data.functionParams = static_cast<const void *>(&params);
8698 data.functionReturnValue = nullptr;
8699
8700 size_t i = 0;
8701 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8702 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8703 TracingHandle *handle = tracingHandle[i];
8704 DEBUG_BREAK_IF(handle == nullptr);
8705 if (handle->getTracingPoint(CL_FUNCTION_clReleaseDevice)) {
8706 data.correlationData = correlationData + i;
8707 handle->call(CL_FUNCTION_clReleaseDevice, &data);
8708 }
8709 ++i;
8710 }
8711
8712 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8713 }
8714
8715 void exit(cl_int *retVal) {
8716 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8717 data.site = CL_CALLBACK_SITE_EXIT;
8718 data.functionReturnValue = retVal;
8719
8720 size_t i = 0;
8721 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8722 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8723 TracingHandle *handle = tracingHandle[i];
8724 DEBUG_BREAK_IF(handle == nullptr);
8725 if (handle->getTracingPoint(CL_FUNCTION_clReleaseDevice)) {
8726 data.correlationData = correlationData + i;
8727 handle->call(CL_FUNCTION_clReleaseDevice, &data);
8728 }
8729 ++i;
8730 }
8731
8732 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8733 }
8734
8735 ~ClReleaseDeviceTracer() {
8736 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8737 }
8738
8739 private:
8740 cl_params_clReleaseDevice params{};
8741 cl_callback_data data{};
8742 uint64_t correlationData[tracingMaxHandleCount];
8743 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8744 };
8745
8746 class ClReleaseEventTracer {
8747 public:
8748 ClReleaseEventTracer() {}
8749
8750 void enter(cl_event *event) {
8751 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8752
8753 params.event = event;
8754
8755 data.site = CL_CALLBACK_SITE_ENTER;
8756 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8757 data.functionName = "clReleaseEvent";
8758 data.functionParams = static_cast<const void *>(&params);
8759 data.functionReturnValue = nullptr;
8760
8761 size_t i = 0;
8762 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8763 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8764 TracingHandle *handle = tracingHandle[i];
8765 DEBUG_BREAK_IF(handle == nullptr);
8766 if (handle->getTracingPoint(CL_FUNCTION_clReleaseEvent)) {
8767 data.correlationData = correlationData + i;
8768 handle->call(CL_FUNCTION_clReleaseEvent, &data);
8769 }
8770 ++i;
8771 }
8772
8773 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8774 }
8775
8776 void exit(cl_int *retVal) {
8777 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8778 data.site = CL_CALLBACK_SITE_EXIT;
8779 data.functionReturnValue = retVal;
8780
8781 size_t i = 0;
8782 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8783 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8784 TracingHandle *handle = tracingHandle[i];
8785 DEBUG_BREAK_IF(handle == nullptr);
8786 if (handle->getTracingPoint(CL_FUNCTION_clReleaseEvent)) {
8787 data.correlationData = correlationData + i;
8788 handle->call(CL_FUNCTION_clReleaseEvent, &data);
8789 }
8790 ++i;
8791 }
8792
8793 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8794 }
8795
8796 ~ClReleaseEventTracer() {
8797 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8798 }
8799
8800 private:
8801 cl_params_clReleaseEvent params{};
8802 cl_callback_data data{};
8803 uint64_t correlationData[tracingMaxHandleCount];
8804 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8805 };
8806
8807 class ClReleaseKernelTracer {
8808 public:
8809 ClReleaseKernelTracer() {}
8810
8811 void enter(cl_kernel *kernel) {
8812 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8813
8814 params.kernel = kernel;
8815
8816 data.site = CL_CALLBACK_SITE_ENTER;
8817 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8818 data.functionName = "clReleaseKernel";
8819 data.functionParams = static_cast<const void *>(&params);
8820 data.functionReturnValue = nullptr;
8821
8822 size_t i = 0;
8823 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8824 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8825 TracingHandle *handle = tracingHandle[i];
8826 DEBUG_BREAK_IF(handle == nullptr);
8827 if (handle->getTracingPoint(CL_FUNCTION_clReleaseKernel)) {
8828 data.correlationData = correlationData + i;
8829 handle->call(CL_FUNCTION_clReleaseKernel, &data);
8830 }
8831 ++i;
8832 }
8833
8834 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8835 }
8836
8837 void exit(cl_int *retVal) {
8838 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8839 data.site = CL_CALLBACK_SITE_EXIT;
8840 data.functionReturnValue = retVal;
8841
8842 size_t i = 0;
8843 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8844 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8845 TracingHandle *handle = tracingHandle[i];
8846 DEBUG_BREAK_IF(handle == nullptr);
8847 if (handle->getTracingPoint(CL_FUNCTION_clReleaseKernel)) {
8848 data.correlationData = correlationData + i;
8849 handle->call(CL_FUNCTION_clReleaseKernel, &data);
8850 }
8851 ++i;
8852 }
8853
8854 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8855 }
8856
8857 ~ClReleaseKernelTracer() {
8858 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8859 }
8860
8861 private:
8862 cl_params_clReleaseKernel params{};
8863 cl_callback_data data{};
8864 uint64_t correlationData[tracingMaxHandleCount];
8865 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8866 };
8867
8868 class ClReleaseMemObjectTracer {
8869 public:
8870 ClReleaseMemObjectTracer() {}
8871
8872 void enter(cl_mem *memobj) {
8873 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8874
8875 params.memobj = memobj;
8876
8877 data.site = CL_CALLBACK_SITE_ENTER;
8878 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8879 data.functionName = "clReleaseMemObject";
8880 data.functionParams = static_cast<const void *>(&params);
8881 data.functionReturnValue = nullptr;
8882
8883 size_t i = 0;
8884 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8885 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8886 TracingHandle *handle = tracingHandle[i];
8887 DEBUG_BREAK_IF(handle == nullptr);
8888 if (handle->getTracingPoint(CL_FUNCTION_clReleaseMemObject)) {
8889 data.correlationData = correlationData + i;
8890 handle->call(CL_FUNCTION_clReleaseMemObject, &data);
8891 }
8892 ++i;
8893 }
8894
8895 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8896 }
8897
8898 void exit(cl_int *retVal) {
8899 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8900 data.site = CL_CALLBACK_SITE_EXIT;
8901 data.functionReturnValue = retVal;
8902
8903 size_t i = 0;
8904 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8905 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8906 TracingHandle *handle = tracingHandle[i];
8907 DEBUG_BREAK_IF(handle == nullptr);
8908 if (handle->getTracingPoint(CL_FUNCTION_clReleaseMemObject)) {
8909 data.correlationData = correlationData + i;
8910 handle->call(CL_FUNCTION_clReleaseMemObject, &data);
8911 }
8912 ++i;
8913 }
8914
8915 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8916 }
8917
8918 ~ClReleaseMemObjectTracer() {
8919 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8920 }
8921
8922 private:
8923 cl_params_clReleaseMemObject params{};
8924 cl_callback_data data{};
8925 uint64_t correlationData[tracingMaxHandleCount];
8926 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8927 };
8928
8929 class ClReleaseProgramTracer {
8930 public:
8931 ClReleaseProgramTracer() {}
8932
8933 void enter(cl_program *program) {
8934 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8935
8936 params.program = program;
8937
8938 data.site = CL_CALLBACK_SITE_ENTER;
8939 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
8940 data.functionName = "clReleaseProgram";
8941 data.functionParams = static_cast<const void *>(&params);
8942 data.functionReturnValue = nullptr;
8943
8944 size_t i = 0;
8945 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8946 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8947 TracingHandle *handle = tracingHandle[i];
8948 DEBUG_BREAK_IF(handle == nullptr);
8949 if (handle->getTracingPoint(CL_FUNCTION_clReleaseProgram)) {
8950 data.correlationData = correlationData + i;
8951 handle->call(CL_FUNCTION_clReleaseProgram, &data);
8952 }
8953 ++i;
8954 }
8955
8956 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
8957 }
8958
8959 void exit(cl_int *retVal) {
8960 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
8961 data.site = CL_CALLBACK_SITE_EXIT;
8962 data.functionReturnValue = retVal;
8963
8964 size_t i = 0;
8965 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
8966 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
8967 TracingHandle *handle = tracingHandle[i];
8968 DEBUG_BREAK_IF(handle == nullptr);
8969 if (handle->getTracingPoint(CL_FUNCTION_clReleaseProgram)) {
8970 data.correlationData = correlationData + i;
8971 handle->call(CL_FUNCTION_clReleaseProgram, &data);
8972 }
8973 ++i;
8974 }
8975
8976 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
8977 }
8978
8979 ~ClReleaseProgramTracer() {
8980 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
8981 }
8982
8983 private:
8984 cl_params_clReleaseProgram params{};
8985 cl_callback_data data{};
8986 uint64_t correlationData[tracingMaxHandleCount];
8987 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
8988 };
8989
8990 class ClReleaseSamplerTracer {
8991 public:
8992 ClReleaseSamplerTracer() {}
8993
8994 void enter(cl_sampler *sampler) {
8995 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
8996
8997 params.sampler = sampler;
8998
8999 data.site = CL_CALLBACK_SITE_ENTER;
9000 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9001 data.functionName = "clReleaseSampler";
9002 data.functionParams = static_cast<const void *>(&params);
9003 data.functionReturnValue = nullptr;
9004
9005 size_t i = 0;
9006 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9007 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9008 TracingHandle *handle = tracingHandle[i];
9009 DEBUG_BREAK_IF(handle == nullptr);
9010 if (handle->getTracingPoint(CL_FUNCTION_clReleaseSampler)) {
9011 data.correlationData = correlationData + i;
9012 handle->call(CL_FUNCTION_clReleaseSampler, &data);
9013 }
9014 ++i;
9015 }
9016
9017 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9018 }
9019
9020 void exit(cl_int *retVal) {
9021 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9022 data.site = CL_CALLBACK_SITE_EXIT;
9023 data.functionReturnValue = retVal;
9024
9025 size_t i = 0;
9026 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9027 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9028 TracingHandle *handle = tracingHandle[i];
9029 DEBUG_BREAK_IF(handle == nullptr);
9030 if (handle->getTracingPoint(CL_FUNCTION_clReleaseSampler)) {
9031 data.correlationData = correlationData + i;
9032 handle->call(CL_FUNCTION_clReleaseSampler, &data);
9033 }
9034 ++i;
9035 }
9036
9037 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9038 }
9039
9040 ~ClReleaseSamplerTracer() {
9041 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9042 }
9043
9044 private:
9045 cl_params_clReleaseSampler params{};
9046 cl_callback_data data{};
9047 uint64_t correlationData[tracingMaxHandleCount];
9048 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9049 };
9050
9051 class ClRetainCommandQueueTracer {
9052 public:
9053 ClRetainCommandQueueTracer() {}
9054
9055 void enter(cl_command_queue *commandQueue) {
9056 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9057
9058 params.commandQueue = commandQueue;
9059
9060 data.site = CL_CALLBACK_SITE_ENTER;
9061 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9062 data.functionName = "clRetainCommandQueue";
9063 data.functionParams = static_cast<const void *>(&params);
9064 data.functionReturnValue = nullptr;
9065
9066 size_t i = 0;
9067 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9068 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9069 TracingHandle *handle = tracingHandle[i];
9070 DEBUG_BREAK_IF(handle == nullptr);
9071 if (handle->getTracingPoint(CL_FUNCTION_clRetainCommandQueue)) {
9072 data.correlationData = correlationData + i;
9073 handle->call(CL_FUNCTION_clRetainCommandQueue, &data);
9074 }
9075 ++i;
9076 }
9077
9078 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9079 }
9080
9081 void exit(cl_int *retVal) {
9082 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9083 data.site = CL_CALLBACK_SITE_EXIT;
9084 data.functionReturnValue = retVal;
9085
9086 size_t i = 0;
9087 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9088 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9089 TracingHandle *handle = tracingHandle[i];
9090 DEBUG_BREAK_IF(handle == nullptr);
9091 if (handle->getTracingPoint(CL_FUNCTION_clRetainCommandQueue)) {
9092 data.correlationData = correlationData + i;
9093 handle->call(CL_FUNCTION_clRetainCommandQueue, &data);
9094 }
9095 ++i;
9096 }
9097
9098 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9099 }
9100
9101 ~ClRetainCommandQueueTracer() {
9102 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9103 }
9104
9105 private:
9106 cl_params_clRetainCommandQueue params{};
9107 cl_callback_data data{};
9108 uint64_t correlationData[tracingMaxHandleCount];
9109 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9110 };
9111
9112 class ClRetainContextTracer {
9113 public:
9114 ClRetainContextTracer() {}
9115
9116 void enter(cl_context *context) {
9117 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9118
9119 params.context = context;
9120
9121 data.site = CL_CALLBACK_SITE_ENTER;
9122 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9123 data.functionName = "clRetainContext";
9124 data.functionParams = static_cast<const void *>(&params);
9125 data.functionReturnValue = nullptr;
9126
9127 size_t i = 0;
9128 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9129 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9130 TracingHandle *handle = tracingHandle[i];
9131 DEBUG_BREAK_IF(handle == nullptr);
9132 if (handle->getTracingPoint(CL_FUNCTION_clRetainContext)) {
9133 data.correlationData = correlationData + i;
9134 handle->call(CL_FUNCTION_clRetainContext, &data);
9135 }
9136 ++i;
9137 }
9138
9139 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9140 }
9141
9142 void exit(cl_int *retVal) {
9143 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9144 data.site = CL_CALLBACK_SITE_EXIT;
9145 data.functionReturnValue = retVal;
9146
9147 size_t i = 0;
9148 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9149 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9150 TracingHandle *handle = tracingHandle[i];
9151 DEBUG_BREAK_IF(handle == nullptr);
9152 if (handle->getTracingPoint(CL_FUNCTION_clRetainContext)) {
9153 data.correlationData = correlationData + i;
9154 handle->call(CL_FUNCTION_clRetainContext, &data);
9155 }
9156 ++i;
9157 }
9158
9159 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9160 }
9161
9162 ~ClRetainContextTracer() {
9163 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9164 }
9165
9166 private:
9167 cl_params_clRetainContext params{};
9168 cl_callback_data data{};
9169 uint64_t correlationData[tracingMaxHandleCount];
9170 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9171 };
9172
9173 class ClRetainDeviceTracer {
9174 public:
9175 ClRetainDeviceTracer() {}
9176
9177 void enter(cl_device_id *device) {
9178 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9179
9180 params.device = device;
9181
9182 data.site = CL_CALLBACK_SITE_ENTER;
9183 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9184 data.functionName = "clRetainDevice";
9185 data.functionParams = static_cast<const void *>(&params);
9186 data.functionReturnValue = nullptr;
9187
9188 size_t i = 0;
9189 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9190 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9191 TracingHandle *handle = tracingHandle[i];
9192 DEBUG_BREAK_IF(handle == nullptr);
9193 if (handle->getTracingPoint(CL_FUNCTION_clRetainDevice)) {
9194 data.correlationData = correlationData + i;
9195 handle->call(CL_FUNCTION_clRetainDevice, &data);
9196 }
9197 ++i;
9198 }
9199
9200 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9201 }
9202
9203 void exit(cl_int *retVal) {
9204 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9205 data.site = CL_CALLBACK_SITE_EXIT;
9206 data.functionReturnValue = retVal;
9207
9208 size_t i = 0;
9209 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9210 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9211 TracingHandle *handle = tracingHandle[i];
9212 DEBUG_BREAK_IF(handle == nullptr);
9213 if (handle->getTracingPoint(CL_FUNCTION_clRetainDevice)) {
9214 data.correlationData = correlationData + i;
9215 handle->call(CL_FUNCTION_clRetainDevice, &data);
9216 }
9217 ++i;
9218 }
9219
9220 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9221 }
9222
9223 ~ClRetainDeviceTracer() {
9224 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9225 }
9226
9227 private:
9228 cl_params_clRetainDevice params{};
9229 cl_callback_data data{};
9230 uint64_t correlationData[tracingMaxHandleCount];
9231 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9232 };
9233
9234 class ClRetainEventTracer {
9235 public:
9236 ClRetainEventTracer() {}
9237
9238 void enter(cl_event *event) {
9239 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9240
9241 params.event = event;
9242
9243 data.site = CL_CALLBACK_SITE_ENTER;
9244 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9245 data.functionName = "clRetainEvent";
9246 data.functionParams = static_cast<const void *>(&params);
9247 data.functionReturnValue = nullptr;
9248
9249 size_t i = 0;
9250 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9251 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9252 TracingHandle *handle = tracingHandle[i];
9253 DEBUG_BREAK_IF(handle == nullptr);
9254 if (handle->getTracingPoint(CL_FUNCTION_clRetainEvent)) {
9255 data.correlationData = correlationData + i;
9256 handle->call(CL_FUNCTION_clRetainEvent, &data);
9257 }
9258 ++i;
9259 }
9260
9261 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9262 }
9263
9264 void exit(cl_int *retVal) {
9265 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9266 data.site = CL_CALLBACK_SITE_EXIT;
9267 data.functionReturnValue = retVal;
9268
9269 size_t i = 0;
9270 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9271 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9272 TracingHandle *handle = tracingHandle[i];
9273 DEBUG_BREAK_IF(handle == nullptr);
9274 if (handle->getTracingPoint(CL_FUNCTION_clRetainEvent)) {
9275 data.correlationData = correlationData + i;
9276 handle->call(CL_FUNCTION_clRetainEvent, &data);
9277 }
9278 ++i;
9279 }
9280
9281 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9282 }
9283
9284 ~ClRetainEventTracer() {
9285 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9286 }
9287
9288 private:
9289 cl_params_clRetainEvent params{};
9290 cl_callback_data data{};
9291 uint64_t correlationData[tracingMaxHandleCount];
9292 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9293 };
9294
9295 class ClRetainKernelTracer {
9296 public:
9297 ClRetainKernelTracer() {}
9298
9299 void enter(cl_kernel *kernel) {
9300 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9301
9302 params.kernel = kernel;
9303
9304 data.site = CL_CALLBACK_SITE_ENTER;
9305 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9306 data.functionName = "clRetainKernel";
9307 data.functionParams = static_cast<const void *>(&params);
9308 data.functionReturnValue = nullptr;
9309
9310 size_t i = 0;
9311 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9312 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9313 TracingHandle *handle = tracingHandle[i];
9314 DEBUG_BREAK_IF(handle == nullptr);
9315 if (handle->getTracingPoint(CL_FUNCTION_clRetainKernel)) {
9316 data.correlationData = correlationData + i;
9317 handle->call(CL_FUNCTION_clRetainKernel, &data);
9318 }
9319 ++i;
9320 }
9321
9322 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9323 }
9324
9325 void exit(cl_int *retVal) {
9326 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9327 data.site = CL_CALLBACK_SITE_EXIT;
9328 data.functionReturnValue = retVal;
9329
9330 size_t i = 0;
9331 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9332 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9333 TracingHandle *handle = tracingHandle[i];
9334 DEBUG_BREAK_IF(handle == nullptr);
9335 if (handle->getTracingPoint(CL_FUNCTION_clRetainKernel)) {
9336 data.correlationData = correlationData + i;
9337 handle->call(CL_FUNCTION_clRetainKernel, &data);
9338 }
9339 ++i;
9340 }
9341
9342 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9343 }
9344
9345 ~ClRetainKernelTracer() {
9346 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9347 }
9348
9349 private:
9350 cl_params_clRetainKernel params{};
9351 cl_callback_data data{};
9352 uint64_t correlationData[tracingMaxHandleCount];
9353 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9354 };
9355
9356 class ClRetainMemObjectTracer {
9357 public:
9358 ClRetainMemObjectTracer() {}
9359
9360 void enter(cl_mem *memobj) {
9361 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9362
9363 params.memobj = memobj;
9364
9365 data.site = CL_CALLBACK_SITE_ENTER;
9366 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9367 data.functionName = "clRetainMemObject";
9368 data.functionParams = static_cast<const void *>(&params);
9369 data.functionReturnValue = nullptr;
9370
9371 size_t i = 0;
9372 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9373 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9374 TracingHandle *handle = tracingHandle[i];
9375 DEBUG_BREAK_IF(handle == nullptr);
9376 if (handle->getTracingPoint(CL_FUNCTION_clRetainMemObject)) {
9377 data.correlationData = correlationData + i;
9378 handle->call(CL_FUNCTION_clRetainMemObject, &data);
9379 }
9380 ++i;
9381 }
9382
9383 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9384 }
9385
9386 void exit(cl_int *retVal) {
9387 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9388 data.site = CL_CALLBACK_SITE_EXIT;
9389 data.functionReturnValue = retVal;
9390
9391 size_t i = 0;
9392 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9393 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9394 TracingHandle *handle = tracingHandle[i];
9395 DEBUG_BREAK_IF(handle == nullptr);
9396 if (handle->getTracingPoint(CL_FUNCTION_clRetainMemObject)) {
9397 data.correlationData = correlationData + i;
9398 handle->call(CL_FUNCTION_clRetainMemObject, &data);
9399 }
9400 ++i;
9401 }
9402
9403 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9404 }
9405
9406 ~ClRetainMemObjectTracer() {
9407 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9408 }
9409
9410 private:
9411 cl_params_clRetainMemObject params{};
9412 cl_callback_data data{};
9413 uint64_t correlationData[tracingMaxHandleCount];
9414 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9415 };
9416
9417 class ClRetainProgramTracer {
9418 public:
9419 ClRetainProgramTracer() {}
9420
9421 void enter(cl_program *program) {
9422 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9423
9424 params.program = program;
9425
9426 data.site = CL_CALLBACK_SITE_ENTER;
9427 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9428 data.functionName = "clRetainProgram";
9429 data.functionParams = static_cast<const void *>(&params);
9430 data.functionReturnValue = nullptr;
9431
9432 size_t i = 0;
9433 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9434 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9435 TracingHandle *handle = tracingHandle[i];
9436 DEBUG_BREAK_IF(handle == nullptr);
9437 if (handle->getTracingPoint(CL_FUNCTION_clRetainProgram)) {
9438 data.correlationData = correlationData + i;
9439 handle->call(CL_FUNCTION_clRetainProgram, &data);
9440 }
9441 ++i;
9442 }
9443
9444 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9445 }
9446
9447 void exit(cl_int *retVal) {
9448 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9449 data.site = CL_CALLBACK_SITE_EXIT;
9450 data.functionReturnValue = retVal;
9451
9452 size_t i = 0;
9453 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9454 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9455 TracingHandle *handle = tracingHandle[i];
9456 DEBUG_BREAK_IF(handle == nullptr);
9457 if (handle->getTracingPoint(CL_FUNCTION_clRetainProgram)) {
9458 data.correlationData = correlationData + i;
9459 handle->call(CL_FUNCTION_clRetainProgram, &data);
9460 }
9461 ++i;
9462 }
9463
9464 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9465 }
9466
9467 ~ClRetainProgramTracer() {
9468 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9469 }
9470
9471 private:
9472 cl_params_clRetainProgram params{};
9473 cl_callback_data data{};
9474 uint64_t correlationData[tracingMaxHandleCount];
9475 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9476 };
9477
9478 class ClRetainSamplerTracer {
9479 public:
9480 ClRetainSamplerTracer() {}
9481
9482 void enter(cl_sampler *sampler) {
9483 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9484
9485 params.sampler = sampler;
9486
9487 data.site = CL_CALLBACK_SITE_ENTER;
9488 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9489 data.functionName = "clRetainSampler";
9490 data.functionParams = static_cast<const void *>(&params);
9491 data.functionReturnValue = nullptr;
9492
9493 size_t i = 0;
9494 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9495 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9496 TracingHandle *handle = tracingHandle[i];
9497 DEBUG_BREAK_IF(handle == nullptr);
9498 if (handle->getTracingPoint(CL_FUNCTION_clRetainSampler)) {
9499 data.correlationData = correlationData + i;
9500 handle->call(CL_FUNCTION_clRetainSampler, &data);
9501 }
9502 ++i;
9503 }
9504
9505 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9506 }
9507
9508 void exit(cl_int *retVal) {
9509 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9510 data.site = CL_CALLBACK_SITE_EXIT;
9511 data.functionReturnValue = retVal;
9512
9513 size_t i = 0;
9514 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9515 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9516 TracingHandle *handle = tracingHandle[i];
9517 DEBUG_BREAK_IF(handle == nullptr);
9518 if (handle->getTracingPoint(CL_FUNCTION_clRetainSampler)) {
9519 data.correlationData = correlationData + i;
9520 handle->call(CL_FUNCTION_clRetainSampler, &data);
9521 }
9522 ++i;
9523 }
9524
9525 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9526 }
9527
9528 ~ClRetainSamplerTracer() {
9529 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9530 }
9531
9532 private:
9533 cl_params_clRetainSampler params{};
9534 cl_callback_data data{};
9535 uint64_t correlationData[tracingMaxHandleCount];
9536 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9537 };
9538
9539 class ClSvmAllocTracer {
9540 public:
9541 ClSvmAllocTracer() {}
9542
9543 void enter(cl_context *context,
9544 cl_svm_mem_flags *flags,
9545 size_t *size,
9546 cl_uint *alignment) {
9547 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9548
9549 params.context = context;
9550 params.flags = flags;
9551 params.size = size;
9552 params.alignment = alignment;
9553
9554 data.site = CL_CALLBACK_SITE_ENTER;
9555 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9556 data.functionName = "clSVMAlloc";
9557 data.functionParams = static_cast<const void *>(&params);
9558 data.functionReturnValue = nullptr;
9559
9560 size_t i = 0;
9561 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9562 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9563 TracingHandle *handle = tracingHandle[i];
9564 DEBUG_BREAK_IF(handle == nullptr);
9565 if (handle->getTracingPoint(CL_FUNCTION_clSVMAlloc)) {
9566 data.correlationData = correlationData + i;
9567 handle->call(CL_FUNCTION_clSVMAlloc, &data);
9568 }
9569 ++i;
9570 }
9571
9572 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9573 }
9574
9575 void exit(void **retVal) {
9576 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9577 data.site = CL_CALLBACK_SITE_EXIT;
9578 data.functionReturnValue = retVal;
9579
9580 size_t i = 0;
9581 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9582 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9583 TracingHandle *handle = tracingHandle[i];
9584 DEBUG_BREAK_IF(handle == nullptr);
9585 if (handle->getTracingPoint(CL_FUNCTION_clSVMAlloc)) {
9586 data.correlationData = correlationData + i;
9587 handle->call(CL_FUNCTION_clSVMAlloc, &data);
9588 }
9589 ++i;
9590 }
9591
9592 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9593 }
9594
9595 ~ClSvmAllocTracer() {
9596 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9597 }
9598
9599 private:
9600 cl_params_clSVMAlloc params{};
9601 cl_callback_data data{};
9602 uint64_t correlationData[tracingMaxHandleCount];
9603 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9604 };
9605
9606 class ClSvmFreeTracer {
9607 public:
9608 ClSvmFreeTracer() {}
9609
9610 void enter(cl_context *context,
9611 void **svmPointer) {
9612 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9613
9614 params.context = context;
9615 params.svmPointer = svmPointer;
9616
9617 data.site = CL_CALLBACK_SITE_ENTER;
9618 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9619 data.functionName = "clSVMFree";
9620 data.functionParams = static_cast<const void *>(&params);
9621 data.functionReturnValue = nullptr;
9622
9623 size_t i = 0;
9624 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9625 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9626 TracingHandle *handle = tracingHandle[i];
9627 DEBUG_BREAK_IF(handle == nullptr);
9628 if (handle->getTracingPoint(CL_FUNCTION_clSVMFree)) {
9629 data.correlationData = correlationData + i;
9630 handle->call(CL_FUNCTION_clSVMFree, &data);
9631 }
9632 ++i;
9633 }
9634
9635 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9636 }
9637
9638 void exit(void *retVal) {
9639 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9640 data.site = CL_CALLBACK_SITE_EXIT;
9641 data.functionReturnValue = retVal;
9642
9643 size_t i = 0;
9644 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9645 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9646 TracingHandle *handle = tracingHandle[i];
9647 DEBUG_BREAK_IF(handle == nullptr);
9648 if (handle->getTracingPoint(CL_FUNCTION_clSVMFree)) {
9649 data.correlationData = correlationData + i;
9650 handle->call(CL_FUNCTION_clSVMFree, &data);
9651 }
9652 ++i;
9653 }
9654
9655 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9656 }
9657
9658 ~ClSvmFreeTracer() {
9659 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9660 }
9661
9662 private:
9663 cl_params_clSVMFree params{};
9664 cl_callback_data data{};
9665 uint64_t correlationData[tracingMaxHandleCount];
9666 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9667 };
9668
9669 class ClSetCommandQueuePropertyTracer {
9670 public:
9671 ClSetCommandQueuePropertyTracer() {}
9672
9673 void enter(cl_command_queue *commandQueue,
9674 cl_command_queue_properties *properties,
9675 cl_bool *enable,
9676 cl_command_queue_properties **oldProperties) {
9677 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9678
9679 params.commandQueue = commandQueue;
9680 params.properties = properties;
9681 params.enable = enable;
9682 params.oldProperties = oldProperties;
9683
9684 data.site = CL_CALLBACK_SITE_ENTER;
9685 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9686 data.functionName = "clSetCommandQueueProperty";
9687 data.functionParams = static_cast<const void *>(&params);
9688 data.functionReturnValue = nullptr;
9689
9690 size_t i = 0;
9691 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9692 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9693 TracingHandle *handle = tracingHandle[i];
9694 DEBUG_BREAK_IF(handle == nullptr);
9695 if (handle->getTracingPoint(CL_FUNCTION_clSetCommandQueueProperty)) {
9696 data.correlationData = correlationData + i;
9697 handle->call(CL_FUNCTION_clSetCommandQueueProperty, &data);
9698 }
9699 ++i;
9700 }
9701
9702 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9703 }
9704
9705 void exit(cl_int *retVal) {
9706 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9707 data.site = CL_CALLBACK_SITE_EXIT;
9708 data.functionReturnValue = retVal;
9709
9710 size_t i = 0;
9711 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9712 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9713 TracingHandle *handle = tracingHandle[i];
9714 DEBUG_BREAK_IF(handle == nullptr);
9715 if (handle->getTracingPoint(CL_FUNCTION_clSetCommandQueueProperty)) {
9716 data.correlationData = correlationData + i;
9717 handle->call(CL_FUNCTION_clSetCommandQueueProperty, &data);
9718 }
9719 ++i;
9720 }
9721
9722 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9723 }
9724
9725 ~ClSetCommandQueuePropertyTracer() {
9726 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9727 }
9728
9729 private:
9730 cl_params_clSetCommandQueueProperty params{};
9731 cl_callback_data data{};
9732 uint64_t correlationData[tracingMaxHandleCount];
9733 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9734 };
9735
9736 class ClSetDefaultDeviceCommandQueueTracer {
9737 public:
9738 ClSetDefaultDeviceCommandQueueTracer() {}
9739
9740 void enter(cl_context *context,
9741 cl_device_id *device,
9742 cl_command_queue *commandQueue) {
9743 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9744
9745 params.context = context;
9746 params.device = device;
9747 params.commandQueue = commandQueue;
9748
9749 data.site = CL_CALLBACK_SITE_ENTER;
9750 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9751 data.functionName = "clSetDefaultDeviceCommandQueue";
9752 data.functionParams = static_cast<const void *>(&params);
9753 data.functionReturnValue = nullptr;
9754
9755 size_t i = 0;
9756 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9757 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9758 TracingHandle *handle = tracingHandle[i];
9759 DEBUG_BREAK_IF(handle == nullptr);
9760 if (handle->getTracingPoint(CL_FUNCTION_clSetDefaultDeviceCommandQueue)) {
9761 data.correlationData = correlationData + i;
9762 handle->call(CL_FUNCTION_clSetDefaultDeviceCommandQueue, &data);
9763 }
9764 ++i;
9765 }
9766
9767 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9768 }
9769
9770 void exit(cl_int *retVal) {
9771 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9772 data.site = CL_CALLBACK_SITE_EXIT;
9773 data.functionReturnValue = retVal;
9774
9775 size_t i = 0;
9776 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9777 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9778 TracingHandle *handle = tracingHandle[i];
9779 DEBUG_BREAK_IF(handle == nullptr);
9780 if (handle->getTracingPoint(CL_FUNCTION_clSetDefaultDeviceCommandQueue)) {
9781 data.correlationData = correlationData + i;
9782 handle->call(CL_FUNCTION_clSetDefaultDeviceCommandQueue, &data);
9783 }
9784 ++i;
9785 }
9786
9787 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9788 }
9789
9790 ~ClSetDefaultDeviceCommandQueueTracer() {
9791 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9792 }
9793
9794 private:
9795 cl_params_clSetDefaultDeviceCommandQueue params{};
9796 cl_callback_data data{};
9797 uint64_t correlationData[tracingMaxHandleCount];
9798 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9799 };
9800
9801 class ClSetEventCallbackTracer {
9802 public:
9803 ClSetEventCallbackTracer() {}
9804
9805 void enter(cl_event *event,
9806 cl_int *commandExecCallbackType,
9807 void(CL_CALLBACK **funcNotify)(cl_event, cl_int, void *),
9808 void **userData) {
9809 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9810
9811 params.event = event;
9812 params.commandExecCallbackType = commandExecCallbackType;
9813 params.funcNotify = funcNotify;
9814 params.userData = userData;
9815
9816 data.site = CL_CALLBACK_SITE_ENTER;
9817 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9818 data.functionName = "clSetEventCallback";
9819 data.functionParams = static_cast<const void *>(&params);
9820 data.functionReturnValue = nullptr;
9821
9822 size_t i = 0;
9823 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9824 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9825 TracingHandle *handle = tracingHandle[i];
9826 DEBUG_BREAK_IF(handle == nullptr);
9827 if (handle->getTracingPoint(CL_FUNCTION_clSetEventCallback)) {
9828 data.correlationData = correlationData + i;
9829 handle->call(CL_FUNCTION_clSetEventCallback, &data);
9830 }
9831 ++i;
9832 }
9833
9834 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9835 }
9836
9837 void exit(cl_int *retVal) {
9838 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9839 data.site = CL_CALLBACK_SITE_EXIT;
9840 data.functionReturnValue = retVal;
9841
9842 size_t i = 0;
9843 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9844 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9845 TracingHandle *handle = tracingHandle[i];
9846 DEBUG_BREAK_IF(handle == nullptr);
9847 if (handle->getTracingPoint(CL_FUNCTION_clSetEventCallback)) {
9848 data.correlationData = correlationData + i;
9849 handle->call(CL_FUNCTION_clSetEventCallback, &data);
9850 }
9851 ++i;
9852 }
9853
9854 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9855 }
9856
9857 ~ClSetEventCallbackTracer() {
9858 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9859 }
9860
9861 private:
9862 cl_params_clSetEventCallback params{};
9863 cl_callback_data data{};
9864 uint64_t correlationData[tracingMaxHandleCount];
9865 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9866 };
9867
9868 class ClSetKernelArgTracer {
9869 public:
9870 ClSetKernelArgTracer() {}
9871
9872 void enter(cl_kernel *kernel,
9873 cl_uint *argIndex,
9874 size_t *argSize,
9875 const void **argValue) {
9876 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9877
9878 params.kernel = kernel;
9879 params.argIndex = argIndex;
9880 params.argSize = argSize;
9881 params.argValue = argValue;
9882
9883 data.site = CL_CALLBACK_SITE_ENTER;
9884 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9885 data.functionName = "clSetKernelArg";
9886 data.functionParams = static_cast<const void *>(&params);
9887 data.functionReturnValue = nullptr;
9888
9889 size_t i = 0;
9890 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9891 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9892 TracingHandle *handle = tracingHandle[i];
9893 DEBUG_BREAK_IF(handle == nullptr);
9894 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArg)) {
9895 data.correlationData = correlationData + i;
9896 handle->call(CL_FUNCTION_clSetKernelArg, &data);
9897 }
9898 ++i;
9899 }
9900
9901 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9902 }
9903
9904 void exit(cl_int *retVal) {
9905 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9906 data.site = CL_CALLBACK_SITE_EXIT;
9907 data.functionReturnValue = retVal;
9908
9909 size_t i = 0;
9910 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9911 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9912 TracingHandle *handle = tracingHandle[i];
9913 DEBUG_BREAK_IF(handle == nullptr);
9914 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArg)) {
9915 data.correlationData = correlationData + i;
9916 handle->call(CL_FUNCTION_clSetKernelArg, &data);
9917 }
9918 ++i;
9919 }
9920
9921 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9922 }
9923
9924 ~ClSetKernelArgTracer() {
9925 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9926 }
9927
9928 private:
9929 cl_params_clSetKernelArg params{};
9930 cl_callback_data data{};
9931 uint64_t correlationData[tracingMaxHandleCount];
9932 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9933 };
9934
9935 class ClSetKernelArgSvmPointerTracer {
9936 public:
9937 ClSetKernelArgSvmPointerTracer() {}
9938
9939 void enter(cl_kernel *kernel,
9940 cl_uint *argIndex,
9941 const void **argValue) {
9942 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
9943
9944 params.kernel = kernel;
9945 params.argIndex = argIndex;
9946 params.argValue = argValue;
9947
9948 data.site = CL_CALLBACK_SITE_ENTER;
9949 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
9950 data.functionName = "clSetKernelArgSVMPointer";
9951 data.functionParams = static_cast<const void *>(&params);
9952 data.functionReturnValue = nullptr;
9953
9954 size_t i = 0;
9955 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9956 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9957 TracingHandle *handle = tracingHandle[i];
9958 DEBUG_BREAK_IF(handle == nullptr);
9959 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgSVMPointer)) {
9960 data.correlationData = correlationData + i;
9961 handle->call(CL_FUNCTION_clSetKernelArgSVMPointer, &data);
9962 }
9963 ++i;
9964 }
9965
9966 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
9967 }
9968
9969 void exit(cl_int *retVal) {
9970 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
9971 data.site = CL_CALLBACK_SITE_EXIT;
9972 data.functionReturnValue = retVal;
9973
9974 size_t i = 0;
9975 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
9976 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
9977 TracingHandle *handle = tracingHandle[i];
9978 DEBUG_BREAK_IF(handle == nullptr);
9979 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgSVMPointer)) {
9980 data.correlationData = correlationData + i;
9981 handle->call(CL_FUNCTION_clSetKernelArgSVMPointer, &data);
9982 }
9983 ++i;
9984 }
9985
9986 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
9987 }
9988
9989 ~ClSetKernelArgSvmPointerTracer() {
9990 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
9991 }
9992
9993 private:
9994 cl_params_clSetKernelArgSVMPointer params{};
9995 cl_callback_data data{};
9996 uint64_t correlationData[tracingMaxHandleCount];
9997 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
9998 };
9999
10000 class ClSetKernelExecInfoTracer {
10001 public:
10002 ClSetKernelExecInfoTracer() {}
10003
10004 void enter(cl_kernel *kernel,
10005 cl_kernel_exec_info *paramName,
10006 size_t *paramValueSize,
10007 const void **paramValue) {
10008 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10009
10010 params.kernel = kernel;
10011 params.paramName = paramName;
10012 params.paramValueSize = paramValueSize;
10013 params.paramValue = paramValue;
10014
10015 data.site = CL_CALLBACK_SITE_ENTER;
10016 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10017 data.functionName = "clSetKernelExecInfo";
10018 data.functionParams = static_cast<const void *>(&params);
10019 data.functionReturnValue = nullptr;
10020
10021 size_t i = 0;
10022 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10023 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10024 TracingHandle *handle = tracingHandle[i];
10025 DEBUG_BREAK_IF(handle == nullptr);
10026 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelExecInfo)) {
10027 data.correlationData = correlationData + i;
10028 handle->call(CL_FUNCTION_clSetKernelExecInfo, &data);
10029 }
10030 ++i;
10031 }
10032
10033 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10034 }
10035
10036 void exit(cl_int *retVal) {
10037 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10038 data.site = CL_CALLBACK_SITE_EXIT;
10039 data.functionReturnValue = retVal;
10040
10041 size_t i = 0;
10042 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10043 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10044 TracingHandle *handle = tracingHandle[i];
10045 DEBUG_BREAK_IF(handle == nullptr);
10046 if (handle->getTracingPoint(CL_FUNCTION_clSetKernelExecInfo)) {
10047 data.correlationData = correlationData + i;
10048 handle->call(CL_FUNCTION_clSetKernelExecInfo, &data);
10049 }
10050 ++i;
10051 }
10052
10053 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10054 }
10055
10056 ~ClSetKernelExecInfoTracer() {
10057 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10058 }
10059
10060 private:
10061 cl_params_clSetKernelExecInfo params{};
10062 cl_callback_data data{};
10063 uint64_t correlationData[tracingMaxHandleCount];
10064 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10065 };
10066
10067 class ClSetMemObjectDestructorCallbackTracer {
10068 public:
10069 ClSetMemObjectDestructorCallbackTracer() {}
10070
10071 void enter(cl_mem *memobj,
10072 void(CL_CALLBACK **funcNotify)(cl_mem, void *),
10073 void **userData) {
10074 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10075
10076 params.memobj = memobj;
10077 params.funcNotify = funcNotify;
10078 params.userData = userData;
10079
10080 data.site = CL_CALLBACK_SITE_ENTER;
10081 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10082 data.functionName = "clSetMemObjectDestructorCallback";
10083 data.functionParams = static_cast<const void *>(&params);
10084 data.functionReturnValue = nullptr;
10085
10086 size_t i = 0;
10087 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10088 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10089 TracingHandle *handle = tracingHandle[i];
10090 DEBUG_BREAK_IF(handle == nullptr);
10091 if (handle->getTracingPoint(CL_FUNCTION_clSetMemObjectDestructorCallback)) {
10092 data.correlationData = correlationData + i;
10093 handle->call(CL_FUNCTION_clSetMemObjectDestructorCallback, &data);
10094 }
10095 ++i;
10096 }
10097
10098 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10099 }
10100
10101 void exit(cl_int *retVal) {
10102 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10103 data.site = CL_CALLBACK_SITE_EXIT;
10104 data.functionReturnValue = retVal;
10105
10106 size_t i = 0;
10107 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10108 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10109 TracingHandle *handle = tracingHandle[i];
10110 DEBUG_BREAK_IF(handle == nullptr);
10111 if (handle->getTracingPoint(CL_FUNCTION_clSetMemObjectDestructorCallback)) {
10112 data.correlationData = correlationData + i;
10113 handle->call(CL_FUNCTION_clSetMemObjectDestructorCallback, &data);
10114 }
10115 ++i;
10116 }
10117
10118 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10119 }
10120
10121 ~ClSetMemObjectDestructorCallbackTracer() {
10122 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10123 }
10124
10125 private:
10126 cl_params_clSetMemObjectDestructorCallback params{};
10127 cl_callback_data data{};
10128 uint64_t correlationData[tracingMaxHandleCount];
10129 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10130 };
10131
10132 class ClSetUserEventStatusTracer {
10133 public:
10134 ClSetUserEventStatusTracer() {}
10135
10136 void enter(cl_event *event,
10137 cl_int *executionStatus) {
10138 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10139
10140 params.event = event;
10141 params.executionStatus = executionStatus;
10142
10143 data.site = CL_CALLBACK_SITE_ENTER;
10144 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10145 data.functionName = "clSetUserEventStatus";
10146 data.functionParams = static_cast<const void *>(&params);
10147 data.functionReturnValue = nullptr;
10148
10149 size_t i = 0;
10150 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10151 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10152 TracingHandle *handle = tracingHandle[i];
10153 DEBUG_BREAK_IF(handle == nullptr);
10154 if (handle->getTracingPoint(CL_FUNCTION_clSetUserEventStatus)) {
10155 data.correlationData = correlationData + i;
10156 handle->call(CL_FUNCTION_clSetUserEventStatus, &data);
10157 }
10158 ++i;
10159 }
10160
10161 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10162 }
10163
10164 void exit(cl_int *retVal) {
10165 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10166 data.site = CL_CALLBACK_SITE_EXIT;
10167 data.functionReturnValue = retVal;
10168
10169 size_t i = 0;
10170 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10171 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10172 TracingHandle *handle = tracingHandle[i];
10173 DEBUG_BREAK_IF(handle == nullptr);
10174 if (handle->getTracingPoint(CL_FUNCTION_clSetUserEventStatus)) {
10175 data.correlationData = correlationData + i;
10176 handle->call(CL_FUNCTION_clSetUserEventStatus, &data);
10177 }
10178 ++i;
10179 }
10180
10181 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10182 }
10183
10184 ~ClSetUserEventStatusTracer() {
10185 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10186 }
10187
10188 private:
10189 cl_params_clSetUserEventStatus params{};
10190 cl_callback_data data{};
10191 uint64_t correlationData[tracingMaxHandleCount];
10192 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10193 };
10194
10195 class ClUnloadCompilerTracer {
10196 public:
10197 ClUnloadCompilerTracer() {}
10198
10199 void enter() {
10200 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10201
10202 data.site = CL_CALLBACK_SITE_ENTER;
10203 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10204 data.functionName = "clUnloadCompiler";
10205 data.functionParams = nullptr;
10206 data.functionReturnValue = nullptr;
10207
10208 size_t i = 0;
10209 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10210 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10211 TracingHandle *handle = tracingHandle[i];
10212 DEBUG_BREAK_IF(handle == nullptr);
10213 if (handle->getTracingPoint(CL_FUNCTION_clUnloadCompiler)) {
10214 data.correlationData = correlationData + i;
10215 handle->call(CL_FUNCTION_clUnloadCompiler, &data);
10216 }
10217 ++i;
10218 }
10219
10220 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10221 }
10222
10223 void exit(cl_int *retVal) {
10224 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10225 data.site = CL_CALLBACK_SITE_EXIT;
10226 data.functionReturnValue = retVal;
10227
10228 size_t i = 0;
10229 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10230 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10231 TracingHandle *handle = tracingHandle[i];
10232 DEBUG_BREAK_IF(handle == nullptr);
10233 if (handle->getTracingPoint(CL_FUNCTION_clUnloadCompiler)) {
10234 data.correlationData = correlationData + i;
10235 handle->call(CL_FUNCTION_clUnloadCompiler, &data);
10236 }
10237 ++i;
10238 }
10239
10240 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10241 }
10242
10243 ~ClUnloadCompilerTracer() {
10244 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10245 }
10246
10247 private:
10248 cl_callback_data data{};
10249 uint64_t correlationData[tracingMaxHandleCount];
10250 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10251 };
10252
10253 class ClUnloadPlatformCompilerTracer {
10254 public:
10255 ClUnloadPlatformCompilerTracer() {}
10256
10257 void enter(cl_platform_id *platform) {
10258 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10259
10260 params.platform = platform;
10261
10262 data.site = CL_CALLBACK_SITE_ENTER;
10263 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10264 data.functionName = "clUnloadPlatformCompiler";
10265 data.functionParams = static_cast<const void *>(&params);
10266 data.functionReturnValue = nullptr;
10267
10268 size_t i = 0;
10269 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10270 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10271 TracingHandle *handle = tracingHandle[i];
10272 DEBUG_BREAK_IF(handle == nullptr);
10273 if (handle->getTracingPoint(CL_FUNCTION_clUnloadPlatformCompiler)) {
10274 data.correlationData = correlationData + i;
10275 handle->call(CL_FUNCTION_clUnloadPlatformCompiler, &data);
10276 }
10277 ++i;
10278 }
10279
10280 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10281 }
10282
10283 void exit(cl_int *retVal) {
10284 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10285 data.site = CL_CALLBACK_SITE_EXIT;
10286 data.functionReturnValue = retVal;
10287
10288 size_t i = 0;
10289 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10290 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10291 TracingHandle *handle = tracingHandle[i];
10292 DEBUG_BREAK_IF(handle == nullptr);
10293 if (handle->getTracingPoint(CL_FUNCTION_clUnloadPlatformCompiler)) {
10294 data.correlationData = correlationData + i;
10295 handle->call(CL_FUNCTION_clUnloadPlatformCompiler, &data);
10296 }
10297 ++i;
10298 }
10299
10300 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10301 }
10302
10303 ~ClUnloadPlatformCompilerTracer() {
10304 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10305 }
10306
10307 private:
10308 cl_params_clUnloadPlatformCompiler params{};
10309 cl_callback_data data{};
10310 uint64_t correlationData[tracingMaxHandleCount];
10311 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10312 };
10313
10314 class ClWaitForEventsTracer {
10315 public:
10316 ClWaitForEventsTracer() {}
10317
10318 void enter(cl_uint *numEvents,
10319 const cl_event **eventList) {
10320 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10321
10322 params.numEvents = numEvents;
10323 params.eventList = eventList;
10324
10325 data.site = CL_CALLBACK_SITE_ENTER;
10326 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10327 data.functionName = "clWaitForEvents";
10328 data.functionParams = static_cast<const void *>(&params);
10329 data.functionReturnValue = nullptr;
10330
10331 size_t i = 0;
10332 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10333 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10334 TracingHandle *handle = tracingHandle[i];
10335 DEBUG_BREAK_IF(handle == nullptr);
10336 if (handle->getTracingPoint(CL_FUNCTION_clWaitForEvents)) {
10337 data.correlationData = correlationData + i;
10338 handle->call(CL_FUNCTION_clWaitForEvents, &data);
10339 }
10340 ++i;
10341 }
10342
10343 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10344 }
10345
10346 void exit(cl_int *retVal) {
10347 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10348 data.site = CL_CALLBACK_SITE_EXIT;
10349 data.functionReturnValue = retVal;
10350
10351 size_t i = 0;
10352 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10353 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10354 TracingHandle *handle = tracingHandle[i];
10355 DEBUG_BREAK_IF(handle == nullptr);
10356 if (handle->getTracingPoint(CL_FUNCTION_clWaitForEvents)) {
10357 data.correlationData = correlationData + i;
10358 handle->call(CL_FUNCTION_clWaitForEvents, &data);
10359 }
10360 ++i;
10361 }
10362
10363 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10364 }
10365
10366 ~ClWaitForEventsTracer() {
10367 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10368 }
10369
10370 private:
10371 cl_params_clWaitForEvents params{};
10372 cl_callback_data data{};
10373 uint64_t correlationData[tracingMaxHandleCount];
10374 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10375 };
10376
10377 class ClCreateFromGlBufferTracer {
10378 public:
10379 ClCreateFromGlBufferTracer() {}
10380
10381 void enter(cl_context *context,
10382 cl_mem_flags *flags,
10383 cl_GLuint *bufobj,
10384 int **errcodeRet) {
10385 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10386
10387 params.context = context;
10388 params.flags = flags;
10389 params.bufobj = bufobj;
10390 params.errcodeRet = errcodeRet;
10391
10392 data.site = CL_CALLBACK_SITE_ENTER;
10393 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10394 data.functionName = "clCreateFromGLBuffer";
10395 data.functionParams = static_cast<const void *>(&params);
10396 data.functionReturnValue = nullptr;
10397
10398 size_t i = 0;
10399 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10400 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10401 TracingHandle *handle = tracingHandle[i];
10402 DEBUG_BREAK_IF(handle == nullptr);
10403 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLBuffer)) {
10404 data.correlationData = correlationData + i;
10405 handle->call(CL_FUNCTION_clCreateFromGLBuffer, &data);
10406 }
10407 ++i;
10408 }
10409
10410 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10411 }
10412
10413 void exit(cl_mem *retVal) {
10414 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10415 data.site = CL_CALLBACK_SITE_EXIT;
10416 data.functionReturnValue = retVal;
10417
10418 size_t i = 0;
10419 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10420 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10421 TracingHandle *handle = tracingHandle[i];
10422 DEBUG_BREAK_IF(handle == nullptr);
10423 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLBuffer)) {
10424 data.correlationData = correlationData + i;
10425 handle->call(CL_FUNCTION_clCreateFromGLBuffer, &data);
10426 }
10427 ++i;
10428 }
10429
10430 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10431 }
10432
10433 ~ClCreateFromGlBufferTracer() {
10434 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10435 }
10436
10437 private:
10438 cl_params_clCreateFromGLBuffer params{};
10439 cl_callback_data data{};
10440 uint64_t correlationData[tracingMaxHandleCount];
10441 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10442 };
10443
10444 class ClCreateFromGlRenderbufferTracer {
10445 public:
10446 ClCreateFromGlRenderbufferTracer() {}
10447
10448 void enter(cl_context *context,
10449 cl_mem_flags *flags,
10450 cl_GLuint *renderbuffer,
10451 cl_int **errcodeRet) {
10452 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10453
10454 params.context = context;
10455 params.flags = flags;
10456 params.renderbuffer = renderbuffer;
10457 params.errcodeRet = errcodeRet;
10458
10459 data.site = CL_CALLBACK_SITE_ENTER;
10460 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10461 data.functionName = "clCreateFromGLRenderbuffer";
10462 data.functionParams = static_cast<const void *>(&params);
10463 data.functionReturnValue = nullptr;
10464
10465 size_t i = 0;
10466 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10467 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10468 TracingHandle *handle = tracingHandle[i];
10469 DEBUG_BREAK_IF(handle == nullptr);
10470 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLRenderbuffer)) {
10471 data.correlationData = correlationData + i;
10472 handle->call(CL_FUNCTION_clCreateFromGLRenderbuffer, &data);
10473 }
10474 ++i;
10475 }
10476
10477 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10478 }
10479
10480 void exit(cl_mem *retVal) {
10481 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10482 data.site = CL_CALLBACK_SITE_EXIT;
10483 data.functionReturnValue = retVal;
10484
10485 size_t i = 0;
10486 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10487 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10488 TracingHandle *handle = tracingHandle[i];
10489 DEBUG_BREAK_IF(handle == nullptr);
10490 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLRenderbuffer)) {
10491 data.correlationData = correlationData + i;
10492 handle->call(CL_FUNCTION_clCreateFromGLRenderbuffer, &data);
10493 }
10494 ++i;
10495 }
10496
10497 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10498 }
10499
10500 ~ClCreateFromGlRenderbufferTracer() {
10501 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10502 }
10503
10504 private:
10505 cl_params_clCreateFromGLRenderbuffer params{};
10506 cl_callback_data data{};
10507 uint64_t correlationData[tracingMaxHandleCount];
10508 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10509 };
10510
10511 class ClCreateFromGlTextureTracer {
10512 public:
10513 ClCreateFromGlTextureTracer() {}
10514
10515 void enter(cl_context *context,
10516 cl_mem_flags *flags,
10517 cl_GLenum *target,
10518 cl_GLint *miplevel,
10519 cl_GLuint *texture,
10520 cl_int **errcodeRet) {
10521 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10522
10523 params.context = context;
10524 params.flags = flags;
10525 params.target = target;
10526 params.miplevel = miplevel;
10527 params.texture = texture;
10528 params.errcodeRet = errcodeRet;
10529
10530 data.site = CL_CALLBACK_SITE_ENTER;
10531 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10532 data.functionName = "clCreateFromGLTexture";
10533 data.functionParams = static_cast<const void *>(&params);
10534 data.functionReturnValue = nullptr;
10535
10536 size_t i = 0;
10537 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10538 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10539 TracingHandle *handle = tracingHandle[i];
10540 DEBUG_BREAK_IF(handle == nullptr);
10541 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture)) {
10542 data.correlationData = correlationData + i;
10543 handle->call(CL_FUNCTION_clCreateFromGLTexture, &data);
10544 }
10545 ++i;
10546 }
10547
10548 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10549 }
10550
10551 void exit(cl_mem *retVal) {
10552 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10553 data.site = CL_CALLBACK_SITE_EXIT;
10554 data.functionReturnValue = retVal;
10555
10556 size_t i = 0;
10557 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10558 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10559 TracingHandle *handle = tracingHandle[i];
10560 DEBUG_BREAK_IF(handle == nullptr);
10561 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture)) {
10562 data.correlationData = correlationData + i;
10563 handle->call(CL_FUNCTION_clCreateFromGLTexture, &data);
10564 }
10565 ++i;
10566 }
10567
10568 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10569 }
10570
10571 ~ClCreateFromGlTextureTracer() {
10572 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10573 }
10574
10575 private:
10576 cl_params_clCreateFromGLTexture params{};
10577 cl_callback_data data{};
10578 uint64_t correlationData[tracingMaxHandleCount];
10579 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10580 };
10581
10582 class ClCreateFromGlTexture2DTracer {
10583 public:
10584 ClCreateFromGlTexture2DTracer() {}
10585
10586 void enter(cl_context *context,
10587 cl_mem_flags *flags,
10588 cl_GLenum *target,
10589 cl_GLint *miplevel,
10590 cl_GLuint *texture,
10591 cl_int **errcodeRet) {
10592 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10593
10594 params.context = context;
10595 params.flags = flags;
10596 params.target = target;
10597 params.miplevel = miplevel;
10598 params.texture = texture;
10599 params.errcodeRet = errcodeRet;
10600
10601 data.site = CL_CALLBACK_SITE_ENTER;
10602 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10603 data.functionName = "clCreateFromGLTexture2D";
10604 data.functionParams = static_cast<const void *>(&params);
10605 data.functionReturnValue = nullptr;
10606
10607 size_t i = 0;
10608 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10609 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10610 TracingHandle *handle = tracingHandle[i];
10611 DEBUG_BREAK_IF(handle == nullptr);
10612 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture2D)) {
10613 data.correlationData = correlationData + i;
10614 handle->call(CL_FUNCTION_clCreateFromGLTexture2D, &data);
10615 }
10616 ++i;
10617 }
10618
10619 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10620 }
10621
10622 void exit(cl_mem *retVal) {
10623 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10624 data.site = CL_CALLBACK_SITE_EXIT;
10625 data.functionReturnValue = retVal;
10626
10627 size_t i = 0;
10628 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10629 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10630 TracingHandle *handle = tracingHandle[i];
10631 DEBUG_BREAK_IF(handle == nullptr);
10632 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture2D)) {
10633 data.correlationData = correlationData + i;
10634 handle->call(CL_FUNCTION_clCreateFromGLTexture2D, &data);
10635 }
10636 ++i;
10637 }
10638
10639 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10640 }
10641
10642 ~ClCreateFromGlTexture2DTracer() {
10643 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10644 }
10645
10646 private:
10647 cl_params_clCreateFromGLTexture2D params{};
10648 cl_callback_data data{};
10649 uint64_t correlationData[tracingMaxHandleCount];
10650 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10651 };
10652
10653 class ClCreateFromGlTexture3DTracer {
10654 public:
10655 ClCreateFromGlTexture3DTracer() {}
10656
10657 void enter(cl_context *context,
10658 cl_mem_flags *flags,
10659 cl_GLenum *target,
10660 cl_GLint *miplevel,
10661 cl_GLuint *texture,
10662 cl_int **errcodeRet) {
10663 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10664
10665 params.context = context;
10666 params.flags = flags;
10667 params.target = target;
10668 params.miplevel = miplevel;
10669 params.texture = texture;
10670 params.errcodeRet = errcodeRet;
10671
10672 data.site = CL_CALLBACK_SITE_ENTER;
10673 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10674 data.functionName = "clCreateFromGLTexture3D";
10675 data.functionParams = static_cast<const void *>(&params);
10676 data.functionReturnValue = nullptr;
10677
10678 size_t i = 0;
10679 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10680 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10681 TracingHandle *handle = tracingHandle[i];
10682 DEBUG_BREAK_IF(handle == nullptr);
10683 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture3D)) {
10684 data.correlationData = correlationData + i;
10685 handle->call(CL_FUNCTION_clCreateFromGLTexture3D, &data);
10686 }
10687 ++i;
10688 }
10689
10690 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10691 }
10692
10693 void exit(cl_mem *retVal) {
10694 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10695 data.site = CL_CALLBACK_SITE_EXIT;
10696 data.functionReturnValue = retVal;
10697
10698 size_t i = 0;
10699 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10700 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10701 TracingHandle *handle = tracingHandle[i];
10702 DEBUG_BREAK_IF(handle == nullptr);
10703 if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture3D)) {
10704 data.correlationData = correlationData + i;
10705 handle->call(CL_FUNCTION_clCreateFromGLTexture3D, &data);
10706 }
10707 ++i;
10708 }
10709
10710 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10711 }
10712
10713 ~ClCreateFromGlTexture3DTracer() {
10714 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10715 }
10716
10717 private:
10718 cl_params_clCreateFromGLTexture3D params{};
10719 cl_callback_data data{};
10720 uint64_t correlationData[tracingMaxHandleCount];
10721 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10722 };
10723
10724 class ClEnqueueAcquireGlObjectsTracer {
10725 public:
10726 ClEnqueueAcquireGlObjectsTracer() {}
10727
10728 void enter(cl_command_queue *commandQueue,
10729 cl_uint *numObjects,
10730 const cl_mem **memObjects,
10731 cl_uint *numEventsInWaitList,
10732 const cl_event **eventWaitList,
10733 cl_event **event) {
10734 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10735
10736 params.commandQueue = commandQueue;
10737 params.numObjects = numObjects;
10738 params.memObjects = memObjects;
10739 params.numEventsInWaitList = numEventsInWaitList;
10740 params.eventWaitList = eventWaitList;
10741 params.event = event;
10742
10743 data.site = CL_CALLBACK_SITE_ENTER;
10744 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10745 data.functionName = "clEnqueueAcquireGLObjects";
10746 data.functionParams = static_cast<const void *>(&params);
10747 data.functionReturnValue = nullptr;
10748
10749 size_t i = 0;
10750 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10751 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10752 TracingHandle *handle = tracingHandle[i];
10753 DEBUG_BREAK_IF(handle == nullptr);
10754 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireGLObjects)) {
10755 data.correlationData = correlationData + i;
10756 handle->call(CL_FUNCTION_clEnqueueAcquireGLObjects, &data);
10757 }
10758 ++i;
10759 }
10760
10761 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10762 }
10763
10764 void exit(cl_int *retVal) {
10765 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10766 data.site = CL_CALLBACK_SITE_EXIT;
10767 data.functionReturnValue = retVal;
10768
10769 size_t i = 0;
10770 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10771 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10772 TracingHandle *handle = tracingHandle[i];
10773 DEBUG_BREAK_IF(handle == nullptr);
10774 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireGLObjects)) {
10775 data.correlationData = correlationData + i;
10776 handle->call(CL_FUNCTION_clEnqueueAcquireGLObjects, &data);
10777 }
10778 ++i;
10779 }
10780
10781 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10782 }
10783
10784 ~ClEnqueueAcquireGlObjectsTracer() {
10785 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10786 }
10787
10788 private:
10789 cl_params_clEnqueueAcquireGLObjects params{};
10790 cl_callback_data data{};
10791 uint64_t correlationData[tracingMaxHandleCount];
10792 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10793 };
10794
10795 class ClEnqueueReleaseGlObjectsTracer {
10796 public:
10797 ClEnqueueReleaseGlObjectsTracer() {}
10798
10799 void enter(cl_command_queue *commandQueue,
10800 cl_uint *numObjects,
10801 const cl_mem **memObjects,
10802 cl_uint *numEventsInWaitList,
10803 const cl_event **eventWaitList,
10804 cl_event **event) {
10805 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10806
10807 params.commandQueue = commandQueue;
10808 params.numObjects = numObjects;
10809 params.memObjects = memObjects;
10810 params.numEventsInWaitList = numEventsInWaitList;
10811 params.eventWaitList = eventWaitList;
10812 params.event = event;
10813
10814 data.site = CL_CALLBACK_SITE_ENTER;
10815 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10816 data.functionName = "clEnqueueReleaseGLObjects";
10817 data.functionParams = static_cast<const void *>(&params);
10818 data.functionReturnValue = nullptr;
10819
10820 size_t i = 0;
10821 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10822 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10823 TracingHandle *handle = tracingHandle[i];
10824 DEBUG_BREAK_IF(handle == nullptr);
10825 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseGLObjects)) {
10826 data.correlationData = correlationData + i;
10827 handle->call(CL_FUNCTION_clEnqueueReleaseGLObjects, &data);
10828 }
10829 ++i;
10830 }
10831
10832 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10833 }
10834
10835 void exit(cl_int *retVal) {
10836 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10837 data.site = CL_CALLBACK_SITE_EXIT;
10838 data.functionReturnValue = retVal;
10839
10840 size_t i = 0;
10841 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10842 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10843 TracingHandle *handle = tracingHandle[i];
10844 DEBUG_BREAK_IF(handle == nullptr);
10845 if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseGLObjects)) {
10846 data.correlationData = correlationData + i;
10847 handle->call(CL_FUNCTION_clEnqueueReleaseGLObjects, &data);
10848 }
10849 ++i;
10850 }
10851
10852 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10853 }
10854
10855 ~ClEnqueueReleaseGlObjectsTracer() {
10856 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10857 }
10858
10859 private:
10860 cl_params_clEnqueueReleaseGLObjects params{};
10861 cl_callback_data data{};
10862 uint64_t correlationData[tracingMaxHandleCount];
10863 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10864 };
10865
10866 class ClGetGlObjectInfoTracer {
10867 public:
10868 ClGetGlObjectInfoTracer() {}
10869
10870 void enter(cl_mem *memobj,
10871 cl_gl_object_type **glObjectType,
10872 cl_GLuint **glObjectName) {
10873 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10874
10875 params.memobj = memobj;
10876 params.glObjectType = glObjectType;
10877 params.glObjectName = glObjectName;
10878
10879 data.site = CL_CALLBACK_SITE_ENTER;
10880 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10881 data.functionName = "clGetGLObjectInfo";
10882 data.functionParams = static_cast<const void *>(&params);
10883 data.functionReturnValue = nullptr;
10884
10885 size_t i = 0;
10886 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10887 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10888 TracingHandle *handle = tracingHandle[i];
10889 DEBUG_BREAK_IF(handle == nullptr);
10890 if (handle->getTracingPoint(CL_FUNCTION_clGetGLObjectInfo)) {
10891 data.correlationData = correlationData + i;
10892 handle->call(CL_FUNCTION_clGetGLObjectInfo, &data);
10893 }
10894 ++i;
10895 }
10896
10897 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10898 }
10899
10900 void exit(cl_int *retVal) {
10901 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10902 data.site = CL_CALLBACK_SITE_EXIT;
10903 data.functionReturnValue = retVal;
10904
10905 size_t i = 0;
10906 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10907 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10908 TracingHandle *handle = tracingHandle[i];
10909 DEBUG_BREAK_IF(handle == nullptr);
10910 if (handle->getTracingPoint(CL_FUNCTION_clGetGLObjectInfo)) {
10911 data.correlationData = correlationData + i;
10912 handle->call(CL_FUNCTION_clGetGLObjectInfo, &data);
10913 }
10914 ++i;
10915 }
10916
10917 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10918 }
10919
10920 ~ClGetGlObjectInfoTracer() {
10921 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10922 }
10923
10924 private:
10925 cl_params_clGetGLObjectInfo params{};
10926 cl_callback_data data{};
10927 uint64_t correlationData[tracingMaxHandleCount];
10928 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10929 };
10930
10931 class ClGetGlTextureInfoTracer {
10932 public:
10933 ClGetGlTextureInfoTracer() {}
10934
10935 void enter(cl_mem *memobj,
10936 cl_gl_texture_info *paramName,
10937 size_t *paramValueSize,
10938 void **paramValue,
10939 size_t **paramValueSizeRet) {
10940 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED);
10941
10942 params.memobj = memobj;
10943 params.paramName = paramName;
10944 params.paramValueSize = paramValueSize;
10945 params.paramValue = paramValue;
10946 params.paramValueSizeRet = paramValueSizeRet;
10947
10948 data.site = CL_CALLBACK_SITE_ENTER;
10949 data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel);
10950 data.functionName = "clGetGLTextureInfo";
10951 data.functionParams = static_cast<const void *>(&params);
10952 data.functionReturnValue = nullptr;
10953
10954 size_t i = 0;
10955 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10956 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10957 TracingHandle *handle = tracingHandle[i];
10958 DEBUG_BREAK_IF(handle == nullptr);
10959 if (handle->getTracingPoint(CL_FUNCTION_clGetGLTextureInfo)) {
10960 data.correlationData = correlationData + i;
10961 handle->call(CL_FUNCTION_clGetGLTextureInfo, &data);
10962 }
10963 ++i;
10964 }
10965
10966 state = TRACING_NOTIFY_STATE_ENTER_CALLED;
10967 }
10968
10969 void exit(cl_int *retVal) {
10970 DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED);
10971 data.site = CL_CALLBACK_SITE_EXIT;
10972 data.functionReturnValue = retVal;
10973
10974 size_t i = 0;
10975 DEBUG_BREAK_IF(tracingHandle[0] == nullptr);
10976 while (i < tracingMaxHandleCount && tracingHandle[i] != nullptr) {
10977 TracingHandle *handle = tracingHandle[i];
10978 DEBUG_BREAK_IF(handle == nullptr);
10979 if (handle->getTracingPoint(CL_FUNCTION_clGetGLTextureInfo)) {
10980 data.correlationData = correlationData + i;
10981 handle->call(CL_FUNCTION_clGetGLTextureInfo, &data);
10982 }
10983 ++i;
10984 }
10985
10986 state = TRACING_NOTIFY_STATE_EXIT_CALLED;
10987 }
10988
10989 ~ClGetGlTextureInfoTracer() {
10990 DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED);
10991 }
10992
10993 private:
10994 cl_params_clGetGLTextureInfo params{};
10995 cl_callback_data data{};
10996 uint64_t correlationData[tracingMaxHandleCount];
10997 TracingNotifyState state = TRACING_NOTIFY_STATE_NOTHING_CALLED;
10998 };
10999
11000 } // namespace HostSideTracing