path: root/contrib/libs/cxxsupp/openmp/ompt-general.c

/***************************************************************************** 
 * system include files 
 ****************************************************************************/ 
 
#include <assert.h> 
 
#include <stdint.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
 
 
 
/***************************************************************************** 
 * ompt include files 
 ****************************************************************************/ 
 
#include "ompt-specific.c" 
 
 
 
/***************************************************************************** 
 * 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 
 
 
/***************************************************************************** 
 * types 
 ****************************************************************************/ 
 
typedef struct { 
    const char *state_name; 
    ompt_state_t  state_id; 
} ompt_state_info_t; 
 
 
enum tool_setting_e { 
    omp_tool_error, 
    omp_tool_unset, 
    omp_tool_disabled, 
    omp_tool_enabled 
}; 
 
 
typedef void (*ompt_initialize_t) ( 
    ompt_function_lookup_t ompt_fn_lookup,  
    const char *version, 
    unsigned int ompt_version 
); 
 
 
 
/***************************************************************************** 
 * global variables 
 ****************************************************************************/ 
 
int ompt_enabled = 0; 
 
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 
}; 
 
ompt_callbacks_t ompt_callbacks; 
 
static ompt_initialize_t  ompt_initialize_fn = NULL; 
 
 
 
/***************************************************************************** 
 * forward declarations 
 ****************************************************************************/ 
 
static ompt_interface_fn_t ompt_fn_lookup(const char *s); 
 
OMPT_API_ROUTINE ompt_thread_id_t ompt_get_thread_id(void); 
 
 
/***************************************************************************** 
 * initialization and finalization (private operations) 
 ****************************************************************************/ 
 
/* On Unix-like systems that support weak symbols the following implementation 
 * of ompt_tool() will be used in case no tool-supplied implementation of 
 * this function is present in the address space of a process. 
 * 
 * On Windows, the ompt_tool_windows function is used to find the 
 * ompt_tool symbol across all modules loaded by a process. If ompt_tool is 
 * found, ompt_tool's return value is used to initialize the tool. Otherwise, 
 * NULL is returned and OMPT won't be enabled */ 
#if OMPT_HAVE_WEAK_ATTRIBUTE 
_OMP_EXTERN  
__attribute__ (( weak )) 
ompt_initialize_t ompt_tool() 
{ 
#if OMPT_DEBUG 
    printf("ompt_tool() is called from the RTL\n"); 
#endif 
    return NULL; 
} 
 
#elif OMPT_HAVE_PSAPI 
 
#include <psapi.h> 
#pragma comment(lib, "psapi.lib") 
#define ompt_tool ompt_tool_windows 
 
// The number of loaded modules to start enumeration with EnumProcessModules() 
#define NUM_MODULES 128 
 
static 
ompt_initialize_t ompt_tool_windows() 
{ 
    int i; 
    DWORD needed, new_size; 
    HMODULE *modules; 
    HANDLE  process = GetCurrentProcess(); 
    modules = (HMODULE*)malloc( NUM_MODULES * sizeof(HMODULE) ); 
    ompt_initialize_t (*ompt_tool_p)() = NULL; 
 
#if OMPT_DEBUG 
    printf("ompt_tool_windows(): looking for ompt_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_tool"); 
        if (ompt_tool_p) { 
#if OMPT_DEBUG 
            TCHAR modName[MAX_PATH]; 
            if (GetModuleFileName(modules[i], modName, MAX_PATH)) 
                printf("ompt_tool_windows(): ompt_tool found in module %s\n", 
                       modName); 
#endif 
            free(modules); 
            return ompt_tool_p(); 
        } 
#if OMPT_DEBUG 
        else { 
            TCHAR modName[MAX_PATH]; 
            if (GetModuleFileName(modules[i], modName, MAX_PATH)) 
                printf("ompt_tool_windows(): ompt_tool not found in module %s\n", 
                       modName); 
        } 
#endif 
    } 
    free(modules); 
    return NULL; 
} 
#else 
# error Either __attribute__((weak)) or psapi.dll are required for OMPT support 
#endif // OMPT_HAVE_WEAK_ATTRIBUTE 
 
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; 
 
#if OMPT_DEBUG 
    printf("ompt_pre_init(): tool_setting = %d\n", tool_setting); 
#endif 
    switch(tool_setting) { 
    case omp_tool_disabled: 
        break; 
 
    case omp_tool_unset: 
    case omp_tool_enabled: 
        ompt_initialize_fn = ompt_tool(); 
        if (ompt_initialize_fn) { 
            ompt_enabled = 1; 
        } 
        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 OMPT_DEBUG 
    printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled); 
#endif 
} 
 
 
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_enabled) { 
        ompt_initialize_fn(ompt_fn_lookup, ompt_get_runtime_version(),  
                           OMPT_VERSION); 
 
        ompt_thread_t *root_thread = ompt_get_thread(); 
 
        ompt_set_thread_state(root_thread, ompt_state_overhead); 
 
        if (ompt_callbacks.ompt_callback(ompt_event_thread_begin)) { 
            ompt_callbacks.ompt_callback(ompt_event_thread_begin) 
                (ompt_thread_initial, ompt_get_thread_id()); 
        } 
 
        ompt_set_thread_state(root_thread, ompt_state_work_serial); 
    } 
} 
 
 
void ompt_fini() 
{ 
    if (ompt_enabled) { 
        if (ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)) { 
            ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)(); 
        } 
    } 
 
    ompt_enabled = 0; 
} 
 
 
/***************************************************************************** 
 * interface operations 
 ****************************************************************************/ 
 
/***************************************************************************** 
 * state 
 ****************************************************************************/ 
 
OMPT_API_ROUTINE int ompt_enumerate_state(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; 
} 
 
 
 
/***************************************************************************** 
 * callbacks 
 ****************************************************************************/ 
 
OMPT_API_ROUTINE int ompt_set_callback(ompt_event_t evid, ompt_callback_t cb) 
{ 
    switch (evid) { 
 
#define ompt_event_macro(event_name, callback_type, event_id)                  \ 
    case event_name:                                                           \ 
        if (ompt_event_implementation_status(event_name)) {                    \ 
            ompt_callbacks.ompt_callback(event_name) = (callback_type) cb;     \ 
        }                                                                      \ 
        return ompt_event_implementation_status(event_name); 
 
    FOREACH_OMPT_EVENT(ompt_event_macro) 
 
#undef ompt_event_macro 
 
    default: return ompt_set_result_registration_error; 
    } 
} 
 
 
OMPT_API_ROUTINE int ompt_get_callback(ompt_event_t evid, ompt_callback_t *cb) 
{ 
    switch (evid) { 
 
#define ompt_event_macro(event_name, callback_type, event_id)                  \ 
    case event_name:                                                           \ 
        if (ompt_event_implementation_status(event_name)) {                    \ 
            ompt_callback_t mycb =                                             \ 
                (ompt_callback_t) ompt_callbacks.ompt_callback(event_name);    \ 
            if (mycb) {                                                        \ 
                *cb = 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 ompt_parallel_id_t ompt_get_parallel_id(int ancestor_level) 
{ 
    return __ompt_get_parallel_id_internal(ancestor_level); 
} 
 
 
OMPT_API_ROUTINE int ompt_get_parallel_team_size(int ancestor_level) 
{ 
    return __ompt_get_parallel_team_size_internal(ancestor_level); 
} 
 
 
OMPT_API_ROUTINE void *ompt_get_parallel_function(int ancestor_level) 
{ 
    return __ompt_get_parallel_function_internal(ancestor_level); 
} 
 
 
OMPT_API_ROUTINE ompt_state_t ompt_get_state(ompt_wait_id_t *ompt_wait_id) 
{ 
    ompt_state_t thread_state = __ompt_get_state_internal(ompt_wait_id); 
 
    if (thread_state == ompt_state_undefined) { 
        thread_state = ompt_state_work_serial; 
    } 
 
    return thread_state; 
} 
 
 
 
/***************************************************************************** 
 * threads 
 ****************************************************************************/ 
 
 
OMPT_API_ROUTINE void *ompt_get_idle_frame() 
{ 
    return __ompt_get_idle_frame_internal(); 
} 
 
 
 
/***************************************************************************** 
 * tasks 
 ****************************************************************************/ 
 
 
OMPT_API_ROUTINE ompt_thread_id_t ompt_get_thread_id(void) 
{ 
    return __ompt_get_thread_id_internal(); 
} 
 
OMPT_API_ROUTINE ompt_task_id_t ompt_get_task_id(int depth) 
{ 
    return __ompt_get_task_id_internal(depth); 
} 
 
 
OMPT_API_ROUTINE ompt_frame_t *ompt_get_task_frame(int depth) 
{ 
    return __ompt_get_task_frame_internal(depth); 
} 
 
 
OMPT_API_ROUTINE void *ompt_get_task_function(int depth) 
{ 
    return __ompt_get_task_function_internal(depth); 
} 
 
 
/***************************************************************************** 
 * placeholders 
 ****************************************************************************/ 
 
// Don't define this as static. The loader may choose to eliminate the symbol 
// even though it is needed by tools.   
#define OMPT_API_PLACEHOLDER  
 
// Ensure that placeholders don't have mangled names in the symbol table. 
#ifdef __cplusplus 
extern "C" { 
#endif 
 
 
OMPT_API_PLACEHOLDER void ompt_idle(void)   
{ 
    // This function is a placeholder used to represent the calling context of 
    // idle OpenMP worker threads. It is not meant to be invoked. 
    assert(0); 
} 
 
 
OMPT_API_PLACEHOLDER void ompt_overhead(void) 
{ 
    // This function is a placeholder used to represent the OpenMP context of 
    // threads working in the OpenMP runtime.  It is not meant to be invoked. 
    assert(0); 
} 
 
 
OMPT_API_PLACEHOLDER void ompt_barrier_wait(void) 
{ 
    // This function is a placeholder used to represent the OpenMP context of 
    // threads waiting for a barrier in the OpenMP runtime. It is not meant 
    // to be invoked. 
    assert(0); 
} 
 
 
OMPT_API_PLACEHOLDER void ompt_task_wait(void) 
{ 
    // This function is a placeholder used to represent the OpenMP context of 
    // threads waiting for a task in the OpenMP runtime. It is not meant 
    // to be invoked. 
    assert(0); 
} 
 
 
OMPT_API_PLACEHOLDER void ompt_mutex_wait(void) 
{ 
    // This function is a placeholder used to represent the OpenMP context of 
    // threads waiting for a mutex in the OpenMP runtime. It is not meant 
    // to be invoked. 
    assert(0); 
} 
 
#ifdef __cplusplus 
}; 
#endif 
 
 
/***************************************************************************** 
 * compatability 
 ****************************************************************************/ 
 
OMPT_API_ROUTINE int ompt_get_ompt_version() 
{ 
    return OMPT_VERSION; 
} 
 
 
 
/***************************************************************************** 
 * application-facing API 
 ****************************************************************************/ 
 
 
/*---------------------------------------------------------------------------- 
 | control 
 ---------------------------------------------------------------------------*/ 
 
_OMP_EXTERN void ompt_control(uint64_t command, uint64_t modifier) 
{ 
    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_control)) { 
        ompt_callbacks.ompt_callback(ompt_event_control)(command, modifier); 
    } 
} 
 
 
 
/***************************************************************************** 
 * API inquiry for tool 
 ****************************************************************************/ 
 
static ompt_interface_fn_t ompt_fn_lookup(const char *s) 
{ 
 
#define ompt_interface_fn(fn) \ 
    if (strcmp(s, #fn) == 0) return (ompt_interface_fn_t) fn; 
 
    FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn) 
 
    FOREACH_OMPT_PLACEHOLDER_FN(ompt_interface_fn) 
 
    return (ompt_interface_fn_t) 0; 
}