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 // prints for an enabled OMP_TOOL_VERBOSE_INIT.
49 // In the future a prefix could be added in the first define, the second define
50 // omits the prefix to allow for continued lines. Example: "PREFIX: Start
51 // tool... Success." instead of "PREFIX: Start tool... PREFIX: Success."
52 #define OMPT_VERBOSE_INIT_PRINT(...) \
53  if (verbose_init) \
54  fprintf(verbose_file, __VA_ARGS__)
55 #define OMPT_VERBOSE_INIT_CONTINUED_PRINT(...) \
56  if (verbose_init) \
57  fprintf(verbose_file, __VA_ARGS__)
58 
59 static FILE *verbose_file;
60 static int verbose_init;
61 
62 /*****************************************************************************
63  * types
64  ****************************************************************************/
65 
66 typedef struct {
67  const char *state_name;
68  ompt_state_t state_id;
69 } ompt_state_info_t;
70 
71 typedef struct {
72  const char *name;
73  kmp_mutex_impl_t id;
74 } kmp_mutex_impl_info_t;
75 
76 enum tool_setting_e {
77  omp_tool_error,
78  omp_tool_unset,
79  omp_tool_disabled,
80  omp_tool_enabled
81 };
82 
83 /*****************************************************************************
84  * global variables
85  ****************************************************************************/
86 
87 ompt_callbacks_active_t ompt_enabled;
88 
89 ompt_state_info_t ompt_state_info[] = {
90 #define ompt_state_macro(state, code) {#state, state},
91  FOREACH_OMPT_STATE(ompt_state_macro)
92 #undef ompt_state_macro
93 };
94 
95 kmp_mutex_impl_info_t kmp_mutex_impl_info[] = {
96 #define kmp_mutex_impl_macro(name, id) {#name, name},
97  FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro)
98 #undef kmp_mutex_impl_macro
99 };
100 
101 ompt_callbacks_internal_t ompt_callbacks;
102 
103 static ompt_start_tool_result_t *ompt_start_tool_result = NULL;
104 
105 #if KMP_OS_WINDOWS
106 static HMODULE ompt_tool_module = NULL;
107 #define OMPT_DLCLOSE(Lib) FreeLibrary(Lib)
108 #else
109 static void *ompt_tool_module = NULL;
110 #define OMPT_DLCLOSE(Lib) dlclose(Lib)
111 #endif
112 
114 static ompt_start_tool_result_t *libomptarget_ompt_result = NULL;
115 
116 /*****************************************************************************
117  * forward declarations
118  ****************************************************************************/
119 
120 static ompt_interface_fn_t ompt_fn_lookup(const char *s);
121 
122 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void);
123 
124 /*****************************************************************************
125  * initialization and finalization (private operations)
126  ****************************************************************************/
127 
128 typedef ompt_start_tool_result_t *(*ompt_start_tool_t)(unsigned int,
129  const char *);
130 
131 #if KMP_OS_DARWIN
132 
133 // While Darwin supports weak symbols, the library that wishes to provide a new
134 // implementation has to link against this runtime which defeats the purpose
135 // of having tools that are agnostic of the underlying runtime implementation.
136 //
137 // Fortunately, the linker includes all symbols of an executable in the global
138 // symbol table by default so dlsym() even finds static implementations of
139 // ompt_start_tool. For this to work on Linux, -Wl,--export-dynamic needs to be
140 // passed when building the application which we don't want to rely on.
141 
142 static ompt_start_tool_result_t *ompt_tool_darwin(unsigned int omp_version,
143  const char *runtime_version) {
144  ompt_start_tool_result_t *ret = NULL;
145  // Search symbol in the current address space.
146  ompt_start_tool_t start_tool =
147  (ompt_start_tool_t)dlsym(RTLD_DEFAULT, "ompt_start_tool");
148  if (start_tool) {
149  ret = start_tool(omp_version, runtime_version);
150  }
151  return ret;
152 }
153 
154 #elif OMPT_HAVE_WEAK_ATTRIBUTE
155 
156 // On Unix-like systems that support weak symbols the following implementation
157 // of ompt_start_tool() will be used in case no tool-supplied implementation of
158 // this function is present in the address space of a process.
159 
160 _OMP_EXTERN OMPT_WEAK_ATTRIBUTE ompt_start_tool_result_t *
161 ompt_start_tool(unsigned int omp_version, const char *runtime_version) {
162  ompt_start_tool_result_t *ret = NULL;
163  // Search next symbol in the current address space. This can happen if the
164  // runtime library is linked before the tool. Since glibc 2.2 strong symbols
165  // don't override weak symbols that have been found before unless the user
166  // sets the environment variable LD_DYNAMIC_WEAK.
167  ompt_start_tool_t next_tool =
168  (ompt_start_tool_t)dlsym(RTLD_NEXT, "ompt_start_tool");
169  if (next_tool) {
170  ret = next_tool(omp_version, runtime_version);
171  }
172  return ret;
173 }
174 
175 #elif OMPT_HAVE_PSAPI
176 
177 // On Windows, the ompt_tool_windows function is used to find the
178 // ompt_start_tool symbol across all modules loaded by a process. If
179 // ompt_start_tool is found, ompt_start_tool's return value is used to
180 // initialize the tool. Otherwise, NULL is returned and OMPT won't be enabled.
181 
182 #include <psapi.h>
183 #pragma comment(lib, "psapi.lib")
184 
185 // The number of loaded modules to start enumeration with EnumProcessModules()
186 #define NUM_MODULES 128
187 
188 static ompt_start_tool_result_t *
189 ompt_tool_windows(unsigned int omp_version, const char *runtime_version) {
190  int i;
191  DWORD needed, new_size;
192  HMODULE *modules;
193  HANDLE process = GetCurrentProcess();
194  modules = (HMODULE *)malloc(NUM_MODULES * sizeof(HMODULE));
195  ompt_start_tool_t ompt_tool_p = NULL;
196 
197 #if OMPT_DEBUG
198  printf("ompt_tool_windows(): looking for ompt_start_tool\n");
199 #endif
200  if (!EnumProcessModules(process, modules, NUM_MODULES * sizeof(HMODULE),
201  &needed)) {
202  // Regardless of the error reason use the stub initialization function
203  free(modules);
204  return NULL;
205  }
206  // Check if NUM_MODULES is enough to list all modules
207  new_size = needed / sizeof(HMODULE);
208  if (new_size > NUM_MODULES) {
209 #if OMPT_DEBUG
210  printf("ompt_tool_windows(): resize buffer to %d bytes\n", needed);
211 #endif
212  modules = (HMODULE *)realloc(modules, needed);
213  // If resizing failed use the stub function.
214  if (!EnumProcessModules(process, modules, needed, &needed)) {
215  free(modules);
216  return NULL;
217  }
218  }
219  for (i = 0; i < new_size; ++i) {
220  (FARPROC &)ompt_tool_p = GetProcAddress(modules[i], "ompt_start_tool");
221  if (ompt_tool_p) {
222 #if OMPT_DEBUG
223  TCHAR modName[MAX_PATH];
224  if (GetModuleFileName(modules[i], modName, MAX_PATH))
225  printf("ompt_tool_windows(): ompt_start_tool found in module %s\n",
226  modName);
227 #endif
228  free(modules);
229  return (*ompt_tool_p)(omp_version, runtime_version);
230  }
231 #if OMPT_DEBUG
232  else {
233  TCHAR modName[MAX_PATH];
234  if (GetModuleFileName(modules[i], modName, MAX_PATH))
235  printf("ompt_tool_windows(): ompt_start_tool not found in module %s\n",
236  modName);
237  }
238 #endif
239  }
240  free(modules);
241  return NULL;
242 }
243 #else
244 #error Activation of OMPT is not supported on this platform.
245 #endif
246 
247 static ompt_start_tool_result_t *
248 ompt_try_start_tool(unsigned int omp_version, const char *runtime_version) {
249  ompt_start_tool_result_t *ret = NULL;
250  ompt_start_tool_t start_tool = NULL;
251 #if KMP_OS_WINDOWS
252  // Cannot use colon to describe a list of absolute paths on Windows
253  const char *sep = ";";
254 #else
255  const char *sep = ":";
256 #endif
257 
258  OMPT_VERBOSE_INIT_PRINT("----- START LOGGING OF TOOL REGISTRATION -----\n");
259  OMPT_VERBOSE_INIT_PRINT("Search for OMP tool in current address space... ");
260 
261 #if KMP_OS_DARWIN
262  // Try in the current address space
263  ret = ompt_tool_darwin(omp_version, runtime_version);
264 #elif OMPT_HAVE_WEAK_ATTRIBUTE
265  ret = ompt_start_tool(omp_version, runtime_version);
266 #elif OMPT_HAVE_PSAPI
267  ret = ompt_tool_windows(omp_version, runtime_version);
268 #else
269 #error Activation of OMPT is not supported on this platform.
270 #endif
271  if (ret) {
272  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
273  OMPT_VERBOSE_INIT_PRINT(
274  "Tool was started and is using the OMPT interface.\n");
275  OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n");
276  return ret;
277  }
278 
279  // Try tool-libraries-var ICV
280  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed.\n");
281  const char *tool_libs = getenv("OMP_TOOL_LIBRARIES");
282  if (tool_libs) {
283  OMPT_VERBOSE_INIT_PRINT("Searching tool libraries...\n");
284  OMPT_VERBOSE_INIT_PRINT("OMP_TOOL_LIBRARIES = %s\n", tool_libs);
285  char *libs = __kmp_str_format("%s", tool_libs);
286  char *buf;
287  char *fname = __kmp_str_token(libs, sep, &buf);
288  // Reset dl-error
289  dlerror();
290 
291  while (fname) {
292 #if KMP_OS_UNIX
293  OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname);
294  void *h = dlopen(fname, RTLD_LAZY);
295  if (!h) {
296  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", dlerror());
297  } else {
298  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success. \n");
299  OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ",
300  fname);
301  dlerror(); // Clear any existing error
302  start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool");
303  if (!start_tool) {
304  char *error = dlerror();
305  if (error != NULL) {
306  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", error);
307  } else {
308  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n",
309  "ompt_start_tool = NULL");
310  }
311  } else
312 #elif KMP_OS_WINDOWS
313  OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname);
314  HMODULE h = LoadLibrary(fname);
315  if (!h) {
316  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n",
317  (unsigned)GetLastError());
318  } else {
319  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success. \n");
320  OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ",
321  fname);
322  start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool");
323  if (!start_tool) {
324  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n",
325  (unsigned)GetLastError());
326  } else
327 #else
328 #error Activation of OMPT is not supported on this platform.
329 #endif
330  { // if (start_tool)
331  ret = (*start_tool)(omp_version, runtime_version);
332  if (ret) {
333  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
334  OMPT_VERBOSE_INIT_PRINT(
335  "Tool was started and is using the OMPT interface.\n");
336  ompt_tool_module = h;
337  break;
338  }
339  OMPT_VERBOSE_INIT_CONTINUED_PRINT(
340  "Found but not using the OMPT interface.\n");
341  OMPT_VERBOSE_INIT_PRINT("Continuing search...\n");
342  }
343  OMPT_DLCLOSE(h);
344  }
345  fname = __kmp_str_token(NULL, sep, &buf);
346  }
347  __kmp_str_free(&libs);
348  } else {
349  OMPT_VERBOSE_INIT_PRINT("No OMP_TOOL_LIBRARIES defined.\n");
350  }
351 
352  // usable tool found in tool-libraries
353  if (ret) {
354  OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n");
355  return ret;
356  }
357 
358 #if KMP_OS_UNIX
359  { // Non-standard: load archer tool if application is built with TSan
360  const char *fname = "libarcher.so";
361  OMPT_VERBOSE_INIT_PRINT(
362  "...searching tool libraries failed. Using archer tool.\n");
363  OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname);
364  void *h = dlopen(fname, RTLD_LAZY);
365  if (h) {
366  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
367  OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ", fname);
368  start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool");
369  if (start_tool) {
370  ret = (*start_tool)(omp_version, runtime_version);
371  if (ret) {
372  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
373  OMPT_VERBOSE_INIT_PRINT(
374  "Tool was started and is using the OMPT interface.\n");
375  OMPT_VERBOSE_INIT_PRINT(
376  "----- END LOGGING OF TOOL REGISTRATION -----\n");
377  return ret;
378  }
379  OMPT_VERBOSE_INIT_CONTINUED_PRINT(
380  "Found but not using the OMPT interface.\n");
381  } else {
382  OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", dlerror());
383  }
384  }
385  }
386 #endif
387  OMPT_VERBOSE_INIT_PRINT("No OMP tool loaded.\n");
388  OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n");
389  return ret;
390 }
391 
392 void ompt_pre_init() {
393  //--------------------------------------------------
394  // Execute the pre-initialization logic only once.
395  //--------------------------------------------------
396  static int ompt_pre_initialized = 0;
397 
398  if (ompt_pre_initialized)
399  return;
400 
401  ompt_pre_initialized = 1;
402 
403  //--------------------------------------------------
404  // Use a tool iff a tool is enabled and available.
405  //--------------------------------------------------
406  const char *ompt_env_var = getenv("OMP_TOOL");
407  tool_setting_e tool_setting = omp_tool_error;
408 
409  if (!ompt_env_var || !strcmp(ompt_env_var, ""))
410  tool_setting = omp_tool_unset;
411  else if (OMPT_STR_MATCH(ompt_env_var, "disabled"))
412  tool_setting = omp_tool_disabled;
413  else if (OMPT_STR_MATCH(ompt_env_var, "enabled"))
414  tool_setting = omp_tool_enabled;
415 
416  const char *ompt_env_verbose_init = getenv("OMP_TOOL_VERBOSE_INIT");
417  // possible options: disabled | stdout | stderr | <filename>
418  // if set, not empty and not disabled -> prepare for logging
419  if (ompt_env_verbose_init && strcmp(ompt_env_verbose_init, "") &&
420  !OMPT_STR_MATCH(ompt_env_verbose_init, "disabled")) {
421  verbose_init = 1;
422  if (OMPT_STR_MATCH(ompt_env_verbose_init, "STDERR"))
423  verbose_file = stderr;
424  else if (OMPT_STR_MATCH(ompt_env_verbose_init, "STDOUT"))
425  verbose_file = stdout;
426  else
427  verbose_file = fopen(ompt_env_verbose_init, "w");
428  } else
429  verbose_init = 0;
430 
431 #if OMPT_DEBUG
432  printf("ompt_pre_init(): tool_setting = %d\n", tool_setting);
433 #endif
434  switch (tool_setting) {
435  case omp_tool_disabled:
436  OMPT_VERBOSE_INIT_PRINT("OMP tool disabled. \n");
437  break;
438 
439  case omp_tool_unset:
440  case omp_tool_enabled:
441 
442  //--------------------------------------------------
443  // Load tool iff specified in environment variable
444  //--------------------------------------------------
445  ompt_start_tool_result =
446  ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version());
447 
448  memset(&ompt_enabled, 0, sizeof(ompt_enabled));
449  break;
450 
451  case omp_tool_error:
452  fprintf(stderr,
453  "Warning: OMP_TOOL has invalid value \"%s\".\n"
454  " legal values are (NULL,\"\",\"disabled\","
455  "\"enabled\").\n",
456  ompt_env_var);
457  break;
458  }
459  if (verbose_init && verbose_file != stderr && verbose_file != stdout)
460  fclose(verbose_file);
461 #if OMPT_DEBUG
462  printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled.enabled);
463 #endif
464 }
465 
466 extern "C" int omp_get_initial_device(void);
467 
468 void ompt_post_init() {
469  //--------------------------------------------------
470  // Execute the post-initialization logic only once.
471  //--------------------------------------------------
472  static int ompt_post_initialized = 0;
473 
474  if (ompt_post_initialized)
475  return;
476 
477  ompt_post_initialized = 1;
478 
479  //--------------------------------------------------
480  // Initialize the tool if so indicated.
481  //--------------------------------------------------
482  if (ompt_start_tool_result) {
483  ompt_enabled.enabled = !!ompt_start_tool_result->initialize(
484  ompt_fn_lookup, omp_get_initial_device(),
485  &(ompt_start_tool_result->tool_data));
486 
487  if (!ompt_enabled.enabled) {
488  // tool not enabled, zero out the bitmap, and done
489  memset(&ompt_enabled, 0, sizeof(ompt_enabled));
490  return;
491  }
492 
493  kmp_info_t *root_thread = ompt_get_thread();
494 
495  ompt_set_thread_state(root_thread, ompt_state_overhead);
496 
497  if (ompt_enabled.ompt_callback_thread_begin) {
498  ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
499  ompt_thread_initial, __ompt_get_thread_data_internal());
500  }
501  ompt_data_t *task_data;
502  ompt_data_t *parallel_data;
503  __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
504  NULL);
505  if (ompt_enabled.ompt_callback_implicit_task) {
506  ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
507  ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
508  }
509 
510  ompt_set_thread_state(root_thread, ompt_state_work_serial);
511  }
512 }
513 
514 void ompt_fini() {
515  if (ompt_enabled.enabled) {
516  if (ompt_start_tool_result && ompt_start_tool_result->finalize) {
517  ompt_start_tool_result->finalize(&(ompt_start_tool_result->tool_data));
518  }
519  if (libomptarget_ompt_result && libomptarget_ompt_result->finalize) {
520  libomptarget_ompt_result->finalize(NULL);
521  }
522  }
523 
524  if (ompt_tool_module)
525  OMPT_DLCLOSE(ompt_tool_module);
526  memset(&ompt_enabled, 0, sizeof(ompt_enabled));
527 }
528 
529 /*****************************************************************************
530  * interface operations
531  ****************************************************************************/
532 
533 /*****************************************************************************
534  * state
535  ****************************************************************************/
536 
537 OMPT_API_ROUTINE int ompt_enumerate_states(int current_state, int *next_state,
538  const char **next_state_name) {
539  const static int len = sizeof(ompt_state_info) / sizeof(ompt_state_info_t);
540  int i = 0;
541 
542  for (i = 0; i < len - 1; i++) {
543  if (ompt_state_info[i].state_id == current_state) {
544  *next_state = ompt_state_info[i + 1].state_id;
545  *next_state_name = ompt_state_info[i + 1].state_name;
546  return 1;
547  }
548  }
549 
550  return 0;
551 }
552 
553 OMPT_API_ROUTINE int ompt_enumerate_mutex_impls(int current_impl,
554  int *next_impl,
555  const char **next_impl_name) {
556  const static int len =
557  sizeof(kmp_mutex_impl_info) / sizeof(kmp_mutex_impl_info_t);
558  int i = 0;
559  for (i = 0; i < len - 1; i++) {
560  if (kmp_mutex_impl_info[i].id != current_impl)
561  continue;
562  *next_impl = kmp_mutex_impl_info[i + 1].id;
563  *next_impl_name = kmp_mutex_impl_info[i + 1].name;
564  return 1;
565  }
566  return 0;
567 }
568 
569 /*****************************************************************************
570  * callbacks
571  ****************************************************************************/
572 
573 OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which,
574  ompt_callback_t callback) {
575  switch (which) {
576 
577 #define ompt_event_macro(event_name, callback_type, event_id) \
578  case event_name: \
579  ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \
580  ompt_enabled.event_name = (callback != 0); \
581  if (callback) \
582  return ompt_event_implementation_status(event_name); \
583  else \
584  return ompt_set_always;
585 
586  FOREACH_OMPT_EVENT(ompt_event_macro)
587 
588 #undef ompt_event_macro
589 
590  default:
591  return ompt_set_error;
592  }
593 }
594 
595 OMPT_API_ROUTINE int ompt_get_callback(ompt_callbacks_t which,
596  ompt_callback_t *callback) {
597  if (!ompt_enabled.enabled)
598  return ompt_get_callback_failure;
599 
600  switch (which) {
601 
602 #define ompt_event_macro(event_name, callback_type, event_id) \
603  case event_name: { \
604  ompt_callback_t mycb = \
605  (ompt_callback_t)ompt_callbacks.ompt_callback(event_name); \
606  if (ompt_enabled.event_name && mycb) { \
607  *callback = mycb; \
608  return ompt_get_callback_success; \
609  } \
610  return ompt_get_callback_failure; \
611  }
612 
613  FOREACH_OMPT_EVENT(ompt_event_macro)
614 
615 #undef ompt_event_macro
616 
617  default:
618  return ompt_get_callback_failure;
619  }
620 }
621 
622 /*****************************************************************************
623  * parallel regions
624  ****************************************************************************/
625 
626 OMPT_API_ROUTINE int ompt_get_parallel_info(int ancestor_level,
627  ompt_data_t **parallel_data,
628  int *team_size) {
629  if (!ompt_enabled.enabled)
630  return 0;
631  return __ompt_get_parallel_info_internal(ancestor_level, parallel_data,
632  team_size);
633 }
634 
635 OMPT_API_ROUTINE int ompt_get_state(ompt_wait_id_t *wait_id) {
636  if (!ompt_enabled.enabled)
637  return ompt_state_work_serial;
638  int thread_state = __ompt_get_state_internal(wait_id);
639 
640  if (thread_state == ompt_state_undefined) {
641  thread_state = ompt_state_work_serial;
642  }
643 
644  return thread_state;
645 }
646 
647 /*****************************************************************************
648  * tasks
649  ****************************************************************************/
650 
651 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void) {
652  if (!ompt_enabled.enabled)
653  return NULL;
654  return __ompt_get_thread_data_internal();
655 }
656 
657 OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type,
658  ompt_data_t **task_data,
659  ompt_frame_t **task_frame,
660  ompt_data_t **parallel_data,
661  int *thread_num) {
662  if (!ompt_enabled.enabled)
663  return 0;
664  return __ompt_get_task_info_internal(ancestor_level, type, task_data,
665  task_frame, parallel_data, thread_num);
666 }
667 
668 OMPT_API_ROUTINE int ompt_get_task_memory(void **addr, size_t *size,
669  int block) {
670  return __ompt_get_task_memory_internal(addr, size, block);
671 }
672 
673 /*****************************************************************************
674  * num_procs
675  ****************************************************************************/
676 
677 OMPT_API_ROUTINE int ompt_get_num_procs(void) {
678  // copied from kmp_ftn_entry.h (but modified: OMPT can only be called when
679  // runtime is initialized)
680  return __kmp_avail_proc;
681 }
682 
683 /*****************************************************************************
684  * places
685  ****************************************************************************/
686 
687 OMPT_API_ROUTINE int ompt_get_num_places(void) {
688 // copied from kmp_ftn_entry.h (but modified)
689 #if !KMP_AFFINITY_SUPPORTED
690  return 0;
691 #else
692  if (!KMP_AFFINITY_CAPABLE())
693  return 0;
694  return __kmp_affinity.num_masks;
695 #endif
696 }
697 
698 OMPT_API_ROUTINE int ompt_get_place_proc_ids(int place_num, int ids_size,
699  int *ids) {
700 // copied from kmp_ftn_entry.h (but modified)
701 #if !KMP_AFFINITY_SUPPORTED
702  return 0;
703 #else
704  int i, count;
705  int tmp_ids[ids_size];
706  for (int j = 0; j < ids_size; j++)
707  tmp_ids[j] = 0;
708  if (!KMP_AFFINITY_CAPABLE())
709  return 0;
710  if (place_num < 0 || place_num >= (int)__kmp_affinity.num_masks)
711  return 0;
712  /* TODO: Is this safe for asynchronous call from signal handler during runtime
713  * shutdown? */
714  kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity.masks, place_num);
715  count = 0;
716  KMP_CPU_SET_ITERATE(i, mask) {
717  if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
718  (!KMP_CPU_ISSET(i, mask))) {
719  continue;
720  }
721  if (count < ids_size)
722  tmp_ids[count] = i;
723  count++;
724  }
725  if (ids_size >= count) {
726  for (i = 0; i < count; i++) {
727  ids[i] = tmp_ids[i];
728  }
729  }
730  return count;
731 #endif
732 }
733 
734 OMPT_API_ROUTINE int ompt_get_place_num(void) {
735 // copied from kmp_ftn_entry.h (but modified)
736 #if !KMP_AFFINITY_SUPPORTED
737  return -1;
738 #else
739  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
740  return -1;
741 
742  int gtid;
743  kmp_info_t *thread;
744  if (!KMP_AFFINITY_CAPABLE())
745  return -1;
746  gtid = __kmp_entry_gtid();
747  thread = __kmp_thread_from_gtid(gtid);
748  if (thread == NULL || thread->th.th_current_place < 0)
749  return -1;
750  return thread->th.th_current_place;
751 #endif
752 }
753 
754 OMPT_API_ROUTINE int ompt_get_partition_place_nums(int place_nums_size,
755  int *place_nums) {
756 // copied from kmp_ftn_entry.h (but modified)
757 #if !KMP_AFFINITY_SUPPORTED
758  return 0;
759 #else
760  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
761  return 0;
762 
763  int i, gtid, place_num, first_place, last_place, start, end;
764  kmp_info_t *thread;
765  if (!KMP_AFFINITY_CAPABLE())
766  return 0;
767  gtid = __kmp_entry_gtid();
768  thread = __kmp_thread_from_gtid(gtid);
769  if (thread == NULL)
770  return 0;
771  first_place = thread->th.th_first_place;
772  last_place = thread->th.th_last_place;
773  if (first_place < 0 || last_place < 0)
774  return 0;
775  if (first_place <= last_place) {
776  start = first_place;
777  end = last_place;
778  } else {
779  start = last_place;
780  end = first_place;
781  }
782  if (end - start <= place_nums_size)
783  for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) {
784  place_nums[i] = place_num;
785  }
786  return end - start + 1;
787 #endif
788 }
789 
790 /*****************************************************************************
791  * places
792  ****************************************************************************/
793 
794 OMPT_API_ROUTINE int ompt_get_proc_id(void) {
795  if (!ompt_enabled.enabled || __kmp_get_gtid() < 0)
796  return -1;
797 #if KMP_HAVE_SCHED_GETCPU
798  return sched_getcpu();
799 #elif KMP_OS_WINDOWS
800  PROCESSOR_NUMBER pn;
801  GetCurrentProcessorNumberEx(&pn);
802  return 64 * pn.Group + pn.Number;
803 #else
804  return -1;
805 #endif
806 }
807 
808 /*****************************************************************************
809  * compatability
810  ****************************************************************************/
811 
812 /*
813  * Currently unused function
814 OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
815 */
816 
817 /*****************************************************************************
818  * application-facing API
819  ****************************************************************************/
820 
821 /*----------------------------------------------------------------------------
822  | control
823  ---------------------------------------------------------------------------*/
824 
825 int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) {
826 
827  if (ompt_enabled.enabled) {
828  if (ompt_enabled.ompt_callback_control_tool) {
829  return ompt_callbacks.ompt_callback(ompt_callback_control_tool)(
830  command, modifier, arg, OMPT_LOAD_RETURN_ADDRESS(__kmp_entry_gtid()));
831  } else {
832  return -1;
833  }
834  } else {
835  return -2;
836  }
837 }
838 
839 /*****************************************************************************
840  * misc
841  ****************************************************************************/
842 
843 OMPT_API_ROUTINE uint64_t ompt_get_unique_id(void) {
844  return __ompt_get_unique_id_internal();
845 }
846 
847 OMPT_API_ROUTINE void ompt_finalize_tool(void) { __kmp_internal_end_atexit(); }
848 
849 /*****************************************************************************
850  * Target
851  ****************************************************************************/
852 
853 OMPT_API_ROUTINE int ompt_get_target_info(uint64_t *device_num,
854  ompt_id_t *target_id,
855  ompt_id_t *host_op_id) {
856  return 0; // thread is not in a target region
857 }
858 
859 OMPT_API_ROUTINE int ompt_get_num_devices(void) {
860  return 1; // only one device (the current device) is available
861 }
862 
863 /*****************************************************************************
864  * API inquiry for tool
865  ****************************************************************************/
866 
867 static ompt_interface_fn_t ompt_fn_lookup(const char *s) {
868 
869 #define ompt_interface_fn(fn) \
870  fn##_t fn##_f = fn; \
871  if (strcmp(s, #fn) == 0) \
872  return (ompt_interface_fn_t)fn##_f;
873 
874  FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn)
875 
876 #undef ompt_interface_fn
877 
878  return NULL;
879 }
880 
882 static ompt_interface_fn_t ompt_libomp_target_fn_lookup(const char *s) {
883 #define ompt_interface_fn(fn, type, code) \
884  if (strcmp(s, #fn) == 0) \
885  return (ompt_interface_fn_t)ompt_callbacks.ompt_callback(fn);
886 
887  FOREACH_OMPT_DEVICE_EVENT(ompt_interface_fn)
888  FOREACH_OMPT_EMI_EVENT(ompt_interface_fn)
889  FOREACH_OMPT_NOEMI_EVENT(ompt_interface_fn)
890 
891 #undef ompt_interface_fn
892 
893  return (ompt_interface_fn_t)0;
894 }
895 
898 _OMP_EXTERN void ompt_libomp_connect(ompt_start_tool_result_t *result) {
899  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Enter libomp_ompt_connect\n");
900 
901  // Ensure libomp callbacks have been added if not already
902  __ompt_force_initialization();
903 
904  if (ompt_enabled.enabled &&
905  // Callbacks are initiated only if the device initialize callback
906  // has been registered by the tool
907  ompt_callbacks.ompt_callback(ompt_callback_device_initialize)) {
908  if (result) {
909  OMPT_VERBOSE_INIT_PRINT(
910  "libomp --> OMPT: Connecting with libomptarget\n");
911  // Pass in the libomp lookup function so that the already registered
912  // functions can be extracted and assigned to the callbacks in
913  // libomptarget
914  result->initialize(ompt_libomp_target_fn_lookup,
915  0 /* initial_device_num */, nullptr /* tool_data */);
916  // Track the object provided by libomptarget so that the finalizer can be
917  // called during OMPT finalization
918  libomptarget_ompt_result = result;
919  }
920  }
921  OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Exit libomp_ompt_connect\n");
922 }