Overhaul OMPT initialization interface

[jmellorcrummey]

Summary

The OMPT specification has changed. This revision brings the LLVM OpenMP implementation up to date.

Technical overview of changes:

Previously, a public weak symbol ompt_initialize was called after the OpenMP runtime is initialized. The new interface calls a global weak symbol ompt_tool prior to initialization. If a tool is present, ompt_tool returns a pointer to a function that matches the signature for ompt_initialize. After OpenMP is initialized the function pointer is called to initialize a tool.

Knowing that OMPT will be enabled before initialization allows OMPT support to be initialized as part of initialization instead of back patching initialization of OMPT support after the fact.

Post OpenMP initialization support has been generalized moves from ompt-specific.c into ompt-general.c, since the OMPT initialization logic is no longer implementation specific.

[Hahnfeld]

LGTM

runtime/src/ompt-general.c

135

Wrong indention (can be fixed on commit)

[omalyshe]

runtime/src/ompt-general.c

115

typo "iff" ->"if"

[jlpeyton]

See inline comments.

runtime/src/kmp_runtime.c

6379–6389

Small nit, can you move this pre_init() call after the 5 KMP_DEBUG_ASSERT()'s?

6631–6633

Small nit, can you move these three lines before the KMP_MB() above?

6768–6771

This is unnecessary since middle_init() -> do_middle_init() -> serial_init() -> do_serial_init(). Plus, the ompt_[pre|post]_init()'s in the do_serial_init() are guarded by the __kmp_initz_lock. The guarentee with all this init() code is that do_serial_init() will happen first and be executed safely by a single thread.

6792–6795

Unnecessary because parallel_init() -> do_middle_init() and so on.

6859

Unnecessary as well since this parallel_init() -> ... -> do_serial_init().

runtime/src/ompt-general.c

55–59

In addition to the indention problem Jonas pointed out, have these be four spaces as well.

115

Olga, this is short for "if and only if". At least I believe that is what is meant here.

[jlpeyton]

Sorry, I missed one.

runtime/src/kmp_runtime.c

6783

I forgot this one, this is unnecessary as well.

[jmellorcrummey]

Addressed comments:

• moved the call to ompt_pre_init to after the calls to KMP_DEBUG_ASSERT in __kmp_do_serial_initialize
• moved the call to ompt_post_init before the call to KMP_MB in __kmp_do_serial_initialize
• removed redundant calls to ompt_pre_init/post_init in kmp_parallel_initialize and kmp_middle_initialize
• fixed indentation issues caused by tabs
• fixed typos in two comments (a missing "is" in the comment with iff and a misspelled synchronize in a pre-existing comment).

[jlpeyton]

Thanks! LGTM. Will commit.

runtime/src/exports_so.txt

 VERSION {
 
     global: # Exported symbols.
 
         #
         # "Normal" symbols.
         #
         omp_*;     # Standard OpenMP functions.
-        ompt_initialize;     # OMPT initialization interface
+
+        #
+        # OMPT API
+        #
+        ompt_tool;           # OMPT initialization interface
         ompt_control;        # OMPT control interface
         
         #
         # OMPT state placeholders
         #
         ompt_idle;
         ompt_overhead;
         ompt_barrier_wait;

runtime/src/include/30/ompt.h.var

 ));
 
 
 
 /****************************************************************************
  * INITIALIZATION FUNCTIONS
  ***************************************************************************/
 
-/* initialization interface to be defined by tool */
-int ompt_initialize(
+OMPT_API_FUNCTION(void, ompt_initialize, (
     ompt_function_lookup_t ompt_fn_lookup,
     const char *runtime_version,
     unsigned int ompt_version
-);
+));
+
+
+/* initialization interface to be defined by tool */
+ompt_initialize_t ompt_tool(void);
 
 typedef enum opt_init_mode_e {
     ompt_init_mode_never  = 0,
     ompt_init_mode_false  = 1,
     ompt_init_mode_true   = 2,
     ompt_init_mode_always = 3
 } ompt_init_mode_t;
 

runtime/src/include/40/ompt.h.var

 ));
 
 
 
 /****************************************************************************
  * INITIALIZATION FUNCTIONS
  ***************************************************************************/
 
-/* initialization interface to be defined by tool */
-int ompt_initialize(
+OMPT_API_FUNCTION(void, ompt_initialize, (
     ompt_function_lookup_t ompt_fn_lookup,
     const char *runtime_version,
     unsigned int ompt_version
-);
+));
+
+
+/* initialization interface to be defined by tool */
+ompt_initialize_t ompt_tool(void);
 
 typedef enum opt_init_mode_e {
     ompt_init_mode_never  = 0,
     ompt_init_mode_false  = 1,
     ompt_init_mode_true   = 2,
     ompt_init_mode_always = 3
 } ompt_init_mode_t;
 

runtime/src/include/41/ompt.h.var

 ));
 
 
 
 /****************************************************************************
  * INITIALIZATION FUNCTIONS
  ***************************************************************************/
 
-/* initialization interface to be defined by tool */
-int ompt_initialize(
+OMPT_API_FUNCTION(void, ompt_initialize, (
     ompt_function_lookup_t ompt_fn_lookup,
     const char *runtime_version,
     unsigned int ompt_version
-);
+));
+
+
+/* initialization interface to be defined by tool */
+ompt_initialize_t ompt_tool(void);
 
 typedef enum opt_init_mode_e {
     ompt_init_mode_never  = 0,
     ompt_init_mode_false  = 1,
     ompt_init_mode_true   = 2,
     ompt_init_mode_always = 3
 } ompt_init_mode_t;
 

runtime/src/kmp_runtime.c

 #endif /* KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS) */
 
 static void
 __kmp_do_serial_initialize( void )
 {
     int i, gtid;
     int size;
 
+#if OMPT_SUPPORT
+    ompt_pre_init();
+#endif
+
     KA_TRACE( 10, ("__kmp_do_serial_initialize: enter\n" ) );
 
     KMP_DEBUG_ASSERT( sizeof( kmp_int32 ) == 4 );
     KMP_DEBUG_ASSERT( sizeof( kmp_uint32 ) == 4 );
     KMP_DEBUG_ASSERT( sizeof( kmp_int64 ) == 8 );
     KMP_DEBUG_ASSERT( sizeof( kmp_uint64 ) == 8 );
     KMP_DEBUG_ASSERT( sizeof( kmp_intptr_t ) == sizeof( void * ) );
 
     __kmp_validate_locks();
 
     /* Initialize internal memory allocator */
     __kmp_init_allocator();
 
     /* Register the library startup via an environment variable
        and check to see whether another copy of the library is already
#if OMP_40_ENABLED
     if (__kmp_display_env || __kmp_display_env_verbose) {
         __kmp_env_print_2();
     }
 #endif // OMP_40_ENABLED
 
     KMP_MB();
 
     KA_TRACE( 10, ("__kmp_do_serial_initialize: exit\n" ) );
 #if OMPT_SUPPORT
-    ompt_init();
+    ompt_post_init();
 #endif
 }
 
 void
 __kmp_serial_initialize( void )
 {
     if ( __kmp_init_serial ) {
         return;
     }
#endif /* KMP_ADJUST_BLOCKTIME */
     TCW_SYNC_4(__kmp_init_middle, TRUE);
 
     KA_TRACE( 10, ("__kmp_do_middle_initialize: exit\n" ) );
 }
 
 void
 __kmp_middle_initialize( void )
 {
+#if OMPT_SUPPORT
+    ompt_pre_init();
+#endif
+
     if ( __kmp_init_middle ) {
         return;
     }
     __kmp_acquire_bootstrap_lock( &__kmp_initz_lock );
     if ( __kmp_init_middle ) {
         __kmp_release_bootstrap_lock( &__kmp_initz_lock );
         return;
     }
     __kmp_do_middle_initialize();
     __kmp_release_bootstrap_lock( &__kmp_initz_lock );
 #if OMPT_SUPPORT
-    ompt_init();
+    ompt_post_init();
 #endif
 }
 
 void
 __kmp_parallel_initialize( void )
 {
     int gtid = __kmp_entry_gtid();      // this might be a new root
 
+#if OMPT_SUPPORT
+    ompt_pre_init();
+#endif
+
     /* syncronize parallel initialization (for sibling) */
     if( TCR_4(__kmp_init_parallel) ) return;
     __kmp_acquire_bootstrap_lock( &__kmp_initz_lock );
     if( TCR_4(__kmp_init_parallel) ) { __kmp_release_bootstrap_lock( &__kmp_initz_lock ); return; }
 
     /* TODO reinitialization after we have already shut down */
     if( TCR_4(__kmp_global.g.g_done) ) {
         KA_TRACE( 10, ("__kmp_parallel_initialize: attempt to init while shutting down\n" ) );
#endif
     /* we have finished parallel initialization */
     TCW_SYNC_4(__kmp_init_parallel, TRUE);
 
     KMP_MB();
     KA_TRACE( 10, ("__kmp_parallel_initialize: exit\n" ) );
 
     __kmp_release_bootstrap_lock( &__kmp_initz_lock );
 #if OMPT_SUPPORT
-    ompt_init();
+    ompt_post_init();
 #endif
 }
 
 
 /* ------------------------------------------------------------------------ */
 
 void
 __kmp_run_before_invoked_task( int gtid, int tid, kmp_info_t *this_thr,

runtime/src/ompt-general.c

  ****************************************************************************/
 
 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
  ****************************************************************************/
 
 ompt_status_t ompt_status = ompt_status_ready;
 
 
 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)
+ ****************************************************************************/
+
+_OMP_EXTERN __attribute__ (( weak ))
+ompt_initialize_t ompt_tool()
+{
+    return NULL;
+}
+
+
+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 available and enabled.
+    //--------------------------------------------------
+    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 (!strcasecmp(ompt_env_var, "disabled"))
+        tool_setting = omp_tool_disabled;
+    else if (!strcasecmp(ompt_env_var, "enabled"))
+        tool_setting = omp_tool_enabled;
+
+    switch(tool_setting) {
+    case omp_tool_disabled:
+        ompt_status = ompt_status_disabled;
+        break;
+
+    case omp_tool_unset:
+    case omp_tool_enabled:
+        ompt_initialize_fn = ompt_tool();
+  if (ompt_initialize_fn) {
+          ompt_status = ompt_status_track_callback;
+        }
+        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;
+    }
+
+}
+
+
+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_status == ompt_status_track_callback) {
+        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_status == ompt_status_track_callback) {
+        if (ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)) {
+            ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)();
+        }
+    }
+
+    ompt_status = ompt_status_disabled;
+}
+
+
+/*****************************************************************************
+ * interface operations
+ ****************************************************************************/
 
 /*****************************************************************************
  * state
  ****************************************************************************/
 
 OMPT_API_ROUTINE int ompt_enumerate_state(int current_state, int *next_state,
                                           const char **next_state_name)
 {

 
 #undef ompt_event_macro
 
     default: return ompt_get_callback_failure;
     }
 }
 
 
-
-/*****************************************************************************
- * intialization/finalization
- ****************************************************************************/
-
-_OMP_EXTERN __attribute__ (( weak ))
-int ompt_initialize(ompt_function_lookup_t ompt_fn_lookup, const char *version,
-                    unsigned int ompt_version)
-{
-    return no_tool_present;
-}
-
-enum tool_setting_e {
-    omp_tool_error,
-    omp_tool_unset,
-    omp_tool_disabled,
-    omp_tool_enabled
-};
-
-void ompt_init()
-{
-    static int ompt_initialized = 0;
-
-    if (ompt_initialized) return;
-
-    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 (!strcmp(ompt_env_var, "disabled"))
-        tool_setting = omp_tool_disabled;
-    else if (!strcmp(ompt_env_var, "enabled"))
-        tool_setting = omp_tool_enabled;
-
-    switch(tool_setting) {
-    case omp_tool_disabled:
-        ompt_status = ompt_status_disabled;
-        break;
-
-    case omp_tool_unset:
-    case omp_tool_enabled:
-    {
-        const char *runtime_version = __ompt_get_runtime_version_internal();
-        int ompt_init_val =
-            ompt_initialize(ompt_fn_lookup, runtime_version, OMPT_VERSION);
-
-        if (ompt_init_val) {
-            ompt_status = ompt_status_track_callback;
-            __ompt_init_internal();
-        }
-        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;
-    }
-
-    ompt_initialized = 1;
-}
-
-
-void ompt_fini()
-{
-    if (ompt_status == ompt_status_track_callback) {
-        if (ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)) {
-            ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)();
-        }
-    }
-
-    ompt_status = ompt_status_disabled;
-}
-
-
-
 /*****************************************************************************
  * parallel regions
  ****************************************************************************/
 
 OMPT_API_ROUTINE ompt_parallel_id_t ompt_get_parallel_id(int ancestor_level)
 {
     return __ompt_get_parallel_id_internal(ancestor_level);
 }

runtime/src/ompt-internal.h

 
 extern ompt_status_t ompt_status;
 extern ompt_callbacks_t ompt_callbacks;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void ompt_init(void);
+void ompt_pre_init(void);
+void ompt_post_init(void);
 void ompt_fini(void);
 
 #ifdef __cplusplus
 };
 #endif
 
 #endif

runtime/src/ompt-specific.h

 #ifndef OMPT_SPECIFIC_H
 #define OMPT_SPECIFIC_H
 
 #include "kmp.h"
 
+typedef kmp_info_t ompt_thread_t;
+
 void __ompt_team_assign_id(kmp_team_t *team, ompt_parallel_id_t ompt_pid);
 void __ompt_thread_assign_wait_id(void *variable);
 
-void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
+void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, ompt_thread_t *thr,
                              int gtid, void *microtask,
                              ompt_parallel_id_t ompt_pid);
 
-void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt,  kmp_info_t *thr);
+void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt,  ompt_thread_t *thr);
 
-ompt_lw_taskteam_t * __ompt_lw_taskteam_unlink(kmp_info_t *thr);
+ompt_lw_taskteam_t * __ompt_lw_taskteam_unlink(ompt_thread_t *thr);
 
 ompt_parallel_id_t __ompt_parallel_id_new(int gtid);
 ompt_task_id_t __ompt_task_id_new(int gtid);
 
 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size);
 
 ompt_task_info_t *__ompt_get_taskinfo(int depth);
 
-inline kmp_info_t *
+void __ompt_thread_begin(ompt_thread_type_t thread_type, int gtid);
+
+void __ompt_thread_end(ompt_thread_type_t thread_type, int gtid);
+
+int __ompt_get_parallel_team_size_internal(int ancestor_level);
+
+ompt_task_id_t __ompt_get_task_id_internal(int depth);
+
+ompt_frame_t *__ompt_get_task_frame_internal(int depth);
+
+
+
+//******************************************************************************
+// inline functions
+//******************************************************************************
+
+inline ompt_thread_t *
 ompt_get_thread_gtid(int gtid)
 {
     return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
 }
 
-inline kmp_info_t *
+
+inline ompt_thread_t *
 ompt_get_thread()
 {
     int gtid = __kmp_gtid_get_specific();
     return ompt_get_thread_gtid(gtid);
 }
 
 
-void __ompt_thread_begin(ompt_thread_type_t thread_type, int gtid);
-
-void __ompt_thread_end(ompt_thread_type_t thread_type, int gtid);
-
-
-int __ompt_get_parallel_team_size_internal(int ancestor_level);
+inline void 
+ompt_set_thread_state(ompt_thread_t *thread, ompt_state_t state)
+{
+    thread->th.ompt_thread_info.state = state; 
+}
 
-ompt_task_id_t __ompt_get_task_id_internal(int depth);
 
-ompt_frame_t *__ompt_get_task_frame_internal(int depth);
+inline const char *
+ompt_get_runtime_version()
+{
+    return &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN];
+}
 
 #endif

runtime/src/ompt-specific.c

 
 
 
 //******************************************************************************
 // interface operations
 //******************************************************************************
 
 //----------------------------------------------------------
-// initialization support
-//----------------------------------------------------------
-
-void
-__ompt_init_internal()
-{
-    if (ompt_status & ompt_status_track) {
-        // initialize initial thread for OMPT
-        kmp_info_t *root_thread = ompt_get_thread();
-        __kmp_task_init_ompt(
-            root_thread->th.th_team->t.t_implicit_task_taskdata, 0);
-        __kmp_task_init_ompt(
-            root_thread->th.th_serial_team->t.t_implicit_task_taskdata, 0);
-
-        // make mandatory callback for creation of initial thread
-        // this needs to occur here rather than in __kmp_register_root because
-        // __kmp_register_root is called before ompt_initialize
-        int gtid = __kmp_get_gtid();
-        if (KMP_UBER_GTID(gtid)) {
-            // initialize the initial thread's idle frame and state
-            root_thread->th.ompt_thread_info.idle_frame = 0;
-            root_thread->th.ompt_thread_info.state = ompt_state_overhead;
-            if ((ompt_status == ompt_status_track_callback) &&
-                ompt_callbacks.ompt_callback(ompt_event_thread_begin)) {
-                __ompt_thread_begin(ompt_thread_initial, gtid);
-            }
-            root_thread->th.ompt_thread_info.state = ompt_state_work_serial;
-        }
-    }
-}
-
-
-//----------------------------------------------------------
 // thread support
 //----------------------------------------------------------
 
 ompt_parallel_id_t
 __ompt_thread_id_new()
 {
     static uint64_t ompt_thread_id = 1;
     return NEXT_ID(&ompt_thread_id, 0);

 // team support
 //----------------------------------------------------------
 
 void
 __ompt_team_assign_id(kmp_team_t *team, ompt_parallel_id_t ompt_pid)
 {
     team->t.ompt_team_info.parallel_id = ompt_pid;
 }
-
-
-//----------------------------------------------------------
-// runtime version support
-//----------------------------------------------------------
-
-const char *
-__ompt_get_runtime_version_internal()
-{
-    return &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN];
-}