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