1 /*
2 * ompt-general.cpp -- OMPT implementation of interface functions
3 */
4
5 //===----------------------------------------------------------------------===//
6 //
7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8 // See https://llvm.org/LICENSE.txt for license information.
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10 //
11 //===----------------------------------------------------------------------===//
12
13 /*****************************************************************************
14 * system include files
15 ****************************************************************************/
16
17 #include <assert.h>
18
19 #include <stdint.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #if KMP_OS_UNIX
24 #include <dlfcn.h>
25 #endif
26
27 /*****************************************************************************
28 * ompt include files
29 ****************************************************************************/
30
31 #include "ompt-specific.cpp"
32
33 /*****************************************************************************
34 * macros
35 ****************************************************************************/
36
37 #define ompt_get_callback_success 1
38 #define ompt_get_callback_failure 0
39
40 #define no_tool_present 0
41
42 #define OMPT_API_ROUTINE static
43
44 #ifndef OMPT_STR_MATCH
45 #define OMPT_STR_MATCH(haystack, needle) (!strcasecmp(haystack, needle))
46 #endif
47
48 /*****************************************************************************
49 * types
50 ****************************************************************************/
51
52 typedef struct {
53 const char *state_name;
54 ompt_state_t state_id;
55 } ompt_state_info_t;
56
57 typedef struct {
58 const char *name;
59 kmp_mutex_impl_t id;
60 } kmp_mutex_impl_info_t;
61
62 enum tool_setting_e {
63 omp_tool_error,
64 omp_tool_unset,
65 omp_tool_disabled,
66 omp_tool_enabled
67 };
68
69 /*****************************************************************************
70 * global variables
71 ****************************************************************************/
72
73 ompt_callbacks_active_t ompt_enabled;
74
75 ompt_state_info_t ompt_state_info[] = {
76 #define ompt_state_macro(state, code) {#state, state},
77 FOREACH_OMPT_STATE(ompt_state_macro)
78 #undef ompt_state_macro
79 };
80
81 kmp_mutex_impl_info_t kmp_mutex_impl_info[] = {
82 #define kmp_mutex_impl_macro(name, id) {#name, name},
83 FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro)
84 #undef kmp_mutex_impl_macro
85 };
86
87 ompt_callbacks_internal_t ompt_callbacks;
88
89 static ompt_start_tool_result_t *ompt_start_tool_result = NULL;
90
91 /*****************************************************************************
92 * forward declarations
93 ****************************************************************************/
94
95 static ompt_interface_fn_t ompt_fn_lookup(const char *s);
96
97 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void);
98
99 /*****************************************************************************
100 * initialization and finalization (private operations)
101 ****************************************************************************/
102
103 typedef ompt_start_tool_result_t *(*ompt_start_tool_t)(unsigned int,
104 const char *);
105
106 #if KMP_OS_DARWIN
107
108 // While Darwin supports weak symbols, the library that wishes to provide a new
109 // implementation has to link against this runtime which defeats the purpose
110 // of having tools that are agnostic of the underlying runtime implementation.
111 //
112 // Fortunately, the linker includes all symbols of an executable in the global
113 // symbol table by default so dlsym() even finds static implementations of
114 // ompt_start_tool. For this to work on Linux, -Wl,--export-dynamic needs to be
115 // passed when building the application which we don't want to rely on.
116
ompt_tool_darwin(unsigned int omp_version,const char * runtime_version)117 static ompt_start_tool_result_t *ompt_tool_darwin(unsigned int omp_version,
118 const char *runtime_version) {
119 ompt_start_tool_result_t *ret = NULL;
120 // Search symbol in the current address space.
121 ompt_start_tool_t start_tool =
122 (ompt_start_tool_t)dlsym(RTLD_DEFAULT, "ompt_start_tool");
123 if (start_tool) {
124 ret = start_tool(omp_version, runtime_version);
125 }
126 return ret;
127 }
128
129 #elif OMPT_HAVE_WEAK_ATTRIBUTE
130
131 // On Unix-like systems that support weak symbols the following implementation
132 // of ompt_start_tool() will be used in case no tool-supplied implementation of
133 // this function is present in the address space of a process.
134
135 _OMP_EXTERN OMPT_WEAK_ATTRIBUTE ompt_start_tool_result_t *
ompt_start_tool(unsigned int omp_version,const char * runtime_version)136 ompt_start_tool(unsigned int omp_version, const char *runtime_version) {
137 ompt_start_tool_result_t *ret = NULL;
138 // Search next symbol in the current address space. This can happen if the
139 // runtime library is linked before the tool. Since glibc 2.2 strong symbols
140 // don't override weak symbols that have been found before unless the user
141 // sets the environment variable LD_DYNAMIC_WEAK.
142 ompt_start_tool_t next_tool =
143 (ompt_start_tool_t)dlsym(RTLD_NEXT, "ompt_start_tool");
144 if (next_tool) {
145 ret = next_tool(omp_version, runtime_version);
146 }
147 return ret;
148 }
149
150 #elif OMPT_HAVE_PSAPI
151
152 // On Windows, the ompt_tool_windows function is used to find the
153 // ompt_start_tool symbol across all modules loaded by a process. If
154 // ompt_start_tool is found, ompt_start_tool's return value is used to
155 // initialize the tool. Otherwise, NULL is returned and OMPT won't be enabled.
156
157 #include <psapi.h>
158 #pragma comment(lib, "psapi.lib")
159
160 // The number of loaded modules to start enumeration with EnumProcessModules()
161 #define NUM_MODULES 128
162
163 static ompt_start_tool_result_t *
ompt_tool_windows(unsigned int omp_version,const char * runtime_version)164 ompt_tool_windows(unsigned int omp_version, const char *runtime_version) {
165 int i;
166 DWORD needed, new_size;
167 HMODULE *modules;
168 HANDLE process = GetCurrentProcess();
169 modules = (HMODULE *)malloc(NUM_MODULES * sizeof(HMODULE));
170 ompt_start_tool_t ompt_tool_p = NULL;
171
172 #if OMPT_DEBUG
173 printf("ompt_tool_windows(): looking for ompt_start_tool\n");
174 #endif
175 if (!EnumProcessModules(process, modules, NUM_MODULES * sizeof(HMODULE),
176 &needed)) {
177 // Regardless of the error reason use the stub initialization function
178 free(modules);
179 return NULL;
180 }
181 // Check if NUM_MODULES is enough to list all modules
182 new_size = needed / sizeof(HMODULE);
183 if (new_size > NUM_MODULES) {
184 #if OMPT_DEBUG
185 printf("ompt_tool_windows(): resize buffer to %d bytes\n", needed);
186 #endif
187 modules = (HMODULE *)realloc(modules, needed);
188 // If resizing failed use the stub function.
189 if (!EnumProcessModules(process, modules, needed, &needed)) {
190 free(modules);
191 return NULL;
192 }
193 }
194 for (i = 0; i < new_size; ++i) {
195 (FARPROC &)ompt_tool_p = GetProcAddress(modules[i], "ompt_start_tool");
196 if (ompt_tool_p) {
197 #if OMPT_DEBUG
198 TCHAR modName[MAX_PATH];
199 if (GetModuleFileName(modules[i], modName, MAX_PATH))
200 printf("ompt_tool_windows(): ompt_start_tool found in module %s\n",
201 modName);
202 #endif
203 free(modules);
204 return (*ompt_tool_p)(omp_version, runtime_version);
205 }
206 #if OMPT_DEBUG
207 else {
208 TCHAR modName[MAX_PATH];
209 if (GetModuleFileName(modules[i], modName, MAX_PATH))
210 printf("ompt_tool_windows(): ompt_start_tool not found in module %s\n",
211 modName);
212 }
213 #endif
214 }
215 free(modules);
216 return NULL;
217 }
218 #else
219 #error Activation of OMPT is not supported on this platform.
220 #endif
221
222 static ompt_start_tool_result_t *
ompt_try_start_tool(unsigned int omp_version,const char * runtime_version)223 ompt_try_start_tool(unsigned int omp_version, const char *runtime_version) {
224 ompt_start_tool_result_t *ret = NULL;
225 ompt_start_tool_t start_tool = NULL;
226 #if KMP_OS_WINDOWS
227 // Cannot use colon to describe a list of absolute paths on Windows
228 const char *sep = ";";
229 #else
230 const char *sep = ":";
231 #endif
232
233 #if KMP_OS_DARWIN
234 // Try in the current address space
235 ret = ompt_tool_darwin(omp_version, runtime_version);
236 #elif OMPT_HAVE_WEAK_ATTRIBUTE
237 ret = ompt_start_tool(omp_version, runtime_version);
238 #elif OMPT_HAVE_PSAPI
239 ret = ompt_tool_windows(omp_version, runtime_version);
240 #else
241 #error Activation of OMPT is not supported on this platform.
242 #endif
243 if (ret)
244 return ret;
245
246 // Try tool-libraries-var ICV
247 const char *tool_libs = getenv("OMP_TOOL_LIBRARIES");
248 if (tool_libs) {
249 char *libs = __kmp_str_format("%s", tool_libs);
250 char *buf;
251 char *fname = __kmp_str_token(libs, sep, &buf);
252 while (fname) {
253 #if KMP_OS_UNIX
254 void *h = dlopen(fname, RTLD_LAZY);
255 if (h) {
256 start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool");
257 #elif KMP_OS_WINDOWS
258 HMODULE h = LoadLibrary(fname);
259 if (h) {
260 start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool");
261 #else
262 #error Activation of OMPT is not supported on this platform.
263 #endif
264 if (start_tool && (ret = (*start_tool)(omp_version, runtime_version)))
265 break;
266 }
267 fname = __kmp_str_token(NULL, sep, &buf);
268 }
269 __kmp_str_free(&libs);
270 }
271 return ret;
272 }
273
274 void ompt_pre_init() {
275 //--------------------------------------------------
276 // Execute the pre-initialization logic only once.
277 //--------------------------------------------------
278 static int ompt_pre_initialized = 0;
279
280 if (ompt_pre_initialized)
281 return;
282
283 ompt_pre_initialized = 1;
284
285 //--------------------------------------------------
286 // Use a tool iff a tool is enabled and available.
287 //--------------------------------------------------
288 const char *ompt_env_var = getenv("OMP_TOOL");
289 tool_setting_e tool_setting = omp_tool_error;
290
291 if (!ompt_env_var || !strcmp(ompt_env_var, ""))
292 tool_setting = omp_tool_unset;
293 else if (OMPT_STR_MATCH(ompt_env_var, "disabled"))
294 tool_setting = omp_tool_disabled;
295 else if (OMPT_STR_MATCH(ompt_env_var, "enabled"))
296 tool_setting = omp_tool_enabled;
297
298 #if OMPT_DEBUG
299 printf("ompt_pre_init(): tool_setting = %d\n", tool_setting);
300 #endif
301 switch (tool_setting) {
302 case omp_tool_disabled:
303 break;
304
305 case omp_tool_unset:
306 case omp_tool_enabled:
307
308 //--------------------------------------------------
309 // Load tool iff specified in environment variable
310 //--------------------------------------------------
311 ompt_start_tool_result =
312 ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version());
313
314 memset(&ompt_enabled, 0, sizeof(ompt_enabled));
315 break;
316
317 case omp_tool_error:
318 fprintf(stderr, "Warning: OMP_TOOL has invalid value \"%s\".\n"
319 " legal values are (NULL,\"\",\"disabled\","
320 "\"enabled\").\n",
321 ompt_env_var);
322 break;
323 }
324 #if OMPT_DEBUG
325 printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled);
326 #endif
327 }
328
329 extern "C" int omp_get_initial_device(void);
330
331 void ompt_post_init() {
332 //--------------------------------------------------
333 // Execute the post-initialization logic only once.
334 //--------------------------------------------------
335 static int ompt_post_initialized = 0;
336
337 if (ompt_post_initialized)
338 return;
339
340 ompt_post_initialized = 1;
341
342 //--------------------------------------------------
343 // Initialize the tool if so indicated.
344 //--------------------------------------------------
345 if (ompt_start_tool_result) {
346 ompt_enabled.enabled = !!ompt_start_tool_result->initialize(
347 ompt_fn_lookup, omp_get_initial_device(), &(ompt_start_tool_result->tool_data));
348
349 if (!ompt_enabled.enabled) {
350 // tool not enabled, zero out the bitmap, and done
351 memset(&ompt_enabled, 0, sizeof(ompt_enabled));
352 return;
353 }
354
355 kmp_info_t *root_thread = ompt_get_thread();
356
357 ompt_set_thread_state(root_thread, ompt_state_overhead);
358
359 if (ompt_enabled.ompt_callback_thread_begin) {
360 ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
361 ompt_thread_initial, __ompt_get_thread_data_internal());
362 }
363 ompt_data_t *task_data;
364 ompt_data_t *parallel_data;
365 __ompt_get_task_info_internal(0, NULL, &task_data, NULL, ¶llel_data, NULL);
366 if (ompt_enabled.ompt_callback_implicit_task) {
367 ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
368 ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
369 }
370
371 ompt_set_thread_state(root_thread, ompt_state_work_serial);
372 }
373 }
374
375 void ompt_fini() {
376 if (ompt_enabled.enabled) {
377 ompt_start_tool_result->finalize(&(ompt_start_tool_result->tool_data));
378 }
379
380 memset(&ompt_enabled, 0, sizeof(ompt_enabled));
381 }
382
383 /*****************************************************************************
384 * interface operations
385 ****************************************************************************/
386
387 /*****************************************************************************
388 * state
389 ****************************************************************************/
390
391 OMPT_API_ROUTINE int ompt_enumerate_states(int current_state, int *next_state,
392 const char **next_state_name) {
393 const static int len = sizeof(ompt_state_info) / sizeof(ompt_state_info_t);
394 int i = 0;
395
396 for (i = 0; i < len - 1; i++) {
397 if (ompt_state_info[i].state_id == current_state) {
398 *next_state = ompt_state_info[i + 1].state_id;
399 *next_state_name = ompt_state_info[i + 1].state_name;
400 return 1;
401 }
402 }
403
404 return 0;
405 }
406
407 OMPT_API_ROUTINE int ompt_enumerate_mutex_impls(int current_impl,
408 int *next_impl,
409 const char **next_impl_name) {
410 const static int len =
411 sizeof(kmp_mutex_impl_info) / sizeof(kmp_mutex_impl_info_t);
412 int i = 0;
413 for (i = 0; i < len - 1; i++) {
414 if (kmp_mutex_impl_info[i].id != current_impl)
415 continue;
416 *next_impl = kmp_mutex_impl_info[i + 1].id;
417 *next_impl_name = kmp_mutex_impl_info[i + 1].name;
418 return 1;
419 }
420 return 0;
421 }
422
423 /*****************************************************************************
424 * callbacks
425 ****************************************************************************/
426
427 OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which,
428 ompt_callback_t callback) {
429 switch (which) {
430
431 #define ompt_event_macro(event_name, callback_type, event_id) \
432 case event_name: \
433 if (ompt_event_implementation_status(event_name)) { \
434 ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \
435 ompt_enabled.event_name = (callback != 0); \
436 } \
437 if (callback) \
438 return ompt_event_implementation_status(event_name); \
439 else \
440 return ompt_set_always;
441
442 FOREACH_OMPT_EVENT(ompt_event_macro)
443
444 #undef ompt_event_macro
445
446 default:
447 return ompt_set_error;
448 }
449 }
450
451 OMPT_API_ROUTINE int ompt_get_callback(ompt_callbacks_t which,
452 ompt_callback_t *callback) {
453 if (!ompt_enabled.enabled)
454 return ompt_get_callback_failure;
455
456 switch (which) {
457
458 #define ompt_event_macro(event_name, callback_type, event_id) \
459 case event_name: \
460 if (ompt_event_implementation_status(event_name)) { \
461 ompt_callback_t mycb = \
462 (ompt_callback_t)ompt_callbacks.ompt_callback(event_name); \
463 if (ompt_enabled.event_name && mycb) { \
464 *callback = mycb; \
465 return ompt_get_callback_success; \
466 } \
467 } \
468 return ompt_get_callback_failure;
469
470 FOREACH_OMPT_EVENT(ompt_event_macro)
471
472 #undef ompt_event_macro
473
474 default:
475 return ompt_get_callback_failure;
476 }
477 }
478
479 /*****************************************************************************
480 * parallel regions
481 ****************************************************************************/
482
483 OMPT_API_ROUTINE int ompt_get_parallel_info(int ancestor_level,
484 ompt_data_t **parallel_data,
485 int *team_size) {
486 if (!ompt_enabled.enabled)
487 return 0;
488 return __ompt_get_parallel_info_internal(ancestor_level, parallel_data,
489 team_size);
490 }
491
492 OMPT_API_ROUTINE int ompt_get_state(ompt_wait_id_t *wait_id) {
493 if (!ompt_enabled.enabled)
494 return ompt_state_work_serial;
495 int thread_state = __ompt_get_state_internal(wait_id);
496
497 if (thread_state == ompt_state_undefined) {
498 thread_state = ompt_state_work_serial;
499 }
500
501 return thread_state;
502 }
503
504 /*****************************************************************************
505 * tasks
506 ****************************************************************************/
507
508 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void) {
509 if (!ompt_enabled.enabled)
510 return NULL;
511 return __ompt_get_thread_data_internal();
512 }
513
514 OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type,
515 ompt_data_t **task_data,
516 ompt_frame_t **task_frame,
517 ompt_data_t **parallel_data,
518 int *thread_num) {
519 if (!ompt_enabled.enabled)
520 return 0;
521 return __ompt_get_task_info_internal(ancestor_level, type, task_data,
522 task_frame, parallel_data, thread_num);
523 }
524
525 OMPT_API_ROUTINE int ompt_get_task_memory(void **addr, size_t *size,
526 int block) {
527 return __ompt_get_task_memory_internal(addr, size, block);
528 }
529
530 /*****************************************************************************
531 * num_procs
532 ****************************************************************************/
533
534 OMPT_API_ROUTINE int ompt_get_num_procs(void) {
535 // copied from kmp_ftn_entry.h (but modified: OMPT can only be called when
536 // runtime is initialized)
537 return __kmp_avail_proc;
538 }
539
540 /*****************************************************************************
541 * places
542 ****************************************************************************/
543
544 OMPT_API_ROUTINE int ompt_get_num_places(void) {
545 // copied from kmp_ftn_entry.h (but modified)
546 #if !KMP_AFFINITY_SUPPORTED
547 return 0;
548 #else
549 if (!KMP_AFFINITY_CAPABLE())
550 return 0;
551 return __kmp_affinity_num_masks;
552 #endif
553 }
554
555 OMPT_API_ROUTINE int ompt_get_place_proc_ids(int place_num, int ids_size,
556 int *ids) {
557 // copied from kmp_ftn_entry.h (but modified)
558 #if !KMP_AFFINITY_SUPPORTED
559 return 0;
560 #else
561 int i, count;
562 int tmp_ids[ids_size];
563 if (!KMP_AFFINITY_CAPABLE())
564 return 0;
565 if (place_num < 0 || place_num >= (int)__kmp_affinity_num_masks)
566 return 0;
567 /* TODO: Is this safe for asynchronous call from signal handler during runtime
568 * shutdown? */
569 kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
570 count = 0;
571 KMP_CPU_SET_ITERATE(i, mask) {
572 if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
573 (!KMP_CPU_ISSET(i, mask))) {
574 continue;
575 }
576 if (count < ids_size)
577 tmp_ids[count] = i;
578 count++;
579 }
580 if (ids_size >= count) {
581 for (i = 0; i < count; i++) {
582 ids[i] = tmp_ids[i];
583 }
584 }
585 return count;
586 #endif
587 }
588
589 OMPT_API_ROUTINE int ompt_get_place_num(void) {
590 // copied from kmp_ftn_entry.h (but modified)
591 #if !KMP_AFFINITY_SUPPORTED
592 return -1;
593 #else
594 if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
595 return -1;
596
597 int gtid;
598 kmp_info_t *thread;
599 if (!KMP_AFFINITY_CAPABLE())
600 return -1;
601 gtid = __kmp_entry_gtid();
602 thread = __kmp_thread_from_gtid(gtid);
603 if (thread == NULL || thread->th.th_current_place < 0)
604 return -1;
605 return thread->th.th_current_place;
606 #endif
607 }
608
609 OMPT_API_ROUTINE int ompt_get_partition_place_nums(int place_nums_size,
610 int *place_nums) {
611 // copied from kmp_ftn_entry.h (but modified)
612 #if !KMP_AFFINITY_SUPPORTED
613 return 0;
614 #else
615 if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
616 return 0;
617
618 int i, gtid, place_num, first_place, last_place, start, end;
619 kmp_info_t *thread;
620 if (!KMP_AFFINITY_CAPABLE())
621 return 0;
622 gtid = __kmp_entry_gtid();
623 thread = __kmp_thread_from_gtid(gtid);
624 if (thread == NULL)
625 return 0;
626 first_place = thread->th.th_first_place;
627 last_place = thread->th.th_last_place;
628 if (first_place < 0 || last_place < 0)
629 return 0;
630 if (first_place <= last_place) {
631 start = first_place;
632 end = last_place;
633 } else {
634 start = last_place;
635 end = first_place;
636 }
637 if (end - start <= place_nums_size)
638 for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) {
639 place_nums[i] = place_num;
640 }
641 return end - start + 1;
642 #endif
643 }
644
645 /*****************************************************************************
646 * places
647 ****************************************************************************/
648
649 OMPT_API_ROUTINE int ompt_get_proc_id(void) {
650 if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
651 return -1;
652 #if KMP_OS_LINUX
653 return sched_getcpu();
654 #elif KMP_OS_WINDOWS
655 PROCESSOR_NUMBER pn;
656 GetCurrentProcessorNumberEx(&pn);
657 return 64 * pn.Group + pn.Number;
658 #else
659 return -1;
660 #endif
661 }
662
663 /*****************************************************************************
664 * compatability
665 ****************************************************************************/
666
667 /*
668 * Currently unused function
669 OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
670 */
671
672 /*****************************************************************************
673 * application-facing API
674 ****************************************************************************/
675
676 /*----------------------------------------------------------------------------
677 | control
678 ---------------------------------------------------------------------------*/
679
680 int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) {
681
682 if (ompt_enabled.enabled) {
683 if (ompt_enabled.ompt_callback_control_tool) {
684 return ompt_callbacks.ompt_callback(ompt_callback_control_tool)(
685 command, modifier, arg, OMPT_LOAD_RETURN_ADDRESS(__kmp_entry_gtid()));
686 } else {
687 return -1;
688 }
689 } else {
690 return -2;
691 }
692 }
693
694 /*****************************************************************************
695 * misc
696 ****************************************************************************/
697
698 OMPT_API_ROUTINE uint64_t ompt_get_unique_id(void) {
699 return __ompt_get_unique_id_internal();
700 }
701
702 OMPT_API_ROUTINE void ompt_finalize_tool(void) { __kmp_internal_end_atexit(); }
703
704 /*****************************************************************************
705 * Target
706 ****************************************************************************/
707
708 OMPT_API_ROUTINE int ompt_get_target_info(uint64_t *device_num,
709 ompt_id_t *target_id,
710 ompt_id_t *host_op_id) {
711 return 0; // thread is not in a target region
712 }
713
714 OMPT_API_ROUTINE int ompt_get_num_devices(void) {
715 return 1; // only one device (the current device) is available
716 }
717
718 /*****************************************************************************
719 * API inquiry for tool
720 ****************************************************************************/
721
722 static ompt_interface_fn_t ompt_fn_lookup(const char *s) {
723
724 #define ompt_interface_fn(fn) \
725 fn##_t fn##_f = fn; \
726 if (strcmp(s, #fn) == 0) \
727 return (ompt_interface_fn_t)fn##_f;
728
729 FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn)
730
731 return (ompt_interface_fn_t)0;
732 }
733