]>
Commit | Line | Data |
---|---|---|
5fae049d TS |
1 | /* OpenACC Profiling Interface |
2 | ||
83ffe9cd | 3 | Copyright (C) 2019-2023 Free Software Foundation, Inc. |
5fae049d TS |
4 | |
5 | Contributed by Mentor, a Siemens Business. | |
6 | ||
7 | This file is part of the GNU Offloading and Multi Processing Library | |
8 | (libgomp). | |
9 | ||
10 | Libgomp is free software; you can redistribute it and/or modify it | |
11 | under the terms of the GNU General Public License as published by | |
12 | the Free Software Foundation; either version 3, or (at your option) | |
13 | any later version. | |
14 | ||
15 | Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY | |
16 | WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | |
17 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
18 | more details. | |
19 | ||
20 | Under Section 7 of GPL version 3, you are granted additional | |
21 | permissions described in the GCC Runtime Library Exception, version | |
22 | 3.1, as published by the Free Software Foundation. | |
23 | ||
24 | You should have received a copy of the GNU General Public License and | |
25 | a copy of the GCC Runtime Library Exception along with this program; | |
26 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
27 | <http://www.gnu.org/licenses/>. */ | |
28 | ||
29 | #define _GNU_SOURCE | |
30 | #include "libgomp.h" | |
31 | #include "oacc-int.h" | |
32 | #include "secure_getenv.h" | |
33 | #include "acc_prof.h" | |
34 | #include <assert.h> | |
35 | #ifdef HAVE_STRING_H | |
36 | # include <string.h> | |
37 | #endif | |
38 | #ifdef PLUGIN_SUPPORT | |
39 | # include <dlfcn.h> | |
40 | #endif | |
41 | ||
42 | #define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")") | |
43 | ||
44 | /* Statically assert that the layout of the common fields in the | |
45 | 'acc_event_info' variants matches. */ | |
46 | /* 'event_type' */ | |
47 | STATIC_ASSERT (offsetof (acc_event_info, event_type) | |
48 | == offsetof (acc_event_info, data_event.event_type)); | |
49 | STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type) | |
50 | == offsetof (acc_event_info, launch_event.event_type)); | |
51 | STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type) | |
52 | == offsetof (acc_event_info, other_event.event_type)); | |
53 | /* 'valid_bytes' */ | |
54 | STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes) | |
55 | == offsetof (acc_event_info, launch_event.valid_bytes)); | |
56 | STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes) | |
57 | == offsetof (acc_event_info, other_event.valid_bytes)); | |
58 | /* 'parent_construct' */ | |
59 | STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct) | |
60 | == offsetof (acc_event_info, launch_event.parent_construct)); | |
61 | STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct) | |
62 | == offsetof (acc_event_info, other_event.parent_construct)); | |
63 | /* 'implicit' */ | |
64 | STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit) | |
65 | == offsetof (acc_event_info, launch_event.implicit)); | |
66 | STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit) | |
67 | == offsetof (acc_event_info, other_event.implicit)); | |
68 | /* 'tool_info' */ | |
69 | STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info) | |
70 | == offsetof (acc_event_info, launch_event.tool_info)); | |
71 | STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info) | |
72 | == offsetof (acc_event_info, other_event.tool_info)); | |
73 | ||
74 | struct goacc_prof_callback_entry | |
75 | { | |
76 | acc_prof_callback cb; | |
77 | int ref; | |
78 | bool enabled; | |
79 | struct goacc_prof_callback_entry *next; | |
80 | }; | |
81 | ||
82 | /* Use a separate flag to minimize run-time performance impact for the (very | |
83 | common) case that profiling is not enabled. | |
84 | ||
85 | Once enabled, we're not going to disable this anymore, anywhere. We | |
86 | probably could, by adding appropriate logic to 'acc_prof_register', | |
87 | 'acc_prof_unregister'. */ | |
88 | bool goacc_prof_enabled = false; | |
89 | ||
90 | /* Global state for registered callbacks. | |
91 | 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */ | |
92 | static bool goacc_prof_callbacks_enabled[acc_ev_last]; | |
93 | static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last]; | |
94 | /* Lock used to protect access to 'goacc_prof_callbacks_enabled', and | |
95 | 'goacc_prof_callback_entries'. */ | |
96 | static gomp_mutex_t goacc_prof_lock; | |
97 | ||
98 | void | |
99 | goacc_profiling_initialize (void) | |
100 | { | |
101 | gomp_mutex_init (&goacc_prof_lock); | |
102 | ||
103 | /* Initially, all callbacks for all events are enabled. */ | |
104 | for (int i = 0; i < acc_ev_last; ++i) | |
105 | goacc_prof_callbacks_enabled[i] = true; | |
106 | ||
107 | ||
108 | #ifdef PLUGIN_SUPPORT | |
109 | char *acc_proflibs = secure_getenv ("ACC_PROFLIB"); | |
110 | while (acc_proflibs != NULL && acc_proflibs[0] != '\0') | |
111 | { | |
112 | char *acc_proflibs_sep = strchr (acc_proflibs, ';'); | |
113 | char *acc_proflib; | |
114 | if (acc_proflibs_sep == acc_proflibs) | |
115 | { | |
116 | /* Stray ';' separator: make sure we don't 'dlopen' the main | |
117 | program. */ | |
118 | acc_proflib = NULL; | |
119 | } | |
120 | else | |
121 | { | |
122 | if (acc_proflibs_sep != NULL) | |
123 | { | |
124 | /* Single out the first library. */ | |
125 | acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1); | |
126 | memcpy (acc_proflib, acc_proflibs, | |
127 | acc_proflibs_sep - acc_proflibs); | |
128 | acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0'; | |
129 | } | |
130 | else | |
131 | { | |
132 | /* No ';' separator, so only one library. */ | |
133 | acc_proflib = acc_proflibs; | |
134 | } | |
135 | ||
136 | gomp_debug (0, "%s: dlopen (\"%s\")\n", __FUNCTION__, acc_proflib); | |
137 | void *dl_handle = dlopen (acc_proflib, RTLD_LAZY); | |
138 | if (dl_handle != NULL) | |
139 | { | |
140 | typeof (&acc_register_library) a_r_l | |
141 | = dlsym (dl_handle, "acc_register_library"); | |
142 | if (a_r_l == NULL) | |
143 | goto dl_fail; | |
144 | gomp_debug (0, " %s: calling %s:acc_register_library\n", | |
145 | __FUNCTION__, acc_proflib); | |
146 | a_r_l (acc_prof_register, acc_prof_unregister, | |
147 | acc_prof_lookup); | |
148 | } | |
149 | else | |
150 | { | |
151 | dl_fail: | |
152 | gomp_error ("while loading ACC_PROFLIB \"%s\": %s", | |
153 | acc_proflib, dlerror ()); | |
154 | if (dl_handle != NULL) | |
155 | { | |
156 | int err = dlclose (dl_handle); | |
157 | dl_handle = NULL; | |
158 | if (err != 0) | |
159 | goto dl_fail; | |
160 | } | |
161 | } | |
162 | } | |
163 | ||
164 | if (acc_proflib != acc_proflibs) | |
165 | { | |
166 | free (acc_proflib); | |
167 | ||
168 | acc_proflibs = acc_proflibs_sep + 1; | |
169 | } | |
170 | else | |
171 | acc_proflibs = NULL; | |
172 | } | |
173 | #endif /* PLUGIN_SUPPORT */ | |
174 | } | |
175 | ||
176 | void | |
177 | acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg) | |
178 | { | |
179 | gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n", | |
180 | __FUNCTION__, (int) ev, (void *) cb, (int) reg); | |
181 | ||
182 | ||
183 | /* For any events to be dispatched, the user first has to register a | |
184 | callback, which makes this here a good place for enabling the whole | |
185 | machinery. */ | |
186 | if (!GOACC_PROF_ENABLED) | |
187 | __atomic_store_n (&goacc_prof_enabled, true, MEMMODEL_RELEASE); | |
188 | ||
189 | ||
190 | enum | |
191 | { | |
192 | EVENT_KIND_BOGUS, | |
193 | EVENT_KIND_NORMAL, | |
194 | /* As end events invoke callbacks in the reverse order, we register these | |
195 | in the reverse order here. */ | |
196 | EVENT_KIND_END, | |
197 | } event_kind = EVENT_KIND_BOGUS; | |
198 | switch (ev) | |
199 | { | |
200 | case acc_ev_none: | |
201 | case acc_ev_device_init_start: | |
202 | case acc_ev_device_shutdown_start: | |
203 | case acc_ev_runtime_shutdown: | |
204 | case acc_ev_create: | |
205 | case acc_ev_delete: | |
206 | case acc_ev_alloc: | |
207 | case acc_ev_free: | |
208 | case acc_ev_enter_data_start: | |
209 | case acc_ev_exit_data_start: | |
210 | case acc_ev_update_start: | |
211 | case acc_ev_compute_construct_start: | |
212 | case acc_ev_enqueue_launch_start: | |
213 | case acc_ev_enqueue_upload_start: | |
214 | case acc_ev_enqueue_download_start: | |
215 | case acc_ev_wait_start: | |
216 | event_kind = EVENT_KIND_NORMAL; | |
217 | break; | |
218 | case acc_ev_device_init_end: | |
219 | case acc_ev_device_shutdown_end: | |
220 | case acc_ev_enter_data_end: | |
221 | case acc_ev_exit_data_end: | |
222 | case acc_ev_update_end: | |
223 | case acc_ev_compute_construct_end: | |
224 | case acc_ev_enqueue_launch_end: | |
225 | case acc_ev_enqueue_upload_end: | |
226 | case acc_ev_enqueue_download_end: | |
227 | case acc_ev_wait_end: | |
228 | event_kind = EVENT_KIND_END; | |
229 | break; | |
230 | case acc_ev_last: | |
231 | break; | |
232 | } | |
233 | if (event_kind == EVENT_KIND_BOGUS) | |
234 | { | |
235 | /* Silently ignore. */ | |
236 | gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n"); | |
237 | return; | |
238 | } | |
239 | ||
240 | bool bogus = true; | |
241 | switch (reg) | |
242 | { | |
243 | case acc_reg: | |
244 | case acc_toggle: | |
245 | case acc_toggle_per_thread: | |
246 | bogus = false; | |
247 | break; | |
248 | } | |
249 | if (bogus) | |
250 | { | |
251 | /* Silently ignore. */ | |
252 | gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n"); | |
253 | return; | |
254 | } | |
255 | ||
256 | /* Special cases. */ | |
257 | if (reg == acc_toggle) | |
258 | { | |
259 | if (cb == NULL) | |
260 | { | |
261 | gomp_debug (0, " globally enabling callbacks\n"); | |
262 | gomp_mutex_lock (&goacc_prof_lock); | |
263 | /* For 'acc_ev_none', this acts as a global toggle. */ | |
264 | goacc_prof_callbacks_enabled[ev] = true; | |
265 | gomp_mutex_unlock (&goacc_prof_lock); | |
266 | return; | |
267 | } | |
268 | else if (ev == acc_ev_none && cb != NULL) | |
269 | { | |
270 | gomp_debug (0, " ignoring request\n"); | |
271 | return; | |
272 | } | |
273 | } | |
274 | else if (reg == acc_toggle_per_thread) | |
275 | { | |
276 | if (ev == acc_ev_none && cb == NULL) | |
277 | { | |
278 | gomp_debug (0, " thread: enabling callbacks\n"); | |
279 | goacc_lazy_initialize (); | |
280 | struct goacc_thread *thr = goacc_thread (); | |
281 | thr->prof_callbacks_enabled = true; | |
282 | return; | |
283 | } | |
284 | /* Silently ignore. */ | |
285 | gomp_debug (0, " ignoring bogus request\n"); | |
286 | return; | |
287 | } | |
288 | ||
289 | gomp_mutex_lock (&goacc_prof_lock); | |
290 | ||
291 | struct goacc_prof_callback_entry *it, *it_p; | |
292 | it = goacc_prof_callback_entries[ev]; | |
293 | it_p = NULL; | |
294 | while (it) | |
295 | { | |
296 | if (it->cb == cb) | |
297 | break; | |
298 | it_p = it; | |
299 | it = it->next; | |
300 | } | |
301 | ||
302 | switch (reg) | |
303 | { | |
304 | case acc_reg: | |
305 | /* If we already have this callback registered, just increment its | |
306 | reference count. */ | |
307 | if (it != NULL) | |
308 | { | |
309 | it->ref++; | |
310 | gomp_debug (0, " already registered;" | |
311 | " incrementing reference count to: %d\n", it->ref); | |
312 | } | |
313 | else | |
314 | { | |
315 | struct goacc_prof_callback_entry *e | |
316 | = gomp_malloc (sizeof (struct goacc_prof_callback_entry)); | |
317 | e->cb = cb; | |
318 | e->ref = 1; | |
319 | e->enabled = true; | |
320 | bool prepend = (event_kind == EVENT_KIND_END); | |
321 | /* If we don't have any callback registered yet, also use the | |
322 | 'prepend' code path. */ | |
323 | if (it_p == NULL) | |
324 | prepend = true; | |
325 | if (prepend) | |
326 | { | |
327 | gomp_debug (0, " prepending\n"); | |
328 | e->next = goacc_prof_callback_entries[ev]; | |
329 | goacc_prof_callback_entries[ev] = e; | |
330 | } | |
331 | else | |
332 | { | |
333 | gomp_debug (0, " appending\n"); | |
334 | e->next = NULL; | |
335 | it_p->next = e; | |
336 | } | |
337 | } | |
338 | break; | |
339 | ||
340 | case acc_toggle: | |
341 | if (it == NULL) | |
342 | { | |
343 | gomp_debug (0, " ignoring request: is not registered\n"); | |
344 | break; | |
345 | } | |
346 | else | |
347 | { | |
348 | gomp_debug (0, " enabling\n"); | |
349 | it->enabled = true; | |
350 | } | |
351 | break; | |
352 | ||
353 | case acc_toggle_per_thread: | |
354 | __builtin_unreachable (); | |
355 | } | |
356 | ||
357 | gomp_mutex_unlock (&goacc_prof_lock); | |
358 | } | |
359 | ||
360 | void | |
361 | acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg) | |
362 | { | |
363 | gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n", | |
364 | __FUNCTION__, (int) ev, (void *) cb, (int) reg); | |
365 | ||
366 | /* If profiling is not enabled, there cannot be anything to unregister. */ | |
367 | if (!GOACC_PROF_ENABLED) | |
368 | return; | |
369 | ||
370 | if (ev < acc_ev_none | |
371 | || ev >= acc_ev_last) | |
372 | { | |
373 | /* Silently ignore. */ | |
374 | gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n"); | |
375 | return; | |
376 | } | |
377 | ||
378 | bool bogus = true; | |
379 | switch (reg) | |
380 | { | |
381 | case acc_reg: | |
382 | case acc_toggle: | |
383 | case acc_toggle_per_thread: | |
384 | bogus = false; | |
385 | break; | |
386 | } | |
387 | if (bogus) | |
388 | { | |
389 | /* Silently ignore. */ | |
390 | gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n"); | |
391 | return; | |
392 | } | |
393 | ||
394 | /* Special cases. */ | |
395 | if (reg == acc_toggle) | |
396 | { | |
397 | if (cb == NULL) | |
398 | { | |
399 | gomp_debug (0, " globally disabling callbacks\n"); | |
400 | gomp_mutex_lock (&goacc_prof_lock); | |
401 | /* For 'acc_ev_none', this acts as a global toggle. */ | |
402 | goacc_prof_callbacks_enabled[ev] = false; | |
403 | gomp_mutex_unlock (&goacc_prof_lock); | |
404 | return; | |
405 | } | |
406 | else if (ev == acc_ev_none && cb != NULL) | |
407 | { | |
408 | gomp_debug (0, " ignoring request\n"); | |
409 | return; | |
410 | } | |
411 | } | |
412 | else if (reg == acc_toggle_per_thread) | |
413 | { | |
414 | if (ev == acc_ev_none && cb == NULL) | |
415 | { | |
416 | gomp_debug (0, " thread: disabling callbacks\n"); | |
417 | goacc_lazy_initialize (); | |
418 | struct goacc_thread *thr = goacc_thread (); | |
419 | thr->prof_callbacks_enabled = false; | |
420 | return; | |
421 | } | |
422 | /* Silently ignore. */ | |
423 | gomp_debug (0, " ignoring bogus request\n"); | |
424 | return; | |
425 | } | |
426 | ||
427 | gomp_mutex_lock (&goacc_prof_lock); | |
428 | ||
429 | struct goacc_prof_callback_entry *it, *it_p; | |
430 | it = goacc_prof_callback_entries[ev]; | |
431 | it_p = NULL; | |
432 | while (it) | |
433 | { | |
434 | if (it->cb == cb) | |
435 | break; | |
436 | it_p = it; | |
437 | it = it->next; | |
438 | } | |
439 | ||
440 | switch (reg) | |
441 | { | |
442 | case acc_reg: | |
443 | if (it == NULL) | |
444 | { | |
445 | /* Silently ignore. */ | |
446 | gomp_debug (0, " ignoring bogus request: is not registered\n"); | |
447 | break; | |
448 | } | |
449 | it->ref--; | |
450 | gomp_debug (0, " decrementing reference count to: %d\n", it->ref); | |
451 | if (it->ref == 0) | |
452 | { | |
453 | if (it_p == NULL) | |
454 | goacc_prof_callback_entries[ev] = it->next; | |
455 | else | |
456 | it_p->next = it->next; | |
457 | free (it); | |
458 | } | |
459 | break; | |
460 | ||
461 | case acc_toggle: | |
462 | if (it == NULL) | |
463 | { | |
464 | gomp_debug (0, " ignoring request: is not registered\n"); | |
465 | break; | |
466 | } | |
467 | else | |
468 | { | |
469 | gomp_debug (0, " disabling\n"); | |
470 | it->enabled = false; | |
471 | } | |
472 | break; | |
473 | ||
474 | case acc_toggle_per_thread: | |
475 | __builtin_unreachable (); | |
476 | } | |
477 | ||
478 | gomp_mutex_unlock (&goacc_prof_lock); | |
479 | } | |
480 | ||
481 | acc_query_fn | |
482 | acc_prof_lookup (const char *name) | |
483 | { | |
484 | gomp_debug (0, "%s (%s)\n", | |
485 | __FUNCTION__, name ?: "NULL"); | |
486 | ||
487 | return NULL; | |
488 | } | |
489 | ||
490 | void | |
491 | acc_register_library (acc_prof_reg reg, acc_prof_reg unreg, | |
492 | acc_prof_lookup_func lookup) | |
493 | { | |
494 | gomp_fatal ("TODO"); | |
495 | } | |
496 | ||
497 | /* Prepare to dispatch events? */ | |
498 | ||
499 | bool | |
500 | _goacc_profiling_dispatch_p (bool check_not_nested_p) | |
501 | { | |
502 | gomp_debug (0, "%s\n", __FUNCTION__); | |
503 | ||
504 | bool ret; | |
505 | ||
506 | struct goacc_thread *thr = goacc_thread (); | |
507 | if (__builtin_expect (thr == NULL, false)) | |
508 | { | |
509 | /* If we don't have any per-thread state yet, that means that per-thread | |
510 | callback dispatch has not been explicitly disabled (which only a call | |
511 | to 'acc_prof_unregister' with 'acc_toggle_per_thread' would do, and | |
512 | that would have allocated per-thread state via | |
513 | 'goacc_lazy_initialize'); initially, all callbacks for all events are | |
514 | enabled. */ | |
515 | gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__); | |
516 | } | |
517 | else | |
518 | { | |
519 | if (check_not_nested_p) | |
520 | { | |
521 | /* No nesting. */ | |
522 | assert (thr->prof_info == NULL); | |
523 | assert (thr->api_info == NULL); | |
524 | } | |
525 | ||
526 | if (__builtin_expect (!thr->prof_callbacks_enabled, true)) | |
527 | { | |
528 | gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__); | |
529 | ret = false; | |
530 | goto out; | |
531 | } | |
532 | } | |
533 | ||
534 | gomp_mutex_lock (&goacc_prof_lock); | |
535 | ||
536 | /* 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */ | |
537 | if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true)) | |
538 | { | |
539 | gomp_debug (0, " %s: disabled globally\n", __FUNCTION__); | |
540 | ret = false; | |
541 | goto out_unlock; | |
542 | } | |
543 | else | |
544 | ret = true; | |
545 | ||
546 | out_unlock: | |
547 | gomp_mutex_unlock (&goacc_prof_lock); | |
548 | ||
549 | out: | |
550 | return ret; | |
551 | } | |
552 | ||
553 | /* Set up to dispatch events? */ | |
554 | ||
555 | bool | |
556 | _goacc_profiling_setup_p (struct goacc_thread *thr, | |
557 | acc_prof_info *prof_info, acc_api_info *api_info) | |
558 | { | |
559 | gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr); | |
560 | ||
561 | /* If we don't have any per-thread state yet, we can't register 'prof_info' | |
562 | and 'api_info'. */ | |
563 | if (__builtin_expect (thr == NULL, false)) | |
564 | { | |
565 | gomp_debug (0, "Can't dispatch OpenACC Profiling Interface events for" | |
566 | " the current call, construct, or directive\n"); | |
567 | return false; | |
568 | } | |
569 | ||
570 | if (thr->prof_info != NULL) | |
571 | { | |
572 | /* Profiling has already been set up for an outer construct. In this | |
573 | case, we continue to use the existing information, and thus return | |
574 | 'false' here. | |
575 | ||
576 | This can happen, for example, for an 'enter data' directive, which | |
577 | sets up profiling, then calls into 'acc_copyin', which should not | |
578 | again set up profiling, should not overwrite the existing | |
579 | information. */ | |
580 | return false; | |
581 | } | |
582 | ||
583 | thr->prof_info = prof_info; | |
584 | thr->api_info = api_info; | |
585 | ||
586 | /* Fill in some defaults. */ | |
587 | ||
588 | prof_info->event_type = -1; /* Must be set later. */ | |
589 | prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES; | |
590 | prof_info->version = _ACC_PROF_INFO_VERSION; | |
591 | if (thr->dev) | |
592 | { | |
593 | prof_info->device_type = acc_device_type (thr->dev->type); | |
594 | prof_info->device_number = thr->dev->target_id; | |
595 | } | |
596 | else | |
597 | { | |
598 | prof_info->device_type = -1; | |
599 | prof_info->device_number = -1; | |
600 | } | |
601 | prof_info->thread_id = -1; | |
602 | prof_info->async = acc_async_sync; | |
603 | prof_info->async_queue = prof_info->async; | |
604 | prof_info->src_file = NULL; | |
605 | prof_info->func_name = NULL; | |
606 | prof_info->line_no = -1; | |
607 | prof_info->end_line_no = -1; | |
608 | prof_info->func_line_no = -1; | |
609 | prof_info->func_end_line_no = -1; | |
610 | ||
611 | api_info->device_api = acc_device_api_none; | |
612 | api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES; | |
613 | api_info->device_type = prof_info->device_type; | |
614 | api_info->vendor = -1; | |
615 | api_info->device_handle = NULL; | |
616 | api_info->context_handle = NULL; | |
617 | api_info->async_handle = NULL; | |
618 | ||
619 | return true; | |
620 | } | |
621 | ||
622 | /* Dispatch events. | |
623 | ||
624 | This must only be called if 'GOACC_PROFILING_DISPATCH_P' or | |
625 | 'GOACC_PROFILING_SETUP_P' returned a true result. */ | |
626 | ||
627 | void | |
628 | goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info, | |
629 | acc_api_info *apt_info) | |
630 | { | |
631 | acc_event_t event_type = event_info->event_type; | |
632 | gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type); | |
633 | assert (event_type > acc_ev_none | |
634 | && event_type < acc_ev_last); | |
635 | ||
636 | gomp_mutex_lock (&goacc_prof_lock); | |
637 | ||
638 | if (!goacc_prof_callbacks_enabled[event_type]) | |
639 | { | |
640 | gomp_debug (0, " disabled for this event type\n"); | |
641 | ||
642 | goto out_unlock; | |
643 | } | |
644 | ||
645 | for (struct goacc_prof_callback_entry *e | |
646 | = goacc_prof_callback_entries[event_type]; | |
647 | e != NULL; | |
648 | e = e->next) | |
649 | { | |
650 | if (!e->enabled) | |
651 | { | |
652 | gomp_debug (0, " disabled for callback %p\n", e->cb); | |
653 | continue; | |
654 | } | |
655 | ||
656 | gomp_debug (0, " calling callback %p\n", e->cb); | |
657 | e->cb (prof_info, event_info, apt_info); | |
658 | } | |
659 | ||
660 | out_unlock: | |
661 | gomp_mutex_unlock (&goacc_prof_lock); | |
662 | } |