LLVM OpenMP* Runtime Library
ompt-general.cpp
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 
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 *
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 *
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 *
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, &parallel_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  ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \
434  ompt_enabled.event_name = (callback != 0); \
435  if (callback) \
436  return ompt_event_implementation_status(event_name); \
437  else \
438  return ompt_set_always;
439 
440  FOREACH_OMPT_EVENT(ompt_event_macro)
441 
442 #undef ompt_event_macro
443 
444  default:
445  return ompt_set_error;
446  }
447 }
448 
449 OMPT_API_ROUTINE int ompt_get_callback(ompt_callbacks_t which,
450  ompt_callback_t *callback) {
451  if (!ompt_enabled.enabled)
452  return ompt_get_callback_failure;
453 
454  switch (which) {
455 
456 #define ompt_event_macro(event_name, callback_type, event_id) \
457  case event_name: { \
458  ompt_callback_t mycb = \
459  (ompt_callback_t)ompt_callbacks.ompt_callback(event_name); \
460  if (ompt_enabled.event_name && mycb) { \
461  *callback = mycb; \
462  return ompt_get_callback_success; \
463  } \
464  return ompt_get_callback_failure; \
465  }
466 
467  FOREACH_OMPT_EVENT(ompt_event_macro)
468 
469 #undef ompt_event_macro
470 
471  default:
472  return ompt_get_callback_failure;
473  }
474 }
475 
476 /*****************************************************************************
477  * parallel regions
478  ****************************************************************************/
479 
480 OMPT_API_ROUTINE int ompt_get_parallel_info(int ancestor_level,
481  ompt_data_t **parallel_data,
482  int *team_size) {
483  if (!ompt_enabled.enabled)
484  return 0;
485  return __ompt_get_parallel_info_internal(ancestor_level, parallel_data,
486  team_size);
487 }
488 
489 OMPT_API_ROUTINE int ompt_get_state(ompt_wait_id_t *wait_id) {
490  if (!ompt_enabled.enabled)
491  return ompt_state_work_serial;
492  int thread_state = __ompt_get_state_internal(wait_id);
493 
494  if (thread_state == ompt_state_undefined) {
495  thread_state = ompt_state_work_serial;
496  }
497 
498  return thread_state;
499 }
500 
501 /*****************************************************************************
502  * tasks
503  ****************************************************************************/
504 
505 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void) {
506  if (!ompt_enabled.enabled)
507  return NULL;
508  return __ompt_get_thread_data_internal();
509 }
510 
511 OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type,
512  ompt_data_t **task_data,
513  ompt_frame_t **task_frame,
514  ompt_data_t **parallel_data,
515  int *thread_num) {
516  if (!ompt_enabled.enabled)
517  return 0;
518  return __ompt_get_task_info_internal(ancestor_level, type, task_data,
519  task_frame, parallel_data, thread_num);
520 }
521 
522 OMPT_API_ROUTINE int ompt_get_task_memory(void **addr, size_t *size,
523  int block) {
524  return __ompt_get_task_memory_internal(addr, size, block);
525 }
526 
527 /*****************************************************************************
528  * num_procs
529  ****************************************************************************/
530 
531 OMPT_API_ROUTINE int ompt_get_num_procs(void) {
532  // copied from kmp_ftn_entry.h (but modified: OMPT can only be called when
533  // runtime is initialized)
534  return __kmp_avail_proc;
535 }
536 
537 /*****************************************************************************
538  * places
539  ****************************************************************************/
540 
541 OMPT_API_ROUTINE int ompt_get_num_places(void) {
542 // copied from kmp_ftn_entry.h (but modified)
543 #if !KMP_AFFINITY_SUPPORTED
544  return 0;
545 #else
546  if (!KMP_AFFINITY_CAPABLE())
547  return 0;
548  return __kmp_affinity_num_masks;
549 #endif
550 }
551 
552 OMPT_API_ROUTINE int ompt_get_place_proc_ids(int place_num, int ids_size,
553  int *ids) {
554 // copied from kmp_ftn_entry.h (but modified)
555 #if !KMP_AFFINITY_SUPPORTED
556  return 0;
557 #else
558  int i, count;
559  int tmp_ids[ids_size];
560  if (!KMP_AFFINITY_CAPABLE())
561  return 0;
562  if (place_num < 0 || place_num >= (int)__kmp_affinity_num_masks)
563  return 0;
564  /* TODO: Is this safe for asynchronous call from signal handler during runtime
565  * shutdown? */
566  kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
567  count = 0;
568  KMP_CPU_SET_ITERATE(i, mask) {
569  if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
570  (!KMP_CPU_ISSET(i, mask))) {
571  continue;
572  }
573  if (count < ids_size)
574  tmp_ids[count] = i;
575  count++;
576  }
577  if (ids_size >= count) {
578  for (i = 0; i < count; i++) {
579  ids[i] = tmp_ids[i];
580  }
581  }
582  return count;
583 #endif
584 }
585 
586 OMPT_API_ROUTINE int ompt_get_place_num(void) {
587 // copied from kmp_ftn_entry.h (but modified)
588 #if !KMP_AFFINITY_SUPPORTED
589  return -1;
590 #else
591  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
592  return -1;
593 
594  int gtid;
595  kmp_info_t *thread;
596  if (!KMP_AFFINITY_CAPABLE())
597  return -1;
598  gtid = __kmp_entry_gtid();
599  thread = __kmp_thread_from_gtid(gtid);
600  if (thread == NULL || thread->th.th_current_place < 0)
601  return -1;
602  return thread->th.th_current_place;
603 #endif
604 }
605 
606 OMPT_API_ROUTINE int ompt_get_partition_place_nums(int place_nums_size,
607  int *place_nums) {
608 // copied from kmp_ftn_entry.h (but modified)
609 #if !KMP_AFFINITY_SUPPORTED
610  return 0;
611 #else
612  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
613  return 0;
614 
615  int i, gtid, place_num, first_place, last_place, start, end;
616  kmp_info_t *thread;
617  if (!KMP_AFFINITY_CAPABLE())
618  return 0;
619  gtid = __kmp_entry_gtid();
620  thread = __kmp_thread_from_gtid(gtid);
621  if (thread == NULL)
622  return 0;
623  first_place = thread->th.th_first_place;
624  last_place = thread->th.th_last_place;
625  if (first_place < 0 || last_place < 0)
626  return 0;
627  if (first_place <= last_place) {
628  start = first_place;
629  end = last_place;
630  } else {
631  start = last_place;
632  end = first_place;
633  }
634  if (end - start <= place_nums_size)
635  for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) {
636  place_nums[i] = place_num;
637  }
638  return end - start + 1;
639 #endif
640 }
641 
642 /*****************************************************************************
643  * places
644  ****************************************************************************/
645 
646 OMPT_API_ROUTINE int ompt_get_proc_id(void) {
647  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
648  return -1;
649 #if KMP_OS_LINUX
650  return sched_getcpu();
651 #elif KMP_OS_WINDOWS
652  PROCESSOR_NUMBER pn;
653  GetCurrentProcessorNumberEx(&pn);
654  return 64 * pn.Group + pn.Number;
655 #else
656  return -1;
657 #endif
658 }
659 
660 /*****************************************************************************
661  * compatability
662  ****************************************************************************/
663 
664 /*
665  * Currently unused function
666 OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
667 */
668 
669 /*****************************************************************************
670 * application-facing API
671  ****************************************************************************/
672 
673 /*----------------------------------------------------------------------------
674  | control
675  ---------------------------------------------------------------------------*/
676 
677 int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) {
678 
679  if (ompt_enabled.enabled) {
680  if (ompt_enabled.ompt_callback_control_tool) {
681  return ompt_callbacks.ompt_callback(ompt_callback_control_tool)(
682  command, modifier, arg, OMPT_LOAD_RETURN_ADDRESS(__kmp_entry_gtid()));
683  } else {
684  return -1;
685  }
686  } else {
687  return -2;
688  }
689 }
690 
691 /*****************************************************************************
692  * misc
693  ****************************************************************************/
694 
695 OMPT_API_ROUTINE uint64_t ompt_get_unique_id(void) {
696  return __ompt_get_unique_id_internal();
697 }
698 
699 OMPT_API_ROUTINE void ompt_finalize_tool(void) { __kmp_internal_end_atexit(); }
700 
701 /*****************************************************************************
702  * Target
703  ****************************************************************************/
704 
705 OMPT_API_ROUTINE int ompt_get_target_info(uint64_t *device_num,
706  ompt_id_t *target_id,
707  ompt_id_t *host_op_id) {
708  return 0; // thread is not in a target region
709 }
710 
711 OMPT_API_ROUTINE int ompt_get_num_devices(void) {
712  return 1; // only one device (the current device) is available
713 }
714 
715 /*****************************************************************************
716  * API inquiry for tool
717  ****************************************************************************/
718 
719 static ompt_interface_fn_t ompt_fn_lookup(const char *s) {
720 
721 #define ompt_interface_fn(fn) \
722  fn##_t fn##_f = fn; \
723  if (strcmp(s, #fn) == 0) \
724  return (ompt_interface_fn_t)fn##_f;
725 
726  FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn)
727 
728  return (ompt_interface_fn_t)0;
729 }