kmp_lock: Change return type of release functions from void to int

[Hahnfeld]

Summary

This is needed for OMPT to retrieve the actual release status of nested locks.

[jcownie]

I think it would be cleaner if you defined the new constants as KMP_LOCK_RELEASED and KMP_LOCK_STILL_HELD, then the non-nested lock implementations can sensibly return KMP_LOCK_RELEASED, which would be preferable to the explicit "0" they return at the moment.

[Hahnfeld]

In D8916#153774, @jcownie wrote:

I think it would be cleaner if you defined the new constants as KMP_LOCK_RELEASED and KMP_LOCK_STILL_HELD, then the non-nested lock implementations can sensibly return KMP_LOCK_RELEASED, which would be preferable to the explicit "0" they return at the moment.

Good idea, have changed it locally and will be included in an updated revision (next week?)

[omalyshe]

LGTM. Please, commit.

[Hahnfeld]

Committed with revision 236114

runtime/src/kmp_lock.h

 //
 // 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_test_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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_test_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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
+
 
 #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.

 //
 // 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_test_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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_test_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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)
 
 
 // ----------------------------------------------------------------------------
 // Ticket locks.

 //    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_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 void __kmp_release_ticket_lock( 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_test_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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 {
     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_test_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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_test_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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
 
 // ----------------------------------------------------------------------------
 // Adaptive locks.
 // ----------------------------------------------------------------------------
union KMP_ALIGN_CACHE kmp_drdpa_lock {
     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_test_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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_test_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_release_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.
 // ============================================================================
 

 static inline int
 __kmp_test_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( __kmp_test_user_lock_with_checks_ != NULL );
     return ( *__kmp_test_user_lock_with_checks_ )( lck, gtid );
 }
 #endif
 
-extern void ( *__kmp_release_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int ( *__kmp_release_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
 static inline void
 __kmp_release_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( __kmp_release_user_lock_with_checks_ != NULL );
     ( *__kmp_release_user_lock_with_checks_ ) ( lck, gtid );
 }
 

 static inline int
 __kmp_test_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( __kmp_test_nested_user_lock_with_checks_ != NULL );
     return ( *__kmp_test_nested_user_lock_with_checks_ )( lck, gtid );
 }
 #endif
 
-extern void ( *__kmp_release_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int ( *__kmp_release_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
 
-static inline void
+static inline int
 __kmp_release_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( __kmp_release_nested_user_lock_with_checks_ != NULL );
-    ( *__kmp_release_nested_user_lock_with_checks_ )( lck, gtid );
+    return ( *__kmp_release_nested_user_lock_with_checks_ )( lck, gtid );
 }
 
 extern void ( *__kmp_init_nested_user_lock_with_checks_ )( kmp_user_lock_p lck );
 
 static inline void __kmp_init_nested_user_lock_with_checks( kmp_user_lock_p lck )
 {
     KMP_DEBUG_ASSERT( __kmp_init_nested_user_lock_with_checks_ != NULL );
     ( *__kmp_init_nested_user_lock_with_checks_ )( lck );

 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##kind##_##suffix;         \
-    __kmp_release##nest##user_lock_with_checks_ = ( void (*)( kmp_user_lock_p, kmp_int32 ) )    \
+    __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 ) )               \
                                                   __kmp_destroy##nest##kind##_##suffix;         \
 }

runtime/src/kmp_lock.cpp

__kmp_test_tas_lock_with_checks( kmp_tas_lock_t *lck, kmp_int32 gtid )
     char const * const func = "omp_test_lock";
     if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     return __kmp_test_tas_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KMP_FSYNC_RELEASING(lck);
     KMP_ST_REL32( &(lck->lk.poll), DYNA_LOCK_FREE(tas) );
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KMP_YIELD( TCR_4( __kmp_nth ) > ( __kmp_avail_proc ? __kmp_avail_proc :
       __kmp_xproc ) );
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_tas_lock_with_checks( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( __kmp_get_tas_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_tas_lock_owner( lck ) >= 0 )
       && ( __kmp_get_tas_lock_owner( lck ) != gtid ) ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_tas_lock( lck, gtid );
+    return __kmp_release_tas_lock( lck, gtid );
 }
 
 void
 __kmp_init_tas_lock( kmp_tas_lock_t * lck )
 {
     TCW_4( lck->lk.poll, DYNA_LOCK_FREE(tas) );
 }
 

 {
     char const * const func = "omp_test_nest_lock";
     if ( ! __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     return __kmp_test_nested_tas_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     KMP_MB();
     if ( --(lck->lk.depth_locked) == 0 ) {
         __kmp_release_tas_lock( lck, gtid );
+        return KMP_LOCK_RELEASED;
     }
+    return KMP_LOCK_STILL_HELD;
 }
 
-static void
+static int
 __kmp_release_nested_tas_lock_with_checks( kmp_tas_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_nest_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( ! __kmp_is_tas_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_tas_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_tas_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_nested_tas_lock( lck, gtid );
+    return __kmp_release_nested_tas_lock( lck, gtid );
 }
 
 void
 __kmp_init_nested_tas_lock( kmp_tas_lock_t * lck )
 {
     __kmp_init_tas_lock( lck );
     lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
__kmp_test_futex_lock_with_checks( kmp_futex_lock_t *lck, kmp_int32 gtid )
     char const * const func = "omp_test_lock";
     if ( ( sizeof ( kmp_futex_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     return __kmp_test_futex_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 1000, ("__kmp_release_futex_lock: lck:%p(0x%x), T#%d entering\n",
       lck, lck->lk.poll, gtid ) );
 
     KMP_FSYNC_RELEASING(lck);
__kmp_release_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 1000, ("__kmp_release_futex_lock: lck:%p(0x%x), T#%d exiting\n",
       lck, lck->lk.poll, gtid ) );
 
     KMP_YIELD( TCR_4( __kmp_nth ) > ( __kmp_avail_proc ? __kmp_avail_proc :
       __kmp_xproc ) );
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_futex_lock_with_checks( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( ( sizeof ( kmp_futex_lock_t ) <= OMP_LOCK_T_SIZE )
       && __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( __kmp_get_futex_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_futex_lock_owner( lck ) >= 0 )
       && ( __kmp_get_futex_lock_owner( lck ) != gtid ) ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_futex_lock( lck, gtid );
+    return __kmp_release_futex_lock( lck, gtid );
 }
 
 void
 __kmp_init_futex_lock( kmp_futex_lock_t * lck )
 {
     TCW_4( lck->lk.poll, DYNA_LOCK_FREE(futex) );
 }
 

 {
     char const * const func = "omp_test_nest_lock";
     if ( ! __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     return __kmp_test_nested_futex_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     KMP_MB();
     if ( --(lck->lk.depth_locked) == 0 ) {
         __kmp_release_futex_lock( lck, gtid );
+        return KMP_LOCK_RELEASED;
     }
+    return KMP_LOCK_STILL_HELD;
 }
 
-static void
+static int
 __kmp_release_nested_futex_lock_with_checks( kmp_futex_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_nest_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( ! __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_futex_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_futex_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_nested_futex_lock( lck, gtid );
+    return __kmp_release_nested_futex_lock( lck, gtid );
 }
 
 void
 __kmp_init_nested_futex_lock( kmp_futex_lock_t * lck )
 {
     __kmp_init_futex_lock( lck );
     lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
__kmp_test_ticket_lock_with_checks( kmp_ticket_lock_t *lck, kmp_int32 gtid )
     int retval = __kmp_test_ticket_lock( lck, gtid );
 
     if ( retval ) {
         lck->lk.owner_id = gtid + 1;
     }
     return retval;
 }
 
-void
+int
 __kmp_release_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     kmp_uint32  distance;
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KMP_FSYNC_RELEASING(lck);
     distance = ( TCR_4( lck->lk.next_ticket ) - TCR_4( lck->lk.now_serving ) );
 
     KMP_ST_REL32( &(lck->lk.now_serving), lck->lk.now_serving + 1 );
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KMP_YIELD( distance
       > (kmp_uint32) (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) );
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_ticket_lock_with_checks( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_is_ticket_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( __kmp_get_ticket_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_ticket_lock_owner( lck ) >= 0 )
       && ( __kmp_get_ticket_lock_owner( lck ) != gtid ) ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
     lck->lk.owner_id = 0;
-    __kmp_release_ticket_lock( lck, gtid );
+    return __kmp_release_ticket_lock( lck, gtid );
 }
 
 void
 __kmp_init_ticket_lock( kmp_ticket_lock_t * lck )
 {
     lck->lk.location = NULL;
     TCW_4( lck->lk.next_ticket, 0 );
     TCW_4( lck->lk.now_serving, 0 );
if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_ticket_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     return __kmp_test_nested_ticket_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     KMP_MB();
     if ( --(lck->lk.depth_locked) == 0 ) {
         KMP_MB();
         lck->lk.owner_id = 0;
         __kmp_release_ticket_lock( lck, gtid );
+        return KMP_LOCK_RELEASED;
     }
+    return KMP_LOCK_STILL_HELD;
 }
 
-static void
+static int
 __kmp_release_nested_ticket_lock_with_checks( kmp_ticket_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_nest_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_ticket_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_ticket_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_ticket_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_nested_ticket_lock( lck, gtid );
+    return __kmp_release_nested_ticket_lock( lck, gtid );
 }
 
 void
 __kmp_init_nested_ticket_lock( kmp_ticket_lock_t * lck )
 {
     __kmp_init_ticket_lock( lck );
     lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
__kmp_test_queuing_lock_with_checks( kmp_queuing_lock_t *lck, kmp_int32 gtid )
     int retval = __kmp_test_queuing_lock( lck, gtid );
 
     if ( retval ) {
         lck->lk.owner_id = gtid + 1;
     }
     return retval;
 }
 
-void
+int
 __kmp_release_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     register kmp_info_t *this_thr;
     volatile kmp_int32 *head_id_p = & lck->lk.head_id;
     volatile kmp_int32 *tail_id_p = & lck->lk.tail_id;
 
     KA_TRACE( 1000, ("__kmp_release_queuing_lock: lck:%p, T#%d entering\n", lck, gtid ));
     KMP_DEBUG_ASSERT( gtid >= 0 );
#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
-                return;
+                return KMP_LOCK_RELEASED;
             }
             dequeued = FALSE;
 
         }
         else {
 
             tail = *tail_id_p;
             if ( head == tail ) {  /* only one thread on the queue */
#endif
             /* reset spin value */
             head_thr->th.th_spin_here = FALSE;
 
             KA_TRACE( 1000, ("__kmp_release_queuing_lock: lck:%p, T#%d exiting: after dequeuing\n",
                       lck, gtid ));
 #ifdef DEBUG_QUEUING_LOCKS
             TRACE_LOCK( gtid+1, "rel exit 2" );
 #endif
-            return;
+            return KMP_LOCK_RELEASED;
         }
         /* KMP_CPU_PAUSE( );  don't want to make releasing thread hold up acquiring threads */
 
 #ifdef DEBUG_QUEUING_LOCKS
         TRACE_LOCK( gtid+1, "rel retry" );
 #endif
 
     } /* while */
     KMP_ASSERT2( 0, "should not get here" );
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_queuing_lock_with_checks( kmp_queuing_lock_t *lck,
   kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized 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 ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_queuing_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
     lck->lk.owner_id = 0;
-    __kmp_release_queuing_lock( lck, gtid );
+    return __kmp_release_queuing_lock( lck, gtid );
 }
 
 void
 __kmp_init_queuing_lock( kmp_queuing_lock_t *lck )
 {
     lck->lk.location = NULL;
     lck->lk.head_id = 0;
     lck->lk.tail_id = 0;
if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_queuing_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     return __kmp_test_nested_queuing_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     KMP_MB();
     if ( --(lck->lk.depth_locked) == 0 ) {
         KMP_MB();
         lck->lk.owner_id = 0;
         __kmp_release_queuing_lock( lck, gtid );
+        return KMP_LOCK_RELEASED;
     }
+    return KMP_LOCK_STILL_HELD;
 }
 
-static void
+static int
 __kmp_release_nested_queuing_lock_with_checks( kmp_queuing_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_nest_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_queuing_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_queuing_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_queuing_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_nested_queuing_lock( lck, gtid );
+    return __kmp_release_nested_queuing_lock( lck, gtid );
 }
 
 void
 __kmp_init_nested_queuing_lock( kmp_queuing_lock_t * lck )
 {
     __kmp_init_queuing_lock( lck );
     lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
if ( __kmp_get_queuing_lock_owner( GET_QLK_PTR(lck) ) == gtid ) {
         KMP_FATAL( LockIsAlreadyOwned, func );
     }
 
     __kmp_acquire_adaptive_lock( lck, gtid );
 
     lck->lk.qlk.owner_id = gtid + 1;
 }
 
-static void
+static int
 __kmp_release_adaptive_lock( kmp_adaptive_lock_t *lck, kmp_int32 gtid )
 {
     if ( __kmp_is_unlocked_queuing_lock( GET_QLK_PTR(lck) ) )
     {   // If the lock doesn't look claimed we must be speculating.
         // (Or the user's code is buggy and they're releasing without locking;
         // if we had XTEST we'd be able to check that case...)
         _xend();        // Exit speculation
         __kmp_update_badness_after_success( lck );
     }
     else
     {   // Since the lock *is* visibly locked we're not speculating,
         // so should use the underlying lock's release scheme.
         __kmp_release_queuing_lock( GET_QLK_PTR(lck), gtid );
     }
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_adaptive_lock_with_checks( kmp_adaptive_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.qlk.initialized != GET_QLK_PTR(lck) ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_get_queuing_lock_owner( GET_QLK_PTR(lck) ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_queuing_lock_owner( GET_QLK_PTR(lck) ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
     lck->lk.qlk.owner_id = 0;
     __kmp_release_adaptive_lock( lck, gtid );
+    return KMP_LOCK_RELEASED;
 }
 
 static void
 __kmp_init_adaptive_lock( kmp_adaptive_lock_t *lck )
 {
     __kmp_init_queuing_lock( GET_QLK_PTR(lck) );
     lck->lk.adaptive.badness = 0;
     lck->lk.adaptive.acquire_attempts = 0; //nonSpeculativeAcquireAttempts = 0;
__kmp_test_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
     int retval = __kmp_test_drdpa_lock( lck, gtid );
 
     if ( retval ) {
         lck->lk.owner_id = gtid + 1;
     }
     return retval;
 }
 
-void
+int
 __kmp_release_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     //
     // Read the ticket value from the lock data struct, then the polls
     // pointer and the mask.  The polls pointer must be read before the
     // mask!!! (See above)
     //
     kmp_uint64 ticket = lck->lk.now_serving + 1;        // non-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
     kmp_uint64 mask = TCR_8(lck->lk.mask);              // volatile load
     KA_TRACE(1000, ("__kmp_release_drdpa_lock: ticket #%lld released lock %p\n",
        ticket - 1, lck));
     KMP_FSYNC_RELEASING(lck);
     KMP_ST_REL64(&(polls[ticket & mask].poll), ticket); // volatile store
+    return KMP_LOCK_RELEASED;
 }
 
-static void
+static int
 __kmp_release_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( __kmp_is_drdpa_lock_nestable( lck ) ) {
         KMP_FATAL( LockNestableUsedAsSimple, func );
     }
     if ( __kmp_get_drdpa_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( ( gtid >= 0 ) && ( __kmp_get_drdpa_lock_owner( lck ) >= 0 )
       && ( __kmp_get_drdpa_lock_owner( lck ) != gtid ) ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
     lck->lk.owner_id = 0;
-    __kmp_release_drdpa_lock( lck, gtid );
+    return __kmp_release_drdpa_lock( lck, gtid );
 }
 
 void
 __kmp_init_drdpa_lock( kmp_drdpa_lock_t *lck )
 {
     lck->lk.location = NULL;
     lck->lk.mask = 0;
     lck->lk.num_polls = 1;
if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_drdpa_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     return __kmp_test_nested_drdpa_lock( lck, gtid );
 }
 
-void
+int
 __kmp_release_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     KMP_DEBUG_ASSERT( gtid >= 0 );
 
     KMP_MB();
     if ( --(lck->lk.depth_locked) == 0 ) {
         KMP_MB();
         lck->lk.owner_id = 0;
         __kmp_release_drdpa_lock( lck, gtid );
+        return KMP_LOCK_RELEASED;
     }
+    return KMP_LOCK_STILL_HELD;
 }
 
-static void
+static int
 __kmp_release_nested_drdpa_lock_with_checks( kmp_drdpa_lock_t *lck, kmp_int32 gtid )
 {
     char const * const func = "omp_unset_nest_lock";
     KMP_MB();  /* in case another processor initialized lock */
     if ( lck->lk.initialized != lck ) {
         KMP_FATAL( LockIsUninitialized, func );
     }
     if ( ! __kmp_is_drdpa_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_drdpa_lock_owner( lck ) == -1 ) {
         KMP_FATAL( LockUnsettingFree, func );
     }
     if ( __kmp_get_drdpa_lock_owner( lck ) != gtid ) {
         KMP_FATAL( LockUnsettingSetByAnother, func );
     }
-    __kmp_release_nested_drdpa_lock( lck, gtid );
+    return __kmp_release_nested_drdpa_lock( lck, gtid );
 }
 
 void
 __kmp_init_nested_drdpa_lock( kmp_drdpa_lock_t * lck )
 {
     __kmp_init_drdpa_lock( lck );
     lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }

 
 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_test_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
-void ( *__kmp_release_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_test_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid ) = NULL;
-void ( *__kmp_release_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;
 void ( *__kmp_set_user_lock_location_ )( kmp_user_lock_p lck, const ident_t *loc ) = NULL;
 kmp_lock_flags_t ( *__kmp_get_user_lock_flags_ )( kmp_user_lock_p lck ) = NULL;
 void ( *__kmp_set_user_lock_flags_ )( kmp_user_lock_p lck, kmp_lock_flags_t flags ) = NULL;