/* * ompt-general.cpp -- OMPT implementation of interface functions */ //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /***************************************************************************** * system include files ****************************************************************************/ #include #include #include #include #include #if KMP_OS_UNIX #include #endif /***************************************************************************** * ompt include files ****************************************************************************/ #include "ompt-specific.cpp" /***************************************************************************** * macros ****************************************************************************/ #define ompt_get_callback_success 1 #define ompt_get_callback_failure 0 #define no_tool_present 0 #define OMPT_API_ROUTINE static #ifndef OMPT_STR_MATCH #define OMPT_STR_MATCH(haystack, needle) (!strcasecmp(haystack, needle)) #endif // prints for an enabled OMP_TOOL_VERBOSE_INIT. // In the future a prefix could be added in the first define, the second define // omits the prefix to allow for continued lines. Example: "PREFIX: Start // tool... Success." instead of "PREFIX: Start tool... PREFIX: Success." #define OMPT_VERBOSE_INIT_PRINT(...) \ if (verbose_init) \ fprintf(verbose_file, __VA_ARGS__) #define OMPT_VERBOSE_INIT_CONTINUED_PRINT(...) \ if (verbose_init) \ fprintf(verbose_file, __VA_ARGS__) static FILE *verbose_file; static int verbose_init; /***************************************************************************** * types ****************************************************************************/ typedef struct { const char *state_name; ompt_state_t state_id; } ompt_state_info_t; typedef struct { const char *name; kmp_mutex_impl_t id; } kmp_mutex_impl_info_t; enum tool_setting_e { omp_tool_error, omp_tool_unset, omp_tool_disabled, omp_tool_enabled }; /***************************************************************************** * global variables ****************************************************************************/ ompt_callbacks_active_t ompt_enabled; ompt_state_info_t ompt_state_info[] = { #define ompt_state_macro(state, code) {#state, state}, FOREACH_OMPT_STATE(ompt_state_macro) #undef ompt_state_macro }; kmp_mutex_impl_info_t kmp_mutex_impl_info[] = { #define kmp_mutex_impl_macro(name, id) {#name, name}, FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro) #undef kmp_mutex_impl_macro }; ompt_callbacks_internal_t ompt_callbacks; static ompt_start_tool_result_t *ompt_start_tool_result = NULL; #if KMP_OS_WINDOWS static HMODULE ompt_tool_module = NULL; #define OMPT_DLCLOSE(Lib) FreeLibrary(Lib) #else static void *ompt_tool_module = NULL; #define OMPT_DLCLOSE(Lib) dlclose(Lib) #endif /// Used to track the initializer and the finalizer provided by libomptarget static ompt_start_tool_result_t *libomptarget_ompt_result = NULL; /***************************************************************************** * forward declarations ****************************************************************************/ static ompt_interface_fn_t ompt_fn_lookup(const char *s); OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void); /***************************************************************************** * initialization and finalization (private operations) ****************************************************************************/ typedef ompt_start_tool_result_t *(*ompt_start_tool_t)(unsigned int, const char *); #if KMP_OS_DARWIN // While Darwin supports weak symbols, the library that wishes to provide a new // implementation has to link against this runtime which defeats the purpose // of having tools that are agnostic of the underlying runtime implementation. // // Fortunately, the linker includes all symbols of an executable in the global // symbol table by default so dlsym() even finds static implementations of // ompt_start_tool. For this to work on Linux, -Wl,--export-dynamic needs to be // passed when building the application which we don't want to rely on. static ompt_start_tool_result_t *ompt_tool_darwin(unsigned int omp_version, const char *runtime_version) { ompt_start_tool_result_t *ret = NULL; // Search symbol in the current address space. ompt_start_tool_t start_tool = (ompt_start_tool_t)dlsym(RTLD_DEFAULT, "ompt_start_tool"); if (start_tool) { ret = start_tool(omp_version, runtime_version); } return ret; } #elif OMPT_HAVE_WEAK_ATTRIBUTE // On Unix-like systems that support weak symbols the following implementation // of ompt_start_tool() will be used in case no tool-supplied implementation of // this function is present in the address space of a process. _OMP_EXTERN OMPT_WEAK_ATTRIBUTE ompt_start_tool_result_t * ompt_start_tool(unsigned int omp_version, const char *runtime_version) { ompt_start_tool_result_t *ret = NULL; // Search next symbol in the current address space. This can happen if the // runtime library is linked before the tool. Since glibc 2.2 strong symbols // don't override weak symbols that have been found before unless the user // sets the environment variable LD_DYNAMIC_WEAK. ompt_start_tool_t next_tool = (ompt_start_tool_t)dlsym(RTLD_NEXT, "ompt_start_tool"); if (next_tool) { ret = next_tool(omp_version, runtime_version); } return ret; } #elif OMPT_HAVE_PSAPI // On Windows, the ompt_tool_windows function is used to find the // ompt_start_tool symbol across all modules loaded by a process. If // ompt_start_tool is found, ompt_start_tool's return value is used to // initialize the tool. Otherwise, NULL is returned and OMPT won't be enabled. #include #pragma comment(lib, "psapi.lib") // The number of loaded modules to start enumeration with EnumProcessModules() #define NUM_MODULES 128 static ompt_start_tool_result_t * ompt_tool_windows(unsigned int omp_version, const char *runtime_version) { int i; DWORD needed, new_size; HMODULE *modules; HANDLE process = GetCurrentProcess(); modules = (HMODULE *)malloc(NUM_MODULES * sizeof(HMODULE)); ompt_start_tool_t ompt_tool_p = NULL; #if OMPT_DEBUG printf("ompt_tool_windows(): looking for ompt_start_tool\n"); #endif if (!EnumProcessModules(process, modules, NUM_MODULES * sizeof(HMODULE), &needed)) { // Regardless of the error reason use the stub initialization function free(modules); return NULL; } // Check if NUM_MODULES is enough to list all modules new_size = needed / sizeof(HMODULE); if (new_size > NUM_MODULES) { #if OMPT_DEBUG printf("ompt_tool_windows(): resize buffer to %d bytes\n", needed); #endif modules = (HMODULE *)realloc(modules, needed); // If resizing failed use the stub function. if (!EnumProcessModules(process, modules, needed, &needed)) { free(modules); return NULL; } } for (i = 0; i < new_size; ++i) { (FARPROC &)ompt_tool_p = GetProcAddress(modules[i], "ompt_start_tool"); if (ompt_tool_p) { #if OMPT_DEBUG TCHAR modName[MAX_PATH]; if (GetModuleFileName(modules[i], modName, MAX_PATH)) printf("ompt_tool_windows(): ompt_start_tool found in module %s\n", modName); #endif free(modules); return (*ompt_tool_p)(omp_version, runtime_version); } #if OMPT_DEBUG else { TCHAR modName[MAX_PATH]; if (GetModuleFileName(modules[i], modName, MAX_PATH)) printf("ompt_tool_windows(): ompt_start_tool not found in module %s\n", modName); } #endif } free(modules); return NULL; } #else #error Activation of OMPT is not supported on this platform. #endif static ompt_start_tool_result_t * ompt_try_start_tool(unsigned int omp_version, const char *runtime_version) { ompt_start_tool_result_t *ret = NULL; ompt_start_tool_t start_tool = NULL; #if KMP_OS_WINDOWS // Cannot use colon to describe a list of absolute paths on Windows const char *sep = ";"; #else const char *sep = ":"; #endif OMPT_VERBOSE_INIT_PRINT("----- START LOGGING OF TOOL REGISTRATION -----\n"); OMPT_VERBOSE_INIT_PRINT("Search for OMP tool in current address space... "); #if KMP_OS_DARWIN // Try in the current address space ret = ompt_tool_darwin(omp_version, runtime_version); #elif OMPT_HAVE_WEAK_ATTRIBUTE ret = ompt_start_tool(omp_version, runtime_version); #elif OMPT_HAVE_PSAPI ret = ompt_tool_windows(omp_version, runtime_version); #else #error Activation of OMPT is not supported on this platform. #endif if (ret) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n"); OMPT_VERBOSE_INIT_PRINT( "Tool was started and is using the OMPT interface.\n"); OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n"); return ret; } // Try tool-libraries-var ICV OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed.\n"); const char *tool_libs = getenv("OMP_TOOL_LIBRARIES"); if (tool_libs) { OMPT_VERBOSE_INIT_PRINT("Searching tool libraries...\n"); OMPT_VERBOSE_INIT_PRINT("OMP_TOOL_LIBRARIES = %s\n", tool_libs); char *libs = __kmp_str_format("%s", tool_libs); char *buf; char *fname = __kmp_str_token(libs, sep, &buf); // Reset dl-error dlerror(); while (fname) { #if KMP_OS_UNIX OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname); void *h = dlopen(fname, RTLD_LAZY); if (!h) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", dlerror()); } else { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success. \n"); OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ", fname); dlerror(); // Clear any existing error start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool"); if (!start_tool) { char *error = dlerror(); if (error != NULL) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", error); } else { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", "ompt_start_tool = NULL"); } } else #elif KMP_OS_WINDOWS OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname); HMODULE h = LoadLibrary(fname); if (!h) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n", (unsigned)GetLastError()); } else { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success. \n"); OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ", fname); start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool"); if (!start_tool) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n", (unsigned)GetLastError()); } else #else #error Activation of OMPT is not supported on this platform. #endif { // if (start_tool) ret = (*start_tool)(omp_version, runtime_version); if (ret) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n"); OMPT_VERBOSE_INIT_PRINT( "Tool was started and is using the OMPT interface.\n"); ompt_tool_module = h; break; } OMPT_VERBOSE_INIT_CONTINUED_PRINT( "Found but not using the OMPT interface.\n"); OMPT_VERBOSE_INIT_PRINT("Continuing search...\n"); } OMPT_DLCLOSE(h); } fname = __kmp_str_token(NULL, sep, &buf); } __kmp_str_free(&libs); } else { OMPT_VERBOSE_INIT_PRINT("No OMP_TOOL_LIBRARIES defined.\n"); } // usable tool found in tool-libraries if (ret) { OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n"); return ret; } #if KMP_OS_UNIX { // Non-standard: load archer tool if application is built with TSan const char *fname = "libarcher.so"; OMPT_VERBOSE_INIT_PRINT( "...searching tool libraries failed. Using archer tool.\n"); OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname); void *h = dlopen(fname, RTLD_LAZY); if (h) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n"); OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ", fname); start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool"); if (start_tool) { ret = (*start_tool)(omp_version, runtime_version); if (ret) { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n"); OMPT_VERBOSE_INIT_PRINT( "Tool was started and is using the OMPT interface.\n"); OMPT_VERBOSE_INIT_PRINT( "----- END LOGGING OF TOOL REGISTRATION -----\n"); return ret; } OMPT_VERBOSE_INIT_CONTINUED_PRINT( "Found but not using the OMPT interface.\n"); } else { OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n", dlerror()); } } } #endif OMPT_VERBOSE_INIT_PRINT("No OMP tool loaded.\n"); OMPT_VERBOSE_INIT_PRINT("----- END LOGGING OF TOOL REGISTRATION -----\n"); return ret; } void ompt_pre_init() { //-------------------------------------------------- // Execute the pre-initialization logic only once. //-------------------------------------------------- static int ompt_pre_initialized = 0; if (ompt_pre_initialized) return; ompt_pre_initialized = 1; //-------------------------------------------------- // Use a tool iff a tool is enabled and available. //-------------------------------------------------- const char *ompt_env_var = getenv("OMP_TOOL"); tool_setting_e tool_setting = omp_tool_error; if (!ompt_env_var || !strcmp(ompt_env_var, "")) tool_setting = omp_tool_unset; else if (OMPT_STR_MATCH(ompt_env_var, "disabled")) tool_setting = omp_tool_disabled; else if (OMPT_STR_MATCH(ompt_env_var, "enabled")) tool_setting = omp_tool_enabled; const char *ompt_env_verbose_init = getenv("OMP_TOOL_VERBOSE_INIT"); // possible options: disabled | stdout | stderr | // if set, not empty and not disabled -> prepare for logging if (ompt_env_verbose_init && strcmp(ompt_env_verbose_init, "") && !OMPT_STR_MATCH(ompt_env_verbose_init, "disabled")) { verbose_init = 1; if (OMPT_STR_MATCH(ompt_env_verbose_init, "STDERR")) verbose_file = stderr; else if (OMPT_STR_MATCH(ompt_env_verbose_init, "STDOUT")) verbose_file = stdout; else verbose_file = fopen(ompt_env_verbose_init, "w"); } else verbose_init = 0; #if OMPT_DEBUG printf("ompt_pre_init(): tool_setting = %d\n", tool_setting); #endif switch (tool_setting) { case omp_tool_disabled: OMPT_VERBOSE_INIT_PRINT("OMP tool disabled. \n"); break; case omp_tool_unset: case omp_tool_enabled: //-------------------------------------------------- // Load tool iff specified in environment variable //-------------------------------------------------- ompt_start_tool_result = ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version()); memset(&ompt_enabled, 0, sizeof(ompt_enabled)); break; case omp_tool_error: fprintf(stderr, "Warning: OMP_TOOL has invalid value \"%s\".\n" " legal values are (NULL,\"\",\"disabled\"," "\"enabled\").\n", ompt_env_var); break; } if (verbose_init && verbose_file != stderr && verbose_file != stdout) fclose(verbose_file); #if OMPT_DEBUG printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled.enabled); #endif } extern "C" int omp_get_initial_device(void); void ompt_post_init() { //-------------------------------------------------- // Execute the post-initialization logic only once. //-------------------------------------------------- static int ompt_post_initialized = 0; if (ompt_post_initialized) return; ompt_post_initialized = 1; //-------------------------------------------------- // Initialize the tool if so indicated. //-------------------------------------------------- if (ompt_start_tool_result) { ompt_enabled.enabled = !!ompt_start_tool_result->initialize( ompt_fn_lookup, omp_get_initial_device(), &(ompt_start_tool_result->tool_data)); if (!ompt_enabled.enabled) { // tool not enabled, zero out the bitmap, and done memset(&ompt_enabled, 0, sizeof(ompt_enabled)); return; } kmp_info_t *root_thread = ompt_get_thread(); ompt_set_thread_state(root_thread, ompt_state_overhead); if (ompt_enabled.ompt_callback_thread_begin) { ompt_callbacks.ompt_callback(ompt_callback_thread_begin)( ompt_thread_initial, __ompt_get_thread_data_internal()); } ompt_data_t *task_data = nullptr; ompt_data_t *parallel_data = nullptr; __ompt_get_task_info_internal(0, NULL, &task_data, NULL, ¶llel_data, NULL); if (ompt_enabled.ompt_callback_implicit_task) { ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial); } ompt_set_thread_state(root_thread, ompt_state_work_serial); } } void ompt_fini() { if (ompt_enabled.enabled) { if (ompt_start_tool_result && ompt_start_tool_result->finalize) { ompt_start_tool_result->finalize(&(ompt_start_tool_result->tool_data)); } if (libomptarget_ompt_result && libomptarget_ompt_result->finalize) { libomptarget_ompt_result->finalize(NULL); } } if (ompt_tool_module) OMPT_DLCLOSE(ompt_tool_module); memset(&ompt_enabled, 0, sizeof(ompt_enabled)); } /***************************************************************************** * interface operations ****************************************************************************/ /***************************************************************************** * state ****************************************************************************/ OMPT_API_ROUTINE int ompt_enumerate_states(int current_state, int *next_state, const char **next_state_name) { const static int len = sizeof(ompt_state_info) / sizeof(ompt_state_info_t); int i = 0; for (i = 0; i < len - 1; i++) { if (ompt_state_info[i].state_id == current_state) { *next_state = ompt_state_info[i + 1].state_id; *next_state_name = ompt_state_info[i + 1].state_name; return 1; } } return 0; } OMPT_API_ROUTINE int ompt_enumerate_mutex_impls(int current_impl, int *next_impl, const char **next_impl_name) { const static int len = sizeof(kmp_mutex_impl_info) / sizeof(kmp_mutex_impl_info_t); int i = 0; for (i = 0; i < len - 1; i++) { if (kmp_mutex_impl_info[i].id != current_impl) continue; *next_impl = kmp_mutex_impl_info[i + 1].id; *next_impl_name = kmp_mutex_impl_info[i + 1].name; return 1; } return 0; } /***************************************************************************** * callbacks ****************************************************************************/ OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which, ompt_callback_t callback) { switch (which) { #define ompt_event_macro(event_name, callback_type, event_id) \ case event_name: \ ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \ ompt_enabled.event_name = (callback != 0); \ if (callback) \ return ompt_event_implementation_status(event_name); \ else \ return ompt_set_always; FOREACH_OMPT_EVENT(ompt_event_macro) #undef ompt_event_macro default: return ompt_set_error; } } OMPT_API_ROUTINE int ompt_get_callback(ompt_callbacks_t which, ompt_callback_t *callback) { if (!ompt_enabled.enabled) return ompt_get_callback_failure; switch (which) { #define ompt_event_macro(event_name, callback_type, event_id) \ case event_name: { \ ompt_callback_t mycb = \ (ompt_callback_t)ompt_callbacks.ompt_callback(event_name); \ if (ompt_enabled.event_name && mycb) { \ *callback = mycb; \ return ompt_get_callback_success; \ } \ return ompt_get_callback_failure; \ } FOREACH_OMPT_EVENT(ompt_event_macro) #undef ompt_event_macro default: return ompt_get_callback_failure; } } /***************************************************************************** * parallel regions ****************************************************************************/ OMPT_API_ROUTINE int ompt_get_parallel_info(int ancestor_level, ompt_data_t **parallel_data, int *team_size) { if (!ompt_enabled.enabled) return 0; return __ompt_get_parallel_info_internal(ancestor_level, parallel_data, team_size); } OMPT_API_ROUTINE int ompt_get_state(ompt_wait_id_t *wait_id) { if (!ompt_enabled.enabled) return ompt_state_work_serial; int thread_state = __ompt_get_state_internal(wait_id); if (thread_state == ompt_state_undefined) { thread_state = ompt_state_work_serial; } return thread_state; } /***************************************************************************** * tasks ****************************************************************************/ OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void) { if (!ompt_enabled.enabled) return NULL; return __ompt_get_thread_data_internal(); } OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type, ompt_data_t **task_data, ompt_frame_t **task_frame, ompt_data_t **parallel_data, int *thread_num) { if (!ompt_enabled.enabled) return 0; return __ompt_get_task_info_internal(ancestor_level, type, task_data, task_frame, parallel_data, thread_num); } OMPT_API_ROUTINE int ompt_get_task_memory(void **addr, size_t *size, int block) { return __ompt_get_task_memory_internal(addr, size, block); } /***************************************************************************** * num_procs ****************************************************************************/ OMPT_API_ROUTINE int ompt_get_num_procs(void) { // copied from kmp_ftn_entry.h (but modified: OMPT can only be called when // runtime is initialized) return __kmp_avail_proc; } /***************************************************************************** * places ****************************************************************************/ OMPT_API_ROUTINE int ompt_get_num_places(void) { // copied from kmp_ftn_entry.h (but modified) #if !KMP_AFFINITY_SUPPORTED return 0; #else if (!KMP_AFFINITY_CAPABLE()) return 0; return __kmp_affinity.num_masks; #endif } OMPT_API_ROUTINE int ompt_get_place_proc_ids(int place_num, int ids_size, int *ids) { // copied from kmp_ftn_entry.h (but modified) #if !KMP_AFFINITY_SUPPORTED return 0; #else int i, count; int tmp_ids[ids_size]; for (int j = 0; j < ids_size; j++) tmp_ids[j] = 0; if (!KMP_AFFINITY_CAPABLE()) return 0; if (place_num < 0 || place_num >= (int)__kmp_affinity.num_masks) return 0; /* TODO: Is this safe for asynchronous call from signal handler during runtime * shutdown? */ kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity.masks, place_num); count = 0; KMP_CPU_SET_ITERATE(i, mask) { if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) || (!KMP_CPU_ISSET(i, mask))) { continue; } if (count < ids_size) tmp_ids[count] = i; count++; } if (ids_size >= count) { for (i = 0; i < count; i++) { ids[i] = tmp_ids[i]; } } return count; #endif } OMPT_API_ROUTINE int ompt_get_place_num(void) { // copied from kmp_ftn_entry.h (but modified) #if !KMP_AFFINITY_SUPPORTED return -1; #else if (!ompt_enabled.enabled || __kmp_get_gtid() < 0) return -1; int gtid; kmp_info_t *thread; if (!KMP_AFFINITY_CAPABLE()) return -1; gtid = __kmp_entry_gtid(); thread = __kmp_thread_from_gtid(gtid); if (thread == NULL || thread->th.th_current_place < 0) return -1; return thread->th.th_current_place; #endif } OMPT_API_ROUTINE int ompt_get_partition_place_nums(int place_nums_size, int *place_nums) { // copied from kmp_ftn_entry.h (but modified) #if !KMP_AFFINITY_SUPPORTED return 0; #else if (!ompt_enabled.enabled || __kmp_get_gtid() < 0) return 0; int i, gtid, place_num, first_place, last_place, start, end; kmp_info_t *thread; if (!KMP_AFFINITY_CAPABLE()) return 0; gtid = __kmp_entry_gtid(); thread = __kmp_thread_from_gtid(gtid); if (thread == NULL) return 0; first_place = thread->th.th_first_place; last_place = thread->th.th_last_place; if (first_place < 0 || last_place < 0) return 0; if (first_place <= last_place) { start = first_place; end = last_place; } else { start = last_place; end = first_place; } if (end - start <= place_nums_size) for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) { place_nums[i] = place_num; } return end - start + 1; #endif } /***************************************************************************** * places ****************************************************************************/ OMPT_API_ROUTINE int ompt_get_proc_id(void) { if (!ompt_enabled.enabled || __kmp_get_gtid() < 0) return -1; #if KMP_HAVE_SCHED_GETCPU return sched_getcpu(); #elif KMP_OS_WINDOWS PROCESSOR_NUMBER pn; GetCurrentProcessorNumberEx(&pn); return 64 * pn.Group + pn.Number; #else return -1; #endif } /***************************************************************************** * compatability ****************************************************************************/ /* * Currently unused function OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; } */ /***************************************************************************** * application-facing API ****************************************************************************/ /*---------------------------------------------------------------------------- | control ---------------------------------------------------------------------------*/ int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) { if (ompt_enabled.enabled) { if (ompt_enabled.ompt_callback_control_tool) { return ompt_callbacks.ompt_callback(ompt_callback_control_tool)( command, modifier, arg, OMPT_LOAD_RETURN_ADDRESS(__kmp_entry_gtid())); } else { return -1; } } else { return -2; } } /***************************************************************************** * misc ****************************************************************************/ OMPT_API_ROUTINE uint64_t ompt_get_unique_id(void) { return __ompt_get_unique_id_internal(); } OMPT_API_ROUTINE void ompt_finalize_tool(void) { __kmp_internal_end_atexit(); } /***************************************************************************** * Target ****************************************************************************/ OMPT_API_ROUTINE int ompt_get_target_info(uint64_t *device_num, ompt_id_t *target_id, ompt_id_t *host_op_id) { return 0; // thread is not in a target region } OMPT_API_ROUTINE int ompt_get_num_devices(void) { return 1; // only one device (the current device) is available } /***************************************************************************** * API inquiry for tool ****************************************************************************/ static ompt_interface_fn_t ompt_fn_lookup(const char *s) { #define ompt_interface_fn(fn) \ fn##_t fn##_f = fn; \ if (strcmp(s, #fn) == 0) \ return (ompt_interface_fn_t)fn##_f; FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn) #undef ompt_interface_fn return NULL; } static ompt_data_t *ompt_get_task_data() { return __ompt_get_task_data(); } static ompt_data_t *ompt_get_target_task_data() { return __ompt_get_target_task_data(); } /// Lookup function to query libomp callbacks registered by the tool static ompt_interface_fn_t ompt_libomp_target_fn_lookup(const char *s) { #define provide_fn(fn) \ if (strcmp(s, #fn) == 0) \ return (ompt_interface_fn_t)fn; provide_fn(ompt_get_callback); provide_fn(ompt_get_task_data); provide_fn(ompt_get_target_task_data); #undef provide_fn #define ompt_interface_fn(fn, type, code) \ if (strcmp(s, #fn) == 0) \ return (ompt_interface_fn_t)ompt_callbacks.ompt_callback(fn); FOREACH_OMPT_DEVICE_EVENT(ompt_interface_fn) FOREACH_OMPT_EMI_EVENT(ompt_interface_fn) FOREACH_OMPT_NOEMI_EVENT(ompt_interface_fn) #undef ompt_interface_fn return (ompt_interface_fn_t)0; } /// This function is called by the libomptarget connector to assign /// callbacks already registered with libomp. _OMP_EXTERN void ompt_libomp_connect(ompt_start_tool_result_t *result) { OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Enter ompt_libomp_connect\n"); // Ensure libomp callbacks have been added if not already __ompt_force_initialization(); if (ompt_enabled.enabled && // Callbacks are initiated only if the device initialize callback // has been registered by the tool ompt_callbacks.ompt_callback(ompt_callback_device_initialize)) { if (result) { OMPT_VERBOSE_INIT_PRINT( "libomp --> OMPT: Connecting with libomptarget\n"); // Pass in the libomp lookup function so that the already registered // functions can be extracted and assigned to the callbacks in // libomptarget result->initialize(ompt_libomp_target_fn_lookup, /* initial_device_num */ 0, /* tool_data */ nullptr); // Track the object provided by libomptarget so that the finalizer can be // called during OMPT finalization libomptarget_ompt_result = result; } } OMPT_VERBOSE_INIT_PRINT("libomp --> OMPT: Exit ompt_libomp_connect\n"); }