[OpenMP][host runtime] Introduce kmp_cpuinfo_flags_t to replace integer flags

[jlpeyton]

Summary

Store CPUID support flags as bits instead of using entire integers.

[Nawrin]

LGTM

openmp/runtime/src/kmp.h

 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 typedef struct kmp_cpuid {
   kmp_uint32 eax;
   kmp_uint32 ebx;
   kmp_uint32 ecx;
   kmp_uint32 edx;
 } kmp_cpuid_t;
 
+typedef struct kmp_cpuinfo_flags_t {
+  unsigned sse2 : 1; // 0 if SSE2 instructions are not supported, 1 otherwise.
+  unsigned rtm : 1; // 0 if RTM instructions are not supported, 1 otherwise.
+  unsigned reserved : 30; // Ensure size of 32 bits
+} kmp_cpuinfo_flags_t;
+
 typedef struct kmp_cpuinfo {
   int initialized; // If 0, other fields are not initialized.
   int signature; // CPUID(1).EAX
   int family; // CPUID(1).EAX[27:20]+CPUID(1).EAX[11:8] (Extended Family+Family)
   int model; // ( CPUID(1).EAX[19:16] << 4 ) + CPUID(1).EAX[7:4] ( ( Extended
   // Model << 4 ) + Model)
   int stepping; // CPUID(1).EAX[3:0] ( Stepping )
-  int sse2; // 0 if SSE2 instructions are not supported, 1 otherwise.
-  int rtm; // 0 if RTM instructions are not supported, 1 otherwise.
+  kmp_cpuinfo_flags_t flags;
   int apic_id;
   int physical_id;
   int logical_id;
   kmp_uint64 frequency; // Nominal CPU frequency in Hz.
   char name[3 * sizeof(kmp_cpuid_t)]; // CPUID(0x80000002,0x80000003,0x80000004)
 } kmp_cpuinfo_t;
 
 extern void __kmp_query_cpuid(kmp_cpuinfo_t *p);

openmp/runtime/src/kmp_csupport.cpp

#else
   // This is to address non-temporal store instructions (sfence needed).
   // The clflush instruction is addressed either (mfence needed).
   // Probably the non-temporal load monvtdqa instruction should also be
   // addressed.
   // mfence is a SSE2 instruction. Do not execute it if CPU is not SSE2.
   if (!__kmp_cpuinfo.initialized) {
     __kmp_query_cpuid(&__kmp_cpuinfo);
   }
-  if (!__kmp_cpuinfo.sse2) {
+  if (!__kmp_cpuinfo.flags.sse2) {
     // CPU cannot execute SSE2 instructions.
   } else {
 #if KMP_COMPILER_ICC
     _mm_mfence();
 #elif KMP_COMPILER_MSVC
     MemoryBarrier();
 #else
     __sync_synchronize();

 static __forceinline kmp_dyna_lockseq_t __kmp_map_hint_to_lock(uintptr_t hint) {
 #if KMP_USE_TSX
 #define KMP_TSX_LOCK(seq) lockseq_##seq
 #else
 #define KMP_TSX_LOCK(seq) __kmp_user_lock_seq
 #endif
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-#define KMP_CPUINFO_RTM (__kmp_cpuinfo.rtm)
+#define KMP_CPUINFO_RTM (__kmp_cpuinfo.flags.rtm)
 #else
 #define KMP_CPUINFO_RTM 0
 #endif
 
   // Hints that do not require further logic
   if (hint & kmp_lock_hint_hle)
     return KMP_TSX_LOCK(hle);
   if (hint & kmp_lock_hint_rtm)

openmp/runtime/src/kmp_lock.cpp

if (OMP_LOCK_T_SIZE < sizeof(void *)) {
       return *((kmp_indirect_lock_t **)user_lock);
     }
   }
 }
 
 static void __kmp_init_indirect_lock(kmp_dyna_lock_t *lock,
                                      kmp_dyna_lockseq_t seq) {
 #if KMP_USE_ADAPTIVE_LOCKS
-  if (seq == lockseq_adaptive && !__kmp_cpuinfo.rtm) {
+  if (seq == lockseq_adaptive && !__kmp_cpuinfo.flags.rtm) {
     KMP_WARNING(AdaptiveNotSupported, "kmp_lockseq_t", "adaptive");
     seq = lockseq_queuing;
   }
 #endif
 #if KMP_USE_TSX
-  if (seq == lockseq_rtm_queuing && !__kmp_cpuinfo.rtm) {
+  if (seq == lockseq_rtm_queuing && !__kmp_cpuinfo.flags.rtm) {
     seq = lockseq_queuing;
   }
 #endif
   kmp_indirect_locktag_t tag = KMP_GET_I_TAG(seq);
   kmp_indirect_lock_t *l =
       __kmp_allocate_indirect_lock((void **)lock, __kmp_entry_gtid(), tag);
   KMP_I_LOCK_FUNC(l, init)(l->lock);
   KA_TRACE(

openmp/runtime/src/kmp_os.h

 #else
 #define KMP_MFENCE_() __sync_synchronize()
 #define KMP_SFENCE_() __sync_synchronize()
 #endif
 #define KMP_MFENCE()                                                           \
   if (UNLIKELY(!__kmp_cpuinfo.initialized)) {                                  \
     __kmp_query_cpuid(&__kmp_cpuinfo);                                         \
   }                                                                            \
-  if (__kmp_cpuinfo.sse2) {                                                    \
+  if (__kmp_cpuinfo.flags.sse2) {                                              \
     KMP_MFENCE_();                                                             \
   }
 #define KMP_SFENCE() KMP_SFENCE_()
 #else
 #define KMP_MFENCE() KMP_MB()
 #define KMP_SFENCE() KMP_MB()
 #endif
 

openmp/runtime/src/kmp_settings.cpp

KMP_STORE_LOCK_SEQ(queuing);
              __kmp_str_match("drdpa-ticket", 1, value) ||
              __kmp_str_match("drdpaticket", 1, value) ||
              __kmp_str_match("drdpa", 1, value)) {
     __kmp_user_lock_kind = lk_drdpa;
     KMP_STORE_LOCK_SEQ(drdpa);
   }
 #if KMP_USE_ADAPTIVE_LOCKS
   else if (__kmp_str_match("adaptive", 1, value)) {
-    if (__kmp_cpuinfo.rtm) { // ??? Is cpuinfo available here?
+    if (__kmp_cpuinfo.flags.rtm) { // ??? Is cpuinfo available here?
       __kmp_user_lock_kind = lk_adaptive;
       KMP_STORE_LOCK_SEQ(adaptive);
     } else {
       KMP_WARNING(AdaptiveNotSupported, name, value);
       __kmp_user_lock_kind = lk_queuing;
       KMP_STORE_LOCK_SEQ(queuing);
     }
   }
 #endif // KMP_USE_ADAPTIVE_LOCKS
 #if KMP_USE_DYNAMIC_LOCK && KMP_USE_TSX
   else if (__kmp_str_match("rtm_queuing", 1, value)) {
-    if (__kmp_cpuinfo.rtm) {
+    if (__kmp_cpuinfo.flags.rtm) {
       __kmp_user_lock_kind = lk_rtm_queuing;
       KMP_STORE_LOCK_SEQ(rtm_queuing);
     } else {
       KMP_WARNING(AdaptiveNotSupported, name, value);
       __kmp_user_lock_kind = lk_queuing;
       KMP_STORE_LOCK_SEQ(queuing);
     }
   } else if (__kmp_str_match("rtm_spin", 1, value)) {
-    if (__kmp_cpuinfo.rtm) {
+    if (__kmp_cpuinfo.flags.rtm) {
       __kmp_user_lock_kind = lk_rtm_spin;
       KMP_STORE_LOCK_SEQ(rtm_spin);
     } else {
       KMP_WARNING(AdaptiveNotSupported, name, value);
       __kmp_user_lock_kind = lk_tas;
       KMP_STORE_LOCK_SEQ(queuing);
     }
   } else if (__kmp_str_match("hle", 1, value)) {

openmp/runtime/src/kmp_utility.cpp

void __kmp_query_cpuid(kmp_cpuinfo_t *p) {
   int max_arg;
   int log_per_phy;
 #ifdef KMP_DEBUG
   int cflush_size;
 #endif
 
   p->initialized = 1;
 
-  p->sse2 = 1; // Assume SSE2 by default.
+  p->flags.sse2 = 1; // Assume SSE2 by default.
 
   __kmp_x86_cpuid(0, 0, &buf);
 
   KA_TRACE(trace_level,
            ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n", 0,
             buf.eax, buf.ebx, buf.ecx, buf.edx));
 
   max_arg = buf.eax;
#undef get_value
       KA_TRACE(trace_level, (" family = %d, model = %d, stepping = %d\n",
                              p->family, p->model, p->stepping));
     }
 
     for (t = buf.ebx, i = 0; i < 4; t >>= 8, ++i) {
       data[i] = (t & 0xff);
     }
 
-    p->sse2 = (buf.edx >> 26) & 1;
+    p->flags.sse2 = (buf.edx >> 26) & 1;
 
 #ifdef KMP_DEBUG
 
     if ((buf.edx >> 4) & 1) {
       /* TSC - Timestamp Counter Available */
       KA_TRACE(trace_level, (" TSC"));
     }
     if ((buf.edx >> 8) & 1) {
#ifdef KMP_DEBUG
     for (i = 2; i <= max_arg; ++i) {
       __kmp_x86_cpuid(i, 0, &buf);
       KA_TRACE(trace_level,
                ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
                 i, buf.eax, buf.ebx, buf.ecx, buf.edx));
     }
 #endif
 #if KMP_USE_ADAPTIVE_LOCKS
-    p->rtm = 0;
+    p->flags.rtm = 0;
     if (max_arg > 7) {
       /* RTM bit CPUID.07:EBX, bit 11 */
       __kmp_x86_cpuid(7, 0, &buf);
-      p->rtm = (buf.ebx >> 11) & 1;
+      p->flags.rtm = (buf.ebx >> 11) & 1;
       KA_TRACE(trace_level, (" RTM"));
     }
 #endif
   }
 
   { // Parse CPU brand string for frequency, saving the string for later.
     int i;
     kmp_cpuid_t *base = (kmp_cpuid_t *)&p->name[0];