Simplify control variable logic for OMPT

[jmellorcrummey]

Summary

Prior to this change, OMPT had a status flag ompt_status, which could take several values. This was due to an earlier OMPT design that had several levels of enablement (ready, disabled, tracking state, tracking callbacks). The current OMPT design has OMPT support either on or off.

This revision replaces ompt_status with a boolean flag ompt_enabled, which simplifies the runtime logic for OMPT.

[Hahnfeld]

LGTM, finally got rid of this :-)

(has to be commited after D12998)

[jlpeyton]

This LGTM as well. I'll commit this after D12998 is fixed.

runtime/src/kmp_atomic.h

 //
 
 typedef kmp_queuing_lock_t kmp_atomic_lock_t;
 
 static inline void
 __kmp_acquire_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
 {
 #if OMPT_SUPPORT && OMPT_TRACE
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled && 
         ompt_callbacks.ompt_callback(ompt_event_wait_atomic)) {
         ompt_callbacks.ompt_callback(ompt_event_wait_atomic)(
             (ompt_wait_id_t) lck);
     }
 #endif
 
     __kmp_acquire_queuing_lock( lck, gtid );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled && 
         ompt_callbacks.ompt_callback(ompt_event_acquired_atomic)) {
         ompt_callbacks.ompt_callback(ompt_event_acquired_atomic)(
             (ompt_wait_id_t) lck);
     }
 #endif
 }
 
 static inline int
 __kmp_test_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
 {
     return __kmp_test_queuing_lock( lck, gtid );
 }
 
 static inline void
 __kmp_release_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
 {
     __kmp_release_queuing_lock( lck, gtid );
 #if OMPT_SUPPORT && OMPT_BLAME
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_release_atomic)) {
         ompt_callbacks.ompt_callback(ompt_event_release_atomic)(
             (ompt_wait_id_t) lck);
   }
 #endif
 }
 
 static inline void

runtime/src/kmp_barrier.cpp

#if OMPT_SUPPORT
     ompt_task_id_t my_task_id;
     ompt_parallel_id_t my_parallel_id;
 #endif
 
     KA_TRACE(15, ("__kmp_barrier: T#%d(%d:%d) has arrived\n",
                   gtid, __kmp_team_from_gtid(gtid)->t.t_id, __kmp_tid_from_gtid(gtid)));
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
 #if OMPT_BLAME
-        if (ompt_status == ompt_status_track_callback) {
-            my_task_id = team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id;
-            my_parallel_id = team->t.ompt_team_info.parallel_id;
 
 #if OMPT_TRACE
-            if (this_thr->th.ompt_thread_info.state == ompt_state_wait_single) {
-                if (ompt_callbacks.ompt_callback(ompt_event_single_others_end)) {
-                    ompt_callbacks.ompt_callback(ompt_event_single_others_end)(
-                        my_parallel_id, my_task_id);
-                }
-            }
 #endif
-            if (ompt_callbacks.ompt_callback(ompt_event_barrier_begin)) {
-                ompt_callbacks.ompt_callback(ompt_event_barrier_begin)(
-                    my_parallel_id, my_task_id);
-            }
-        } 
 #endif
         // It is OK to report the barrier state after the barrier begin callback.
         // According to the OMPT specification, a compliant implementation may
         // even delay reporting this state until the barrier begins to wait.
         this_thr->th.ompt_thread_info.state = ompt_state_wait_barrier;
     }
 #endif
 
#else
             KMP_DEBUG_ASSERT(this_thr->th.th_task_team == NULL);
 #endif
         }
     }
     KA_TRACE(15, ("__kmp_barrier: T#%d(%d:%d) is leaving with return value %d\n",
                   gtid, __kmp_team_from_gtid(gtid)->t.t_id, __kmp_tid_from_gtid(gtid), status));
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
 #if OMPT_BLAME
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_barrier_end)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_barrier_end)) {
             ompt_callbacks.ompt_callback(ompt_event_barrier_end)(
                 my_parallel_id, my_task_id);
         }
 #endif
         this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
     }
 #endif
 
#endif /* KMP_DEBUG */
     KMP_DEBUG_ASSERT(__kmp_threads && __kmp_threads[gtid]);
     KMP_DEBUG_ASSERT(TCR_PTR(this_thr->th.th_team));
     KMP_DEBUG_ASSERT(TCR_PTR(this_thr->th.th_root));
     KMP_DEBUG_ASSERT(this_thr == team->t.t_threads[tid]);
     KA_TRACE(10, ("__kmp_join_barrier: T#%d(%d:%d) arrived at join barrier\n", gtid, team_id, tid));
 
 #if OMPT_SUPPORT 
 #if OMPT_TRACE
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_barrier_begin)) {
         ompt_callbacks.ompt_callback(ompt_event_barrier_begin)(
             team->t.ompt_team_info.parallel_id,
             team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
     }
 #endif
     this_thr->th.ompt_thread_info.state = ompt_state_wait_barrier;
 #endif
#if KMP_DEBUG
     }
 #endif /* KMP_DEBUG */
 
     // TODO now, mark worker threads as done so they may be disbanded
     KMP_MB(); // Flush all pending memory write invalidates.
     KA_TRACE(10, ("__kmp_join_barrier: T#%d(%d:%d) leaving\n", gtid, team_id, tid));
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
 #if OMPT_BLAME
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_barrier_end)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_barrier_end)) {
             ompt_callbacks.ompt_callback(ompt_event_barrier_end)(
                 team->t.ompt_team_info.parallel_id,
                 team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
         }
 #endif
 
         // return to default state
         this_thr->th.ompt_thread_info.state = ompt_state_overhead;
     }
 #endif
 }
 

runtime/src/kmp_csupport.c

#endif
   {
     va_list     ap;
     va_start(   ap, microtask );
 
 #if OMPT_SUPPORT
     int tid = __kmp_tid_from_gtid( gtid );
     kmp_info_t *master_th = __kmp_threads[ gtid ];
     kmp_team_t *parent_team = master_th->th.th_team;
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
        parent_team->t.t_implicit_task_taskdata[tid].
            ompt_task_info.frame.reenter_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
 #if INCLUDE_SSC_MARKS
     SSC_MARK_FORKING();
 #endif

 #if OMPT_SUPPORT
         , fork_context_intel
 #endif
     );
 
     va_end( ap );
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_team->t.t_implicit_task_taskdata[tid].
             ompt_task_info.frame.reenter_runtime_frame = 0;
     }
 #endif
   }
 #if (KMP_STATS_ENABLED)  
   if (!inParallel)
       KMP_START_EXPLICIT_TIMER(OMP_serial);
__kmpc_fork_teams(ident_t *loc, kmp_int32 argc, kmpc_micro microtask, ...)
 
     // remember teams entry point and nesting level
     this_thr->th.th_teams_microtask = microtask;
     this_thr->th.th_teams_level = this_thr->th.th_team->t.t_level; // AC: can be >0 on host
 
 #if OMPT_SUPPORT
     kmp_team_t *parent_team = this_thr->th.th_team;
     int tid = __kmp_tid_from_gtid( gtid );
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_team->t.t_implicit_task_taskdata[tid].
            ompt_task_info.frame.reenter_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
     // check if __kmpc_push_num_teams called, set default number of teams otherwise
     if ( this_thr->th.th_teams_size.nteams == 0 ) {
         __kmp_push_num_teams( loc, gtid, 0, 0 );
#endif
             );
     __kmp_join_call( loc, gtid
 #if OMPT_SUPPORT
         , fork_context_intel
 #endif
     );
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_team->t.t_implicit_task_taskdata[tid].
            ompt_task_info.frame.reenter_runtime_frame = NULL;
     }
 #endif
 
     this_thr->th.th_teams_microtask = NULL;
     this_thr->th.th_teams_level = 0;
     *(kmp_int64*)(&this_thr->th.th_teams_size) = 0L;
__kmpc_master(ident_t *loc, kmp_int32 global_tid)
 
     if( KMP_MASTER_GTID( global_tid )) {
         KMP_START_EXPLICIT_TIMER(OMP_master);
         status = 1;
     }
 
 #if OMPT_SUPPORT && OMPT_TRACE
     if (status) {
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_master_begin)) {
             kmp_info_t  *this_thr        = __kmp_threads[ global_tid ];
             kmp_team_t  *team            = this_thr -> th.th_team;
 
             int  tid = __kmp_tid_from_gtid( global_tid );
             ompt_callbacks.ompt_callback(ompt_event_master_begin)(
                 team->t.ompt_team_info.parallel_id,
                 team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
__kmpc_end_master(ident_t *loc, kmp_int32 global_tid)
     KC_TRACE( 10, ("__kmpc_end_master: called T#%d\n", global_tid ) );
 
     KMP_DEBUG_ASSERT( KMP_MASTER_GTID( global_tid ));
     KMP_STOP_EXPLICIT_TIMER(OMP_master);
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t  *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t  *team            = this_thr -> th.th_team;
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_master_end)) {
         int  tid = __kmp_tid_from_gtid( global_tid );
         ompt_callbacks.ompt_callback(ompt_event_master_end)(
             team->t.ompt_team_info.parallel_id,
             team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
     }
 #endif
 

 #if USE_ITT_BUILD
     __kmp_itt_ordered_prep( gtid );
     // TODO: ordered_wait_id
 #endif /* USE_ITT_BUILD */
 
     th = __kmp_threads[ gtid ];
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         /* OMPT state update */
         th->th.ompt_thread_info.wait_id = (uint64_t) loc;
         th->th.ompt_thread_info.state = ompt_state_wait_ordered;
 
         /* OMPT event callback */
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_wait_ordered)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_wait_ordered)) {
             ompt_callbacks.ompt_callback(ompt_event_wait_ordered)(
                 th->th.ompt_thread_info.wait_id);
         }
     }
 #endif
 
     if ( th -> th.th_dispatch -> th_deo_fcn != 0 )
         (*th->th.th_dispatch->th_deo_fcn)( & gtid, & cid, loc );
     else
         __kmp_parallel_deo( & gtid, & cid, loc );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         /* OMPT state update */
         th->th.ompt_thread_info.state = ompt_state_work_parallel;
         th->th.ompt_thread_info.wait_id = 0;
 
         /* OMPT event callback */
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_acquired_ordered)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_acquired_ordered)) {
             ompt_callbacks.ompt_callback(ompt_event_acquired_ordered)(
                 th->th.ompt_thread_info.wait_id);
         }
     }
 #endif
 
 #if USE_ITT_BUILD
     __kmp_itt_ordered_start( gtid );
#endif /* USE_ITT_BUILD */
     th = __kmp_threads[ gtid ];
 
     if ( th -> th.th_dispatch -> th_dxo_fcn != 0 )
         (*th->th.th_dispatch->th_dxo_fcn)( & gtid, & cid, loc );
     else
         __kmp_parallel_dxo( & gtid, & cid, loc );
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_release_ordered)) {
         ompt_callbacks.ompt_callback(ompt_event_release_ordered)(
             th->th.ompt_thread_info.wait_id);
     }
 #endif
 }
 
 #if KMP_USE_DYNAMIC_LOCK

 
 #if USE_ITT_BUILD
     __kmp_itt_critical_releasing( lck );
 #endif /* USE_ITT_BUILD */
     // Value of 'crit' should be good for using as a critical_id of the critical section directive.
     __kmp_release_user_lock_with_checks( lck, global_tid );
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_release_critical)) {
         ompt_callbacks.ompt_callback(ompt_event_release_critical)(
             (uint64_t) lck);
     }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 
if(rc == TRUE) {
         KMP_START_EXPLICIT_TIMER(OMP_single);
     }
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t *team            = this_thr -> th.th_team;
     int tid = __kmp_tid_from_gtid( global_tid );
 
-    if ((ompt_status == ompt_status_track_callback)) {
+    if (ompt_enabled) {
         if (rc) {
             if (ompt_callbacks.ompt_callback(ompt_event_single_in_block_begin)) {
                 ompt_callbacks.ompt_callback(ompt_event_single_in_block_begin)(
                     team->t.ompt_team_info.parallel_id,
                     team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id,
                     team->t.ompt_team_info.microtask);
             }
         } else {
__kmpc_end_single(ident_t *loc, kmp_int32 global_tid)
     __kmp_exit_single( global_tid );
     KMP_STOP_EXPLICIT_TIMER(OMP_single);
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t *team            = this_thr -> th.th_team;
     int tid = __kmp_tid_from_gtid( global_tid );
 
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_single_in_block_end)) {
         ompt_callbacks.ompt_callback(ompt_event_single_in_block_end)(
             team->t.ompt_team_info.parallel_id,
             team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
     }
 #endif
 }
 

 {
     KE_TRACE( 10, ("__kmpc_for_static_fini called T#%d\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t *team            = this_thr -> th.th_team;
     int tid = __kmp_tid_from_gtid( global_tid );
 
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_loop_end)) {
         ompt_callbacks.ompt_callback(ompt_event_loop_end)(
             team->t.ompt_team_info.parallel_id,
             team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
     }
 #endif
 
     if ( __kmp_env_consistency_check )

 
 #if USE_ITT_BUILD
     __kmp_itt_lock_releasing( lck );
 #endif /* USE_ITT_BUILD */
 
     RELEASE_LOCK( lck, gtid );
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_release_lock)) {
         ompt_callbacks.ompt_callback(ompt_event_release_lock)((uint64_t) lck);
     }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 

 
 #if USE_ITT_BUILD
     __kmp_itt_lock_releasing( lck );
 #endif /* USE_ITT_BUILD */
 
     int release_status;
     release_status = RELEASE_NESTED_LOCK( lck, gtid );
 #if OMPT_SUPPORT && OMPT_BLAME
-    if (ompt_status == ompt_status_track_callback) {
+    if (ompt_enabled) {
         if (release_status == KMP_LOCK_RELEASED) {
             if (ompt_callbacks.ompt_callback(ompt_event_release_nest_lock_last)) {
                 ompt_callbacks.ompt_callback(ompt_event_release_nest_lock_last)(
                     (uint64_t) lck);
             }
         } else if (ompt_callbacks.ompt_callback(ompt_event_release_nest_lock_prev)) {
             ompt_callbacks.ompt_callback(ompt_event_release_nest_lock_prev)(
                 (uint64_t) lck);

runtime/src/kmp_dispatch.cpp

if ( ___kmp_size_type < 8 ) {
         // This is a flag showing that other threads may steal from this thread since then.
         volatile T * p = &pr->u.p.static_steal_counter;
         *p = *p + 1;
       }
     }
     #endif // ( KMP_STATIC_STEAL_ENABLED && USE_STEALING )
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
         ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
         ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
         ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
             team_info->parallel_id, task_info->task_id, team_info->microtask);
     }
 #endif
 }

 #endif /* KMP_GOMP_COMPAT */
 
 /* Define a macro for exiting __kmp_dispatch_next(). If status is 0
  * (no more work), then tell OMPT the loop is over. In some cases
  * kmp_dispatch_fini() is not called. */
 #if OMPT_SUPPORT && OMPT_TRACE
 #define OMPT_LOOP_END                                                          \
     if (status == 0) {                                                         \
-        if ((ompt_status == ompt_status_track_callback) &&                     \
+        if (ompt_enabled &&                     \
             ompt_callbacks.ompt_callback(ompt_event_loop_end)) {               \
             ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);        \
             ompt_task_info_t *task_info = __ompt_get_taskinfo(0);              \
             ompt_callbacks.ompt_callback(ompt_event_loop_end)(                 \
                 team_info->parallel_id, task_info->task_id);                   \
         }                                                                      \
     }
 #else

runtime/src/kmp_gsupport.c

 __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
   void *data)
 {
 #if OMPT_SUPPORT
     kmp_info_t *thr;
     ompt_frame_t *ompt_frame;
     ompt_state_t enclosing_state;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         // get pointer to thread data structure
         thr = __kmp_threads[*gtid];
 
         // save enclosing task state; set current state for task
         enclosing_state = thr->th.ompt_thread_info.state;
         thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
         // set task frame
         ompt_frame = __ompt_get_task_frame_internal(0);
         ompt_frame->exit_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
     task(data);
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         // clear task frame
         ompt_frame->exit_runtime_frame = NULL;
 
         // restore enclosing state
         thr->th.ompt_thread_info.state = enclosing_state;
     }
 #endif
 }
enum sched_type schedule, long start, long end, long incr, long chunk_size)
     KMP_DISPATCH_INIT(loc, *gtid, schedule, start, end, incr, chunk_size,
       schedule != kmp_sch_static);
 
 #if OMPT_SUPPORT
     kmp_info_t *thr;
     ompt_frame_t *ompt_frame;
     ompt_state_t enclosing_state;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         thr = __kmp_threads[*gtid];
         // save enclosing task state; set current state for task
         enclosing_state = thr->th.ompt_thread_info.state;
         thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
         // set task frame
         ompt_frame = __ompt_get_task_frame_internal(0);
         ompt_frame->exit_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
     //
     // Now invoke the microtask.
     //
     task(data);
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         // clear task frame
         ompt_frame->exit_runtime_frame = NULL;
 
         // reset enclosing state
         thr->th.ompt_thread_info.state = enclosing_state;
     }
 #endif
 }
#endif
 
     va_end(ap);
 
     if (rc) {
         __kmp_run_before_invoked_task(gtid, tid, thr, team);
     }
 
 #if OMPT_SUPPORT 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
 #if OMPT_TRACE
         ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
         ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
 
         // implicit task callback
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
                 team_info->parallel_id, task_info->task_id);
         }
 #endif
         thr->th.ompt_thread_info.state = ompt_state_work_parallel;
     }
 #endif
 }
 
 static void
 __kmp_GOMP_serialized_parallel(ident_t *loc, kmp_int32 gtid, void (*task)(void *))
 {
     __kmp_serialized_parallel(loc, gtid);
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         ompt_task_id_t ompt_task_id = __ompt_get_task_id_internal(0);
         ompt_frame_t  *ompt_frame = __ompt_get_task_frame_internal(0);
         kmp_info_t *thr = __kmp_threads[gtid];
 
         ompt_parallel_id_t ompt_parallel_id = __ompt_parallel_id_new(gtid);
         ompt_task_id_t my_ompt_task_id = __ompt_task_id_new(gtid);
 
         ompt_frame->exit_runtime_frame = NULL;
 
         // parallel region callback
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_parallel_begin)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_parallel_begin)) {
             int team_size = 1;
             ompt_callbacks.ompt_callback(ompt_event_parallel_begin)(
                 ompt_task_id, ompt_frame, ompt_parallel_id,
                 team_size, (void *) task,
                 OMPT_INVOKER(fork_context_gnu));
         }
 
         // set up lightweight task
         ompt_lw_taskteam_t *lwt = (ompt_lw_taskteam_t *)
             __kmp_allocate(sizeof(ompt_lw_taskteam_t));
         __ompt_lw_taskteam_init(lwt, thr, gtid, (void *) task, ompt_parallel_id);
         lwt->ompt_task_info.task_id = my_ompt_task_id;
         lwt->ompt_task_info.frame.exit_runtime_frame = 0;
         __ompt_lw_taskteam_link(lwt, thr);
 
 #if OMPT_TRACE
         // implicit task callback
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
                 ompt_parallel_id, my_ompt_task_id);
         }
         thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 #endif
     }
 #endif
 }
 
 
 void
 xexpand(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *), void *data, unsigned num_threads)
 {
     int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
     ompt_frame_t *parent_frame;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_frame = __ompt_get_task_frame_internal(0);
         parent_frame->reenter_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
     MKLOC(loc, "GOMP_parallel_start");
     KA_TRACE(20, ("GOMP_parallel_start: T#%d\n", gtid));
 
     if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
         if (num_threads != 0) {
             __kmp_push_num_threads(&loc, gtid, num_threads);
         }
         __kmp_GOMP_fork_call(&loc, gtid, task,
           (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task, data);
     }
     else {
         __kmp_GOMP_serialized_parallel(&loc, gtid, task);
     }
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_frame->reenter_runtime_frame = NULL;
     }
 #endif
 }
 
 
 void
 xexpand(KMP_API_NAME_GOMP_PARALLEL_END)(void)
 {
     int gtid = __kmp_get_gtid();
     kmp_info_t *thr;
 
     thr = __kmp_threads[gtid];
 
     MKLOC(loc, "GOMP_parallel_end");
     KA_TRACE(20, ("GOMP_parallel_end: T#%d\n", gtid));
 
 
 #if OMPT_SUPPORT
     ompt_parallel_id_t parallel_id;
     ompt_frame_t *ompt_frame = NULL;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
         parallel_id = team_info->parallel_id;
 
         // Record that we re-entered the runtime system in the implicit
         // task frame representing the parallel region. 
         ompt_frame = __ompt_get_task_frame_internal(0);
         ompt_frame->reenter_runtime_frame = __builtin_frame_address(0);
 
 #if OMPT_TRACE
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
             ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                 parallel_id, task_info->task_id);
         }
 #endif
 
         // unlink if necessary. no-op if there is not a lightweight task.
         ompt_lw_taskteam_t *lwt = __ompt_lw_taskteam_unlink(thr);
         // GOMP allocates/frees lwt since it can't be kept on the stack
         if (lwt) { 
            __kmp_free(lwt);
      
 #if OMPT_SUPPORT
-           if (ompt_status & ompt_status_track) {
+           if (ompt_enabled) {
               // Since a lightweight task was destroyed, make sure that the
               // remaining deepest task knows the stack frame where the runtime 
               // was reentered.
               ompt_frame = __ompt_get_task_frame_internal(0);
               ompt_frame->reenter_runtime_frame = __builtin_frame_address(0);
            }
 #endif
         }
     }
 #endif
 
     if (! thr->th.th_team->t.t_serialized) {
         __kmp_run_after_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,
           thr->th.th_team);
 
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
           // Set reenter frame in parent task, which will become current task
           // in the midst of join. This is needed before the end_parallel callback.
           ompt_frame = __ompt_get_task_frame_internal(1);
           ompt_frame->reenter_runtime_frame = __builtin_frame_address(0);
         }
 #endif
 
         __kmp_join_call(&loc, gtid
 #if OMPT_SUPPORT
             , fork_context_gnu
 #endif
         );
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
           ompt_frame->reenter_runtime_frame = NULL;
         }
 #endif
     }
     else {
         __kmpc_end_serialized_parallel(&loc, gtid);
 
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
             // Record that we re-entered the runtime system in the frame that 
             // created the parallel region.
             ompt_frame->reenter_runtime_frame = __builtin_frame_address(0);
 
-            if ((ompt_status == ompt_status_track_callback) &&
-                ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
+            if (ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
                 ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
                 ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
                     parallel_id, task_info->task_id, 
                     OMPT_INVOKER(fork_context_gnu));
             }
 
             ompt_frame->reenter_runtime_frame = NULL;
 
#define PARALLEL_LOOP_START(func, schedule, ompt_pre, ompt_post) \
     }
 
 
 
 #if OMPT_SUPPORT
 
 #define OMPT_LOOP_PRE() \
     ompt_frame_t *parent_frame; \
-    if (ompt_status & ompt_status_track) { \
+    if (ompt_enabled) { \
         parent_frame = __ompt_get_task_frame_internal(0); \
         parent_frame->reenter_runtime_frame = __builtin_frame_address(0); \
     }
 
 
 #define OMPT_LOOP_POST() \
-    if (ompt_status & ompt_status_track) { \
+    if (ompt_enabled) { \
         parent_frame->reenter_runtime_frame = NULL; \
     }
 
 #else
 
 #define OMPT_LOOP_PRE() 
 
 #define OMPT_LOOP_POST()
long arg_size, long arg_align, int if_cond, unsigned gomp_flags)
     if (if_cond) {
         __kmpc_omp_task(&loc, gtid, task);
     }
     else {
 #if OMPT_SUPPORT
         ompt_thread_info_t oldInfo;
         kmp_info_t *thread;
         kmp_taskdata_t *taskdata;
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
             // Store the threads states and restore them after the task
             thread = __kmp_threads[ gtid ];
             taskdata = KMP_TASK_TO_TASKDATA(task);
             oldInfo = thread->th.ompt_thread_info;
             thread->th.ompt_thread_info.wait_id = 0;
             thread->th.ompt_thread_info.state = ompt_state_work_parallel;
             taskdata->ompt_task_info.frame.exit_runtime_frame =
                 __builtin_frame_address(0);
         }
 #endif
 
         __kmpc_omp_task_begin_if0(&loc, gtid, task);
         func(data);
         __kmpc_omp_task_complete_if0(&loc, gtid, task);
 
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
             thread->th.ompt_thread_info = oldInfo;
             taskdata->ompt_task_info.frame.exit_runtime_frame = 0;
         }
 #endif
     }
 
     KA_TRACE(20, ("GOMP_task exit: T#%d\n", gtid));
 }

 xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(void (*task) (void *), void *data,
   unsigned num_threads, unsigned count)
 {
     int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
     ompt_frame_t *parent_frame;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_frame = __ompt_get_task_frame_internal(0);
         parent_frame->reenter_runtime_frame = __builtin_frame_address(0);
     }
 #endif
 
     MKLOC(loc, "GOMP_parallel_sections_start");
     KA_TRACE(20, ("GOMP_parallel_sections_start: T#%d\n", gtid));
 
     if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
         if (num_threads != 0) {
             __kmp_push_num_threads(&loc, gtid, num_threads);
         }
         __kmp_GOMP_fork_call(&loc, gtid, task,
           (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9, task, data,
           num_threads, &loc, kmp_nm_dynamic_chunked, (kmp_int)1,
           (kmp_int)count, (kmp_int)1, (kmp_int)1);
     }
     else {
         __kmp_GOMP_serialized_parallel(&loc, gtid, task);
     }
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         parent_frame->reenter_runtime_frame = NULL;
     }
 #endif
 
     KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
     KA_TRACE(20, ("GOMP_parallel_sections_start exit: T#%d\n", gtid));
 }

runtime/src/kmp_lock.cpp

#endif
 
                     KA_TRACE( 1000, ("__kmp_acquire_queuing_lock: lck:%p, T#%d exiting: no queuing\n",
                               lck, gtid ));
 #ifdef DEBUG_QUEUING_LOCKS
                     TRACE_LOCK_HT( gtid+1, "acq exit: ", head, 0 );
 #endif
 
 #if OMPT_SUPPORT
-                    if ((ompt_status & ompt_status_track) &&
-                        prev_state != ompt_state_undefined) {
+                    if (ompt_enabled && prev_state != ompt_state_undefined) {
                         /* change the state before clearing wait_id */
                         this_thr->th.ompt_thread_info.state = prev_state;
                         this_thr->th.ompt_thread_info.wait_id = 0;
                     }
 #endif
 
                     KMP_FSYNC_ACQUIRED( lck );
                     return; /* lock holder cannot be on queue */
                 }
                 enqueued = FALSE;
             }
             break;
         }
 
 #if OMPT_SUPPORT
-        if ((ompt_status & ompt_status_track) &&
-            prev_state == ompt_state_undefined) {
+        if (ompt_enabled && prev_state == ompt_state_undefined) {
             /* this thread will spin; set wait_id before entering wait state */
             prev_state = this_thr->th.ompt_thread_info.state;
             this_thr->th.ompt_thread_info.wait_id = (uint64_t) lck;
             this_thr->th.ompt_thread_info.state = ompt_state_wait_lock;
         }
 #endif
 
         if ( enqueued ) {

runtime/src/kmp_runtime.c

#ifdef BUILD_PARALLEL_ORDERED
     if ( ! team->t.t_serialized ) {
         KMP_MB();       /* Flush all pending memory write invalidates.  */
 
         /* use the tid of the next thread in this team */
         /* TODO repleace with general release procedure */
         team->t.t_ordered.dt.t_value = ((tid + 1) % team->t.t_nproc );
 
 #if OMPT_SUPPORT && OMPT_BLAME
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_release_ordered)) {
             /* accept blame for "ordered" waiting */
             kmp_info_t *this_thread = __kmp_threads[gtid];
             ompt_callbacks.ompt_callback(ompt_event_release_ordered)(
                 this_thread->th.ompt_thread_info.wait_id);
         }
 #endif
 

 
 #if OMPT_SUPPORT
     ompt_parallel_id_t ompt_parallel_id;
     ompt_task_id_t ompt_task_id;
     ompt_frame_t *ompt_frame;
     ompt_task_id_t my_task_id;
     ompt_parallel_id_t my_parallel_id;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         ompt_parallel_id = __ompt_parallel_id_new(gtid);
         ompt_task_id = __ompt_get_task_id_internal(0);
         ompt_frame = __ompt_get_task_frame_internal(0);
     }
 #endif
 
     // Nested level will be an index in the nested nthreads array
     level         = parent_team->t.t_level;
 #if OMP_40_ENABLED
     active_level  = parent_team->t.t_active_level; // is used to launch non-serial teams even if nested is not allowed
     teams_level    = master_th->th.th_teams_level; // needed to check nesting inside the teams
 #endif
 #if KMP_NESTED_HOT_TEAMS
     p_hot_teams   = &master_th->th.th_hot_teams;
     if( *p_hot_teams == NULL && __kmp_hot_teams_max_level > 0 ) {
         *p_hot_teams = (kmp_hot_team_ptr_t*)__kmp_allocate(
                 sizeof(kmp_hot_team_ptr_t) * __kmp_hot_teams_max_level);
         (*p_hot_teams)[0].hot_team = root->r.r_hot_team;
         (*p_hot_teams)[0].hot_team_nth = 1; // it is either actual or not needed (when active_level > 0)
     }
 #endif
 
 #if OMPT_SUPPORT
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_parallel_begin)) {
         int team_size = master_set_numthreads;
 
         ompt_callbacks.ompt_callback(ompt_event_parallel_begin)(
             ompt_task_id, ompt_frame, ompt_parallel_id,
             team_size, unwrapped_task, OMPT_INVOKER(call_context));
     }
 #endif
#endif
                                            //     work correctly, will restore at join time
 
 #if OMPT_SUPPORT
             void *dummy;
             void **exit_runtime_p;
 
             ompt_lw_taskteam_t lw_taskteam;
 
-            if (ompt_status & ompt_status_track) {
+            if (ompt_enabled) {
                 __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                     unwrapped_task, ompt_parallel_id);
                 lw_taskteam.ompt_task_info.task_id = __ompt_task_id_new(gtid);
                 exit_runtime_p = &(lw_taskteam.ompt_task_info.frame.exit_runtime_frame);
 
                 __ompt_lw_taskteam_link(&lw_taskteam, master_th);
 
 #if OMPT_TRACE
                 /* OMPT implicit task begin */
                 my_task_id = lw_taskteam.ompt_task_info.task_id;
                 my_parallel_id = parent_team->t.ompt_team_info.parallel_id;
-                if ((ompt_status == ompt_status_track_callback) &&
-                    ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
+                if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
                     ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
                         my_parallel_id, my_task_id);
                 }
 #endif
 
                 /* OMPT state */
                 master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
             } else {
                 exit_runtime_p = &dummy;
             }
 #endif
 
             {
                 KMP_TIME_BLOCK(OMP_work);
                 __kmp_invoke_microtask( microtask, gtid, 0, argc, parent_team->t.t_argv
 #if OMPT_SUPPORT
                                         , exit_runtime_p
 #endif
                                         );
             }
 
 #if OMPT_SUPPORT
-            if (ompt_status & ompt_status_track) {
+            if (ompt_enabled) {
 #if OMPT_TRACE
                 lw_taskteam.ompt_task_info.frame.exit_runtime_frame = 0;
 
-                if ((ompt_status == ompt_status_track_callback) &&
-                    ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
+                if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
                     ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                         ompt_parallel_id, ompt_task_id);
                 }
 
                 __ompt_lw_taskteam_unlink(master_th);
                 // reset clear the task id only after unlinking the task
                 lw_taskteam.ompt_task_info.task_id = ompt_task_id_none;
 #endif
 
-                if ((ompt_status == ompt_status_track_callback) &&
-                    ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
+                if (ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
                     ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
                         ompt_parallel_id, ompt_task_id,
                         OMPT_INVOKER(call_context));
                 }
                 master_th->th.ompt_thread_info.state = ompt_state_overhead;
             }
 #endif
             return TRUE;
#if OMP_40_ENABLED
                 // Get args from parent team for teams construct
 
 #if OMPT_SUPPORT
                 void *dummy;
                 void **exit_runtime_p;
 
                 ompt_lw_taskteam_t lw_taskteam;
 
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
                     __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                         unwrapped_task, ompt_parallel_id);
                     lw_taskteam.ompt_task_info.task_id = __ompt_task_id_new(gtid);
                     exit_runtime_p = &(lw_taskteam.ompt_task_info.frame.exit_runtime_frame);
 
                     __ompt_lw_taskteam_link(&lw_taskteam, master_th);
 
 #if OMPT_TRACE
                     my_task_id = lw_taskteam.ompt_task_info.task_id;
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
                         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
                             ompt_parallel_id, my_task_id);
                     }
 #endif
 
                     /* OMPT state */
                     master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
                 } else {
                     exit_runtime_p = &dummy;
                 }
 #endif
 
                 {
                     KMP_TIME_BLOCK(OMP_work);
                     __kmp_invoke_microtask( microtask, gtid, 0, argc, parent_team->t.t_argv
 #if OMPT_SUPPORT
                         , exit_runtime_p
 #endif
                     );
                 }
 
 #if OMPT_SUPPORT
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
                     lw_taskteam.ompt_task_info.frame.exit_runtime_frame = 0;
 
 #if OMPT_TRACE
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
                         ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                             ompt_parallel_id, ompt_task_id);
                     }
 #endif
 
                     __ompt_lw_taskteam_unlink(master_th);
                     // reset clear the task id only after unlinking the task
                     lw_taskteam.ompt_task_info.task_id = ompt_task_id_none;
 
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
                         ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
                             ompt_parallel_id, ompt_task_id,
                             OMPT_INVOKER(call_context));
                     }
                     master_th->th.ompt_thread_info.state = ompt_state_overhead;
                 }
 #endif
             } else if ( microtask == (microtask_t)__kmp_teams_master ) {
#endif
                 KMP_MB();
 
 #if OMPT_SUPPORT
                 void *dummy;
                 void **exit_runtime_p;
 
                 ompt_lw_taskteam_t lw_taskteam;
 
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
                     __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                         unwrapped_task, ompt_parallel_id);
                     lw_taskteam.ompt_task_info.task_id = __ompt_task_id_new(gtid);
                     exit_runtime_p = &(lw_taskteam.ompt_task_info.frame.exit_runtime_frame);
 
                     __ompt_lw_taskteam_link(&lw_taskteam, master_th);
 
 #if OMPT_TRACE
                     /* OMPT implicit task begin */
                     my_task_id = lw_taskteam.ompt_task_info.task_id;
                     my_parallel_id = ompt_parallel_id;
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
                         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
                             my_parallel_id, my_task_id);
                     }
 #endif
 
                     /* OMPT state */
                     master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
                 } else {
                     exit_runtime_p = &dummy;
                 }
 #endif
 
                 {
                     KMP_TIME_BLOCK(OMP_work);
                     __kmp_invoke_microtask( microtask, gtid, 0, argc, args
 #if OMPT_SUPPORT
                         , exit_runtime_p
 #endif
                     );
                 }
 
 #if OMPT_SUPPORT
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
 #if OMPT_TRACE
                     lw_taskteam.ompt_task_info.frame.exit_runtime_frame = 0;
 
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
                         ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                             my_parallel_id, my_task_id);
                     }
 #endif
 
                     __ompt_lw_taskteam_unlink(master_th);
                     // reset clear the task id only after unlinking the task
                     lw_taskteam.ompt_task_info.task_id = ompt_task_id_none;
 
-                    if ((ompt_status == ompt_status_track_callback) &&
-                        ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
+                    if (ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
                         ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
                             ompt_parallel_id, ompt_task_id,
                             OMPT_INVOKER(call_context));
                     }
                     master_th->th.ompt_thread_info.state = ompt_state_overhead;
                 }
 #endif
 #if OMP_40_ENABLED
#endif /* OMP_40_ENABLED */
     }
     KA_TRACE( 20, ("__kmp_fork_call: T#%d(%d:0) done microtask = %p\n",
         gtid, team->t.t_id, team->t.t_pkfn ) );
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 20, ("__kmp_fork_call: parallel exit T#%d\n", gtid ));
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         master_th->th.ompt_thread_info.state = ompt_state_overhead;
     }
 #endif
 
     return TRUE;
 }
 
 #if OMPT_SUPPORT
)
     master_th     = __kmp_threads[ gtid ];
     root          = master_th->th.th_root;
     team          = master_th->th.th_team;
     parent_team   = team->t.t_parent;
 
     master_th->th.th_ident = loc;
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         master_th->th.ompt_thread_info.state = ompt_state_overhead;
     }
 #endif
 
 #if KMP_DEBUG
     if ( __kmp_tasking_mode != tskm_immediate_exec ) {
         KA_TRACE( 20, ( "__kmp_join_call: T#%d, old team = %p old task_team = %p, th_task_team = %p\n",
                          __kmp_gtid_from_thread( master_th ), team,
#if OMP_40_ENABLED
                 //     in order to restore it in the next call to __kmpc_end_serialized_parallel
                 team->t.t_serialized++;
             }
         }
 #endif /* OMP_40_ENABLED */
         __kmpc_end_serialized_parallel( loc, gtid );
 
 #if OMPT_SUPPORT
-        if (ompt_status == ompt_status_track_callback) {
+        if (ompt_enabled) {
             __kmp_join_restore_state(master_th, parent_team);
         }
 #endif
 
         return;
     }
 
     master_active = team->t.t_master_active;
#endif
                 if ( __kmp_tasking_mode != tskm_immediate_exec ) {
                     // Synchronize thread's task state
                     other_threads[i]->th.th_task_state = master_th->th.th_task_state;
                 }
             }
         }
 
 #if OMPT_SUPPORT
-        if (ompt_status == ompt_status_track_callback) {
+        if (ompt_enabled) {
             __kmp_join_ompt(master_th, parent_team, parallel_id, fork_context);
         }
 #endif
 
         return;
     }
 #endif /* OMP_40_ENABLED */
 
#endif /* OMP_40_ENABLED */
 
      // TODO: GEH - cannot do this assertion because root thread not set up as executing
      // KMP_ASSERT( master_th->th.th_current_task->td_flags.executing == 0 );
      master_th->th.th_current_task->td_flags.executing = 1;
 
     __kmp_release_bootstrap_lock( &__kmp_forkjoin_lock );
 
 #if OMPT_SUPPORT
-    if (ompt_status == ompt_status_track_callback) {
+    if (ompt_enabled) {
         __kmp_join_ompt(master_th, parent_team, parallel_id, fork_context);
     }
 #endif
 
     KMP_MB();
     KA_TRACE( 20, ("__kmp_join_call: exit T#%d\n", gtid ));
 }
 
#if KMP_OS_WINDOWS
         /* Close Handle of root duplicated in __kmp_create_worker (tr #62919) */
         KA_TRACE( 10, ("__kmp_reset_root: free handle, th = %p, handle = %" KMP_UINTPTR_SPEC "\n",
             (LPVOID)&(root->r.r_uber_thread->th),
             root->r.r_uber_thread->th.th_info.ds.ds_thread ) );
         __kmp_free_handle( root->r.r_uber_thread->th.th_info.ds.ds_thread );
     #endif /* KMP_OS_WINDOWS */
 
 #if OMPT_SUPPORT
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_thread_end)) {
         int gtid = __kmp_get_gtid();
         __ompt_thread_end(ompt_thread_initial, gtid);
     }
 #endif
 
     TCW_4(__kmp_nth, __kmp_nth - 1); // __kmp_reap_thread will decrement __kmp_all_nth.
     __kmp_reap_thread( root->r.r_uber_thread, 1 );
/*    void                 *stack_data;*/
     KMP_MB();
     KA_TRACE( 10, ("__kmp_launch_thread: T#%d start\n", gtid ) );
 
     if( __kmp_env_consistency_check ) {
         this_thr->th.th_cons = __kmp_allocate_cons_stack( gtid );  // ATT: Memory leak?
     }
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         this_thr->th.ompt_thread_info.state = ompt_state_overhead;
         this_thr->th.ompt_thread_info.wait_id = 0;
         this_thr->th.ompt_thread_info.idle_frame = __builtin_frame_address(0);
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_thread_begin)) {
+        if (ompt_callbacks.ompt_callback(ompt_event_thread_begin)) {
             __ompt_thread_begin(ompt_thread_worker, gtid);
         }
     }
 #endif
 
     /* This is the place where threads wait for work */
     while( ! TCR_4(__kmp_global.g.g_done) ) {
         KMP_DEBUG_ASSERT( this_thr == __kmp_threads[ gtid ] );
         KMP_MB();
 
         /* wait for work to do */
         KA_TRACE( 20, ("__kmp_launch_thread: T#%d waiting for work\n", gtid ));
 
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
             this_thr->th.ompt_thread_info.state = ompt_state_idle;
         }
 #endif
 
         /* No tid yet since not part of a team */
         __kmp_fork_barrier( gtid, KMP_GTID_DNE );
 
 #if OMPT_SUPPORT
-        if (ompt_status & ompt_status_track) {
+        if (ompt_enabled) {
             this_thr->th.ompt_thread_info.state = ompt_state_overhead;
         }
 #endif
 
         pteam = (kmp_team_t *(*))(& this_thr->th.th_team);
 
         /* have we been allocated? */
         if ( TCR_SYNC_PTR(*pteam) && !TCR_4(__kmp_global.g.g_done) ) {
             /* we were just woken up, so run our new task */
             if ( TCR_SYNC_PTR((*pteam)->t.t_pkfn) != NULL ) {
                 int rc;
                 KA_TRACE(20, ("__kmp_launch_thread: T#%d(%d:%d) invoke microtask = %p\n",
                               gtid, (*pteam)->t.t_id, __kmp_tid_from_gtid(gtid), (*pteam)->t.t_pkfn));
 
                 updateHWFPControl (*pteam);
 
 #if OMPT_SUPPORT
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
                     this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
                     // Initialize OMPT task id for implicit task.
                     int tid = __kmp_tid_from_gtid(gtid);
                     (*pteam)->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id = 
                     __ompt_task_id_new(tid);
                 }
 #endif
 
                 KMP_STOP_DEVELOPER_EXPLICIT_TIMER(USER_launch_thread_loop);
                 {
                     KMP_TIME_DEVELOPER_BLOCK(USER_worker_invoke);
                     rc = (*pteam)->t.t_invoke( gtid );
                 }
                 KMP_START_DEVELOPER_EXPLICIT_TIMER(USER_launch_thread_loop);
                 KMP_ASSERT( rc );
 
 #if OMPT_SUPPORT
-                if (ompt_status & ompt_status_track) {
+                if (ompt_enabled) {
                     /* no frame set while outside task */
                     int tid = __kmp_tid_from_gtid(gtid);
                     (*pteam)->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_runtime_frame = 0;
 
                     this_thr->th.ompt_thread_info.state = ompt_state_overhead;
                 }
 #endif
                 KMP_MB();
                 KA_TRACE(20, ("__kmp_launch_thread: T#%d(%d:%d) done microtask = %p\n",
                               gtid, (*pteam)->t.t_id, __kmp_tid_from_gtid(gtid), (*pteam)->t.t_pkfn));
             }
             /* join barrier after parallel region */
             __kmp_join_barrier( gtid );
         }
     }
     TCR_SYNC_PTR((intptr_t)__kmp_global.g.g_done);
 
 #if OMPT_SUPPORT
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_thread_end)) {
         __ompt_thread_end(ompt_thread_worker, gtid);
     }
 #endif
 
     if ( TCR_PTR( this_thr->th.th_task_team ) != NULL ) {
         __kmp_unref_task_team( this_thr->th.th_task_team, this_thr );
     }

 #endif
 
 #if OMPT_SUPPORT
     void *dummy;
     void **exit_runtime_p;
     ompt_task_id_t my_task_id;
     ompt_parallel_id_t my_parallel_id;
 
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         exit_runtime_p = &(team->t.t_implicit_task_taskdata[tid].
             ompt_task_info.frame.exit_runtime_frame);
     } else {
         exit_runtime_p = &dummy;
     }
 
 #if OMPT_TRACE
     my_task_id = team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id;
     my_parallel_id = team->t.ompt_team_info.parallel_id;
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
             my_parallel_id, my_task_id);
     }
 #endif
 #endif
 
     {
         KMP_TIME_BLOCK(OMP_work);
         rc = __kmp_invoke_microtask( (microtask_t) TCR_SYNC_PTR(team->t.t_pkfn),
                                      gtid, tid, (int) team->t.t_argc, (void **) team->t.t_argv
 #if OMPT_SUPPORT
                                      , exit_runtime_p
 #endif
                                      );
     }
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_status & ompt_status_track) {
-        if ((ompt_status == ompt_status_track_callback) &&
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
+    if (ompt_enabled) {
+        if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                 my_parallel_id, my_task_id);
         }
         // the implicit task is not dead yet, so we can't clear its task id here
         team->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_runtime_frame = 0;
     }
 #endif
 

runtime/src/kmp_sched.cpp

upper=0,stride=1) - JPH June 23, 2009.
                 traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec, traits_t< T >::spec );
             KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride, loc->psource ) );
             __kmp_str_free( &buff );
         }
         #endif
         KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
                 team_info->parallel_id, task_info->task_id,
                 team_info->microtask);
         }
 #endif
         KMP_COUNT_VALUE (FOR_static_iterations, 0);
         return;
if ( team -> t.t_serialized ) {
                 traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
             KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
             __kmp_str_free( &buff );
         }
         #endif
         KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
                 team_info->parallel_id, task_info->task_id,
                 team_info->microtask);
         }
 #endif
         return;
     }
if ( nth == 1 ) {
                 traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
             KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
             __kmp_str_free( &buff );
         }
         #endif
         KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if ((ompt_status == ompt_status_track_callback) &&
+        if (ompt_enabled &&
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
                 team_info->parallel_id, task_info->task_id,
                 team_info->microtask);
         }
 #endif
         return;
     }
#ifdef KMP_DEBUG
             traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec, traits_t< T >::spec );
         KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
         __kmp_str_free( &buff );
     }
     #endif
     KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
         ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
             team_info->parallel_id, task_info->task_id, team_info->microtask);
     }
 #endif
 
     return;
 }

runtime/src/kmp_tasking.c

#endif /* BUILD_TIED_TASK_STACK */
     // APT: yes, we will pass location here.
     // need to store current thread state (in a thread or taskdata structure)
     // before setting work_state, otherwise wrong state is set after end of task
 
     KA_TRACE(10, ("__kmp_task_start(exit): T#%d task=%p\n",
                   gtid, taskdata ) );
 
 #if OMPT_SUPPORT
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_task_begin)) {
         kmp_taskdata_t *parent = taskdata->td_parent;
         ompt_callbacks.ompt_callback(ompt_event_task_begin)(
             parent ? parent->ompt_task_info.task_id : ompt_task_id_none,
             parent ? &(parent->ompt_task_info.frame) : NULL,
             taskdata->ompt_task_info.task_id,
             taskdata->ompt_task_info.function);
     }

 static void
 __kmp_task_finish( kmp_int32 gtid, kmp_task_t *task, kmp_taskdata_t *resumed_task )
 {
     kmp_taskdata_t * taskdata = KMP_TASK_TO_TASKDATA(task);
     kmp_info_t * thread = __kmp_threads[ gtid ];
     kmp_int32 children = 0;
 
 #if OMPT_SUPPORT
-    if ((ompt_status == ompt_status_track_callback) &&
+    if (ompt_enabled &&
         ompt_callbacks.ompt_callback(ompt_event_task_end)) {
         kmp_taskdata_t *parent = taskdata->td_parent;
         ompt_callbacks.ompt_callback(ompt_event_task_end)(
             taskdata->ompt_task_info.task_id);
     }
 #endif
 
     KA_TRACE(10, ("__kmp_task_finish(enter): T#%d finishing task %p and resuming task %p\n",
#endif
             KMP_TEST_THEN_INC32( (kmp_int32 *)(& taskdata->td_parent->td_allocated_child_tasks) );
         }
     }
 
     KA_TRACE(20, ("__kmp_task_alloc(exit): T#%d created task %p parent=%p\n",
                   gtid, taskdata, taskdata->td_parent) );
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         taskdata->ompt_task_info.task_id = __ompt_task_id_new(gtid);
         taskdata->ompt_task_info.function = (void*) task_entry;
         taskdata->ompt_task_info.frame.exit_runtime_frame = NULL; 
         taskdata->ompt_task_info.frame.reenter_runtime_frame = NULL;
     }
 #endif
 
     return task;
#if OMP_41_ENABLED
     // Proxy tasks are not handled by the runtime
     if ( taskdata->td_flags.proxy != TASK_PROXY )
 #endif
     __kmp_task_start( gtid, task, current_task );
 
 #if OMPT_SUPPORT
     ompt_thread_info_t oldInfo;
     kmp_info_t * thread;
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         // Store the threads states and restore them after the task
         thread = __kmp_threads[ gtid ];
         oldInfo = thread->th.ompt_thread_info;
         thread->th.ompt_thread_info.wait_id = 0;
         thread->th.ompt_thread_info.state = ompt_state_work_parallel;
         taskdata->ompt_task_info.frame.exit_runtime_frame = __builtin_frame_address(0);
     }
 #endif
#endif /* KMP_GOMP_COMPAT */
             (*(task->routine))(gtid, task);
         }
 #if OMP_40_ENABLED
     }
 #endif // OMP_40_ENABLED
 
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         thread->th.ompt_thread_info = oldInfo;
         taskdata->ompt_task_info.frame.exit_runtime_frame = 0;
     }
 #endif
 
 #if OMP_41_ENABLED
     // Proxy tasks are not handled by the runtime
     if ( taskdata->td_flags.proxy != TASK_PROXY )

 //    TASK_CURRENT_NOT_QUEUED (0) if did not suspend and queue current task to be resumed later.
 //    TASK_CURRENT_QUEUED (1) if suspended and queued the current task to be resumed later.
 kmp_int32
 __kmp_omp_task( kmp_int32 gtid, kmp_task_t * new_task, bool serialize_immediate )
 {
     kmp_taskdata_t * new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         new_taskdata->ompt_task_info.frame.reenter_runtime_frame =
             __builtin_frame_address(0);
     }
 #endif
 
     /* Should we execute the new task or queue it?   For now, let's just always try to
        queue it.  If the queue fills up, then we'll execute it.  */
 #if OMP_41_ENABLED
     if ( new_taskdata->td_flags.proxy == TASK_PROXY || __kmp_push_task( gtid, new_task ) == TASK_NOT_PUSHED ) // if cannot defer
 #else
     if ( __kmp_push_task( gtid, new_task ) == TASK_NOT_PUSHED ) // if cannot defer
 #endif
     {                                                           // Execute this task immediately
         kmp_taskdata_t * current_task = __kmp_threads[ gtid ] -> th.th_current_task;
         if ( serialize_immediate )
           new_taskdata -> td_flags.task_serial = 1;
         __kmp_invoke_task( gtid, new_task, current_task );
     }
 
 #if OMPT_SUPPORT
-    if (ompt_status & ompt_status_track) {
+    if (ompt_enabled) {
         new_taskdata->ompt_task_info.frame.reenter_runtime_frame = 0;
     }
 #endif
 
     return TASK_CURRENT_NOT_QUEUED;
 }
 
 //---------------------------------------------------------------------

runtime/src/kmp_wait_release.h

if (flag->done_check()) {
         KMP_FSYNC_SPIN_ACQUIRED(spin);
         return;
     }
     th_gtid = this_thr->th.th_info.ds.ds_gtid;
     KA_TRACE(20, ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
 
 #if OMPT_SUPPORT && OMPT_BLAME
     ompt_state_t ompt_state = this_thr->th.ompt_thread_info.state;
-    if (ompt_status == ompt_status_track_callback &&
+    if (ompt_enabled &&
         ompt_state != ompt_state_undefined) {
         if (ompt_state == ompt_state_idle) {
             if (ompt_callbacks.ompt_callback(ompt_event_idle_begin)) {
                 ompt_callbacks.ompt_callback(ompt_event_idle_begin)(th_gtid + 1);
             }
         } else if (ompt_callbacks.ompt_callback(ompt_event_wait_barrier_begin)) {
             KMP_DEBUG_ASSERT(ompt_state == ompt_state_wait_barrier ||
                              ompt_state == ompt_state_wait_barrier_implicit ||
while (flag->notdone_check()) {
             if (__kmp_global.g.g_abort)
                 __kmp_abort_thread();
             break;
         }
         // TODO: If thread is done with work and times out, disband/free
     }
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    if (ompt_status == ompt_status_track_callback &&
+    if (ompt_enabled &&
         ompt_state != ompt_state_undefined) {
         if (ompt_state == ompt_state_idle) {
             if (ompt_callbacks.ompt_callback(ompt_event_idle_end)) {
                 ompt_callbacks.ompt_callback(ompt_event_idle_end)(th_gtid + 1);
             }
         } else if (ompt_callbacks.ompt_callback(ompt_event_wait_barrier_end)) {
             KMP_DEBUG_ASSERT(ompt_state == ompt_state_wait_barrier ||
                              ompt_state == ompt_state_wait_barrier_implicit ||

runtime/src/ompt-general.c

 );
 
 
 
 /*****************************************************************************
  * global variables
  ****************************************************************************/
 
-ompt_status_t ompt_status = ompt_status_ready;
-
+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;
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;
+          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);
void ompt_post_init()
 
     if (ompt_post_initialized) return;
 
     ompt_post_initialized = 1;
 
     //--------------------------------------------------
     // Initialize the tool if so indicated.
     //--------------------------------------------------
-    if (ompt_status == ompt_status_track_callback) {
+    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_status == ompt_status_track_callback) {
+    if (ompt_enabled) {
         if (ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)) {
             ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)();
         }
     }
 
-    ompt_status = ompt_status_disabled;
+    ompt_enabled = 0;
 }
 
 
 /*****************************************************************************
  * interface operations
  ****************************************************************************/
 
 /*****************************************************************************

 
 
 /*----------------------------------------------------------------------------
  | control
  ---------------------------------------------------------------------------*/
 
 _OMP_EXTERN void ompt_control(uint64_t command, uint64_t modifier)
 {
-    if (ompt_status == ompt_status_track_callback &&
-        ompt_callbacks.ompt_callback(ompt_event_control)) {
+    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_control)) {
         ompt_callbacks.ompt_callback(ompt_event_control)(command, modifier);
     }
 }
 
 
 
 /*****************************************************************************
  * API inquiry for tool

runtime/src/ompt-internal.h

 #ifndef __OMPT_INTERNAL_H__
 #define __OMPT_INTERNAL_H__
 
 #include "ompt.h"
 #include "ompt-event-specific.h"
 
 #define OMPT_VERSION 1
 
 #define _OMP_EXTERN extern "C"
 
 #define OMPT_INVOKER(x) \
   ((x == fork_context_gnu) ? ompt_invoker_program : ompt_invoker_runtime)
 
 
 #define ompt_callback(e) e ## _callback
 
-/* track and track_callback share a bit so that one can test whether either is
- * set by anding a bit.
- */
-typedef enum {
-    ompt_status_disabled       = 0x0,
-    ompt_status_ready          = 0x1,
-    ompt_status_track          = 0x2,
-    ompt_status_track_callback = 0x6,
-} ompt_status_t;
-
 
 typedef struct ompt_callbacks_s {
 #define ompt_event_macro(event, callback, eventid) callback ompt_callback(event);
 
     FOREACH_OMPT_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 } ompt_callbacks_t;

 
 typedef struct {
     ompt_state_t        state;
     ompt_wait_id_t      wait_id;
     void                *idle_frame;
 } ompt_thread_info_t;
 
 
-extern ompt_status_t ompt_status;
 extern ompt_callbacks_t ompt_callbacks;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 void ompt_pre_init(void);
 void ompt_post_init(void);
 void ompt_fini(void);
 
+extern int ompt_enabled;
+
 #ifdef __cplusplus
 };
 #endif
 
 #endif