Cleanup: two consecutive PAUSE instructions per spin loop iteration replaced with single one

[AndreyChurbanov]

Summary

Multiple consecutive hint to a processor about execution of a spin loop look redundant. This patch eliminates extra PAUSE leaving single one per iteration of spin loop on a barrier.

Testing on many platforms showed no performance impact of this change. But on Intel KNC the patch revealed performance regressions on Spec OMPM 2001 test suite (actually the pause instruction is not supported there - _mm_delay_32 intrinsic used instead). Making the pause two times longer restored the performance, and making it three times longer showed even better results - performance improvement on some tests - 314.mgrid_m, 324.apsi_m and 328.fma3d_m. So the delay interval changed from 100 ticks to 300.

[tlwilmar]

LGTM

runtime/src/kmp.h

typedef struct kmp_cpuid {
   kmp_uint32 ebx;
   kmp_uint32 ecx;
   kmp_uint32 edx;
 } kmp_cpuid_t;
 extern void __kmp_x86_cpuid(int mode, int mode2, struct kmp_cpuid *p);
 #if KMP_ARCH_X86
 extern void __kmp_x86_pause(void);
 #elif KMP_MIC
-static void __kmp_x86_pause(void) { _mm_delay_32(100); }
+// Performance testing on KNC (C0QS-7120 P/A/X/D, 61-core, 16 GB Memory) showed
+// regression after removal of extra PAUSE from KMP_YIELD_SPIN(). Changing
+// the delay from 100 to 300 showed even better performance than double PAUSE
+// on Spec OMP2001 and LCPC tasking tests, no regressions on EPCC.
+static void __kmp_x86_pause(void) { _mm_delay_32(300); }
 #else
 static void __kmp_x86_pause(void) { _mm_pause(); }
 #endif
 #define KMP_CPU_PAUSE() __kmp_x86_pause()
 #elif KMP_ARCH_PPC64
 #define KMP_PPC64_PRI_LOW() __asm__ volatile("or 1, 1, 1")
 #define KMP_PPC64_PRI_MED() __asm__ volatile("or 2, 2, 2")
 #define KMP_PPC64_PRI_LOC_MB() __asm__ volatile("" : : : "memory")

 // Note the decrement of 2 in the following Macros. With KMP_LIBRARY=turnaround,
 // there should be no yielding since initial value from KMP_INIT_YIELD() is odd.
 
 #define KMP_YIELD_WHEN(cond, count)                                            \
   {                                                                            \
     KMP_CPU_PAUSE();                                                           \
     (count) -= 2;                                                              \
     if (!(count)) {                                                            \
-      KMP_YIELD(cond);                                                         \
+      __kmp_yield(cond);                                                       \
       (count) = __kmp_yield_next;                                              \
     }                                                                          \
   }
 #define KMP_YIELD_SPIN(count)                                                  \
   {                                                                            \
     KMP_CPU_PAUSE();                                                           \
     (count) -= 2;                                                              \
     if (!(count)) {                                                            \
-      KMP_YIELD(1);                                                            \
+      __kmp_yield(1);                                                          \
       (count) = __kmp_yield_next;                                              \
     }                                                                          \
   }
 
 /* ------------------------------------------------------------------------ */
 /* Support datatypes for the orphaned construct nesting checks.             */
 /* ------------------------------------------------------------------------ */
 

runtime/src/kmp_wait_release.h

enum flag_type {
   flag_oncore /**< special 64-bit flag for on-core barrier (hierarchical) */
 };
 
 /*!
  * Base class for wait/release volatile flag
  */
 template <typename P> class kmp_flag {
   volatile P
       *loc; /**< Pointer to the flag storage that is modified by another thread
              */
   flag_type t; /**< "Type" of the flag in loc */
 public:
   typedef P flag_t;
   kmp_flag(volatile P *p, flag_type ft) : loc(p), t(ft) {}
   /*!
    * @result the pointer to the actual flag
    */
while (flag->notdone_check()) {
     if (TCR_4(__kmp_global.g.g_done)) {
       if (__kmp_global.g.g_abort)
         __kmp_abort_thread();
       break;
     }
 
     // If we are oversubscribed, or have waited a bit (and
     // KMP_LIBRARY=throughput), then yield
-    KMP_YIELD(oversubscribed);
     // TODO: Should it be number of cores instead of thread contexts? Like:
     // KMP_YIELD(TCR_4(__kmp_nth) > __kmp_ncores);
     // Need performance improvement data to make the change...
+    if (oversubscribed) {
+      KMP_YIELD(1);
+    } else {
       KMP_YIELD_SPIN(spins);
+    }
     // Check if this thread was transferred from a team
     // to the thread pool (or vice-versa) while spinning.
     in_pool = !!TCR_4(this_thr->th.th_in_pool);
     if (in_pool != !!this_thr->th.th_active_in_pool) {
       if (in_pool) { // Recently transferred from team to pool
         KMP_TEST_THEN_INC32(&__kmp_thread_pool_active_nth);
         this_thr->th.th_active_in_pool = TRUE;
         /* Here, we cannot assert that: