1 files changed, 535 insertions, 0 deletions
diff --git a/openmp/runtime/src/ompt-general.cpp b/openmp/runtime/src/ompt-general.cpp
new file mode 100644
index 00000000000..37c1c220d26
--- /dev/null
+++ b/openmp/runtime/src/ompt-general.cpp
@@ -0,0 +1,535 @@
+/*****************************************************************************
+ * 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;
+}