Clean all the mess around KMP_USE_FUTEX and kmp_lock.h

[pawosm01]

Summary

KMP_USE_FUTEX preprocessor definition defined in kmp_lock.h is used
inconsequently throughout LLVM libomp code.

• some .c files that use this define do not include kmp_lock.h file, in effect guarded part of code are never compiled
• some places in code use architecture-depending preprocessor logic expressions which effectively disable use of Futex for AArch64 architecture, all these places should use '#if KMP_USE_FUTEX' instead to avoid any further confusions
• some places use KMP_HAS_FUTEX which is nowhere defined, KMP_USE_FUTEX should be used instead

[hbae]

The change looks good to me.

[pawosm01]

In D19629#429892, @hbae wrote:

The change looks good to me.

Can it land?

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp.h

 extern int __kmp_aux_unset_affinity_mask_proc(int proc, void **mask);
 extern int __kmp_aux_get_affinity_mask_proc(int proc, void **mask);
 extern void __kmp_balanced_affinity( int tid, int team_size );
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 extern void __kmp_cleanup_hierarchy();
 extern void __kmp_get_hierarchy(kmp_uint32 nproc, kmp_bstate_t *thr_bar);
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#if KMP_USE_FUTEX
 
 extern int __kmp_futex_determine_capable( void );
 
-#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#endif // KMP_USE_FUTEX
 
 extern void __kmp_gtid_set_specific( int gtid );
 extern int  __kmp_gtid_get_specific( void );
 
 extern double __kmp_read_cpu_time( void );
 
 extern int  __kmp_read_system_info( struct kmp_sys_info *info );
 

openmp/trunk/runtime/src/kmp_csupport.c

 //
 //===----------------------------------------------------------------------===//
 
 
 #include "omp.h"        /* extern "C" declarations of user-visible routines */
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
+#include "kmp_lock.h"
 #include "kmp_error.h"
 #include "kmp_stats.h"
 
 #if OMPT_SUPPORT
 #include "ompt-internal.h"
 #include "ompt-specific.h"
 #endif
 

openmp/trunk/runtime/src/kmp_lock.cpp

 #include <stddef.h>
 
 #include "kmp.h"
 #include "kmp_itt.h"
 #include "kmp_i18n.h"
 #include "kmp_lock.h"
 #include "kmp_io.h"
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#if KMP_USE_FUTEX
 # include <unistd.h>
 # include <sys/syscall.h>
 // We should really include <futex.h>, but that causes compatibility problems on different
 // Linux* OS distributions that either require that you include (or break when you try to include)
 // <pci/types.h>.
 // Since all we need is the two macros below (which are part of the kernel ABI, so can't change)
 // we just define the constants here and don't include <futex.h>
 # ifndef FUTEX_WAIT
__kmp_destroy_nested_tas_lock_with_checks( kmp_tas_lock_t *lck )
     }
     if ( __kmp_get_tas_lock_owner( lck ) != -1 ) {
         KMP_FATAL( LockStillOwned, func );
     }
     __kmp_destroy_nested_tas_lock( lck );
 }
 
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#if KMP_USE_FUTEX
 
 /* ------------------------------------------------------------------------ */
 /* futex locks */
 
 // futex locks are really just test and set locks, with a different method
 // of handling contention.  They take the same amount of space as test and
 // set locks, and are allocated the same way (i.e. use the area allocated by
 // the compiler for non-nested locks / allocate nested locks on the heap).
if ( ! __kmp_is_futex_lock_nestable( lck ) ) {
         KMP_FATAL( LockSimpleUsedAsNestable, func );
     }
     if ( __kmp_get_futex_lock_owner( lck ) != -1 ) {
         KMP_FATAL( LockStillOwned, func );
     }
     __kmp_destroy_nested_futex_lock( lck );
 }
 
-#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#endif // KMP_USE_FUTEX
 
 
 /* ------------------------------------------------------------------------ */
 /* ticket (bakery) locks */
 
 static kmp_int32
 __kmp_get_ticket_lock_owner( kmp_ticket_lock_t *lck )
 {

 // This is used only in kmp_error.c when consistency checking is on.
 kmp_int32
 __kmp_get_user_lock_owner(kmp_user_lock_p lck, kmp_uint32 seq)
 {
     switch (seq) {
         case lockseq_tas:
         case lockseq_nested_tas:
             return __kmp_get_tas_lock_owner((kmp_tas_lock_t *)lck);
-#if KMP_HAS_FUTEX
+#if KMP_USE_FUTEX
         case lockseq_futex:
         case lockseq_nested_futex:
             return __kmp_get_futex_lock_owner((kmp_futex_lock_t *)lck);
 #endif
         case lockseq_ticket:
         case lockseq_nested_ticket:
             return __kmp_get_ticket_lock_owner((kmp_ticket_lock_t *)lck);
         case lockseq_queuing:
switch ( user_lock_kind ) {
              __kmp_get_user_lock_flags_ =
                ( kmp_lock_flags_t ( * )( kmp_user_lock_p ) ) NULL;
 
              __kmp_set_user_lock_flags_ =
                ( void ( * )( kmp_user_lock_p, kmp_lock_flags_t ) ) NULL;
         }
         break;
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#if KMP_USE_FUTEX
 
         case lk_futex: {
             __kmp_base_user_lock_size = sizeof( kmp_base_futex_lock_t );
             __kmp_user_lock_size = sizeof( kmp_futex_lock_t );
 
             __kmp_get_user_lock_owner_ =
               ( kmp_int32 ( * )( kmp_user_lock_p ) )
               ( &__kmp_get_futex_lock_owner );
#if KMP_USE_FUTEX
              __kmp_get_user_lock_flags_ =
                ( kmp_lock_flags_t ( * )( kmp_user_lock_p ) ) NULL;
 
              __kmp_set_user_lock_flags_ =
                ( void ( * )( kmp_user_lock_p, kmp_lock_flags_t ) ) NULL;
         }
         break;
 
-#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#endif // KMP_USE_FUTEX
 
         case lk_ticket: {
             __kmp_base_user_lock_size = sizeof( kmp_base_ticket_lock_t );
             __kmp_user_lock_size = sizeof( kmp_ticket_lock_t );
 
             __kmp_get_user_lock_owner_ =
               ( kmp_int32 ( * )( kmp_user_lock_p ) )
               ( &__kmp_get_ticket_lock_owner );

openmp/trunk/runtime/src/kmp_settings.c

 #include "kmp.h"
 #include "kmp_wrapper_getpid.h"
 #include "kmp_environment.h"
 #include "kmp_atomic.h"
 #include "kmp_itt.h"
 #include "kmp_str.h"
 #include "kmp_settings.h"
 #include "kmp_i18n.h"
+#include "kmp_lock.h"
 #include "kmp_io.h"
 
 static int __kmp_env_toPrint( char const * name, int flag );
 
 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
 // -------------------------------------------------------------------------------------------------
 // Helper string functions. Subject to move to kmp_str.
 // -------------------------------------------------------------------------------------------------
if ( __kmp_str_match( "tas", 2, value )
       || __kmp_str_match( "test-andset", 2, value )
       || __kmp_str_match( "testand set", 2, value )
       || __kmp_str_match( "testand_set", 2, value )
       || __kmp_str_match( "testand-set", 2, value )
       || __kmp_str_match( "testandset", 2, value ) ) {
         __kmp_user_lock_kind = lk_tas;
         KMP_STORE_LOCK_SEQ(tas);
     }
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)
+#if KMP_USE_FUTEX
     else if ( __kmp_str_match( "futex", 1, value ) ) {
         if ( __kmp_futex_determine_capable() ) {
             __kmp_user_lock_kind = lk_futex;
             KMP_STORE_LOCK_SEQ(futex);
         }
         else {
             KMP_WARNING( FutexNotSupported, name, value );
         }
switch ( __kmp_user_lock_kind ) {
         case lk_default:
         value = "default";
         break;
 
         case lk_tas:
         value = "tas";
         break;
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_USE_FUTEX
         case lk_futex:
         value = "futex";
         break;
 #endif
 
 #if KMP_USE_DYNAMIC_LOCK && KMP_USE_TSX
         case lk_rtm:
         value = "rtm";

openmp/trunk/runtime/src/z_Linux_util.c

 //===----------------------------------------------------------------------===//
 
 
 #include "kmp.h"
 #include "kmp_wrapper_getpid.h"
 #include "kmp_itt.h"
 #include "kmp_str.h"
 #include "kmp_i18n.h"
+#include "kmp_lock.h"
 #include "kmp_io.h"
 #include "kmp_stats.h"
 #include "kmp_wait_release.h"
 
 #if !KMP_OS_FREEBSD && !KMP_OS_NETBSD
 # include <alloca.h>
 #endif
 #include <unistd.h>
 #include <math.h>               // HUGE_VAL.
 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 
 #if KMP_OS_LINUX && !KMP_OS_CNK
 # include <sys/sysinfo.h>
-# if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+# if KMP_USE_FUTEX
 // We should really include <futex.h>, but that causes compatibility problems on different
 // Linux* OS distributions that either require that you include (or break when you try to include)
 // <pci/types.h>.
 // Since all we need is the two macros below (which are part of the kernel ABI, so can't change)
 // we just define the constants here and don't include <futex.h>
 #  ifndef FUTEX_WAIT
 #   define FUTEX_WAIT    0
 #  endif
# define KMP_CPU_SET_SIZE_LIMIT          (1024*1024)
     }
 }
 
 #endif // KMP_OS_LINUX && KMP_AFFINITY_SUPPORTED
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && !KMP_OS_CNK
+#if KMP_USE_FUTEX && !KMP_OS_CNK
 
 int
 __kmp_futex_determine_capable()
 {
     int loc = 0;
     int rc = syscall( __NR_futex, &loc, FUTEX_WAKE, 1, NULL, NULL, 0 );
     int retval = ( rc == 0 ) || ( errno != ENOSYS );
 
     KA_TRACE(10, ( "__kmp_futex_determine_capable: rc = %d errno = %d\n", rc,
       errno ) );
     KA_TRACE(10, ( "__kmp_futex_determine_capable: futex syscall%s supported\n",
         retval ? "" : " not" ) );
 
     return retval;
 }
 
-#endif // KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM) && !KMP_OS_CNK
+#endif // KMP_USE_FUTEX && !KMP_OS_CNK
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64) && (! KMP_ASM_INTRINS)
 /*
  * Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to
  * use compare_and_store for these routines