Add OMPT events for API locking

[tcramer]

Summary

This fix implements the following OMPT events for the API locking routines:

• ompt_event_acquired_lock
• ompt_event_acquired_nest_lock_first
• ompt_event_acquired_nest_lock_next
• ompt_event_init_lock
• ompt_event_init_nest_lock
• ompt_event_destroy_lock
• ompt_event_destroy_nest_lock

For the acquired events the depths of the locks ist required, so a return value was added similiar to the return values we already have for the release lock routines.

[jmellorcrummey]

The lock init and acquired callbacks are conditionally included according to #if OMPT_SUPPORT && OMPT_BLAME

The proper condition should be #if OMPT_SUPPORT && OMPT_TRACE

I notice that there aren't any patches to kmp_gsupport.c. I looked in that file and didn't see any support for locking. What will happen when using gcc with this support? Will the instrumented locking routines be called to generate the promised callbacks?

[jcownie]

I notice that there aren't any patches to kmp_gsupport.c. I looked in that file and didn't see any support for locking. What will happen when using gcc with this support? Will the instrumented locking routines be called to generate the promised callbacks?

Yes these functions will be called. The OpenMP lock functions are simply normal C functions which are called by the compiler just like any other extern function. They are not name-mangled in a compiler specific fashion, or generated in any special way, so the correct functions will be called at no extra effort.

[jmellorcrummey]

In reading this patch over again, I realized that you implemented the OMPT TR2 lock initialization callback rather than the OMPT working draft, which also passes a lock hint and a lock type to the init callback. The OMPT implementation in LLVM OpenMP is evolving with the current version of the OMPT draft. There are features already in the code that aren't in OMPT TR2. Fort that reason, I think you should add the lock hint and lock type parameters.

[tcramer]

Changed OMPT_BLAME to OMPT_TRACE for the acquire, init and destroy lock events (thanks John for reading the patch carefully!).

[tcramer]

In D13689#265972, @jcownie wrote:

I notice that there aren't any patches to kmp_gsupport.c. I looked in that file and didn't see any support for locking. What will happen when using gcc with this support? Will the instrumented locking routines be called to generate the promised callbacks?

Yes these functions will be called. The OpenMP lock functions are simply normal C functions which are called by the compiler just like any other extern function. They are not name-mangled in a compiler specific fashion, or generated in any special way, so the correct functions will be called at no extra effort.

Yes, seems to work for me. I just verified with gcc 5.2.

[tcramer]

In D13689#265984, @jmellorcrummey wrote:

In reading this patch over again, I realized that you implemented the OMPT TR2 lock initialization callback rather than the OMPT working draft, which also passes a lock hint and a lock type to the init callback. The OMPT implementation in LLVM OpenMP is evolving with the current version of the OMPT draft. There are features already in the code that aren't in OMPT TR2. Fort that reason, I think you should add the lock hint and lock type parameters.

Thats true. However, the OpenMP runtime library routine "omp_init_lock_with_hint" seems not to be implemented at the moment, because it will come with OpenMP 4.5 (aka 4.1). Thus, I can only pass a hard-coded 0 (which will be omp_lock_hint_none) as hint at the moment.

I agree that the lock type is already implementable, but since it is a change in OMPT infrastructure itself, it should be a separated patch anyway.

I would propose to use the old signature for now and change it as soon as we have the new locking library routine. Does that sound reasonable?

[jmellorcrummey]

I am fine with the approach proposed below. We can refine the interface at a later date when the lock hints become available.

John Mellor-Crummey Professor
Dept of Computer Science Rice University
email: [e-mail] phone: [phone]

[jlpeyton]

LGTM.

openmp/trunk/runtime/src/kmp_csupport.c

#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
     }
 #endif
     else {
         lck = __kmp_user_lock_allocate( user_lock, gtid, 0 );
     }
     INIT_LOCK( lck );
     __kmp_set_user_lock_location( lck, loc );
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled &&
+        ompt_callbacks.ompt_callback(ompt_event_init_lock)) {
+        ompt_callbacks.ompt_callback(ompt_event_init_lock)((uint64_t) lck);
+    }
+#endif
+
 #if USE_ITT_BUILD
     __kmp_itt_lock_creating( lck );
 #endif /* USE_ITT_BUILD */
 
 #endif // KMP_USE_DYNAMIC_LOCK
 } // __kmpc_init_lock
 
 /* initialize the lock */

 #endif
     else {
         lck = __kmp_user_lock_allocate( user_lock, gtid, 0 );
     }
 
     INIT_NESTED_LOCK( lck );
     __kmp_set_user_lock_location( lck, loc );
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled &&
+        ompt_callbacks.ompt_callback(ompt_event_init_nest_lock)) {
+        ompt_callbacks.ompt_callback(ompt_event_init_nest_lock)((uint64_t) lck);
+    }
+#endif
+
 #if USE_ITT_BUILD
     __kmp_itt_lock_creating( lck );
 #endif /* USE_ITT_BUILD */
 
 #endif // KMP_USE_DYNAMIC_LOCK
 } // __kmpc_init_nest_lock
 
 void
else if ( ( __kmp_user_lock_kind == lk_futex )
       && ( sizeof( lck->futex.lk.poll ) <= OMP_LOCK_T_SIZE ) ) {
         lck = (kmp_user_lock_p)user_lock;
     }
 #endif
     else {
         lck = __kmp_lookup_user_lock( user_lock, "omp_destroy_lock" );
     }
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled &&
+        ompt_callbacks.ompt_callback(ompt_event_destroy_lock)) {
+        ompt_callbacks.ompt_callback(ompt_event_destroy_lock)((uint64_t) lck);
+    }
+#endif
+
 #if USE_ITT_BUILD
     __kmp_itt_lock_destroyed( lck );
 #endif /* USE_ITT_BUILD */
     DESTROY_LOCK( lck );
 
     if ( ( __kmp_user_lock_kind == lk_tas )
       && ( sizeof( lck->tas.lk.poll ) <= OMP_LOCK_T_SIZE ) ) {
         ;
#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
      <= OMP_NEST_LOCK_T_SIZE ) ) {
         lck = (kmp_user_lock_p)user_lock;
     }
 #endif
     else {
         lck = __kmp_lookup_user_lock( user_lock, "omp_destroy_nest_lock" );
     }
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled &&
+        ompt_callbacks.ompt_callback(ompt_event_destroy_nest_lock)) {
+        ompt_callbacks.ompt_callback(ompt_event_destroy_nest_lock)((uint64_t) lck);
+    }
+#endif
+
 #if USE_ITT_BUILD
     __kmp_itt_lock_destroyed( lck );
 #endif /* USE_ITT_BUILD */
 
     DESTROY_NESTED_LOCK( lck );
 
     if ( ( __kmp_user_lock_kind == lk_tas ) && ( sizeof( lck->tas.lk.poll )
      + sizeof( lck->tas.lk.depth_locked ) <= OMP_NEST_LOCK_T_SIZE ) ) {

 #endif /* USE_ITT_BUILD */
 
     ACQUIRE_LOCK( lck, gtid );
 
 #if USE_ITT_BUILD
     __kmp_itt_lock_acquired( lck );
 #endif /* USE_ITT_BUILD */
 
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled &&
+        ompt_callbacks.ompt_callback(ompt_event_acquired_lock)) {
+        ompt_callbacks.ompt_callback(ompt_event_acquired_lock)((uint64_t) lck);
+    }
+#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
     DYNA_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
 
 #else // KMP_USE_DYNAMIC_LOCK
+    int acquire_status;
     kmp_user_lock_p lck;
 
     if ( ( __kmp_user_lock_kind == lk_tas ) && ( sizeof( lck->tas.lk.poll )
       + sizeof( lck->tas.lk.depth_locked ) <= OMP_NEST_LOCK_T_SIZE ) ) {
         lck = (kmp_user_lock_p)user_lock;
     }
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
     else if ( ( __kmp_user_lock_kind == lk_futex )
      && ( sizeof( lck->futex.lk.poll ) + sizeof( lck->futex.lk.depth_locked )
      <= OMP_NEST_LOCK_T_SIZE ) ) {
         lck = (kmp_user_lock_p)user_lock;
     }
 #endif
     else {
         lck = __kmp_lookup_user_lock( user_lock, "omp_set_nest_lock" );
     }
 
 #if USE_ITT_BUILD
     __kmp_itt_lock_acquiring( lck );
 #endif /* USE_ITT_BUILD */
 
-    ACQUIRE_NESTED_LOCK( lck, gtid );
+    ACQUIRE_NESTED_LOCK( lck, gtid, &acquire_status );
 
 #if USE_ITT_BUILD
     __kmp_itt_lock_acquired( lck );
 #endif /* USE_ITT_BUILD */
 #endif // KMP_USE_DYNAMIC_LOCK
+
+#if OMPT_SUPPORT && OMPT_TRACE
+    if (ompt_enabled) {
+        if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
+           if(ompt_callbacks.ompt_callback(ompt_event_acquired_nest_lock_first))
+              ompt_callbacks.ompt_callback(ompt_event_acquired_nest_lock_first)((uint64_t) lck);
+        } else {
+           if(ompt_callbacks.ompt_callback(ompt_event_acquired_nest_lock_next))
+              ompt_callbacks.ompt_callback(ompt_event_acquired_nest_lock_next)((uint64_t) lck);
+        }
+    }
+#endif
 }
 
 void
 __kmpc_unset_lock( ident_t *loc, kmp_int32 gtid, void **user_lock )
 {
 #if KMP_USE_DYNAMIC_LOCK
 
     int tag = DYNA_EXTRACT_D_TAG(user_lock);

openmp/trunk/runtime/src/kmp_lock.h

 typedef union kmp_tas_lock kmp_tas_lock_t;
 
 //
 // Static initializer for test and set lock variables. Usage:
 //    kmp_tas_lock_t xlock = KMP_TAS_LOCK_INITIALIZER( xlock );
 //
 #define KMP_TAS_LOCK_INITIALIZER( lock ) { { 0, 0 } }
 
-extern void __kmp_acquire_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_tas_lock( kmp_tas_lock_t *lck );
 extern void __kmp_destroy_tas_lock( kmp_tas_lock_t *lck );
 
-extern void __kmp_acquire_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_nested_tas_lock( kmp_tas_lock_t *lck );
 extern void __kmp_destroy_nested_tas_lock( kmp_tas_lock_t *lck );
 
 #define KMP_LOCK_RELEASED       1
 #define KMP_LOCK_STILL_HELD     0
-
+#define KMP_LOCK_ACQUIRED_FIRST 1
+#define KMP_LOCK_ACQUIRED_NEXT  0
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 // ----------------------------------------------------------------------------
 // futex locks.  futex locks are only available on Linux* OS.
 //
 // Like non-nested test and set lock, non-nested futex locks use the memory
 // allocated by the compiler for the lock, rather than a pointer to it.

 typedef union kmp_futex_lock kmp_futex_lock_t;
 
 //
 // Static initializer for futex lock variables. Usage:
 //    kmp_futex_lock_t xlock = KMP_FUTEX_LOCK_INITIALIZER( xlock );
 //
 #define KMP_FUTEX_LOCK_INITIALIZER( lock ) { { 0, 0 } }
 
-extern void __kmp_acquire_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_futex_lock( kmp_futex_lock_t *lck );
 extern void __kmp_destroy_futex_lock( kmp_futex_lock_t *lck );
 
-extern void __kmp_acquire_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_nested_futex_lock( kmp_futex_lock_t *lck );
 extern void __kmp_destroy_nested_futex_lock( kmp_futex_lock_t *lck );
 
 #endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 

 
 //
 // Static initializer for simple ticket lock variables. Usage:
 //    kmp_ticket_lock_t xlock = KMP_TICKET_LOCK_INITIALIZER( xlock );
 // Note the macro argument. It is important to make var properly initialized.
 //
 #define KMP_TICKET_LOCK_INITIALIZER( lock ) { { (kmp_ticket_lock_t *) & (lock), NULL, 0, 0, 0, -1 } }
 
-extern void __kmp_acquire_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_ticket_lock_with_cheks( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_ticket_lock( kmp_ticket_lock_t *lck );
 extern void __kmp_destroy_ticket_lock( kmp_ticket_lock_t *lck );
 
-extern void __kmp_acquire_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_nested_ticket_lock( kmp_ticket_lock_t *lck );
 extern void __kmp_destroy_nested_ticket_lock( kmp_ticket_lock_t *lck );
 
 
 // ----------------------------------------------------------------------------
 // Queuing locks.
union KMP_ALIGN_CACHE kmp_queuing_lock {
     kmp_base_queuing_lock_t lk;       // This field must be first to allow static initializing.
     kmp_lock_pool_t pool;
     double                   lk_align; // use worst case alignment
     char                     lk_pad[ KMP_PAD( kmp_base_queuing_lock_t, CACHE_LINE ) ];
 };
 
 typedef union kmp_queuing_lock kmp_queuing_lock_t;
 
-extern void __kmp_acquire_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_queuing_lock( kmp_queuing_lock_t *lck );
 extern void __kmp_destroy_queuing_lock( kmp_queuing_lock_t *lck );
 
-extern void __kmp_acquire_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_nested_queuing_lock( kmp_queuing_lock_t *lck );
 extern void __kmp_destroy_nested_queuing_lock( kmp_queuing_lock_t *lck );
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
 // ----------------------------------------------------------------------------
union KMP_ALIGN_CACHE kmp_drdpa_lock {
     kmp_base_drdpa_lock_t lk;       // This field must be first to allow static initializing. */
     kmp_lock_pool_t pool;
     double                lk_align; // use worst case alignment
     char                  lk_pad[ KMP_PAD( kmp_base_drdpa_lock_t, CACHE_LINE ) ];
 };
 
 typedef union kmp_drdpa_lock kmp_drdpa_lock_t;
 
-extern void __kmp_acquire_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_drdpa_lock( kmp_drdpa_lock_t *lck );
 extern void __kmp_destroy_drdpa_lock( kmp_drdpa_lock_t *lck );
 
-extern void __kmp_acquire_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
+extern int __kmp_acquire_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_test_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern int __kmp_release_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
 extern void __kmp_init_nested_drdpa_lock( kmp_drdpa_lock_t *lck );
 extern void __kmp_destroy_nested_drdpa_lock( kmp_drdpa_lock_t *lck );
 
 
 // ============================================================================
 // Lock purposes.

 // They could also be implemented as test and set lock, but cannot be
 // implemented with other lock kinds as they require gtids which are not
 // available at initialization time.
 
 typedef kmp_ticket_lock_t kmp_bootstrap_lock_t;
 
 #define KMP_BOOTSTRAP_LOCK_INITIALIZER( lock ) KMP_TICKET_LOCK_INITIALIZER( (lock) )
 
-static inline void
+static inline int
 __kmp_acquire_bootstrap_lock( kmp_bootstrap_lock_t *lck )
 {
-    __kmp_acquire_ticket_lock( lck, KMP_GTID_DNE );
+    return __kmp_acquire_ticket_lock( lck, KMP_GTID_DNE );
 }
 
 static inline int
 __kmp_test_bootstrap_lock( kmp_bootstrap_lock_t *lck )
 {
     return __kmp_test_ticket_lock( lck, KMP_GTID_DNE );
 }
 

 //
 // FIXME - We should go through and figure out which lock kind works best for
 // each internal lock, and use the type declaration and function calls for
 // that explicit lock kind (and get rid of this section).
 //
 
 typedef kmp_ticket_lock_t kmp_lock_t;
 
-static inline void
+static inline int
 __kmp_acquire_lock( kmp_lock_t *lck, kmp_int32 gtid )
 {
-    __kmp_acquire_ticket_lock( lck, gtid );
+    return __kmp_acquire_ticket_lock( lck, gtid );
 }
 
 static inline int
 __kmp_test_lock( kmp_lock_t *lck, kmp_int32 gtid )
 {
     return __kmp_test_ticket_lock( lck, gtid );
 }
 

 
 static inline kmp_int32
 __kmp_get_user_lock_owner( kmp_user_lock_p lck )
 {
     KMP_DEBUG_ASSERT( __kmp_get_user_lock_owner_ != NULL );
     return ( *__kmp_get_user_lock_owner_ )( lck );
 }
 
-extern void ( *__kmp_acquire_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int ( *__kmp_acquire_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 #define __kmp_acquire_user_lock_with_checks(lck,gtid)                                           \
     if (__kmp_user_lock_kind == lk_tas) {                                                       \
         if ( __kmp_env_consistency_check ) {                                                    \
             char const * const func = "omp_set_lock";                                           \
             if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )                               \
if (__kmp_user_lock_kind == lk_tas) {                                                       \
         }                                                                                       \
         KMP_FSYNC_ACQUIRED( lck );                                                              \
     } else {                                                                                    \
         KMP_DEBUG_ASSERT( __kmp_acquire_user_lock_with_checks_ != NULL );                       \
         ( *__kmp_acquire_user_lock_with_checks_ )( lck, gtid );                                 \
     }
 
 #else
-static inline void
+static inline int
 __kmp_acquire_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( __kmp_acquire_user_lock_with_checks_ != NULL );
-    ( *__kmp_acquire_user_lock_with_checks_ )( lck, gtid );
+    return ( *__kmp_acquire_user_lock_with_checks_ )( lck, gtid );
 }
 #endif
 
 extern int ( *__kmp_test_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 #include "kmp_i18n.h"                       /* AC: KMP_FATAL definition */

 
 static inline void
 __kmp_destroy_user_lock_with_checks( kmp_user_lock_p lck )
 {
     KMP_DEBUG_ASSERT( __kmp_destroy_user_lock_with_checks_ != NULL );
     ( *__kmp_destroy_user_lock_with_checks_ )( lck );
 }
 
-extern void ( *__kmp_acquire_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int ( *__kmp_acquire_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 
-#define __kmp_acquire_nested_user_lock_with_checks(lck,gtid)                                        \
+#define __kmp_acquire_nested_user_lock_with_checks(lck,gtid,depth)                                  \
     if (__kmp_user_lock_kind == lk_tas) {                                                           \
         if ( __kmp_env_consistency_check ) {                                                        \
             char const * const func = "omp_set_nest_lock";                                          \
             if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_NEST_LOCK_T_SIZE )                              \
                 && lck->tas.lk.depth_locked == -1 ) {                                               \
                 KMP_FATAL( LockSimpleUsedAsNestable, func );                                        \
             }                                                                                       \
         }                                                                                           \
         if ( lck->tas.lk.poll - 1 == gtid ) {                                                       \
             lck->tas.lk.depth_locked += 1;                                                          \
+            *depth = KMP_LOCK_ACQUIRED_NEXT;                                                        \
         } else {                                                                                    \
             if ( ( lck->tas.lk.poll != 0 ) ||                                                       \
               ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  ) {            \
                 kmp_uint32 spins;                                                                   \
                 KMP_FSYNC_PREPARE( lck );                                                           \
                 KMP_INIT_YIELD( spins );                                                            \
                 if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) {     \
                     KMP_YIELD( TRUE );                                                              \
                 } else {                                                                            \
                     KMP_YIELD_SPIN( spins );                                                        \
                 }                                                                                   \
                 while ( ( lck->tas.lk.poll != 0 ) ||                                                \
                   ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  ) {        \
                     if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) { \
                         KMP_YIELD( TRUE );                                                          \
                     } else {                                                                        \
                         KMP_YIELD_SPIN( spins );                                                    \
                     }                                                                               \
                 }                                                                                   \
             }                                                                                       \
             lck->tas.lk.depth_locked = 1;                                                           \
+            *depth = KMP_LOCK_ACQUIRED_FIRST;                                                       \
         }                                                                                           \
         KMP_FSYNC_ACQUIRED( lck );                                                                  \
     } else {                                                                                        \
         KMP_DEBUG_ASSERT( __kmp_acquire_nested_user_lock_with_checks_ != NULL );                    \
-        ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );                              \
+        *depth = ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );                     \
     }
 
 #else
 static inline void
-__kmp_acquire_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
+__kmp_acquire_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid, int* depth )
 {
     KMP_DEBUG_ASSERT( __kmp_acquire_nested_user_lock_with_checks_ != NULL );
-    ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );
+    *depth = ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );
 }
 #endif
 
 extern int ( *__kmp_test_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 static inline int
 __kmp_test_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )

 // The fuction which sets up all of the vtbl pointers for kmp_user_lock_t.
 //
 extern void __kmp_set_user_lock_vptrs( kmp_lock_kind_t user_lock_kind );
 
 //
 // Macros for binding user lock functions.
 //
 #define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix) {                                       \
-    __kmp_acquire##nest##user_lock_with_checks_ = ( void (*)( kmp_user_lock_p, kmp_int32 ) )    \
+    __kmp_acquire##nest##user_lock_with_checks_ = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
                                                   __kmp_acquire##nest##kind##_##suffix;         \
     __kmp_release##nest##user_lock_with_checks_ = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
                                                   __kmp_release##nest##kind##_##suffix;         \
     __kmp_test##nest##user_lock_with_checks_    = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
                                                   __kmp_test##nest##kind##_##suffix;            \
     __kmp_init##nest##user_lock_with_checks_    = ( void (*)( kmp_user_lock_p ) )               \
                                                   __kmp_init##nest##kind##_##suffix;            \
     __kmp_destroy##nest##user_lock_with_checks_ = ( void (*)( kmp_user_lock_p ) )               \

openmp/trunk/runtime/src/kmp_lock.cpp

 }
 
 static inline bool
 __kmp_is_tas_lock_nestable( kmp_tas_lock_t *lck )
 {
     return lck->lk.depth_locked != -1;
 }
 
-__forceinline static void
+__forceinline static int
 __kmp_acquire_tas_lock_timed_template( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     KMP_MB();
 
 #ifdef USE_LOCK_PROFILE
     kmp_uint32 curr = TCR_4( lck->lk.poll );
     if ( ( curr != 0 ) && ( curr != gtid + 1 ) )
         __kmp_printf( "LOCK CONTENTION: %p\n", lck );
     /* else __kmp_printf( "." );*/
 #endif /* USE_LOCK_PROFILE */
 
     if ( ( lck->lk.poll == DYNA_LOCK_FREE(tas) )
       && KMP_COMPARE_AND_STORE_ACQ32( & ( lck->lk.poll ), DYNA_LOCK_FREE(tas), DYNA_LOCK_BUSY(gtid+1, tas) ) ) {
         KMP_FSYNC_ACQUIRED(lck);
-        return;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 
     kmp_uint32 spins;
     KMP_FSYNC_PREPARE( lck );
     KMP_INIT_YIELD( spins );
     if ( TCR_4( __kmp_nth ) > ( __kmp_avail_proc ? __kmp_avail_proc :
       __kmp_xproc ) ) {
         KMP_YIELD( TRUE );
while ( ( lck->lk.poll != DYNA_LOCK_FREE(tas) ) ||
           __kmp_xproc ) ) {
             KMP_YIELD( TRUE );
         }
         else {
             KMP_YIELD_SPIN( spins );
         }
     }
     KMP_FSYNC_ACQUIRED( lck );
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
-void
+int
 __kmp_acquire_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
-    __kmp_acquire_tas_lock_timed_template( lck, gtid );
+    return __kmp_acquire_tas_lock_timed_template( lck, gtid );
 }
 
-static void
+static int
 __kmp_acquire_tas_lock_with_checks( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_lock";
     if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_tas_lock_owner( lck ) == gtid ) ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
-    __kmp_acquire_tas_lock( lck, gtid );
+    return __kmp_acquire_tas_lock( lck, gtid );
 }
 
 int
 __kmp_test_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     if ( ( lck->lk.poll == DYNA_LOCK_FREE(tas) )
       && KMP_COMPARE_AND_STORE_ACQ32( & ( lck->lk.poll ), DYNA_LOCK_FREE(tas), DYNA_LOCK_BUSY(gtid+1, tas) ) ) {
         KMP_FSYNC_ACQUIRED( lck );
__kmp_destroy_tas_lock_with_checks( kmp_tas_lock_t *lck )
     __kmp_destroy_tas_lock( lck );
 }
 
 
 //
 // nested test and set locks
 //
 
-void
+int
 __kmp_acquire_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     if ( __kmp_get_tas_lock_owner( lck ) == gtid ) {
         lck->lk.depth_locked += 1;
+        return KMP_LOCK_ACQUIRED_NEXT;
     }
     else {
         __kmp_acquire_tas_lock_timed_template( lck, gtid );
         lck->lk.depth_locked = 1;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 }
 
-static void
+static int
 __kmp_acquire_nested_tas_lock_with_checks( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_nest_lock";
     if ( ! __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
-    __kmp_acquire_nested_tas_lock( lck, gtid );
+    return __kmp_acquire_nested_tas_lock( lck, gtid );
 }
 
 int
 __kmp_test_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     int retval;
 
     KMP_DEBUG_ASSERT( gtid >= 0 );

 }
 
 static inline bool
 __kmp_is_futex_lock_nestable( kmp_futex_lock_t *lck )
 {
     return lck->lk.depth_locked != -1;
 }
 
-__forceinline static void
+__forceinline static int
 __kmp_acquire_futex_lock_timed_template( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     kmp_int32 gtid_code = ( gtid + 1 ) << 1;
 
     KMP_MB();
 
 #ifdef USE_LOCK_PROFILE
     kmp_uint32 curr = TCR_4( lck->lk.poll );
while ( ( poll_val = KMP_COMPARE_AND_STORE_RET32( & ( lck->lk.poll ), DYNA_LOCK_FREE(futex),
         // other threads are in the queue.
         //
         gtid_code |= 1;
     }
 
     KMP_FSYNC_ACQUIRED( lck );
     KA_TRACE( 1000, ("__kmp_acquire_futex_lock: lck:%p(0x%x), T#%d exiting\n",
       lck, lck->lk.poll, gtid ) );
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
-void
+int
 __kmp_acquire_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
-    __kmp_acquire_futex_lock_timed_template( lck, gtid );
+   return __kmp_acquire_futex_lock_timed_template( lck, gtid );
 }
 
-static void
+static int
 __kmp_acquire_futex_lock_with_checks( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_lock";
     if ( ( sizeof ( kmp_futex_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_futex_lock_owner( lck ) == gtid ) ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
-    __kmp_acquire_futex_lock( lck, gtid );
+    return __kmp_acquire_futex_lock( lck, gtid );
 }
 
 int
 __kmp_test_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     if ( KMP_COMPARE_AND_STORE_ACQ32( & ( lck->lk.poll ), DYNA_LOCK_FREE(futex), DYNA_LOCK_BUSY(gtid+1, futex) << 1 ) ) {
         KMP_FSYNC_ACQUIRED( lck );
         return TRUE;
__kmp_destroy_futex_lock_with_checks( kmp_futex_lock_t *lck )
     __kmp_destroy_futex_lock( lck );
 }
 
 
 //
 // nested futex locks
 //
 
-void
+int
 __kmp_acquire_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     if ( __kmp_get_futex_lock_owner( lck ) == gtid ) {
         lck->lk.depth_locked += 1;
+        return KMP_LOCK_ACQUIRED_NEXT;
     }
     else {
         __kmp_acquire_futex_lock_timed_template( lck, gtid );
         lck->lk.depth_locked = 1;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 }
 
-static void
+static int
 __kmp_acquire_nested_futex_lock_with_checks( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_nest_lock";
     if ( ! __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
-    __kmp_acquire_nested_futex_lock( lck, gtid );
+    return __kmp_acquire_nested_futex_lock( lck, gtid );
 }
 
 int
 __kmp_test_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     int retval;
 
     KMP_DEBUG_ASSERT( gtid >= 0 );
__kmp_bakery_check(kmp_uint value, kmp_uint checker)
 
     if (value == checker) {
         return TRUE;
     }
     for (pause = checker - value; pause != 0; --pause);
     return FALSE;
 }
 
-__forceinline static void
+__forceinline static int
 __kmp_acquire_ticket_lock_timed_template( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     kmp_uint32 my_ticket;
     KMP_MB();
 
     my_ticket = KMP_TEST_THEN_INC32( (kmp_int32 *) &lck->lk.next_ticket );
 
 #ifdef USE_LOCK_PROFILE
     if ( TCR_4( lck->lk.now_serving ) != my_ticket )
         __kmp_printf( "LOCK CONTENTION: %p\n", lck );
     /* else __kmp_printf( "." );*/
 #endif /* USE_LOCK_PROFILE */
 
     if ( TCR_4( lck->lk.now_serving ) == my_ticket ) {
         KMP_FSYNC_ACQUIRED(lck);
-        return;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
     KMP_WAIT_YIELD( &lck->lk.now_serving, my_ticket, __kmp_bakery_check, lck );
     KMP_FSYNC_ACQUIRED(lck);
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
-void
+int
 __kmp_acquire_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
-    __kmp_acquire_ticket_lock_timed_template( lck, gtid );
+    return __kmp_acquire_ticket_lock_timed_template( lck, gtid );
 }
 
-static void
+static int
 __kmp_acquire_ticket_lock_with_checks( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_lock";
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_is_ticket_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_ticket_lock_owner( lck ) == gtid ) ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
 
     __kmp_acquire_ticket_lock( lck, gtid );
 
     lck->lk.owner_id = gtid + 1;
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
 int
 __kmp_test_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     kmp_uint32 my_ticket = TCR_4( lck->lk.next_ticket );
     if ( TCR_4( lck->lk.now_serving ) == my_ticket ) {
         kmp_uint32 next_ticket = my_ticket + 1;
__kmp_destroy_ticket_lock_with_checks( kmp_ticket_lock_t *lck )
     __kmp_destroy_ticket_lock( lck );
 }
 
 
 //
 // nested ticket locks
 //
 
-void
+int
 __kmp_acquire_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     if ( __kmp_get_ticket_lock_owner( lck ) == gtid ) {
         lck->lk.depth_locked += 1;
+        return KMP_LOCK_ACQUIRED_NEXT;
     }
     else {
         __kmp_acquire_ticket_lock_timed_template( lck, gtid );
         KMP_MB();
         lck->lk.depth_locked = 1;
         KMP_MB();
         lck->lk.owner_id = gtid + 1;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 }
 
-static void
+static int
 __kmp_acquire_nested_ticket_lock_with_checks( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_nest_lock";
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_ticket_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
-    __kmp_acquire_nested_ticket_lock( lck, gtid );
+    return __kmp_acquire_nested_ticket_lock( lck, gtid );
 }
 
 int
 __kmp_test_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     int retval;
 
     KMP_DEBUG_ASSERT( gtid >= 0 );

 {
     return lck->lk.depth_locked != -1;
 }
 
 /* Acquire a lock using a the queuing lock implementation */
 template <bool takeTime>
 /* [TLW] The unused template above is left behind because of what BEB believes is a
    potential compiler problem with __forceinline. */
-__forceinline static void
+__forceinline static int
 __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
                     if (ompt_enabled && prev_state != ompt_state_undefined) {
                         /* change the state before clearing wait_id */
                         this_thr->th.ompt_thread_info.state = prev_state;
                         this_thr->th.ompt_thread_info.wait_id = 0;
                     }
 #endif
 
                     KMP_FSYNC_ACQUIRED( lck );
-                    return; /* lock holder cannot be on queue */
+                    return KMP_LOCK_ACQUIRED_FIRST; /* lock holder cannot be on queue */
                 }
                 enqueued = FALSE;
             }
             break;
         }
 
 #if OMPT_SUPPORT
         if (ompt_enabled && prev_state == ompt_state_undefined) {

 
 #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;
+            return KMP_LOCK_ACQUIRED_FIRST;
         }
 
         /* 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 :
           __kmp_xproc ) );
 #ifdef DEBUG_QUEUING_LOCKS
         TRACE_LOCK( gtid+1, "acq retry" );
 #endif
 
     }
     KMP_ASSERT2( 0, "should not get here" );
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
-void
+int
 __kmp_acquire_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
-    __kmp_acquire_queuing_lock_timed_template<false>( lck, gtid );
+    return __kmp_acquire_queuing_lock_timed_template<false>( lck, gtid );
 }
 
-static void
+static int
 __kmp_acquire_queuing_lock_with_checks( kmp_queuing_lock_t *lck,
   kmp_int32 gtid )
 {
     char const * const func = "omp_set_lock";
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_is_queuing_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( __kmp_get_queuing_lock_owner( lck ) == gtid ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
 
     __kmp_acquire_queuing_lock( lck, gtid );
 
     lck->lk.owner_id = gtid + 1;
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
 int
 __kmp_test_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     volatile kmp_int32 *head_id_p  = & lck->lk.head_id;
     kmp_int32 head;
 #ifdef KMP_DEBUG
__kmp_destroy_queuing_lock_with_checks( kmp_queuing_lock_t *lck )
     __kmp_destroy_queuing_lock( lck );
 }
 
 
 //
 // nested queuing locks
 //
 
-void
+int
 __kmp_acquire_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     if ( __kmp_get_queuing_lock_owner( lck ) == gtid ) {
         lck->lk.depth_locked += 1;
+        return KMP_LOCK_ACQUIRED_NEXT;
     }
     else {
         __kmp_acquire_queuing_lock_timed_template<false>( lck, gtid );
         KMP_MB();
         lck->lk.depth_locked = 1;
         KMP_MB();
         lck->lk.owner_id = gtid + 1;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 }
 
-static void
+static int
 __kmp_acquire_nested_queuing_lock_with_checks( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_nest_lock";
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_queuing_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
-    __kmp_acquire_nested_queuing_lock( lck, gtid );
+    return __kmp_acquire_nested_queuing_lock( lck, gtid );
 }
 
 int
 __kmp_test_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     int retval;
 
     KMP_DEBUG_ASSERT( gtid >= 0 );

 }
 
 static inline bool
 __kmp_is_drdpa_lock_nestable( kmp_drdpa_lock_t *lck )
 {
     return lck->lk.depth_locked != -1;
 }
 
-__forceinline static void
+__forceinline static int
 __kmp_acquire_drdpa_lock_timed_template( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     kmp_uint64 ticket = KMP_TEST_THEN_INC64((kmp_int64 *)&lck->lk.next_ticket);
     kmp_uint64 mask = TCR_8(lck->lk.mask);              // volatile load
     volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls
       = (volatile struct kmp_base_drdpa_lock::kmp_lock_poll *)
       TCR_PTR(lck->lk.polls);                           // volatile load
 
if (lck->lk.old_polls == NULL) {
             // Only after the new polling area and mask have been flushed
             // to main memory can we update the cleanup ticket field.
             //
             // volatile load / non-volatile store
             //
             lck->lk.cleanup_ticket = TCR_8(lck->lk.next_ticket);
         }
     }
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
-void
+int
 __kmp_acquire_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
-    __kmp_acquire_drdpa_lock_timed_template( lck, gtid );
+    return __kmp_acquire_drdpa_lock_timed_template( lck, gtid );
 }
 
-static void
+static int
 __kmp_acquire_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_lock";
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_is_drdpa_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_drdpa_lock_owner( lck ) == gtid ) ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
 
     __kmp_acquire_drdpa_lock( lck, gtid );
 
     lck->lk.owner_id = gtid + 1;
+    return KMP_LOCK_ACQUIRED_FIRST;
 }
 
 int
 __kmp_test_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     //
     // First get a ticket, then read the polls pointer and the mask.
     // The polls pointer must be read before the mask!!! (See above)
__kmp_destroy_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck )
     __kmp_destroy_drdpa_lock( lck );
 }
 
 
 //
 // nested drdpa ticket locks
 //
 
-void
+int
 __kmp_acquire_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     if ( __kmp_get_drdpa_lock_owner( lck ) == gtid ) {
         lck->lk.depth_locked += 1;
+        return KMP_LOCK_ACQUIRED_NEXT;
     }
     else {
         __kmp_acquire_drdpa_lock_timed_template( lck, gtid );
         KMP_MB();
         lck->lk.depth_locked = 1;
         KMP_MB();
         lck->lk.owner_id = gtid + 1;
+        return KMP_LOCK_ACQUIRED_FIRST;
     }
 }
 
 static void
 __kmp_acquire_nested_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_set_nest_lock";
     if ( lck->lk.initialized != lck ) {

  */
 
 enum kmp_lock_kind __kmp_user_lock_kind = lk_default;
 
 size_t __kmp_base_user_lock_size = 0;
 size_t __kmp_user_lock_size = 0;
 
 kmp_int32 ( *__kmp_get_user_lock_owner_ )( kmp_user_lock_p lck ) = NULL;
-void ( *__kmp_acquire_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
+int ( *__kmp_acquire_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 
 int ( *__kmp_test_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 int ( *__kmp_release_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 void ( *__kmp_init_user_lock_with_checks_ )( kmp_user_lock_p lck ) = NULL;
 void ( *__kmp_destroy_user_lock_ )( kmp_user_lock_p lck ) = NULL;
 void ( *__kmp_destroy_user_lock_with_checks_ )( kmp_user_lock_p lck ) = NULL;
-void ( *__kmp_acquire_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
+int ( *__kmp_acquire_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 
 int ( *__kmp_test_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 int ( *__kmp_release_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
 void ( *__kmp_init_nested_user_lock_with_checks_ )( kmp_user_lock_p lck ) = NULL;
 void ( *__kmp_destroy_nested_user_lock_with_checks_ )( kmp_user_lock_p lck ) = NULL;
 
 int ( *__kmp_is_user_lock_initialized_ )( kmp_user_lock_p lck ) = NULL;
 const ident_t * ( *__kmp_get_user_lock_location_ )( kmp_user_lock_p lck ) = NULL;

openmp/trunk/runtime/src/ompt-event-specific.h

 
 #define ompt_event_release_nest_lock_prev_implemented   ompt_event_MAY_ALWAYS_TRACE
 #define ompt_event_wait_lock_implemented                ompt_event_UNIMPLEMENTED
 #define ompt_event_wait_nest_lock_implemented           ompt_event_UNIMPLEMENTED
 #define ompt_event_wait_critical_implemented            ompt_event_UNIMPLEMENTED
 #define ompt_event_wait_atomic_implemented              ompt_event_MAY_ALWAYS_TRACE
 #define ompt_event_wait_ordered_implemented             ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_acquired_lock_implemented            ompt_event_UNIMPLEMENTED
-#define ompt_event_acquired_nest_lock_first_implemented ompt_event_UNIMPLEMENTED
-#define ompt_event_acquired_nest_lock_next_implemented  ompt_event_UNIMPLEMENTED
+#define ompt_event_acquired_lock_implemented            ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_nest_lock_first_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_nest_lock_next_implemented  ompt_event_MAY_ALWAYS_TRACE
 #define ompt_event_acquired_critical_implemented        ompt_event_UNIMPLEMENTED
 #define ompt_event_acquired_atomic_implemented          ompt_event_MAY_ALWAYS_TRACE
 #define ompt_event_acquired_ordered_implemented         ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_init_lock_implemented                ompt_event_UNIMPLEMENTED
-#define ompt_event_init_nest_lock_implemented           ompt_event_UNIMPLEMENTED
+#define ompt_event_init_lock_implemented                ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_init_nest_lock_implemented           ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_destroy_lock_implemented             ompt_event_UNIMPLEMENTED
-#define ompt_event_destroy_nest_lock_implemented        ompt_event_UNIMPLEMENTED
+#define ompt_event_destroy_lock_implemented             ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_destroy_nest_lock_implemented        ompt_event_MAY_ALWAYS_TRACE
 
 #define ompt_event_flush_implemented                    ompt_event_UNIMPLEMENTED
 
 #endif