[OMPT] Rename ompt_wait_id to omp_wait_id

[protze.joachim]

Summary

Similar as in D43568, this patch renames ompt_wait_id* to omp_wait_id*. This renaming was introduced in OpenMP TR6.

Since this patch might bring similar trouble to tool writers as D43568, I would submit both patches at the same time.

[Hahnfeld]

Sounds good if that's the direction of the spec. It was clear that the implementation of OMPT might change based on newer Technical Reports.

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

290 ↗

(On Diff #145481)

You should add another space before /* here and in many more places below

openmp/trunk/runtime/src/include/50/ompt.h.var

 
 typedef union ompt_data_t {
   uint64_t value; /* data initialized by runtime to unique id */
   void *ptr;      /* pointer under tool control */
 } ompt_data_t;
 
 static const ompt_data_t ompt_data_none = {0};
 
-typedef uint64_t ompt_wait_id_t;
-static const ompt_wait_id_t ompt_wait_id_none = 0;
+typedef uint64_t omp_wait_id_t;
+static const omp_wait_id_t omp_wait_id_none = 0;
 
 typedef void ompt_device_t;
 
 /*---------------------
  * omp_frame_t
  *---------------------*/
 
 typedef struct omp_frame_t {
typedef void (*ompt_callback_thread_begin_t) (
     ompt_data_t *thread_data              /* data of thread                      */
 );
 
 typedef void (*ompt_callback_thread_end_t) (
     ompt_data_t *thread_data              /* data of thread                      */
 );
 
 typedef void (*ompt_wait_callback_t) (
-    ompt_wait_id_t wait_id                /* wait data                           */
+    omp_wait_id_t wait_id                /* wait data                           */
 );
 
 /* parallel and workshares */
 typedef enum ompt_scope_endpoint_t {
     ompt_scope_begin = 1,
     ompt_scope_end   = 2
 } ompt_scope_endpoint_t;
 
typedef enum ompt_mutex_kind_t {
     ompt_mutex_atomic    = 0x14,
     ompt_mutex_ordered   = 0x20
 } ompt_mutex_kind_t;
 
 typedef void (*ompt_callback_mutex_acquire_t) (
     ompt_mutex_kind_t kind,               /* mutex kind                          */
     unsigned int hint,                    /* mutex hint                          */
     unsigned int impl,                    /* mutex implementation                */
-    ompt_wait_id_t wait_id,               /* id of object being awaited          */
+    omp_wait_id_t wait_id,               /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_mutex_t) (
     ompt_mutex_kind_t kind,               /* mutex kind                          */
-    ompt_wait_id_t wait_id,               /* id of object being awaited          */
+    omp_wait_id_t wait_id,               /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_nest_lock_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of nested lock             */
-    ompt_wait_id_t wait_id,               /* id of object being awaited          */
+    omp_wait_id_t wait_id,               /* id of object being awaited          */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_master_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of master region           */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of task                        */
     const void *codeptr_ra                /* return address of runtime call      */

 
 
 /****************************************************************************
  * INQUIRY FUNCTIONS
  ***************************************************************************/
 
 /* state */
 OMPT_API_FUNCTION(omp_state_t, ompt_get_state, (
-    ompt_wait_id_t *wait_id
+    omp_wait_id_t *wait_id
 ));
 
 /* thread */
 OMPT_API_FUNCTION(ompt_data_t*, ompt_get_thread_data, (void));
 
 /* parallel region */
 OMPT_API_FUNCTION(int, ompt_get_parallel_info, (
     int ancestor_level,

openmp/trunk/runtime/src/kmp_atomic.h

 // 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_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
-        ompt_mutex_atomic, 0, kmp_mutex_impl_queuing, (ompt_wait_id_t)lck,
+        ompt_mutex_atomic, 0, kmp_mutex_impl_queuing, (omp_wait_id_t)lck,
         OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 
   __kmp_acquire_queuing_lock(lck, gtid);
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-        ompt_mutex_atomic, (ompt_wait_id_t)lck, OMPT_GET_RETURN_ADDRESS(0));
+        ompt_mutex_atomic, (omp_wait_id_t)lck, OMPT_GET_RETURN_ADDRESS(0));
   }
 #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_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-        ompt_mutex_atomic, (ompt_wait_id_t)lck, OMPT_GET_RETURN_ADDRESS(0));
+        ompt_mutex_atomic, (omp_wait_id_t)lck, OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 }
 
 static inline void __kmp_init_atomic_lock(kmp_atomic_lock_t *lck) {
   __kmp_init_queuing_lock(lck);
 }
 

openmp/trunk/runtime/src/kmp_csupport.cpp

#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_OPTIONAL
   kmp_team_t *team;
-  ompt_wait_id_t lck;
+  omp_wait_id_t lck;
   void *codeptr_ra;
   if (ompt_enabled.enabled) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
     team = __kmp_team_from_gtid(gtid);
-    lck = (ompt_wait_id_t)&team->t.t_ordered.dt.t_value;
+    lck = (omp_wait_id_t)&team->t.t_ordered.dt.t_value;
     /* OMPT state update */
     th->th.ompt_thread_info.wait_id = lck;
     th->th.ompt_thread_info.state = omp_state_wait_ordered;
 
     /* OMPT event callback */
     codeptr_ra = OMPT_LOAD_RETURN_ADDRESS(gtid);
     if (ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_ordered, omp_lock_hint_none, kmp_mutex_impl_spin,
-          (ompt_wait_id_t)lck, codeptr_ra);
+          (omp_wait_id_t)lck, codeptr_ra);
     }
   }
 #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_OPTIONAL
   if (ompt_enabled.enabled) {
     /* OMPT state update */
     th->th.ompt_thread_info.state = omp_state_work_parallel;
     th->th.ompt_thread_info.wait_id = 0;
 
     /* OMPT event callback */
     if (ompt_enabled.ompt_callback_mutex_acquired) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-          ompt_mutex_ordered, (ompt_wait_id_t)lck, codeptr_ra);
+          ompt_mutex_ordered, (omp_wait_id_t)lck, codeptr_ra);
     }
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_ordered_start(gtid);
 #endif /* USE_ITT_BUILD */
 }
#endif /* USE_ITT_BUILD */
   else
     __kmp_parallel_dxo(&gtid, &cid, loc);
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
         ompt_mutex_ordered,
-        (ompt_wait_id_t)&__kmp_team_from_gtid(gtid)->t.t_ordered.dt.t_value,
+        (omp_wait_id_t)&__kmp_team_from_gtid(gtid)->t.t_ordered.dt.t_value,
         OMPT_LOAD_RETURN_ADDRESS(gtid));
   }
 #endif
 }
 
 #if KMP_USE_DYNAMIC_LOCK
 
 static __forceinline void

 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
   void *codeptr_ra = NULL;
   if (ompt_enabled.enabled) {
     ti = __kmp_threads[global_tid]->th.ompt_thread_info;
     /* OMPT state update */
     prev_state = ti.state;
-    ti.wait_id = (ompt_wait_id_t)lck;
+    ti.wait_id = (omp_wait_id_t)lck;
     ti.state = omp_state_wait_critical;
 
     /* OMPT event callback */
     codeptr_ra = OMPT_LOAD_RETURN_ADDRESS(gtid);
     if (ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_critical, omp_lock_hint_none, __ompt_get_mutex_impl_type(),
-          (ompt_wait_id_t)crit, codeptr_ra);
+          (omp_wait_id_t)crit, codeptr_ra);
     }
   }
 #endif
   // Value of 'crit' should be good for using as a critical_id of the critical
   // section directive.
   __kmp_acquire_user_lock_with_checks(lck, global_tid);
 
 #if USE_ITT_BUILD
   __kmp_itt_critical_acquired(lck);
 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     /* OMPT state update */
     ti.state = prev_state;
     ti.wait_id = 0;
 
     /* OMPT event callback */
     if (ompt_enabled.ompt_callback_mutex_acquired) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-          ompt_mutex_critical, (ompt_wait_id_t)crit, codeptr_ra);
+          ompt_mutex_critical, (omp_wait_id_t)crit, codeptr_ra);
     }
   }
 #endif
 
   KMP_START_EXPLICIT_TIMER(OMP_critical);
   KA_TRACE(15, ("__kmpc_critical: done T#%d\n", global_tid));
 #endif // KMP_USE_DYNAMIC_LOCK
 }

 #if USE_ITT_BUILD
     __kmp_itt_critical_acquiring(lck);
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ti = __kmp_threads[global_tid]->th.ompt_thread_info;
       /* OMPT state update */
       prev_state = ti.state;
-      ti.wait_id = (ompt_wait_id_t)lck;
+      ti.wait_id = (omp_wait_id_t)lck;
       ti.state = omp_state_wait_critical;
 
       /* OMPT event callback */
       if (ompt_enabled.ompt_callback_mutex_acquire) {
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
             ompt_mutex_critical, (unsigned int)hint,
-            __ompt_get_mutex_impl_type(crit), (ompt_wait_id_t)crit, codeptr);
+            __ompt_get_mutex_impl_type(crit), (omp_wait_id_t)crit, codeptr);
       }
     }
 #endif
 #if KMP_USE_INLINED_TAS
     if (__kmp_user_lock_seq == lockseq_tas && !__kmp_env_consistency_check) {
       KMP_ACQUIRE_TAS_LOCK(lck, global_tid);
     } else
 #elif KMP_USE_INLINED_FUTEX

 #if USE_ITT_BUILD
     __kmp_itt_critical_acquiring(lck);
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ti = __kmp_threads[global_tid]->th.ompt_thread_info;
       /* OMPT state update */
       prev_state = ti.state;
-      ti.wait_id = (ompt_wait_id_t)lck;
+      ti.wait_id = (omp_wait_id_t)lck;
       ti.state = omp_state_wait_critical;
 
       /* OMPT event callback */
       if (ompt_enabled.ompt_callback_mutex_acquire) {
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
             ompt_mutex_critical, (unsigned int)hint,
-            __ompt_get_mutex_impl_type(0, ilk), (ompt_wait_id_t)crit, codeptr);
+            __ompt_get_mutex_impl_type(0, ilk), (omp_wait_id_t)crit, codeptr);
       }
     }
 #endif
     KMP_I_LOCK_FUNC(ilk, set)(lck, global_tid);
   }
 
 #if USE_ITT_BUILD
   __kmp_itt_critical_acquired(lck);
 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     /* OMPT state update */
     ti.state = prev_state;
     ti.wait_id = 0;
 
     /* OMPT event callback */
     if (ompt_enabled.ompt_callback_mutex_acquired) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-          ompt_mutex_critical, (ompt_wait_id_t)crit, codeptr);
+          ompt_mutex_critical, (omp_wait_id_t)crit, codeptr);
     }
   }
 #endif
 
   KMP_PUSH_PARTITIONED_TIMER(OMP_critical);
   KA_TRACE(15, ("__kmpc_critical: done T#%d\n", global_tid));
 } // __kmpc_critical_with_hint
 

 #endif // KMP_USE_DYNAMIC_LOCK
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   /* OMPT release event triggers after lock is released; place here to trigger
    * for all #if branches */
   OMPT_STORE_RETURN_ADDRESS(global_tid);
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-        ompt_mutex_critical, (ompt_wait_id_t)crit, OMPT_LOAD_RETURN_ADDRESS(0));
+        ompt_mutex_critical, (omp_wait_id_t)crit, OMPT_LOAD_RETURN_ADDRESS(0));
   }
 #endif
 
   KMP_POP_PARTITIONED_TIMER();
   KA_TRACE(15, ("__kmpc_end_critical: done T#%d\n", global_tid));
 }
 
 /*!

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_lock, (omp_lock_hint_t)hint,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 }
 
 /* initialize the lock with a hint */
 void __kmpc_init_nest_lock_with_hint(ident_t *loc, kmp_int32 gtid,
                                      void **user_lock, uintptr_t hint) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
   if (__kmp_env_consistency_check && user_lock == NULL) {
     KMP_FATAL(LockIsUninitialized, "omp_init_nest_lock_with_hint");
   }
 
   __kmp_init_nest_lock_with_hint(loc, user_lock, __kmp_map_hint_to_lock(hint));
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_nest_lock, (omp_lock_hint_t)hint,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 }
 
 #endif // KMP_USE_DYNAMIC_LOCK
 
 /* initialize the lock */

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_lock, omp_lock_hint_none,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   static char const *const func = "omp_init_lock";
   kmp_user_lock_p lck;

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_lock, omp_lock_hint_none, __ompt_get_mutex_impl_type(),
-        (ompt_wait_id_t)user_lock, codeptr);
+        (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_creating(lck);
 #endif /* USE_ITT_BUILD */
 
 #endif // KMP_USE_DYNAMIC_LOCK

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_nest_lock, omp_lock_hint_none,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   static char const *const func = "omp_init_nest_lock";
   kmp_user_lock_p lck;

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_init) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_init)(
         ompt_mutex_nest_lock, omp_lock_hint_none, __ompt_get_mutex_impl_type(),
-        (ompt_wait_id_t)user_lock, codeptr);
+        (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_creating(lck);
 #endif /* USE_ITT_BUILD */
 
 #endif // KMP_USE_DYNAMIC_LOCK
#if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_lock_destroy) {
     kmp_user_lock_p lck;
     if (KMP_EXTRACT_D_TAG(user_lock) == 0) {
       lck = ((kmp_indirect_lock_t *)KMP_LOOKUP_I_LOCK(user_lock))->lock;
     } else {
       lck = (kmp_user_lock_p)user_lock;
     }
     ompt_callbacks.ompt_callback(ompt_callback_lock_destroy)(
-        ompt_mutex_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
   KMP_D_LOCK_FUNC(user_lock, destroy)((kmp_dyna_lock_t *)user_lock);
 #else
   kmp_user_lock_p lck;
 
   if ((__kmp_user_lock_kind == lk_tas) &&
       (sizeof(lck->tas.lk.poll) <= OMP_LOCK_T_SIZE)) {

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_destroy) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_destroy)(
-        ompt_mutex_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_destroyed(lck);
 #endif /* USE_ITT_BUILD */
   DESTROY_LOCK(lck);
 

 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_destroy) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_destroy)(
-        ompt_mutex_nest_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_nest_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
   KMP_D_LOCK_FUNC(user_lock, destroy)((kmp_dyna_lock_t *)user_lock);
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   kmp_user_lock_p lck;
 

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_lock_destroy) {
     ompt_callbacks.ompt_callback(ompt_callback_lock_destroy)(
-        ompt_mutex_nest_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_nest_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_destroyed(lck);
 #endif /* USE_ITT_BUILD */
 
   DESTROY_NESTED_LOCK(lck);

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
         ompt_mutex_lock, omp_lock_hint_none,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 #if KMP_USE_INLINED_TAS
   if (tag == locktag_tas && !__kmp_env_consistency_check) {
     KMP_ACQUIRE_TAS_LOCK(user_lock, gtid);
   } else
 #elif KMP_USE_INLINED_FUTEX
   if (tag == locktag_futex && !__kmp_env_consistency_check) {
     KMP_ACQUIRE_FUTEX_LOCK(user_lock, gtid);
   } else
 #endif
   {
     __kmp_direct_set[tag]((kmp_dyna_lock_t *)user_lock, gtid);
   }
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-        ompt_mutex_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   kmp_user_lock_p lck;
 
   if ((__kmp_user_lock_kind == lk_tas) &&

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
         ompt_mutex_lock, omp_lock_hint_none, __ompt_get_mutex_impl_type(),
-        (ompt_wait_id_t)lck, codeptr);
+        (omp_wait_id_t)lck, codeptr);
   }
 #endif
 
   ACQUIRE_LOCK(lck, gtid);
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired(lck);
 #endif /* USE_ITT_BUILD */
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-        ompt_mutex_lock, (ompt_wait_id_t)lck, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)lck, codeptr);
   }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 void __kmpc_set_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
 #if KMP_USE_DYNAMIC_LOCK
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquiring((kmp_user_lock_p)user_lock);
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_nest_lock, omp_lock_hint_none,
-          __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+          __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
           codeptr);
     }
   }
 #endif
   int acquire_status =
       KMP_D_LOCK_FUNC(user_lock, set)((kmp_dyna_lock_t *)user_lock, gtid);
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
 #endif
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {
         // lock_first
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)user_lock, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)user_lock, codeptr);
       }
     } else {
       if (ompt_enabled.ompt_callback_nest_lock) {
         // lock_next
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-            ompt_scope_begin, (ompt_wait_id_t)user_lock, codeptr);
+            ompt_scope_begin, (omp_wait_id_t)user_lock, codeptr);
       }
     }
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
   int acquire_status;
   kmp_user_lock_p lck;
#if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_nest_lock, omp_lock_hint_none,
-          __ompt_get_mutex_impl_type(), (ompt_wait_id_t)lck, codeptr);
+          __ompt_get_mutex_impl_type(), (omp_wait_id_t)lck, codeptr);
     }
   }
 #endif
 
   ACQUIRE_NESTED_LOCK(lck, gtid, &acquire_status);
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired(lck);
 #endif /* USE_ITT_BUILD */
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {
         // lock_first
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)lck, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)lck, codeptr);
       }
     } else {
       if (ompt_enabled.ompt_callback_nest_lock) {
         // lock_next
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-            ompt_scope_begin, (ompt_wait_id_t)lck, codeptr);
+            ompt_scope_begin, (omp_wait_id_t)lck, codeptr);
       }
     }
   }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-        ompt_mutex_lock, (ompt_wait_id_t)user_lock, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)user_lock, codeptr);
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   kmp_user_lock_p lck;
 
   /* Can't use serial interval since not block structured */

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     // This is the case, if called from omp_init_lock_with_hint:
     void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
     if (!codeptr)
       codeptr = OMPT_GET_RETURN_ADDRESS(0);
     if (ompt_enabled.ompt_callback_mutex_released) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-          ompt_mutex_lock, (ompt_wait_id_t)lck, codeptr);
+          ompt_mutex_lock, (omp_wait_id_t)lck, codeptr);
     }
 #endif
 
     return;
 #else
     lck = (kmp_user_lock_p)user_lock;
 #endif
   }

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-        ompt_mutex_lock, (ompt_wait_id_t)lck, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)lck, codeptr);
   }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 /* release the lock */
 void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
#if OMPT_SUPPORT && OMPT_OPTIONAL
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (release_status == KMP_LOCK_RELEASED) {
       if (ompt_enabled.ompt_callback_mutex_released) {
         // release_lock_last
         ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)user_lock, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)user_lock, codeptr);
       }
     } else if (ompt_enabled.ompt_callback_nest_lock) {
       // release_lock_prev
       ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-          ompt_scope_end, (ompt_wait_id_t)user_lock, codeptr);
+          ompt_scope_end, (omp_wait_id_t)user_lock, codeptr);
     }
   }
 #endif
 
 #else // KMP_USE_DYNAMIC_LOCK
 
   kmp_user_lock_p lck;
 
#if OMPT_SUPPORT && OMPT_OPTIONAL
     void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
     if (!codeptr)
       codeptr = OMPT_GET_RETURN_ADDRESS(0);
     if (ompt_enabled.enabled) {
       if (release_status == KMP_LOCK_RELEASED) {
         if (ompt_enabled.ompt_callback_mutex_released) {
           // release_lock_last
           ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-              ompt_mutex_nest_lock, (ompt_wait_id_t)lck, codeptr);
+              ompt_mutex_nest_lock, (omp_wait_id_t)lck, codeptr);
         }
       } else if (ompt_enabled.ompt_callback_nest_lock) {
         // release_lock_previous
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-            ompt_mutex_scope_end, (ompt_wait_id_t)lck, codeptr);
+            ompt_mutex_scope_end, (omp_wait_id_t)lck, codeptr);
       }
     }
 #endif
 
     return;
 #else
     lck = (kmp_user_lock_p)user_lock;
 #endif
#if OMPT_SUPPORT && OMPT_OPTIONAL
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (release_status == KMP_LOCK_RELEASED) {
       if (ompt_enabled.ompt_callback_mutex_released) {
         // release_lock_last
         ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)lck, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)lck, codeptr);
       }
     } else if (ompt_enabled.ompt_callback_nest_lock) {
       // release_lock_previous
       ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-          ompt_mutex_scope_end, (ompt_wait_id_t)lck, codeptr);
+          ompt_mutex_scope_end, (omp_wait_id_t)lck, codeptr);
     }
   }
 #endif
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 /* try to acquire the lock */

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
         ompt_mutex_lock, omp_lock_hint_none,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
 #if KMP_USE_INLINED_TAS
   if (tag == locktag_tas && !__kmp_env_consistency_check) {
     KMP_TEST_TAS_LOCK(user_lock, gtid, rc);
   } else
 #elif KMP_USE_INLINED_FUTEX
   if (tag == locktag_futex && !__kmp_env_consistency_check) {
     KMP_TEST_FUTEX_LOCK(user_lock, gtid, rc);
   } else
 #endif
   {
     rc = __kmp_direct_test[tag]((kmp_dyna_lock_t *)user_lock, gtid);
   }
   if (rc) {
 #if USE_ITT_BUILD
     __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.ompt_callback_mutex_acquired) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-          ompt_mutex_lock, (ompt_wait_id_t)user_lock, codeptr);
+          ompt_mutex_lock, (omp_wait_id_t)user_lock, codeptr);
     }
 #endif
     return FTN_TRUE;
   } else {
 #if USE_ITT_BUILD
     __kmp_itt_lock_cancelled((kmp_user_lock_p)user_lock);
 #endif
     return FTN_FALSE;

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
         ompt_mutex_lock, omp_lock_hint_none, __ompt_get_mutex_impl_type(),
-        (ompt_wait_id_t)lck, codeptr);
+        (omp_wait_id_t)lck, codeptr);
   }
 #endif
 
   rc = TEST_LOCK(lck, gtid);
 #if USE_ITT_BUILD
   if (rc) {
     __kmp_itt_lock_acquired(lck);
   } else {
     __kmp_itt_lock_cancelled(lck);
   }
 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (rc && ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-        ompt_mutex_lock, (ompt_wait_id_t)lck, codeptr);
+        ompt_mutex_lock, (omp_wait_id_t)lck, codeptr);
   }
 #endif
 
   return (rc ? FTN_TRUE : FTN_FALSE);
 
 /* Can't use serial interval since not block structured */
 
 #endif // KMP_USE_DYNAMIC_LOCK

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
         ompt_mutex_nest_lock, omp_lock_hint_none,
-        __ompt_get_mutex_impl_type(user_lock), (ompt_wait_id_t)user_lock,
+        __ompt_get_mutex_impl_type(user_lock), (omp_wait_id_t)user_lock,
         codeptr);
   }
 #endif
   rc = KMP_D_LOCK_FUNC(user_lock, test)((kmp_dyna_lock_t *)user_lock, gtid);
 #if USE_ITT_BUILD
   if (rc) {
     __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
   } else {
     __kmp_itt_lock_cancelled((kmp_user_lock_p)user_lock);
   }
 #endif
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled && rc) {
     if (rc == 1) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {
         // lock_first
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)user_lock, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)user_lock, codeptr);
       }
     } else {
       if (ompt_enabled.ompt_callback_nest_lock) {
         // lock_next
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-            ompt_scope_begin, (ompt_wait_id_t)user_lock, codeptr);
+            ompt_scope_begin, (omp_wait_id_t)user_lock, codeptr);
       }
     }
   }
 #endif
   return rc;
 
 #else // KMP_USE_DYNAMIC_LOCK
 
#if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) &&
         ompt_enabled.ompt_callback_mutex_acquire) {
       ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
           ompt_mutex_nest_lock, omp_lock_hint_none,
-          __ompt_get_mutex_impl_type(), (ompt_wait_id_t)lck, codeptr);
+          __ompt_get_mutex_impl_type(), (omp_wait_id_t)lck, codeptr);
     }
 #endif
 
   rc = TEST_NESTED_LOCK(lck, gtid);
 #if USE_ITT_BUILD
   if (rc) {
     __kmp_itt_lock_acquired(lck);
   } else {
     __kmp_itt_lock_cancelled(lck);
   }
 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled && rc) {
     if (rc == 1) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {
         // lock_first
         ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-            ompt_mutex_nest_lock, (ompt_wait_id_t)lck, codeptr);
+            ompt_mutex_nest_lock, (omp_wait_id_t)lck, codeptr);
       }
     } else {
       if (ompt_enabled.ompt_callback_nest_lock) {
         // lock_next
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
-            ompt_mutex_scope_begin, (ompt_wait_id_t)lck, codeptr);
+            ompt_mutex_scope_begin, (omp_wait_id_t)lck, codeptr);
       }
     }
   }
 #endif
   return rc;
 
 /* Can't use serial interval since not block structured */
 

openmp/trunk/runtime/src/ompt-general.cpp

 
 OMPT_API_ROUTINE int ompt_get_parallel_info(int ancestor_level,
                                             ompt_data_t **parallel_data,
                                             int *team_size) {
   return __ompt_get_parallel_info_internal(ancestor_level, parallel_data,
                                            team_size);
 }
 
-OMPT_API_ROUTINE omp_state_t ompt_get_state(ompt_wait_id_t *wait_id) {
+OMPT_API_ROUTINE omp_state_t ompt_get_state(omp_wait_id_t *wait_id) {
   omp_state_t thread_state = __ompt_get_state_internal(wait_id);
 
   if (thread_state == omp_state_undefined) {
     thread_state = omp_state_work_serial;
   }
 
   return thread_state;
 }

openmp/trunk/runtime/src/ompt-internal.h

 } ompt_lw_taskteam_t;
 
 typedef struct {
   ompt_data_t thread_data;
   ompt_data_t task_data; /* stored here from implicit barrier-begin until
                             implicit-task-end */
   void *return_address; /* stored here on entry of runtime */
   omp_state_t state;
-  ompt_wait_id_t wait_id;
+  omp_wait_id_t wait_id;
   int ompt_task_yielded;
   void *idle_frame;
 } ompt_thread_info_t;
 
 extern ompt_callbacks_internal_t ompt_callbacks;
 
 #if OMP_40_ENABLED && OMPT_SUPPORT && OMPT_OPTIONAL
 #if USE_FAST_MEMORY

openmp/trunk/runtime/src/ompt-specific.cpp

 
 //----------------------------------------------------------
 // state support
 //----------------------------------------------------------
 
 void __ompt_thread_assign_wait_id(void *variable) {
   kmp_info_t *ti = ompt_get_thread();
 
-  ti->th.ompt_thread_info.wait_id = (ompt_wait_id_t)variable;
+  ti->th.ompt_thread_info.wait_id = (omp_wait_id_t)variable;
 }
 
-omp_state_t __ompt_get_state_internal(ompt_wait_id_t *ompt_wait_id) {
+omp_state_t __ompt_get_state_internal(omp_wait_id_t *omp_wait_id) {
   kmp_info_t *ti = ompt_get_thread();
 
   if (ti) {
-    if (ompt_wait_id)
-      *ompt_wait_id = ti->th.ompt_thread_info.wait_id;
+    if (omp_wait_id)
+      *omp_wait_id = ti->th.ompt_thread_info.wait_id;
     return ti->th.ompt_thread_info.state;
   }
   return omp_state_undefined;
 }
 
 //----------------------------------------------------------
 // parallel region support
 //----------------------------------------------------------

openmp/trunk/runtime/test/ompt/callback.h

#define print_fuzzy_address_blocks(addr) \
   ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES - 1, \
   ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES, addr)
 
 static void
 on_ompt_callback_mutex_acquire(
   ompt_mutex_kind_t kind,
   unsigned int hint,
   unsigned int impl,
-  ompt_wait_id_t wait_id,
+  omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_wait_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
switch(kind)
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_mutex_acquired(
   ompt_mutex_kind_t kind,
-  ompt_wait_id_t wait_id,
+  omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_acquired_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
switch(kind)
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_mutex_released(
   ompt_mutex_kind_t kind,
-  ompt_wait_id_t wait_id,
+  omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_release_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
switch(kind)
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_nest_lock(
     ompt_scope_endpoint_t endpoint,
-    ompt_wait_id_t wait_id,
+    omp_wait_id_t wait_id,
     const void *codeptr_ra)
 {
   switch(endpoint)
   {
     case ompt_scope_begin:
       printf("%" PRIu64 ": ompt_event_acquired_nest_lock_next: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_scope_end:
on_ompt_callback_implicit_task(
   }
 }
 
 static void
 on_ompt_callback_lock_init(
   ompt_mutex_kind_t kind,
   unsigned int hint,
   unsigned int impl,
-  ompt_wait_id_t wait_id,
+  omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_init_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
       break;
     case ompt_mutex_nest_lock:
       printf("%" PRIu64 ": ompt_event_init_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
       break;
     default:
       break;
   }
 }
 
 static void
 on_ompt_callback_lock_destroy(
   ompt_mutex_kind_t kind,
-  ompt_wait_id_t wait_id,
+  omp_wait_id_t wait_id,
   const void *codeptr_ra)
 {
   switch(kind)
   {
     case ompt_mutex_lock:
       printf("%" PRIu64 ": ompt_event_destroy_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra);
       break;
     case ompt_mutex_nest_lock: