Modify runtime to call correct functions for OMPT

[omalyshe]

runtime/src/kmp.h

3071–3075

It seems to be reasonable to put this additional argument under #if OMPT_SUPPORT macro as well.

runtime/src/kmp_gsupport.c

343

Same here - let's put the additional argument under #if OMPT_SUPPORT

[Hahnfeld]

runtime/src/kmp.h

3071–3075

No problem, will do

runtime/src/kmp_gsupport.c

343

While I'm ok with this change as well, this is a bit more tricky: __kmp_GOMP_fork_call is used inside macros (line #832 for example).
I can't think of a better solution than defining a new macro that always takes the same arguments. The substitution will then depend on OMPT_SUPPORT...
I think that doesn't fulfill any purpose. Other ideas?

While at it we could also change the new __kmp_GOMP_serialized_parallel (line #389)

[omalyshe]

runtime/src/kmp_gsupport.c

343

OK, let's then remain this function as is and change only __kmp_fork_call() above. Thank you.

[omalyshe]

LGTM. Can be committed.

[jlpeyton]

I accepted the revision, which now lets you close the revision. To do this you scroll to the bottom of the Phabricator page where it gives a list of Actions you can perform and choose Close Revision.

runtime/src/kmp.h

 #endif
 extern void __kmp_suspend_initialize( void );
 extern void __kmp_suspend_uninitialize_thread( kmp_info_t *th );
 
 extern kmp_info_t * __kmp_allocate_thread( kmp_root_t *root,
                                            kmp_team_t *team, int tid);
 #if OMP_40_ENABLED
 extern kmp_team_t * __kmp_allocate_team( kmp_root_t *root, int new_nproc, int max_nproc,
+#if OMPT_SUPPORT
+                                         ompt_parallel_id_t ompt_parallel_id,
+#endif
                                          kmp_proc_bind_t proc_bind,
                                          kmp_internal_control_t *new_icvs,
                                          int argc USE_NESTED_HOT_ARG(kmp_info_t *thr) );
 #else
 extern kmp_team_t * __kmp_allocate_team( kmp_root_t *root, int new_nproc, int max_nproc,
+#if OMPT_SUPPORT
+                                         ompt_parallel_id_t ompt_parallel_id,
+#endif
                                          kmp_internal_control_t *new_icvs,
                                          int argc USE_NESTED_HOT_ARG(kmp_info_t *thr) );
 #endif // OMP_40_ENABLED
 extern void __kmp_free_thread( kmp_info_t * );
 extern void __kmp_free_team( kmp_root_t *, kmp_team_t *  USE_NESTED_HOT_ARG(kmp_info_t *) );
 extern kmp_team_t * __kmp_reap_team( kmp_team_t * );
 
 /* ------------------------------------------------------------------------ */

  */
 enum fork_context_e
 {
     fork_context_gnu,                           /**< Called from GNU generated code, so must not invoke the microtask internally. */
     fork_context_intel,                         /**< Called from Intel generated code.  */
     fork_context_last
 };
 extern int __kmp_fork_call( ident_t *loc, int gtid, enum fork_context_e fork_context,
-  kmp_int32 argc, microtask_t microtask, launch_t invoker,
+  kmp_int32 argc,
+#if OMPT_SUPPORT
+  void *unwrapped_task,
+#endif
+  microtask_t microtask, launch_t invoker,
 /* TODO: revert workaround for Intel(R) 64 tracker #96 */
 #if (KMP_ARCH_ARM || KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                              va_list *ap
 #else
                              va_list ap
 #endif
                              );
 

 
 extern void __kmp_load_x87_fpu_control_word( kmp_int16 *p );
 extern void __kmp_store_x87_fpu_control_word( kmp_int16 *p );
 extern void __kmp_clear_x87_fpu_status_word();
 # define KMP_X86_MXCSR_MASK      0xffffffc0   /* ignore status flags (6 lsb) */
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
-extern int __kmp_invoke_microtask( microtask_t pkfn, int gtid, int npr, int argc, void *argv[] );
+extern int __kmp_invoke_microtask( microtask_t pkfn, int gtid, int npr, int argc, void *argv[]
+#if OMPT_SUPPORT
+                                   , void **exit_frame_ptr
+#endif
+);
 
 
 /* ------------------------------------------------------------------------ */
 
 KMP_EXPORT void   __kmpc_begin                ( ident_t *, kmp_int32 flags );
 KMP_EXPORT void   __kmpc_end                  ( ident_t * );
 
 KMP_EXPORT void   __kmpc_threadprivate_register_vec ( ident_t *, void * data, kmpc_ctor_vec ctor,

runtime/src/kmp_atomic.h

 
 
 #ifndef KMP_ATOMIC_H
 #define KMP_ATOMIC_H
 
 #include "kmp_os.h"
 #include "kmp_lock.h"
 
+#if OMPT_SUPPORT
+#include "ompt-specific.h"
+#endif
+
 // C++ build port.
 // Intel compiler does not support _Complex datatype on win.
 // Intel compiler supports _Complex datatype on lin and mac.
 // On the other side, there is a problem of stack alignment on lin_32 and mac_32
 // if the rhs is cmplx80 or cmplx128 typedef'ed datatype.
 // The decision is: to use compiler supported _Complex type on lin and mac,
 //                  to use typedef'ed types on win.
 // Condition for WIN64 was modified in anticipation of 10.1 build compiler.

 // Atomic locks can easily become contended, so we use queuing locks for them.
 //
 
 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) &&
+        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) &&
+        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) &&
+        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
 __kmp_init_atomic_lock( kmp_atomic_lock_t *lck )
 {
     __kmp_init_queuing_lock( lck );
 }
 

runtime/src/kmp_barrier.cpp

__kmp_barrier(enum barrier_type bt, int gtid, int is_split, size_t reduce_size,
               void *reduce_data, void (*reduce)(void *, void *))
 {
     KMP_TIME_BLOCK(KMP_barrier);
     register int tid = __kmp_tid_from_gtid(gtid);
     register kmp_info_t *this_thr = __kmp_threads[gtid];
     register kmp_team_t *team = this_thr->th.th_team;
     register int status = 0;
     ident_t *loc = __kmp_threads[gtid]->th.th_ident;
+#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 && OMPT_TRACE
+    if (ompt_status & ompt_status_track) {
+        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 (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);
+                }
+            }
+            this_thr->th.ompt_thread_info.state = ompt_state_wait_barrier;
+            if (ompt_callbacks.ompt_callback(ompt_event_barrier_begin)) {
+                ompt_callbacks.ompt_callback(ompt_event_barrier_begin)(
+                    my_parallel_id, my_task_id);
+            }
+        } else {
+            this_thr->th.ompt_thread_info.state = ompt_state_wait_barrier;
+        }
+    }
+#endif
+
     if (! team->t.t_serialized) {
 #if USE_ITT_BUILD
         // This value will be used in itt notify events below.
         void *itt_sync_obj = NULL;
 # if USE_ITT_NOTIFY
         if (__itt_sync_create_ptr || KMP_ITT_DEBUG)
             itt_sync_obj = __kmp_itt_barrier_object(gtid, bt, 1);
 # endif
#endif /* USE_ITT_BUILD */
         if (__kmp_tasking_mode != tskm_immediate_exec) {
             // The task team should be NULL for serialized code (tasks will be executed immediately)
             KMP_DEBUG_ASSERT(team->t.t_task_team[this_thr->th.th_task_state] == NULL);
             KMP_DEBUG_ASSERT(this_thr->th.th_task_team == NULL);
         }
     }
     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_TRACE
+        if ((ompt_status == ompt_status_track_callback) &&
+            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
+
     return status;
 }
 
 
 void
 __kmp_end_split_barrier(enum barrier_type bt, int gtid)
 {
     KMP_TIME_BLOCK(KMP_end_split_barrier);
#endif /* KMP_DEBUG */
 
     // Verify state
     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 && OMPT_TRACE
+    if ((ompt_status == ompt_status_track_callback) &&
+        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);
+    }
+    this_thr->th.ompt_thread_info.state = ompt_state_wait_barrier;
+#endif
+
     if (__kmp_tasking_mode == tskm_extra_barrier) {
         __kmp_tasking_barrier(team, this_thr, gtid);
         KA_TRACE(10, ("__kmp_join_barrier: T#%d(%d:%d) past taking barrier\n", gtid, team_id, tid));
     }
 # ifdef KMP_DEBUG
     if (__kmp_tasking_mode != tskm_immediate_exec) {
         KA_TRACE(20, ( "__kmp_join_barrier: T#%d, old team = %d, old task_team = %p, th_task_team = %p\n",
                        __kmp_gtid_from_thread(this_thr), team_id, team->t.t_task_team[this_thr->th.th_task_state],
if (KMP_MASTER_TID(tid)) {
         KA_TRACE(15, ("__kmp_join_barrier: T#%d(%d:%d) says all %d team threads arrived\n",
                       gtid, team_id, tid, nproc));
     }
 #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_TRACE
+        if ((ompt_status == ompt_status_track_callback) &&
+            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
 }
 
 
 // TODO release worker threads' fork barriers as we are ready instead of all at once
 void
 __kmp_fork_barrier(int gtid, int tid)
 {
     KMP_TIME_BLOCK(KMP_fork_barrier);

runtime/src/kmp_csupport.c

 
 #include "omp.h"        /* extern "C" declarations of user-visible routines */
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_error.h"
 #include "kmp_stats.h"
 
+#if OMPT_SUPPORT
+#include "ompt-internal.h"
+#include "ompt-specific.h"
+#endif
+
 #define MAX_MESSAGE 512
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 /*  flags will be used in future, e.g., to implement */
 /*  openmp_strict library restrictions               */
 
__kmpc_fork_call(ident_t *loc, kmp_int32 argc, kmpc_micro microtask, ...)
   KMP_STOP_EXPLICIT_TIMER(OMP_serial);
   KMP_COUNT_BLOCK(OMP_PARALLEL);
   int         gtid = __kmp_entry_gtid();
   // maybe to save thr_state is enough here
   {
     va_list     ap;
     va_start(   ap, microtask );
 
+#if OMPT_SUPPORT
+    kmp_info_t *master_th = __kmp_threads[ gtid ];
+    kmp_team_t *parent_team = master_th->th.th_team;
+    int tid = __kmp_tid_from_gtid( gtid );
+    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
     __kmp_fork_call( loc, gtid, fork_context_intel,
             argc,
-            VOLATILE_CAST(microtask_t) microtask,
+#if OMPT_SUPPORT
+            VOLATILE_CAST(void *) microtask,      // "unwrapped" task
+#endif
+            VOLATILE_CAST(microtask_t) microtask, // "wrapped" task
             VOLATILE_CAST(launch_t)    __kmp_invoke_task_func,
 /* TODO: revert workaround for Intel(R) 64 tracker #96 */
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
             &ap
 #else
             ap
 #endif
             );
 #if INCLUDE_SSC_MARKS
     SSC_MARK_JOINING();
 #endif
     __kmp_join_call( loc, gtid );
 
     va_end( ap );
+
+#if OMPT_SUPPORT
+    if (ompt_status & ompt_status_track) {
+        parent_team->t.t_implicit_task_taskdata[tid].
+            ompt_task_info.frame.reenter_runtime_frame = 0;
+    }
+#endif
   }
   KMP_START_EXPLICIT_TIMER(OMP_serial);
 }
 
 #if OMP_40_ENABLED
 /*!
 @ingroup PARALLEL
 @param loc source location information
if ( this_thr->th.th_teams_size.nteams == 0 ) {
         __kmp_push_num_teams( loc, gtid, 0, 0 );
     }
     KMP_DEBUG_ASSERT(this_thr->th.th_set_nproc >= 1);
     KMP_DEBUG_ASSERT(this_thr->th.th_teams_size.nteams >= 1);
     KMP_DEBUG_ASSERT(this_thr->th.th_teams_size.nth >= 1);
 
     __kmp_fork_call( loc, gtid, fork_context_intel,
             argc,
-            VOLATILE_CAST(microtask_t) __kmp_teams_master,
+#if OMPT_SUPPORT
+            VOLATILE_CAST(void *) microtask,               // "unwrapped" task
+#endif
+            VOLATILE_CAST(microtask_t) __kmp_teams_master, // "wrapped" task
             VOLATILE_CAST(launch_t)    __kmp_invoke_teams_master,
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
             &ap
 #else
             ap
 #endif
             );
     __kmp_join_call( loc, gtid );
__kmpc_master(ident_t *loc, kmp_int32 global_tid)
     KC_TRACE( 10, ("__kmpc_master: called T#%d\n", global_tid ) );
 
     if( ! TCR_4( __kmp_init_parallel ) )
         __kmp_parallel_initialize();
 
     if( KMP_MASTER_GTID( global_tid ))
         status = 1;
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (status) {
+        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) &&
+            ompt_callbacks.ompt_callback(ompt_event_master_begin)) {
+            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);
+        }
+    }
+#endif
+
     if ( __kmp_env_consistency_check ) {
 #if KMP_USE_DYNAMIC_LOCK
         if (status)
             __kmp_push_sync( global_tid, ct_master, loc, NULL, 0 );
         else
             __kmp_check_sync( global_tid, ct_master, loc, NULL, 0 );
 #else
         if (status)

 */
 void
 __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 ));
 
+#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) &&
+        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 ( __kmp_env_consistency_check ) {
         if( global_tid < 0 )
             KMP_WARNING( ThreadIdentInvalid );
 
         if( KMP_MASTER_GTID( global_tid ))
             __kmp_pop_sync( global_tid, ct_master, loc );
     }
 }

 
 #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) {
+        /* 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)) {
+            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) {
+        /* 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)) {
+            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 */
 }
 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.

 #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) &&
+        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
 
 static __forceinline kmp_indirect_lock_t *
 __kmp_get_indirect_csptr(kmp_critical_name * crit, ident_t const * loc, kmp_int32 gtid, kmp_dyna_lockseq_t seq)
 {
     // Code from __kmp_get_critical_section_ptr
if ( __kmp_env_consistency_check )
         __kmp_pop_sync( global_tid, ct_critical, loc );
 
 #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) &&
+        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
 
     KA_TRACE( 15, ("__kmpc_end_critical: done T#%d\n", global_tid ));
 }
 
 /*!
 @ingroup SYNCHRONIZATION
 @param loc source location information

 introduce an explicit barrier if it is required.
 */
 
 kmp_int32
 __kmpc_single(ident_t *loc, kmp_int32 global_tid)
 {
     KMP_COUNT_BLOCK(OMP_SINGLE);
     kmp_int32 rc = __kmp_enter_single( global_tid, loc, TRUE );
+
+#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 (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 {
+            if (ompt_callbacks.ompt_callback(ompt_event_single_others_begin)) {
+                ompt_callbacks.ompt_callback(ompt_event_single_others_begin)(
+                    team->t.ompt_team_info.parallel_id,
+                    team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id);
+            }
+            this_thr->th.ompt_thread_info.state = ompt_state_wait_single;
+        }
+    }
+#endif
+
     return rc;
 }
 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information
 @param global_tid  global thread number
 
 Mark the end of a <tt>single</tt> construct.  This function should
 only be called by the thread that executed the block of code protected
 by the `single` construct.
 */
 void
 __kmpc_end_single(ident_t *loc, kmp_int32 global_tid)
 {
     __kmp_exit_single( 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) &&
+        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
 }
 
 /*!
 @ingroup WORK_SHARING
 @param loc Source location
 @param global_tid Global thread id
 
 Mark the end of a statically scheduled loop.
 */
 void
 __kmpc_for_static_fini( ident_t *loc, kmp_int32 global_tid )
 {
     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) &&
+        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 )
      __kmp_pop_workshare( global_tid, ct_pdo, loc );
 }
 
 /*
  * User routines which take C-style arguments (call by value)
  * different from the Fortran equivalent routines
  */
#endif
     }
 
 #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) &&
+        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
 }
 
 /* release the lock */
 void
 __kmpc_unset_nest_lock( ident_t *loc, kmp_int32 gtid, void **user_lock )
 {
 #if KMP_USE_DYNAMIC_LOCK
#endif
     else {
         lck = __kmp_lookup_user_lock( user_lock, "omp_unset_nest_lock" );
     }
 
 #if USE_ITT_BUILD
     __kmp_itt_lock_releasing( lck );
 #endif /* USE_ITT_BUILD */
 
-    RELEASE_NESTED_LOCK( lck, gtid );
+    int release_status = RELEASE_NESTED_LOCK( lck, gtid );
+#if OMPT_SUPPORT && OMPT_BLAME
+    if (ompt_status == ompt_status_track_callback) {
+        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);
+        }
+    }
+#endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 /* try to acquire the lock */
 int
 __kmpc_test_lock( ident_t *loc, kmp_int32 gtid, void **user_lock )
 {

runtime/src/kmp_dispatch.cpp

 #include "kmp_itt.h"
 #include "kmp_str.h"
 #include "kmp_error.h"
 #include "kmp_stats.h"
 #if KMP_OS_WINDOWS && KMP_ARCH_X86
     #include <float.h>
 #endif
 
+#if OMPT_SUPPORT
+#include "ompt-internal.h"
+#include "ompt-specific.h"
+#endif
+
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 // template for type limits
 template< typename T >
 struct i_maxmin {
     static const T mx;
     static const T mn;
if ( ___kmp_size_type < 8 ) {
       if( schedule == kmp_sch_static_steal ) {
         // Other threads will inspect this variable when searching for a victim.
         // 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) &&
+        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
 }
 
 /*
  * For ordered loops, either __kmp_dispatch_finish() should be called after
  * every iteration, or __kmp_dispatch_finish_chunk() should be called after
  * every chunk of iterations.  If the ordered section(s) were not executed
  * for this iteration (or every iteration in this chunk), we need to set the
  * ordered iteration counters so that the next thread can proceed.
//!!!!! TODO check if the inc should be unsigned, or signed???
             }
 //        }
     }
     KD_TRACE(100, ("__kmp_dispatch_finish_chunk: T#%d returned\n", gtid ) );
 }
 
 #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) &&                     \
+            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
+#define OMPT_LOOP_END // no-op
+#endif
+
 template< typename T >
 static int
 __kmp_dispatch_next(
     ident_t *loc, int gtid, kmp_int32 *p_last, T *p_lb, T *p_ub, typename traits_t< T >::signed_t *p_st
 ) {
 
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
//                    *p_last = 0;
                 traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
             KD_TRACE(10, ( buff, gtid, *p_lb, *p_ub, *p_st, p_last, *p_last, status) );
             __kmp_str_free( &buff );
         }
         #endif
 #if INCLUDE_SSC_MARKS
         SSC_MARK_DISPATCH_NEXT();
 #endif
+        OMPT_LOOP_END;
         return status;
     } else {
         kmp_int32 last = 0;
         dispatch_shared_info_template< UT > *sh;
         T         start;
         ST        incr;
         UT        limit, trip, init;
 
#ifdef KMP_DEBUG
             traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
         KD_TRACE(10, ( buff, gtid, *p_lb, *p_ub, p_st ? *p_st : 0, p_last, status ) );
         __kmp_str_free( &buff );
     }
     #endif
 #if INCLUDE_SSC_MARKS
     SSC_MARK_DISPATCH_NEXT();
 #endif
+    OMPT_LOOP_END;
     return status;
 }
 
 template< typename T >
 static void
 __kmp_dist_get_bounds(
     ident_t                          *loc,
     kmp_int32                         gtid,

runtime/src/kmp_gsupport.c

 
 
 #if defined(__x86_64) || defined (__powerpc64__) || defined(__aarch64__)
 # define KMP_I8
 #endif
 #include "kmp.h"
 #include "kmp_atomic.h"
 
+#if OMPT_SUPPORT
+#include "ompt-specific.h"
+#endif
+
 #ifdef __cplusplus
     extern "C" {
 #endif // __cplusplus
 
 #define MKLOC(loc,routine) \
     static ident_t (loc) = {0, KMP_IDENT_KMPC, 0, 0, ";unknown;unknown;0;0;;" };
 
 #include "kmp_ftn_os.h"

 // the update and GOMP_atomic_end() afterward, regardless of the data type.
 //
 
 void
 xexpand(KMP_API_NAME_GOMP_ATOMIC_START)(void)
 {
     int gtid = __kmp_entry_gtid();
     KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));
+
+#if OMPT_SUPPORT
+    __ompt_thread_assign_wait_id(0);
+#endif
+
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
 }
 
 
 void
 xexpand(KMP_API_NAME_GOMP_ATOMIC_END)(void)
 {
     int gtid = __kmp_get_gtid();

 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
 void
 __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) {
+        // 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) {
+        // clear task frame
+        ompt_frame->exit_runtime_frame = NULL;
+
+        // restore enclosing state
+        thr->th.ompt_thread_info.state = enclosing_state;
+    }
+#endif
 }
 
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
 void
 __kmp_GOMP_parallel_microtask_wrapper(int *gtid, int *npr,
   void (*task)(void *), void *data, unsigned num_threads, ident_t *loc,
   enum sched_type schedule, long start, long end, long incr, long chunk_size)
 {
     //
     // Intialize the loop worksharing construct.
     //
     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) {
+        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) {
+        // clear task frame
+        ompt_frame->exit_runtime_frame = NULL;
+
+        // reset enclosing state
+        thr->th.ompt_thread_info.state = enclosing_state;
+    }
+#endif
 }
 
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
 void
-__kmp_GOMP_fork_call(ident_t *loc, int gtid, microtask_t wrapper, int argc,...)
+__kmp_GOMP_fork_call(ident_t *loc, int gtid, void (*unwrapped_task)(void *), microtask_t wrapper, int argc,...)
 {
     int rc;
+    kmp_info_t *thr = __kmp_threads[gtid];
+    kmp_team_t *team = thr->th.th_team;
+    int tid = __kmp_tid_from_gtid(gtid);
 
     va_list ap;
     va_start(ap, argc);
 
-    rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc, wrapper, __kmp_invoke_task_func,
+#if OMPT_SUPPORT
+    team->t.t_implicit_task_taskdata[tid].
+        ompt_task_info.frame.reenter_runtime_frame = NULL;
+#endif
+
+    rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc,
+#if OMPT_SUPPORT
+      VOLATILE_CAST(void *) unwrapped_task,
+#endif
+      wrapper, __kmp_invoke_task_func,
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
       &ap
 #else
       ap
 #endif
       );
 
     va_end(ap);
 
     if (rc) {
+        __kmp_run_before_invoked_task(gtid, tid, thr, team);
+    }
+
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_status & ompt_status_track) {
+        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)) {
+            ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
+                team_info->parallel_id, task_info->task_id);
+        }
+        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) {
+        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];
-        __kmp_run_before_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,
-          thr->th.th_team);
+
+        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)) {
+            int team_size = 1;
+            ompt_callbacks.ompt_callback(ompt_event_parallel_begin)(
+                ompt_task_id, ompt_frame, ompt_parallel_id,
+                team_size, (void *) task);
+        }
+
+        // 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)) {
+            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) {
+        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,
+        __kmp_GOMP_fork_call(&loc, gtid, task,
           (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task, data);
     }
     else {
-        __kmpc_serialized_parallel(&loc, gtid);
+        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
     }
+
+#if OMPT_SUPPORT
+    if (ompt_status & ompt_status_track) {
+        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 = __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) {
+        ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
+        parallel_id = team_info->parallel_id;
+
+        ompt_frame = __ompt_get_task_frame_internal(0);
+        ompt_frame->exit_runtime_frame = __builtin_frame_address(0);
+
+#if OMPT_TRACE
+        if ((ompt_status == ompt_status_track_callback) &&
+            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);
+    }
+#endif
+
     if (! __kmp_threads[gtid]->th.th_team->t.t_serialized) {
         kmp_info_t *thr = __kmp_threads[gtid];
         __kmp_run_after_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,
           thr->th.th_team);
         __kmp_join_call(&loc, gtid);
     }
     else {
         __kmpc_end_serialized_parallel(&loc, gtid);
+
+#if OMPT_SUPPORT
+        if (ompt_status & ompt_status_track) {
+            if ((ompt_status == ompt_status_track_callback) &&
+                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);
+            }
+
+            thr->th.ompt_thread_info.state =
+                (((thr->th.th_team)->t.t_serialized) ?
+                ompt_state_work_serial : ompt_state_work_parallel);
+        }
+#endif
+
     }
 }
 
 
 //
 // Loop worksharing constructs
 //
 
void func (void (*task) (void *), void *data, unsigned num_threads,      \
         MKLOC(loc, #func);                                                   \
         KA_TRACE(20, ( #func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n",        \
           gtid, lb, ub, str, chunk_sz ));                                    \
                                                                              \
         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,                                 \
+            __kmp_GOMP_fork_call(&loc, gtid, task,                           \
               (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,         \
               task, data, num_threads, &loc, (schedule), lb,                 \
               (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);               \
         }                                                                    \
         else {                                                               \
-            __kmpc_serialized_parallel(&loc, gtid);                          \
+            __kmp_GOMP_serialized_parallel(&loc, gtid, task);                \
         }                                                                    \
                                                                              \
         KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                        \
           (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,                    \
           (schedule) != kmp_sch_static);                                     \
                                                                              \
         KA_TRACE(20, ( #func " exit: T#%d\n", gtid));                        \
     }
if (arg_size > 0) {
             KMP_MEMCPY(task->shareds, data, arg_size);
         }
     }
 
     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) {
+            // 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) {
+            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));
 }
 
 
 void
 xexpand(KMP_API_NAME_GOMP_TASKWAIT)(void)

 
 
 void
 xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(void (*task) (void *), void *data,
   unsigned num_threads, unsigned count)
 {
     int gtid = __kmp_entry_gtid();
     int last = FALSE;
+
+#if OMPT_SUPPORT
+    ompt_frame_t *parent_frame;
+
+    if (ompt_status & ompt_status_track) {
+        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,
+        __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 {
-        __kmpc_serialized_parallel(&loc, gtid);
+        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
+    }
+
+#if OMPT_SUPPORT
+    if (ompt_status & ompt_status_track) {
+        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));
 }
 
 
 void
xexpand(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *), void *data, unsigned num_threads, unsigned int flags)
 
     if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
         if (num_threads != 0) {
             __kmp_push_num_threads(&loc, gtid, num_threads);
         }
         if(flags != 0) {
             __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);
         }
-        __kmp_GOMP_fork_call(&loc, gtid,
+        __kmp_GOMP_fork_call(&loc, gtid, task,
           (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task, data);
     }
     else {
-        __kmpc_serialized_parallel(&loc, gtid);
+        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
     }
     task(data);
     xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
 }
 
 void
 xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task) (void *), void *data,
   unsigned num_threads, unsigned count, unsigned flags)
 {
     int gtid = __kmp_entry_gtid();
     int last = FALSE;
     MKLOC(loc, "GOMP_parallel_sections");
     KA_TRACE(20, ("GOMP_parallel_sections: 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);
         }
         if(flags != 0) {
             __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);
         }
-        __kmp_GOMP_fork_call(&loc, gtid,
+        __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 {
-        __kmpc_serialized_parallel(&loc, gtid);
+        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
     }
 
     KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
     task(data);
     xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
     KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid));
 }
void func (void (*task) (void *), void *data, unsigned num_threads,      \
                                                                              \
         if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                 \
             if (num_threads != 0) {                                          \
                 __kmp_push_num_threads(&loc, gtid, num_threads);             \
             }                                                                \
             if (flags != 0) {                                                \
                 __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);    \
             }                                                                \
-            __kmp_GOMP_fork_call(&loc, gtid,                                 \
+            __kmp_GOMP_fork_call(&loc, gtid, task,                           \
               (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,         \
               task, data, num_threads, &loc, (schedule), lb,                 \
               (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);               \
         }                                                                    \
         else {                                                               \
-            __kmpc_serialized_parallel(&loc, gtid);                          \
+            __kmp_GOMP_serialized_parallel(&loc, gtid, task);                \
         }                                                                    \
                                                                              \
         KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                        \
           (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,                    \
           (schedule) != kmp_sch_static);                                     \
         task(data);                                                          \
         xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();                           \
                                                                              \

runtime/src/kmp_lock.cpp

__kmp_acquire_queuing_lock_timed_template( kmp_queuing_lock_t *lck,
   kmp_int32 gtid )
 {
     register kmp_info_t *this_thr    = __kmp_thread_from_gtid( gtid );
     volatile kmp_int32  *head_id_p   = & lck->lk.head_id;
     volatile kmp_int32  *tail_id_p   = & lck->lk.tail_id;
     volatile kmp_uint32 *spin_here_p;
     kmp_int32 need_mf = 1;
 
+#if OMPT_SUPPORT
+    ompt_state_t prev_state = ompt_state_undefined;
+#endif
+
     KA_TRACE( 1000, ("__kmp_acquire_queuing_lock: lck:%p, T#%d entering\n", lck, gtid ));
 
     KMP_FSYNC_PREPARE( lck );
     KMP_DEBUG_ASSERT( this_thr != NULL );
     spin_here_p = & this_thr->th.th_spin_here;
 
 #ifdef DEBUG_QUEUING_LOCKS
     TRACE_LOCK( gtid+1, "acq ent" );
#endif
 
                     *spin_here_p = FALSE;
 
                     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) {
+                        /* 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) {
+            /* 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 ) {
             if ( tail > 0 ) {
                 kmp_info_t *tail_thr = __kmp_thread_from_gtid( tail - 1 );
                 KMP_ASSERT( tail_thr != NULL );
                 tail_thr->th.th_next_waiting = gtid+1;
                 /* corresponding wait for this write in release code */
             }
             KA_TRACE( 1000, ("__kmp_acquire_queuing_lock: lck:%p, T#%d waiting for lock\n", lck, gtid ));

 #endif
             KMP_DEBUG_ASSERT( this_thr->th.th_next_waiting == 0 );
             KA_TRACE( 1000, ("__kmp_acquire_queuing_lock: lck:%p, T#%d exiting: after waiting on queue\n",
                       lck, gtid ));
 
 #ifdef DEBUG_QUEUING_LOCKS
             TRACE_LOCK( gtid+1, "acq exit 2" );
 #endif
+
+#if OMPT_SUPPORT
+            /* 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
+
             /* got lock, we were dequeued by the thread that released lock */
             return;
         }
 
         /* Yield if number of threads > number of logical processors */
         /* ToDo: Not sure why this should only be in oversubscription case,
            maybe should be traditional YIELD_INIT/YIELD_WHEN loop */
         KMP_YIELD( TCR_4( __kmp_nth ) > (__kmp_avail_proc ? __kmp_avail_proc :
#endif
 
             /* try (-1,0)->(0,0) */
             if ( KMP_COMPARE_AND_STORE_REL32( head_id_p, -1, 0 ) ) {
                 KA_TRACE( 1000, ("__kmp_release_queuing_lock: lck:%p, T#%d exiting: queue empty\n",
                           lck, gtid ));
 #ifdef DEBUG_QUEUING_LOCKS
                 TRACE_LOCK_HT( gtid+1, "rel exit: ", 0, 0 );
 #endif
+
+#if OMPT_SUPPORT
+                /* nothing to do - no other thread is trying to shift blame */
+#endif
+
                 return KMP_LOCK_RELEASED;
             }
             dequeued = FALSE;
 
         }
         else {
 
             tail = *tail_id_p;

runtime/src/kmp_runtime.c

 #include "kmp_str.h"
 #include "kmp_settings.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_error.h"
 #include "kmp_stats.h"
 #include "kmp_wait_release.h"
 
+#if OMPT_SUPPORT
+#include "ompt-specific.h"
+#endif
+
 /* these are temporary issues to be dealt with */
 #define KMP_USE_PRCTL 0
 #define KMP_USE_POOLED_ALLOC 0
 
 #if KMP_OS_WINDOWS
 #include <process.h>
 #endif
 

 #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) &&
+            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
+
         KMP_MB();       /* Flush all pending memory write invalidates.  */
     }
 #endif /* BUILD_PARALLEL_ORDERED */
 }
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
if( this_thr->th.th_team != serial_team ) {
         if( serial_team->t.t_serialized ) {
             /* this serial team was already used
              * TODO increase performance by making this locks more specific */
             kmp_team_t *new_team;
             int tid = this_thr->th.th_info.ds.ds_tid;
 
             __kmp_acquire_bootstrap_lock( &__kmp_forkjoin_lock );
 
+#if OMPT_SUPPORT
+            ompt_parallel_id_t ompt_parallel_id = __ompt_parallel_id_new(global_tid);
+#endif
+
             new_team = __kmp_allocate_team(this_thr->th.th_root, 1, 1,
+#if OMPT_SUPPORT
+                                           ompt_parallel_id,
+#endif
 #if OMP_40_ENABLED
                                            proc_bind,
 #endif
                                            & this_thr->th.th_current_task->td_icvs,
                                            0 USE_NESTED_HOT_ARG(NULL) );
             __kmp_release_bootstrap_lock( &__kmp_forkjoin_lock );
             KMP_ASSERT( new_team );
 
#endif /* OMP_40_ENABLED */
         /* check if we need to allocate dispatch buffers stack */
         KMP_DEBUG_ASSERT(serial_team->t.t_dispatch);
         if ( !serial_team->t.t_dispatch->th_disp_buffer ) {
             serial_team->t.t_dispatch->th_disp_buffer = (dispatch_private_info_t *)
                 __kmp_allocate( sizeof( dispatch_private_info_t ) );
         }
         this_thr->th.th_dispatch = serial_team->t.t_dispatch;
 
+#if OMPT_SUPPORT
+        ompt_parallel_id_t ompt_parallel_id = __ompt_parallel_id_new(global_tid);
+        __ompt_team_assign_id(serial_team, ompt_parallel_id);
+#endif
+
         KMP_MB();
 
     } else {
         /* this serialized team is already being used,
          * that's fine, just add another nested level */
         KMP_DEBUG_ASSERT( this_thr->th.th_team == serial_team );
         KMP_DEBUG_ASSERT( serial_team->t.t_threads );
         KMP_DEBUG_ASSERT( serial_team->t.t_threads[0] == this_thr );

 /* most of the work for a fork */
 /* return true if we really went parallel, false if serialized */
 int
 __kmp_fork_call(
     ident_t   * loc,
     int         gtid,
     enum fork_context_e  call_context, // Intel, GNU, ...
     kmp_int32   argc,
+#if OMPT_SUPPORT
+    void       *unwrapped_task,
+#endif
     microtask_t microtask,
     launch_t    invoker,
 /* TODO: revert workaround for Intel(R) 64 tracker #96 */
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
     va_list   * ap
 #else
     va_list     ap
 #endif
#endif
     /* setup current data */
     master_th     = __kmp_threads[ gtid ]; // AC: potentially unsafe, not in sync with shutdown
     parent_team   = master_th->th.th_team;
     master_tid    = master_th->th.th_info.ds.ds_tid;
     master_this_cons = master_th->th.th_local.this_construct;
     root          = master_th->th.th_root;
     master_active = root->r.r_active;
     master_set_numthreads = master_th->th.th_set_nproc;
+
+#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) {
+        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) &&
+        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);
+    }
+#endif
 
     master_th->th.th_ident = loc;
 
 #if OMP_40_ENABLED
     if ( master_th->th.th_teams_microtask &&
          ap && microtask != (microtask_t)__kmp_teams_master && level == teams_level ) {
         // AC: This is start of parallel that is nested inside teams construct.
         //     The team is actual (hot), all workers are ready at the fork barrier.

 #endif
         /* Increment our nested depth levels, but not increase the serialization */
         if ( parent_team == master_th->th.th_serial_team ) {
             // AC: we are in serialized parallel
             __kmpc_serialized_parallel(loc, gtid);
             KMP_DEBUG_ASSERT( parent_team->t.t_serialized > 1 );
             parent_team->t.t_serialized--; // AC: need this in order enquiry functions
                                            //     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) {
+                __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)) {
+                    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 );
+            __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_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)) {
+                    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)) {
+                    ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
+                        ompt_parallel_id, ompt_task_id);
+                }
+                master_th->th.ompt_thread_info.state = ompt_state_overhead;
+            }
+#endif
             return TRUE;
         }
+
         parent_team->t.t_pkfn  = microtask;
+#if OMPT_SUPPORT
+        parent_team->t.ompt_team_info.microtask = unwrapped_task;
+#endif
         parent_team->t.t_invoke = invoker;
         KMP_TEST_THEN_INC32( (kmp_int32*) &root->r.r_in_parallel );
         parent_team->t.t_active_level ++;
         parent_team->t.t_level ++;
 
         /* Change number of threads in the team if requested */
         if ( master_set_numthreads ) {   // The parallel has num_threads clause
             if ( master_set_numthreads < master_th->th.th_teams_size.nth ) {
#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) */
         if ( call_context == fork_context_intel ) {
             /* TODO this sucks, use the compiler itself to pass args! :) */
             master_th->th.th_serial_team->t.t_ident = loc;
 #if OMP_40_ENABLED
             if ( !ap ) {
                 // revert change made in __kmpc_serialized_parallel()
                 master_th->th.th_serial_team->t.t_level--;
                 // 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) {
+                    __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)) {
+                        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 );
+                    __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) {
+                    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)) {
+                        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)) {
+                        ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
+                            ompt_parallel_id, ompt_task_id);
+                    }
+                    master_th->th.ompt_thread_info.state = ompt_state_overhead;
+                }
+#endif
             } else if ( microtask == (microtask_t)__kmp_teams_master ) {
                 KMP_DEBUG_ASSERT( master_th->th.th_team == master_th->th.th_serial_team );
                 team = master_th->th.th_team;
                 //team->t.t_pkfn = microtask;
                 team->t.t_invoke = invoker;
                 __kmp_alloc_argv_entries( argc, team, TRUE );
                 team->t.t_argc = argc;
                 argv = (void**) team->t.t_argv;
#endif /* OMP_40_ENABLED */
                 for( i=argc-1; i >= 0; --i )
 // TODO: revert workaround for Intel(R) 64 tracker #96
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                     *argv++ = va_arg( *ap, void * );
 #else
                     *argv++ = va_arg( ap, void * );
 #endif
                 KMP_MB();
+
+#if OMPT_SUPPORT
+                void *dummy;
+                void **exit_runtime_p;
+
+                ompt_lw_taskteam_t lw_taskteam;
+
+                if (ompt_status & ompt_status_track) {
+                    __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)) {
+                        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 );
+                    __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_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)) {
+                        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)) {
+                        ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
+                            ompt_parallel_id, ompt_task_id);
                     }
+                    master_th->th.ompt_thread_info.state = ompt_state_overhead;
+                }
+#endif
 #if OMP_40_ENABLED
             }
 #endif /* OMP_40_ENABLED */
         }
         else if ( call_context == fork_context_gnu ) {
+#if OMPT_SUPPORT
+            ompt_lw_taskteam_t *lwt = (ompt_lw_taskteam_t *)
+                __kmp_allocate(sizeof(ompt_lw_taskteam_t));
+            __ompt_lw_taskteam_init(lwt, master_th, gtid,
+                unwrapped_task, ompt_parallel_id);
+
+            lwt->ompt_task_info.task_id = __ompt_task_id_new(gtid);
+            lwt->ompt_task_info.frame.exit_runtime_frame = 0;
+            __ompt_lw_taskteam_link(lwt, master_th);
+#endif
+
             // we were called from GNU native code
             KA_TRACE( 20, ("__kmp_fork_call: T#%d serial exit\n", gtid ));
             return FALSE;
         }
         else {
             KMP_ASSERT2( call_context < fork_context_last, "__kmp_fork_call: unknown fork_context parameter" );
         }
 
#if OMP_40_ENABLED
         if (proc_bind_icv != proc_bind_default) {
             new_icvs.proc_bind = proc_bind_icv;
         }
 #endif /* OMP_40_ENABLED */
 
         /* allocate a new parallel team */
         KF_TRACE( 10, ( "__kmp_fork_call: before __kmp_allocate_team\n" ) );
         team = __kmp_allocate_team(root, nthreads, nthreads,
+#if OMPT_SUPPORT
+                                   ompt_parallel_id,
+#endif
 #if OMP_40_ENABLED
                                    proc_bind,
 #endif
                                    &new_icvs, argc USE_NESTED_HOT_ARG(master_th) );
     } else {
         /* allocate a new parallel team */
         KF_TRACE( 10, ( "__kmp_fork_call: before __kmp_allocate_team\n" ) );
         team = __kmp_allocate_team(root, nthreads, nthreads,
+#if OMPT_SUPPORT
+                                   ompt_parallel_id,
+#endif
 #if OMP_40_ENABLED
                                    proc_bind,
 #endif
                                    &master_th->th.th_current_task->td_icvs, argc
                                    USE_NESTED_HOT_ARG(master_th) );
     }
     KF_TRACE( 10, ( "__kmp_fork_call: after __kmp_allocate_team - team = %p\n", team ) );
 
     /* setup the new team */
     team->t.t_master_tid = master_tid;
     team->t.t_master_this_cons = master_this_cons;
     team->t.t_ident      = loc;
     team->t.t_parent     = parent_team;
     TCW_SYNC_PTR(team->t.t_pkfn, microtask);
+#if OMPT_SUPPORT
+    TCW_SYNC_PTR(team->t.ompt_team_info.microtask, unwrapped_task);
+#endif
     team->t.t_invoke     = invoker;  /* TODO move this to root, maybe */
     // TODO: parent_team->t.t_level == INT_MAX ???
 #if OMP_40_ENABLED
     if ( !master_th->th.th_teams_microtask || level > teams_level ) {
 #endif /* OMP_40_ENABLED */
         team->t.t_level        = parent_team->t.t_level + 1;
         team->t.t_active_level = parent_team->t.t_active_level + 1;
 #if OMP_40_ENABLED
#endif /* OMP_40_ENABLED */
     /* now actually fork the threads */
     team->t.t_master_active = master_active;
     if (!root->r.r_active) // Only do assignment if it prevents cache ping-pong
         root->r.r_active = TRUE;
 
     __kmp_fork_team_threads( root, team, master_th, gtid );
     __kmp_setup_icv_copy( team, nthreads, &master_th->th.th_current_task->td_icvs, loc );
 
+#if OMPT_SUPPORT
+    master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
+#endif
 
     __kmp_release_bootstrap_lock( &__kmp_forkjoin_lock );
 
 
 #if USE_ITT_BUILD
     // Mark start of "parallel" region for VTune. Only use one of frame notification scheme at the moment.
     if ((__itt_frame_begin_v3_ptr && __kmp_forkjoin_frames && !__kmp_forkjoin_frames_mode) || KMP_ITT_DEBUG) {
 # if OMP_40_ENABLED
KA_TRACE( 20, ("__kmp_fork_call: T#%d(%d:0) invoke microtask = %p\n",
         }
     }
     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) {
+        master_th->th.ompt_thread_info.state = ompt_state_overhead;
+    }
+#endif
+
     return TRUE;
 }
 
+#if OMPT_SUPPORT
+static inline void
+__kmp_join_restore_state(
+    kmp_info_t *thread,
+    kmp_team_t *team)
+{
+    // restore state outside the region
+    thread->th.ompt_thread_info.state = ((team->t.t_serialized) ?
+        ompt_state_work_serial : ompt_state_work_parallel);
+}
+
+static inline void
+__kmp_join_ompt(
+    kmp_info_t *thread,
+    kmp_team_t *team,
+    ompt_parallel_id_t parallel_id)
+{
+    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);
+    }
+
+    __kmp_join_restore_state(thread,team);
+}
+#endif
+
 void
 __kmp_join_call(ident_t *loc, int gtid
 #if OMP_40_ENABLED
                , int exit_teams
 #endif /* OMP_40_ENABLED */
 )
 {
     KMP_TIME_BLOCK(KMP_join_call);
)
     /* setup current data */
     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) {
+        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,
                          team->t.t_task_team[master_th->th.th_task_state], master_th->th.th_task_team) );
         KMP_DEBUG_ASSERT( master_th->th.th_task_team == team->t.t_task_team[master_th->th.th_task_state] );
     }
 #endif
#if OMP_40_ENABLED
             } else if ( level == tlevel + 1 ) {
                 // AC: we are exiting parallel inside teams, need to increment serialization
                 //     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) {
+            __kmp_join_restore_state(master_th, parent_team);
+        }
+#endif
+
         return;
     }
 
     master_active = team->t.t_master_active;
 
 #if OMP_40_ENABLED
     if (!exit_teams)
 #endif /* OMP_40_ENABLED */
     {
         // AC: No barrier for internal teams at exit from teams construct.
         //     But there is barrier for external team (league).
         __kmp_internal_join( loc, gtid, team );
     }
     else {
         master_th->th.th_task_state = 0; // AC: no tasking in teams (out of any parallel)
     }
 
     KMP_MB();
 
+#if OMPT_SUPPORT
+    ompt_parallel_id_t parallel_id = team->t.ompt_team_info.parallel_id;
+#endif
+
 #if USE_ITT_BUILD
     if ( __itt_stack_caller_create_ptr ) {
         __kmp_itt_stack_caller_destroy( (__itt_caller)team->t.t_stack_id ); // destroy the stack stitching id after join barrier
     }
 
     // Mark end of "parallel" region for VTune. Only use one of frame notification scheme at the moment.
     if ( ( __itt_frame_end_v3_ptr && __kmp_forkjoin_frames && ! __kmp_forkjoin_frames_mode ) || KMP_ITT_DEBUG ) {
 # if OMP_40_ENABLED
if ( master_th->th.th_teams_microtask &&
                     KMP_DEBUG_ASSERT(balign[ b ].bb.wait_flag != KMP_BARRIER_PARENT_FLAG);
                 }
                 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) {
+            __kmp_join_ompt(master_th, parent_team, parallel_id);
+        }
+#endif
+
         return;
     }
 #endif /* OMP_40_ENABLED */
 
     /* do cleanup and restore the parent team */
     master_th->th.th_info .ds.ds_tid = team->t.t_master_tid;
     master_th->th.th_local.this_construct = team->t.t_master_this_cons;
 
#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) {
+        __kmp_join_ompt(master_th, parent_team, parallel_id);
+    }
+#endif
+
     KMP_MB();
     KA_TRACE( 20, ("__kmp_join_call: exit T#%d\n", gtid ));
 }
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 /* Check whether we should push an internal control record onto the
__kmp_initialize_root( kmp_root_t *root )
     root->r.r_active       = FALSE;
     root->r.r_in_parallel  = 0;
     root->r.r_blocktime    = __kmp_dflt_blocktime;
     root->r.r_nested       = __kmp_dflt_nested;
 
     /* setup the root team for this task */
     /* allocate the root team structure */
     KF_TRACE( 10, ( "__kmp_initialize_root: before root_team\n" ) );
+
     root_team =
         __kmp_allocate_team(
             root,
             1,                                                         // new_nproc
             1,                                                         // max_nproc
+#if OMPT_SUPPORT
+            0, // root parallel id
+#endif
 #if OMP_40_ENABLED
             __kmp_nested_proc_bind.bind_types[0],
 #endif
             &r_icvs,
             0                                                          // argc
             USE_NESTED_HOT_ARG(NULL)                                   // master thread is unknown
         );
 
#endif
     root_team->t.t_sched.r_sched_type = r_sched.r_sched_type;
     root_team->t.t_sched.chunk        = r_sched.chunk;
     KA_TRACE( 20, ("__kmp_initialize_root: init root team %d arrived: join=%u, plain=%u\n",
                     root_team->t.t_id, KMP_INIT_BARRIER_STATE, KMP_INIT_BARRIER_STATE ));
 
     /* setup the  hot team for this task */
     /* allocate the hot team structure */
     KF_TRACE( 10, ( "__kmp_initialize_root: before hot_team\n" ) );
+
     hot_team =
         __kmp_allocate_team(
             root,
             1,                                                         // new_nproc
             __kmp_dflt_team_nth_ub * 2,                                // max_nproc
+#if OMPT_SUPPORT
+            0, // root parallel id
+#endif
 #if OMP_40_ENABLED
             __kmp_nested_proc_bind.bind_types[0],
 #endif
             &r_icvs,
             0                                                          // argc
             USE_NESTED_HOT_ARG(NULL)                                   // master thread is unknown
         );
     KF_TRACE( 10, ( "__kmp_initialize_root: after hot_team = %p\n", hot_team ) );
if( root->r.r_uber_thread ) {
         #endif
         __kmp_init_random( root_thread );  // Initialize random number generator
     }
 
     /* setup the serial team held in reserve by the root thread */
     if( ! root_thread->th.th_serial_team ) {
         kmp_internal_control_t r_icvs = __kmp_get_global_icvs();
         KF_TRACE( 10, ( "__kmp_register_root: before serial_team\n" ) );
+
         root_thread->th.th_serial_team = __kmp_allocate_team( root, 1, 1,
+#if OMPT_SUPPORT
+          0, // root parallel id
+#endif
 #if OMP_40_ENABLED
           proc_bind_default,
 #endif
           &r_icvs,
           0 USE_NESTED_HOT_ARG(NULL) );
     }
     KMP_ASSERT( root_thread->th.th_serial_team );
     KF_TRACE( 10, ( "__kmp_register_root: after serial_team = %p\n",
#endif
     #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) &&
+        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 );
 
         // We canot put root thread to __kmp_thread_pool, so we have to reap it istead of freeing.
     root->r.r_uber_thread = NULL;
     /* mark root as no longer in use */
     root->r.r_begin = FALSE;
 
#endif
     if ( __kmp_storage_map ) {
         __kmp_print_thread_storage_map( new_thr, new_gtid );
     }
 
     /* add the reserve serialized team, initialized from the team's master thread */
     {
     kmp_internal_control_t r_icvs = __kmp_get_x_global_icvs( team );
     KF_TRACE( 10, ( "__kmp_allocate_thread: before th_serial/serial_team\n" ) );
+
     new_thr->th.th_serial_team = serial_team =
         (kmp_team_t*) __kmp_allocate_team( root, 1, 1,
+#if OMPT_SUPPORT
+                                           0, // root parallel id
+#endif
 #if OMP_40_ENABLED
                                            proc_bind_default,
 #endif
                                            &r_icvs,
                                            0 USE_NESTED_HOT_ARG(NULL) );
     }
     KMP_ASSERT ( serial_team );
     serial_team->t.t_serialized = 0;   // AC: the team created in reserve, not for execution (it is unused for now).
__kmp_partition_places( kmp_team_t *team )
     KA_TRACE( 20, ("__kmp_partition_places: exit T#%d\n", team->t.t_id ) );
 }
 
 #endif /* OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED */
 
 /* allocate a new team data structure to use.  take one off of the free pool if available */
 kmp_team_t *
 __kmp_allocate_team( kmp_root_t *root, int new_nproc, int max_nproc,
+#if OMPT_SUPPORT
+    ompt_parallel_id_t ompt_parallel_id,
+#endif
 #if OMP_40_ENABLED
     kmp_proc_bind_t new_proc_bind,
 #endif
     kmp_internal_control_t *new_icvs,
     int argc USE_NESTED_HOT_ARG(kmp_info_t *master) )
 {
     KMP_TIME_BLOCK(KMP_allocate_team);
     int f;

 
 #if KMP_DEBUG
         if ( __kmp_tasking_mode != tskm_immediate_exec ) {
             KA_TRACE( 20, ("__kmp_allocate_team: hot team task_team[0] = %p task_team[1] = %p after reinit\n",
                            team->t.t_task_team[0], team->t.t_task_team[1] ));
         }
 #endif
 
+#if OMPT_SUPPORT
+        __ompt_team_assign_id(team, ompt_parallel_id);
+#endif
+
         KMP_MB();
 
         return team;
     }
 
     /* next, let's try to take one from the team pool */
     KMP_MB();
     for( team = (kmp_team_t*) __kmp_team_pool ; (team) ; )
for( team = (kmp_team_t*) __kmp_team_pool ; (team) ; )
                 }
             }
 
 #if OMP_40_ENABLED
             team->t.t_proc_bind = new_proc_bind;
 #endif
 
             KA_TRACE( 20, ("__kmp_allocate_team: using team from pool %d.\n", team->t.t_id ));
+
+#if OMPT_SUPPORT
+            __ompt_team_assign_id(team, ompt_parallel_id);
+#endif
+
             KMP_MB();
 
             return team;
         }
 
         /* reap team if it is too small, then loop back and check the next one */
         /* not sure if this is wise, but, will be redone during the hot-teams rewrite. */
         /* TODO: Use technique to find the right size hot-team, don't reap them */
KA_TRACE( 20, ("__kmp_allocate_team: team %d init arrived: join=%u, plain=%u\n",
             team->t.t_bar[ b ].b_arrived        = KMP_INIT_BARRIER_STATE;
         }
     }
 
 #if OMP_40_ENABLED
     team->t.t_proc_bind = new_proc_bind;
 #endif
 
+#if OMPT_SUPPORT
+    __ompt_team_assign_id(team, ompt_parallel_id);
+    team->t.ompt_serialized_team_info = NULL;
+#endif
+
     KMP_MB();
 
     KA_TRACE( 20, ("__kmp_allocate_team: done creating a new team %d.\n", team->t.t_id ));
 
     return team;
 }
 
 /* TODO implement hot-teams at all levels */
/*    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) {
+        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)) {
+            __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) {
+            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) {
+            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) {
+                    this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
+                }
+#endif
+
                 KMP_STOP_EXPLICIT_TIMER(USER_launch_thread_loop);
                 {
                     KMP_TIME_BLOCK(USER_worker_invoke);
                     rc = (*pteam)->t.t_invoke( gtid );
                 }
                 KMP_START_EXPLICIT_TIMER(USER_launch_thread_loop);
                 KMP_ASSERT( rc );
 
+#if OMPT_SUPPORT
+                if (ompt_status & ompt_status_track) {
+                    /* 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) &&
+        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 );
     }
     /* run the destructors for the threadprivate data for this thread */
     __kmp_common_destroy_gtid( gtid );
 
     KA_TRACE( 10, ("__kmp_launch_thread: T#%d done\n", gtid ) );
     KMP_MB();
//                    KMP_ASSERT( ! KMP_UBER_GTID( i ) );         // AC: there can be uber threads alive here
         KA_TRACE( 10, ("__kmp_internal_end: monitor reaped\n" ) );
 
     } /* else !__kmp_global.t_active */
     TCW_4(__kmp_init_gtid, FALSE);
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
 
     __kmp_cleanup();
+#if OMPT_SUPPORT
+    ompt_fini();
+#endif
 }
 
 void
 __kmp_internal_end_library( int gtid_req )
 {
     int i;
 
     /* if we have already cleaned up, don't try again, it wouldn't be pretty */
#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();
+#endif
 }
 
 void
 __kmp_serial_initialize( void )
 {
     if ( __kmp_init_serial ) {
         return;
     }
__kmp_middle_initialize( void )
     }
     __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();
+#endif
 }
 
 void
 __kmp_parallel_initialize( void )
 {
     int gtid = __kmp_entry_gtid();      // this might be a new root
 
     /* syncronize parallel initialization (for sibling) */
#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();
+#endif
 }
 
 
 /* ------------------------------------------------------------------------ */
 
 void
 __kmp_run_before_invoked_task( int gtid, int tid, kmp_info_t *this_thr,
   kmp_team_t *team )

 #if USE_ITT_BUILD
     if ( __itt_stack_caller_create_ptr ) {
         __kmp_itt_stack_callee_enter( (__itt_caller)team->t.t_stack_id ); // inform ittnotify about entering user's code
     }
 #endif /* USE_ITT_BUILD */
 #if INCLUDE_SSC_MARKS
     SSC_MARK_INVOKING();
 #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) {
+        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) &&
+        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
+
     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 );
+      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)) {
+            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
 
 #if USE_ITT_BUILD
     if ( __itt_stack_caller_create_ptr ) {
         __kmp_itt_stack_callee_leave( (__itt_caller)team->t.t_stack_id ); // inform ittnotify about leaving user's code
     }
 #endif /* USE_ITT_BUILD */
     __kmp_run_after_invoked_task( gtid, tid, this_thr, team );
 
KA_TRACE( 20, ("__kmp_teams_master: T#%d, Tid %d, microtask %p\n",
                    gtid, __kmp_tid_from_gtid( gtid ), thr->th.th_teams_microtask ) );
     // Launch league of teams now, but not let workers execute
     // (they hang on fork barrier until next parallel)
 #if INCLUDE_SSC_MARKS
     SSC_MARK_FORKING();
 #endif
     __kmp_fork_call( loc, gtid, fork_context_intel,
             team->t.t_argc,
-            (microtask_t)thr->th.th_teams_microtask,
+#if OMPT_SUPPORT
+            (void *)thr->th.th_teams_microtask,      // "unwrapped" task
+#endif
+            (microtask_t)thr->th.th_teams_microtask, // "wrapped" task
             VOLATILE_CAST(launch_t) __kmp_invoke_task_func,
             NULL );
 #if INCLUDE_SSC_MARKS
     SSC_MARK_JOINING();
 #endif
     __kmp_join_call( loc, gtid, 1 ); // AC: last parameter "1" eliminates join barrier which won't work because
                                      // worker threads are in a fork barrier waiting for more parallel regions
 }

runtime/src/kmp_sched.cpp

 
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 #include "kmp_error.h"
 #include "kmp_stats.h"
 #include "kmp_itt.h"
 
+#if OMPT_SUPPORT
+#include "ompt-specific.h"
+#endif
+
 // template for type limits
 template< typename T >
 struct i_maxmin {
     static const T mx;
     static const T mn;
 };
 template<>
 struct i_maxmin< int > {
) {
     typedef typename traits_t< T >::signed_t    ST;
     /*  this all has to be changed back to TID and such.. */
     register kmp_int32   gtid = global_tid;
     register kmp_uint32  tid;
     register kmp_uint32  nth;
     register UT          trip_count;
     register kmp_team_t *team;
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
+    ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
+#endif
+
     KMP_DEBUG_ASSERT( plastiter && plower && pupper && pstride );
     KE_TRACE( 10, ("__kmpc_for_static_init called (%d)\n", global_tid));
     #ifdef KMP_DEBUG
     {
         const char * buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format(
             "__kmpc_for_static_init: T#%%d sched=%%d liter=%%d iter=(%%%s," \
upper=0,stride=1) - JPH June 23, 2009.
             buff = __kmp_str_format(
                 "__kmpc_for_static_init:(ZERO TRIP) liter=%%d lower=%%%s upper=%%%s stride = %%%s signed?<%s>, loc = %%s\n",
                 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) &&
+            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 OMP_40_ENABLED
     if ( schedtype > kmp_ord_upper ) {
         // we are in DISTRIBUTE construct
         schedtype += kmp_sch_static - kmp_distribute_static;      // AC: convert to usual schedule type
         tid  = __kmp_threads[ gtid ]->th.th_team->t.t_master_tid;
if ( team -> t.t_serialized ) {
             buff = __kmp_str_format(
                 "__kmpc_for_static_init: (serial) liter=%%d lower=%%%s upper=%%%s stride = %%%s\n",
                 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) &&
+            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;
     }
     nth = team->t.t_nproc;
     if ( nth == 1 ) {
         if( plastiter != NULL )
             *plastiter = TRUE;
         *pstride = (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
         #ifdef KMP_DEBUG
         {
             const char * buff;
             // create format specifiers before the debug output
             buff = __kmp_str_format(
                 "__kmpc_for_static_init: (serial) liter=%%d lower=%%%s upper=%%%s stride = %%%s\n",
                 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) &&
+            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;
     }
 
     /* compute trip count */
     if ( incr == 1 ) {
         trip_count = *pupper - *plower + 1;
     } else if (incr == -1) {
         trip_count = *plower - *pupper + 1;
#ifdef KMP_DEBUG
         buff = __kmp_str_format(
             "__kmpc_for_static_init: liter=%%d lower=%%%s upper=%%%s stride = %%%s signed?<%s>\n",
             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) &&
+        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;
 }
 
 template< typename T >
 static void
 __kmp_dist_for_static_init(
     ident_t                          *loc,
     kmp_int32                         gtid,

runtime/src/kmp_tasking.c

#endif /* BUILD_TIED_TASK_STACK */
     // GEH TODO: shouldn't we pass some sort of location identifier here?
     // 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) &&
+        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);
+    }
+#endif
+
     return;
 }
 
 
 //----------------------------------------------------------------------
 // __kmpc_omp_task_begin_if0: report that a given serialized task has started execution
 // loc_ref: source location information; points to beginning of task block.
 // gtid: global thread number.

 
 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) &&
+        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",
                   gtid, taskdata, resumed_task) );
 
     KMP_DEBUG_ASSERT( taskdata -> td_flags.tasktype == TASK_EXPLICIT );
 
     // Pop task from stack if tied
 #ifdef BUILD_TIED_TASK_STACK
     if ( taskdata -> td_flags.tiedness == TASK_TIED )
#endif // OMP_40_ENABLED
     }
     else {
         KMP_DEBUG_ASSERT( resumed_task != NULL );        // verify that resumed task is passed as arguemnt
     }
 
     // Free this task and then ancestor tasks if they have no children.
     __kmp_free_task_and_ancestors(gtid, taskdata, thread);
 
+    // FIXME johnmc: I this statement should be before the last one so if an
+    // asynchronous inquiry peers into the runtime system it doesn't see the freed
+    // task as the current task
     __kmp_threads[ gtid ] -> th.th_current_task = resumed_task; // restore current_task
 
     // TODO: GEH - make sure root team implicit task is initialized properly.
     // KMP_DEBUG_ASSERT( resumed_task->td_flags.executing == 0 );
     resumed_task->td_flags.executing = 1;  // resume previous task
 
     KA_TRACE(10, ("__kmp_task_finish(exit): T#%d finished task %p, resuming task %p\n",
                   gtid, taskdata, resumed_task) );
#if OMP_40_ENABLED
         task->td_taskgroup = NULL;           // An implicit task does not have taskgroup
 #endif
         __kmp_push_current_task_to_thread( this_thr, team, tid );
     } else {
         KMP_DEBUG_ASSERT(task->td_incomplete_child_tasks == 0);
         KMP_DEBUG_ASSERT(task->td_allocated_child_tasks  == 0);
     }
 
+#if OMPT_SUPPORT
+    __kmp_task_init_ompt(task, tid);
+#endif
+
     KF_TRACE(10, ("__kmp_init_implicit_task(exit): T#:%d team=%p task=%p\n",
                   tid, team, task ) );
 }
 
 // Round up a size to a power of two specified by val
 // Used to insert padding between structures co-allocated using a single malloc() call
 static size_t
 __kmp_round_up_to_val( size_t size, size_t val ) {
#endif
         if ( taskdata->td_parent->td_flags.tasktype == TASK_EXPLICIT ) {
             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) {
+        taskdata->ompt_task_info.task_id = __ompt_task_id_new(gtid);
+        taskdata->ompt_task_info.function = (void*) task_entry;
+        taskdata->ompt_task_info.frame = (ompt_frame_t)
+            { .exit_runtime_frame = NULL, .reenter_runtime_frame = NULL };
+    }
+#endif
+
     return task;
 }
 
 
 kmp_task_t *
 __kmpc_omp_task_alloc( ident_t *loc_ref, kmp_int32 gtid, kmp_int32 flags,
                        size_t sizeof_kmp_task_t, size_t sizeof_shareds,
                        kmp_routine_entry_t task_entry )

 #if OMP_40_ENABLED
     int discard = 0 /* false */;
 #endif
     KA_TRACE(30, ("__kmp_invoke_task(enter): T#%d invoking task %p, current_task=%p\n",
                   gtid, taskdata, current_task) );
 
     __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) {
+        // 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
+
 #if OMP_40_ENABLED
     // TODO: cancel tasks if the parallel region has also been cancelled
     // TODO: check if this sequence can be hoisted above __kmp_task_start
     // if cancellation has been enabled for this run ...
     if (__kmp_omp_cancellation) {
         kmp_info_t *this_thr = __kmp_threads [ gtid ];
         kmp_team_t * this_team = this_thr->th.th_team;
         kmp_taskgroup_t * taskgroup = taskdata->td_taskgroup;

 #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) {
+        thread->th.ompt_thread_info = oldInfo;
+        taskdata->ompt_task_info.frame.exit_runtime_frame = 0;
+    }
+#endif
+
     __kmp_task_finish( gtid, task, current_task );
 
     KA_TRACE(30, ("__kmp_inovke_task(exit): T#%d completed task %p, resuming task %p\n",
                   gtid, taskdata, current_task) );
     return;
 }
 
 //-----------------------------------------------------------------------

 //
 //    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) {
+        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 ( __kmp_push_task( gtid, new_task ) == TASK_NOT_PUSHED ) // if cannot defer
     {                                                           // 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) {
+        new_taskdata->ompt_task_info.frame.reenter_runtime_frame = 0;
+    }
+#endif
 
     return TASK_CURRENT_NOT_QUEUED;
 }
 
 //---------------------------------------------------------------------
 // __kmpc_omp_task: Wrapper around __kmp_omp_task to schedule a non-thread-switchable task from
 // the parent thread only!
 // loc_ref: location of original task pragma (ignored)

runtime/src/kmp_wait_release.h

static inline void __kmp_wait_template(kmp_info_t *this_thr, C *flag, int final_spin
     KMP_FSYNC_SPIN_INIT(spin, NULL);
     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
+    if (ompt_status == ompt_status_track_callback) {
+        if (this_thr->th.ompt_thread_info.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(this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier ||
+                             this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier_implicit ||
+                             this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier_explicit);
+
+            ompt_lw_taskteam_t* team = this_thr->th.th_team->t.ompt_serialized_team_info;
+            ompt_parallel_id_t pId;
+            ompt_task_id_t tId;
+            if (team){
+                pId = team->ompt_team_info.parallel_id;
+                tId = team->ompt_task_info.task_id;
+            } else {
+                pId = this_thr->th.th_team->t.ompt_team_info.parallel_id;
+                tId = this_thr->th.th_current_task->ompt_task_info.task_id;
+            }
+            ompt_callbacks.ompt_callback(ompt_event_wait_barrier_begin)(pId, tId);
+        }
+    }
+#endif
+
     // Setup for waiting
     KMP_INIT_YIELD(spins);
 
     if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
         // The worker threads cannot rely on the team struct existing at this point.
         // Use the bt values cached in the thread struct instead.
 #ifdef KMP_ADJUST_BLOCKTIME
         if (__kmp_zero_bt && !this_thr->th.th_team_bt_set)
while (flag->notdone_check()) {
 
         if (TCR_4(__kmp_global.g.g_done)) {
             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 (this_thr->th.ompt_thread_info.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(this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier ||
+                             this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier_implicit ||
+                             this_thr->th.ompt_thread_info.state == ompt_state_wait_barrier_explicit);
+
+            ompt_lw_taskteam_t* team = this_thr->th.th_team->t.ompt_serialized_team_info;
+            ompt_parallel_id_t pId;
+            ompt_task_id_t tId;
+            if (team){
+                pId = team->ompt_team_info.parallel_id;
+                tId = team->ompt_task_info.task_id;
+            } else {
+                pId = this_thr->th.th_team->t.ompt_team_info.parallel_id;
+                tId = this_thr->th.th_current_task->ompt_task_info.task_id;
+            }
+            ompt_callbacks.ompt_callback(ompt_event_wait_barrier_end)(pId, tId);
+        }
+    }
+#endif
+
     KMP_FSYNC_SPIN_ACQUIRED(spin);
 }
 
 /* Release any threads specified as waiting on the flag by releasing the flag and resume the waiting thread
    if indicated by the sleep bit(s). A thread that calls __kmp_wait_template must call this function to wake
    up the potentially sleeping thread and prevent deadlocks!  */
 template <class C>
 static inline void __kmp_release_template(C *flag)

runtime/src/z_Linux_asm.s

// mark_begin;
   movl %esp,%ebp    // establish the base pointer for this routine.
   KMP_CFI_REGISTER ebp
   subl $8,%esp    // allocate space for two local variables.
         // These varibales are:
         //  argv: -4(%ebp)
         //  temp: -8(%ebp)
         //
   pushl %ebx    // save %ebx to use during this routine
+        //
+#if OMPT_SUPPORT
+  movl 28(%ebp),%ebx  // get exit_frame address
+  movl %ebp,(%ebx)  // save exit_frame
+#endif
+
   movl 20(%ebp),%ebx  // Stack alignment - # args
   addl $2,%ebx    // #args +2  Always pass at least 2 args (gtid and tid)
   shll $2,%ebx    // Number of bytes used on stack: (#args+2)*4
   movl %esp,%eax    //
   subl %ebx,%eax    // %esp-((#args+2)*4) -> %eax -- without mods, stack ptr would be this
   movl %eax,%ebx    // Save to %ebx
   andl $0xFFFFFF80,%eax // mask off 7 bits
   subl %eax,%ebx    // Amount to subtract from %esp

 //  at call to pkfn must have %rsp 128-byte aligned for compiler
 //
 // parameters:
 //      %rdi:   pkfn
 //  %esi: gtid
 //  %edx: tid
 //  %ecx: argc
 //  %r8:  p_argv
+//  %r9:  &exit_frame
 //
 // locals:
 //  __gtid: gtid parm pushed on stack so can pass &gtid to pkfn
 //  __tid:  tid parm pushed on stack so can pass &tid to pkfn
 //
 // reg temps:
 //  %rax: used all over the place
 //  %rdx: used in stack pointer alignment calculation
// mark_begin;
         .text
   PROC  __kmp_invoke_microtask
 
   pushq   %rbp    // save base pointer
   KMP_CFI_DEF_OFFSET 16
   KMP_CFI_OFFSET rbp,-16
   movq  %rsp,%rbp // establish the base pointer for this routine.
   KMP_CFI_REGISTER rbp
+
+#if OMPT_SUPPORT
+  movq  %rbp, (%r9) // save exit_frame
+#endif
+
   pushq   %rbx    // %rbx is callee-saved register
   pushq %rsi    // Put gtid on stack so can pass &tgid to pkfn
   pushq %rdx    // Put tid on stack so can pass &tid to pkfn
 
   movq  %rcx, %rax  // Stack alignment calculation begins; argc -> %rax
   movq  $0, %rbx  // constant for cmovs later
   subq  $4, %rax  // subtract four args passed in registers to pkfn
 #if __MIC__ || __MIC2__

runtime/src/z_Windows_NT-586_asm.asm

 PUBLIC  ___kmp_invoke_microtask
 _TEXT   SEGMENT
         ALIGN 16
 _pkfn$ = 8
 _gtid$ = 12
 _tid$ = 16
 _argc$ = 20
 _argv$ = 24
+if OMPT_SUPPORT
+_exit_frame$ = 28
+endif
 _i$ = -8
 _stk_adj$ = -16
 _vptr$ = -12
 _qptr$ = -4
 
 ___kmp_invoke_microtask PROC NEAR
 ; Line 102
         push    ebp
         mov     ebp, esp
         sub     esp, 16                                 ; 00000010H
         push    ebx
         push    esi
         push    edi
+if OMPT_SUPPORT
+        mov     eax, DWORD PTR _exit_frame$[ebp]
+        mov     DWORD PTR [eax], ebp
+endif
 ; Line 114
         mov     eax, DWORD PTR _argc$[ebp]
         mov     DWORD PTR _i$[ebp], eax
 
 ;; ------------------------------------------------------------
   lea     edx, DWORD PTR [eax*4+8]
   mov     ecx, esp                                ; Save current SP into ECX
   mov eax,edx   ; Save the size of the args in eax

 ; return:      eax    (always 1/TRUE)
 ;
 
 $_pkfn   = 16
 $_gtid   = 24
 $_tid    = 32
 $_argc   = 40
 $_p_argv = 48
+if OMPT_SUPPORT
+$_exit_frame = 56
+endif
 
 PUBLIC  __kmp_invoke_microtask
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_invoke_microtask PROC FRAME ;NEAR
   mov  QWORD PTR 16[rsp], rdx  ; home gtid parameter
   mov   QWORD PTR 24[rsp], r8  ; home tid parameter
         push    rbp   ; save base pointer
         .pushreg rbp
   sub rsp, 0    ; no fixed allocation necessary - end prolog
 
         lea     rbp, QWORD PTR [rsp]     ; establish the base pointer
         .setframe rbp, 0
         .ENDPROLOG
+if OMPT_SUPPORT
+        mov     rax, QWORD PTR $_exit_frame[rbp]
+        mov     QWORD PTR [rax], rbp
+endif
   mov r10, rcx  ; save pkfn pointer for later
 
 ;; ------------------------------------------------------------
         mov     rax, r9   ; rax <= argc
         cmp     rax, 2
         jge     SHORT $_kmp_invoke_stack_align
         mov     rax, 2          ; set 4 homes if less than 2 parms
 $_kmp_invoke_stack_align: