Enable yield cycle on Linux

[hbae]

Summary

This change allows the runtime to turn __kmp_yield() on/off repeatedly on Linux.
This feature was removed when disabling monitor thread, but there are applications that perform better with this feature on.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp.h

 #define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups)  \
                                  ( ( (blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1 ) /  \
                                    (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) )
 #else
 # if KMP_OS_UNIX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
    // HW TSC is used to reduce overhead (clock tick instead of nanosecond).
    extern double __kmp_ticks_per_nsec;
 #  define KMP_NOW() __kmp_hardware_timestamp()
+#  define KMP_NOW_MSEC() ((kmp_uint64)(KMP_NOW()/__kmp_ticks_per_nsec)/KMP_USEC_PER_SEC)
 #  define KMP_BLOCKTIME_INTERVAL() (__kmp_dflt_blocktime * KMP_USEC_PER_SEC * __kmp_ticks_per_nsec)
 #  define KMP_BLOCKING(goal, count) ((goal) > KMP_NOW())
 # else
    // System time is retrieved sporadically while blocking.
    extern kmp_uint64 __kmp_now_nsec();
 #  define KMP_NOW() __kmp_now_nsec()
+#  define KMP_NOW_MSEC() (KMP_NOW()/KMP_USEC_PER_SEC)
 #  define KMP_BLOCKTIME_INTERVAL() (__kmp_dflt_blocktime * KMP_USEC_PER_SEC)
 #  define KMP_BLOCKING(goal, count) ((count) % 1000 != 0 || (goal) > KMP_NOW())
 # endif
+# define KMP_YIELD_NOW() (KMP_NOW_MSEC() / KMP_MAX(__kmp_dflt_blocktime, 1)  \
+                         % (__kmp_yield_on_count + __kmp_yield_off_count) < (kmp_uint32)__kmp_yield_on_count)
 #endif // KMP_USE_MONITOR
 
 #define KMP_MIN_STATSCOLS       40
 #define KMP_MAX_STATSCOLS       4096
 #define KMP_DEFAULT_STATSCOLS   80
 
 #define KMP_MIN_INTERVAL        0
 #define KMP_MAX_INTERVAL        (INT_MAX-1)

 extern int        __kmp_suspend_count;  /* count inside __kmp_suspend_template() */
 #endif
 
 extern kmp_uint32 __kmp_yield_init;
 extern kmp_uint32 __kmp_yield_next;
 
 #if KMP_USE_MONITOR
 extern kmp_uint32 __kmp_yielding_on;
+#endif
 extern kmp_uint32 __kmp_yield_cycle;
 extern kmp_int32  __kmp_yield_on_count;
 extern kmp_int32  __kmp_yield_off_count;
-#endif
 
 /* ------------------------------------------------------------------------- */
 extern int        __kmp_allThreadsSpecified;
 
 extern size_t     __kmp_align_alloc;
 /* following data protected by initialization routines */
 extern int        __kmp_xproc;          /* number of processors in the system */
 extern int        __kmp_avail_proc;      /* number of processors available to the process */

openmp/trunk/runtime/src/kmp_global.cpp

 int        __kmp_env_checks      = FALSE;  /* KMP_CHECKS specified?    */
 int        __kmp_env_consistency_check  = FALSE;  /* KMP_CONSISTENCY_CHECK specified? */
 
 kmp_uint32 __kmp_yield_init = KMP_INIT_WAIT;
 kmp_uint32 __kmp_yield_next = KMP_NEXT_WAIT;
 
 #if KMP_USE_MONITOR
 kmp_uint32 __kmp_yielding_on = 1;
+#endif
 #if KMP_OS_CNK
 kmp_uint32 __kmp_yield_cycle = 0;
 #else
 kmp_uint32 __kmp_yield_cycle = 1;     /* Yield-cycle is on by default */
 #endif
 kmp_int32  __kmp_yield_on_count = 10; /* By default, yielding is on for 10 monitor periods. */
 kmp_int32  __kmp_yield_off_count = 1; /* By default, yielding is off for 1 monitor periods. */
-#endif
 /* ----------------------------------------------------- */
 
 
 /* ------------------------------------------------------ */
 /* STATE mostly syncronized with global lock */
 /* data written to rarely by masters, read often by workers */
 /*
  * SHALL WE EDIT THE COMMENT BELOW IN SOME WAY?

openmp/trunk/runtime/src/kmp_settings.cpp

 
 static void
 __kmp_stg_print_par_range_env( kmp_str_buf_t * buffer, char const * name, void * data ) {
     if (__kmp_par_range != 0) {
         __kmp_stg_print_str( buffer, name, par_range_to_print );
     }
 } // __kmp_stg_print_par_range_env
 
-#if KMP_USE_MONITOR
 // -------------------------------------------------------------------------------------------------
 // KMP_YIELD_CYCLE, KMP_YIELD_ON, KMP_YIELD_OFF
 // -------------------------------------------------------------------------------------------------
 
 static void
 __kmp_stg_parse_yield_cycle( char const * name, char const * value, void * data ) {
     int flag = __kmp_yield_cycle;
     __kmp_stg_parse_bool( name, value, & flag );

 __kmp_stg_parse_yield_off( char const * name, char const * value, void * data ) {
         __kmp_stg_parse_int( name, value, 2, INT_MAX, & __kmp_yield_off_count );
 } // __kmp_stg_parse_yield_off
 
 static void
 __kmp_stg_print_yield_off( kmp_str_buf_t * buffer, char const * name, void * data ) {
     __kmp_stg_print_int( buffer, name, __kmp_yield_off_count );
 } // __kmp_stg_print_yield_off
-#endif // KMP_USE_MONITOR
 
 #endif
 
 // -------------------------------------------------------------------------------------------------
 // KMP_INIT_WAIT, KMP_NEXT_WAIT
 // -------------------------------------------------------------------------------------------------
 
 static void
#ifdef KMP_DEBUG
     { "KMP_DEBUG",                         __kmp_stg_parse_debug,              NULL, /* no print */                NULL, 0, 0 },
     { "KMP_DEBUG_BUF",                     __kmp_stg_parse_debug_buf,          __kmp_stg_print_debug_buf,          NULL, 0, 0 },
     { "KMP_DEBUG_BUF_ATOMIC",              __kmp_stg_parse_debug_buf_atomic,   __kmp_stg_print_debug_buf_atomic,   NULL, 0, 0 },
     { "KMP_DEBUG_BUF_CHARS",               __kmp_stg_parse_debug_buf_chars,    __kmp_stg_print_debug_buf_chars,    NULL, 0, 0 },
     { "KMP_DEBUG_BUF_LINES",               __kmp_stg_parse_debug_buf_lines,    __kmp_stg_print_debug_buf_lines,    NULL, 0, 0 },
     { "KMP_DIAG",                          __kmp_stg_parse_diag,               __kmp_stg_print_diag,               NULL, 0, 0 },
 
     { "KMP_PAR_RANGE",                     __kmp_stg_parse_par_range_env,      __kmp_stg_print_par_range_env,      NULL, 0, 0 },
-#if KMP_USE_MONITOR
     { "KMP_YIELD_CYCLE",                   __kmp_stg_parse_yield_cycle,        __kmp_stg_print_yield_cycle,        NULL, 0, 0 },
     { "KMP_YIELD_ON",                      __kmp_stg_parse_yield_on,           __kmp_stg_print_yield_on,           NULL, 0, 0 },
     { "KMP_YIELD_OFF",                     __kmp_stg_parse_yield_off,          __kmp_stg_print_yield_off,          NULL, 0, 0 },
-#endif
 #endif // KMP_DEBUG
 
     { "KMP_ALIGN_ALLOC",                   __kmp_stg_parse_align_alloc,        __kmp_stg_print_align_alloc,        NULL, 0, 0 },
 
     { "KMP_PLAIN_BARRIER",                 __kmp_stg_parse_barrier_branch_bit, __kmp_stg_print_barrier_branch_bit, NULL, 0, 0 },
     { "KMP_PLAIN_BARRIER_PATTERN",         __kmp_stg_parse_barrier_pattern,    __kmp_stg_print_barrier_pattern,    NULL, 0, 0 },
     { "KMP_FORKJOIN_BARRIER",              __kmp_stg_parse_barrier_branch_bit, __kmp_stg_print_barrier_branch_bit, NULL, 0, 0 },
     { "KMP_FORKJOIN_BARRIER_PATTERN",      __kmp_stg_parse_barrier_pattern,    __kmp_stg_print_barrier_pattern,    NULL, 0, 0 },

openmp/trunk/runtime/src/z_Linux_util.cpp

 #endif // KMP_USE_MONITOR
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 void
 __kmp_yield( int cond )
 {
-    if (cond
+    if (!cond)
+        return;
 #if KMP_USE_MONITOR
-        && __kmp_yielding_on
+    if (!__kmp_yielding_on)
+        return;
+#else
+    if (__kmp_yield_cycle && !KMP_YIELD_NOW())
+        return;
 #endif
-    ) {
-        sched_yield();
-    }
-}
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 void
 __kmp_gtid_set_specific( int gtid )
 {
     if( __kmp_init_gtid ) {