3041982dd1
This patch contains the clang-format and cleanup of the entire code base. Some of clang-formats changes made the code look worse in places. A best effort was made to resolve the bulk of these problems, but many remain. Most of the problems were mangling line-breaks and tabbing of comments. Patch by Terry Wilmarth Differential Revision: https://reviews.llvm.org/D32659 llvm-svn: 302929
467 lines
15 KiB
C++
467 lines
15 KiB
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.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
|
|
|
|
/*****************************************************************************
|
|
* 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;
|
|
}
|