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