Disable monitor thread creation by default.

[hbae]

Summary

This change set disables creation of monitor thread by default.
The global counter maintained by the monitor thread was replaced by logic that uses system time directly, and cyclic yielding on Linux target was also removed since there was no clear benefit of using it. Turning on KMP_USE_MONITOR variable (=1) enables creation of monitor thread again if it is really necessary for some reasons.

[tlwilmar]

LGTM

[jlpeyton]

LGTM

openmp/trunk/runtime/src/dllexports

%ifndef stub
     # the tools contain meaningful names for all the functions that might
     # appear in a backtrace of a thread which is blocked in the RTL.
     #
 
     # Regular entry points
         __kmp_wait_yield_4
         __kmp_fork_call
         __kmp_invoke_microtask
+    %ifdef KMP_USE_MONITOR
         __kmp_launch_monitor
-        __kmp_launch_worker
         __kmp_reap_monitor
+    %endif
+        __kmp_launch_worker
         __kmp_reap_worker
         __kmp_acquire_tas_lock
         __kmp_acquire_nested_tas_lock
         __kmp_acquire_ticket_lock
         __kmp_acquire_nested_ticket_lock
         __kmp_acquire_queuing_lock
         __kmp_acquire_nested_queuing_lock
         __kmp_acquire_drdpa_lock

openmp/trunk/runtime/src/exports_so.txt

#if USE_ITT_BUILD
         __kmp_acquire_queuing_lock;
         __kmp_acquire_tas_lock;
         __kmp_acquire_ticket_lock;
         __kmp_fork_call;
         __kmp_get_reduce_method;
         __kmp_invoke_microtask;
         __kmp_itt_fini_ittlib;
         __kmp_itt_init_ittlib;
+#if KMP_USE_MONITOR
         __kmp_launch_monitor;
-        __kmp_launch_worker;
         __kmp_reap_monitor;
+#endif
+        __kmp_launch_worker;
         __kmp_reap_worker;
         __kmp_release_64;
         __kmp_wait_64;
         __kmp_wait_yield_4;
 
         # ittnotify symbols to be used by debugger
         __kmp_itt_fini_ittlib;
         __kmp_itt_init_ittlib;

openmp/trunk/runtime/src/kmp.h

 extern kmp_cpuinfo_t    __kmp_cpuinfo;
 #endif
 
 extern volatile int __kmp_init_serial;
 extern volatile int __kmp_init_gtid;
 extern volatile int __kmp_init_common;
 extern volatile int __kmp_init_middle;
 extern volatile int __kmp_init_parallel;
+#if KMP_USE_MONITOR
 extern volatile int __kmp_init_monitor;
+#endif
 extern volatile int __kmp_init_user_locks;
 extern int __kmp_init_counter;
 extern int __kmp_root_counter;
 extern int __kmp_version;
 
 /* list of address of allocated caches for commons */
 extern kmp_cached_addr_t *__kmp_threadpriv_cache_list;
 

 extern char const   *__kmp_barrier_pattern_env_name    [ bs_last_barrier ];
 extern char const   *__kmp_barrier_type_name           [ bs_last_barrier ];
 extern char const   *__kmp_barrier_pattern_name        [ bp_last_bar ];
 
 /* Global Locks */
 extern kmp_bootstrap_lock_t __kmp_initz_lock;     /* control initialization */
 extern kmp_bootstrap_lock_t __kmp_forkjoin_lock;  /* control fork/join access */
 extern kmp_bootstrap_lock_t __kmp_exit_lock;      /* exit() is not always thread-safe */
+#if KMP_USE_MONITOR
 extern kmp_bootstrap_lock_t __kmp_monitor_lock;   /* control monitor thread creation */
+#endif
 extern kmp_bootstrap_lock_t __kmp_tp_cached_lock; /* used for the hack to allow threadprivate cache and __kmp_threads expansion to co-exist */
 
 extern kmp_lock_t __kmp_global_lock;    /* control OS/global access  */
 extern kmp_queuing_lock_t __kmp_dispatch_lock;  /* control dispatch access  */
 extern kmp_lock_t __kmp_debug_lock;     /* control I/O access for KMP_DEBUG */
 
 /* used for yielding spin-waits */
 extern unsigned int __kmp_init_wait;    /* initial number of spin-tests   */
 extern unsigned int __kmp_next_wait;    /* susequent number of spin-tests */
 
 extern enum library_type __kmp_library;
 
 extern enum sched_type  __kmp_sched;    /* default runtime scheduling */
 extern enum sched_type  __kmp_static;   /* default static scheduling method */
 extern enum sched_type  __kmp_guided;   /* default guided scheduling method */
 extern enum sched_type  __kmp_auto;     /* default auto scheduling method */
 extern int              __kmp_chunk;    /* default runtime chunk size */
 
 extern size_t     __kmp_stksize;        /* stack size per thread         */
+#if KMP_USE_MONITOR
 extern size_t     __kmp_monitor_stksize;/* stack size for monitor thread */
+#endif
 extern size_t     __kmp_stkoffset;      /* stack offset per thread       */
 extern int        __kmp_stkpadding;     /* Should we pad root thread(s) stack */
 
 extern size_t     __kmp_malloc_pool_incr; /* incremental size of pool for kmp_malloc() */
 extern int        __kmp_env_chunk;      /* was KMP_CHUNK specified?     */
 extern int        __kmp_env_stksize;    /* was KMP_STACKSIZE specified? */
 extern int        __kmp_env_omp_stksize;/* was OMP_STACKSIZE specified? */
 extern int        __kmp_env_all_threads;    /* was KMP_ALL_THREADS or KMP_MAX_THREADS specified? */
 extern int        __kmp_env_omp_all_threads;/* was OMP_THREAD_LIMIT specified? */
 extern int        __kmp_env_blocktime;  /* was KMP_BLOCKTIME specified? */
 extern int        __kmp_env_checks;     /* was KMP_CHECKS specified?    */
 extern int        __kmp_env_consistency_check;     /* was KMP_CONSISTENCY_CHECK specified?    */
 extern int        __kmp_generate_warnings; /* should we issue warnings? */
 extern int        __kmp_reserve_warn;   /* have we issued reserve_threads warning? */
 
 #ifdef DEBUG_SUSPEND
 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;
 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 */

 extern void __kmp_clear_system_time( void );
 extern void __kmp_read_system_time( double *delta );
 
 extern void __kmp_check_stack_overlap( kmp_info_t *thr );
 
 extern void __kmp_expand_host_name( char *buffer, size_t size );
 extern void __kmp_expand_file_name( char *result, size_t rlen, char *pattern );
 
-#if KMP_OS_WINDOWS
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 extern void __kmp_initialize_system_tick( void );  /* Initialize timer tick value */
 #endif
 
 extern void __kmp_runtime_initialize( void );  /* machine specific initialization */
 extern void __kmp_runtime_destroy( void );
 
 #if KMP_AFFINITY_SUPPORTED
 extern char *__kmp_affinity_print_mask(char *buf, int buf_len, kmp_affin_mask_t *mask);

 
 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 );
 
+#if KMP_USE_MONITOR
 extern void __kmp_create_monitor( kmp_info_t *th );
+#endif
 
 extern void *__kmp_launch_thread( kmp_info_t *thr );
 
 extern void __kmp_create_worker( int gtid, kmp_info_t *th, size_t stack_size );
 
 #if KMP_OS_WINDOWS
 extern int  __kmp_still_running(kmp_info_t *th);
 extern int  __kmp_is_thread_alive( kmp_info_t * th, DWORD *exit_val );
 extern void __kmp_free_handle( kmp_thread_t tHandle );
 #endif
 
+#if KMP_USE_MONITOR
 extern void __kmp_reap_monitor( kmp_info_t *th );
+#endif
 extern void __kmp_reap_worker( kmp_info_t *th );
 extern void __kmp_terminate_thread( int gtid );
 
 extern void __kmp_suspend_32( int th_gtid, kmp_flag_32 *flag );
 extern void __kmp_suspend_64( int th_gtid, kmp_flag_64 *flag );
 extern void __kmp_suspend_oncore( int th_gtid, kmp_flag_oncore *flag );
 extern void __kmp_resume_32( int target_gtid, kmp_flag_32 *flag );
 extern void __kmp_resume_64( int target_gtid, kmp_flag_64 *flag );

openmp/trunk/runtime/src/kmp_global.c

 /* ----------------------------------------------------- */
 /* INITIALIZATION VARIABLES */
 /* they are syncronized to write during init, but read anytime */
 volatile int        __kmp_init_serial     = FALSE;
 volatile int        __kmp_init_gtid       = FALSE;
 volatile int        __kmp_init_common     = FALSE;
 volatile int        __kmp_init_middle     = FALSE;
 volatile int        __kmp_init_parallel   = FALSE;
+#if KMP_USE_MONITOR
 volatile int        __kmp_init_monitor    = 0;  /* 1 - launched, 2 - actually started (Windows* OS only) */
+#endif
 volatile int        __kmp_init_user_locks = FALSE;
 
 /* list of address of allocated caches for commons */
 kmp_cached_addr_t  *__kmp_threadpriv_cache_list = NULL;
 
 int                 __kmp_init_counter  = 0;
 int                 __kmp_root_counter  = 0;
 int                 __kmp_version       = 0;
 
 volatile kmp_uint32 __kmp_team_counter  = 0;
 volatile kmp_uint32 __kmp_task_counter  = 0;
 
 unsigned int __kmp_init_wait = KMP_DEFAULT_INIT_WAIT;   /* initial number of spin-tests   */
 unsigned int __kmp_next_wait = KMP_DEFAULT_NEXT_WAIT;   /* susequent number of spin-tests */
 
 size_t      __kmp_stksize         = KMP_DEFAULT_STKSIZE;
+#if KMP_USE_MONITOR
 size_t      __kmp_monitor_stksize = 0;  // auto adjust
+#endif
 size_t      __kmp_stkoffset       = KMP_DEFAULT_STKOFFSET;
 int         __kmp_stkpadding      = KMP_MIN_STKPADDING;
 
 size_t    __kmp_malloc_pool_incr  = KMP_DEFAULT_MALLOC_POOL_INCR;
 
 /* Barrier method defaults, settings, and strings */
 /* branch factor = 2^branch_bits (only relevant for tree and hyper barrier types) */
 #if KMP_ARCH_X86_64

 int        __kmp_env_all_threads     = FALSE;/* KMP_ALL_THREADS or KMP_MAX_THREADS specified? */
 int        __kmp_env_omp_all_threads = FALSE;/* OMP_THREAD_LIMIT specified? */
 int        __kmp_env_blocktime   = FALSE;  /* KMP_BLOCKTIME specified? */
 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;
 #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?

  * false sharing if the alignment is not large enough for these locks */
 KMP_ALIGN_CACHE_INTERNODE
 
 kmp_bootstrap_lock_t __kmp_initz_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_initz_lock   ); /* Control initializations */
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_forkjoin_lock; /* control fork/join access */
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_exit_lock;   /* exit() is not always thread-safe */
+#if KMP_USE_MONITOR
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_monitor_lock; /* control monitor thread creation */
+#endif
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_tp_cached_lock; /* used for the hack to allow threadprivate cache and __kmp_threads expansion to co-exist */
 
 KMP_ALIGN_CACHE_INTERNODE
 kmp_lock_t __kmp_global_lock;           /* Control OS/global access */
 KMP_ALIGN_CACHE_INTERNODE
 kmp_queuing_lock_t __kmp_dispatch_lock;         /* Control dispatch access  */
 KMP_ALIGN_CACHE_INTERNODE
 kmp_lock_t __kmp_debug_lock;            /* Control I/O access for KMP_DEBUG */
 #else
 KMP_ALIGN_CACHE
 
 kmp_bootstrap_lock_t __kmp_initz_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_initz_lock   ); /* Control initializations */
 kmp_bootstrap_lock_t __kmp_forkjoin_lock; /* control fork/join access */
 kmp_bootstrap_lock_t __kmp_exit_lock;   /* exit() is not always thread-safe */
+#if KMP_USE_MONITOR
 kmp_bootstrap_lock_t __kmp_monitor_lock; /* control monitor thread creation */
+#endif
 kmp_bootstrap_lock_t __kmp_tp_cached_lock; /* used for the hack to allow threadprivate cache and __kmp_threads expansion to co-exist */
 
 KMP_ALIGN(128)
 kmp_lock_t __kmp_global_lock;           /* Control OS/global access */
 KMP_ALIGN(128)
 kmp_queuing_lock_t __kmp_dispatch_lock;         /* Control dispatch access  */
 KMP_ALIGN(128)
 kmp_lock_t __kmp_debug_lock;            /* Control I/O access for KMP_DEBUG */

openmp/trunk/runtime/src/kmp_runtime.c

#endif
         return new_thr;
     }
 
 
     /* no, well fork a new one */
     KMP_ASSERT( __kmp_nth    == __kmp_all_nth );
     KMP_ASSERT( __kmp_all_nth < __kmp_threads_capacity );
 
+#if KMP_USE_MONITOR
     //
     // If this is the first worker thread the RTL is creating, then also
     // launch the monitor thread.  We try to do this as early as possible.
     //
     if ( ! TCR_4( __kmp_init_monitor ) ) {
         __kmp_acquire_bootstrap_lock( & __kmp_monitor_lock );
         if ( ! TCR_4( __kmp_init_monitor ) ) {
             KF_TRACE( 10, ( "before __kmp_create_monitor\n" ) );
if ( ! TCR_4( __kmp_init_monitor ) ) {
                 while ( TCR_4(__kmp_init_monitor) < 2 ) {
                     KMP_YIELD( TRUE );
                 }
                 KF_TRACE( 10, ( "after monitor thread has started\n" ) );
             #endif
         }
         __kmp_release_bootstrap_lock( & __kmp_monitor_lock );
     }
+#endif
 
     KMP_MB();
     for( new_gtid=1 ; TCR_PTR(__kmp_threads[new_gtid]) != NULL; ++new_gtid ) {
         KMP_DEBUG_ASSERT( new_gtid < __kmp_threads_capacity );
     }
 
     /* allocate space for it. */
     new_thr = (kmp_info_t*) __kmp_allocate( sizeof(kmp_info_t) );
__kmp_internal_end(void)
     for( i=0 ; i<__kmp_threads_capacity ; i++ )
         if( __kmp_root[i] )
             if( __kmp_root[i]->r.r_active )
                 break;
     KMP_MB();       /* Flush all pending memory write invalidates.  */
     TCW_SYNC_4(__kmp_global.g.g_done, TRUE);
 
     if ( i < __kmp_threads_capacity ) {
+#if KMP_USE_MONITOR
         // 2009-09-08 (lev): Other alive roots found. Why do we kill the monitor??
         KMP_MB();       /* Flush all pending memory write invalidates.  */
 
         //
         // Need to check that monitor was initialized before reaping it.
         // If we are called form __kmp_atfork_child (which sets
         // __kmp_init_parallel = 0), then __kmp_monitor will appear to
         // contain valid data, but it is only valid in the parent process,
         // not the child.
         //
         // New behavior (201008): instead of keying off of the flag
         // __kmp_init_parallel, the monitor thread creation is keyed off
         // of the new flag __kmp_init_monitor.
         //
         __kmp_acquire_bootstrap_lock( & __kmp_monitor_lock );
         if ( TCR_4( __kmp_init_monitor ) ) {
             __kmp_reap_monitor( & __kmp_monitor );
             TCW_4( __kmp_init_monitor, 0 );
         }
         __kmp_release_bootstrap_lock( & __kmp_monitor_lock );
         KA_TRACE( 10, ("__kmp_internal_end: monitor reaped\n" ) );
+#endif // KMP_USE_MONITOR
     } else {
         /* TODO move this to cleanup code */
         #ifdef KMP_DEBUG
             /* make sure that everything has properly ended */
             for ( i = 0; i < __kmp_threads_capacity; i++ ) {
                 if( __kmp_root[i] ) {
 //                    KMP_ASSERT( ! KMP_UBER_GTID( i ) );         // AC: there can be uber threads alive here
                     KMP_ASSERT( ! __kmp_root[i]->r.r_active );  // TODO: can they be active?
//                    KMP_ASSERT( ! KMP_UBER_GTID( i ) );         // AC: there can be uber threads alive here
 
         /* Make sure all threadprivate destructors get run by joining with all worker
            threads before resetting this flag */
         TCW_SYNC_4(__kmp_init_common, FALSE);
 
         KA_TRACE( 10, ("__kmp_internal_end: all workers reaped\n" ) );
         KMP_MB();
 
+#if KMP_USE_MONITOR
         //
         // See note above: One of the possible fixes for CQ138434 / CQ140126
         //
         // FIXME: push both code fragments down and CSE them?
         // push them into __kmp_cleanup() ?
         //
         __kmp_acquire_bootstrap_lock( & __kmp_monitor_lock );
         if ( TCR_4( __kmp_init_monitor ) ) {
             __kmp_reap_monitor( & __kmp_monitor );
             TCW_4( __kmp_init_monitor, 0 );
         }
         __kmp_release_bootstrap_lock( & __kmp_monitor_lock );
         KA_TRACE( 10, ("__kmp_internal_end: monitor reaped\n" ) );
-
+#endif
     } /* else !__kmp_global.t_active */
     TCW_4(__kmp_init_gtid, FALSE);
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     __kmp_cleanup();
 #if OMPT_SUPPORT
     ompt_fini();
 #endif

 ) {
 
     char * name   = __kmp_reg_status_name();  // Name of the environment variable.
     int    done   = 0;
     union {
         double dtime;
         long   ltime;
     } time;
-    #if KMP_OS_WINDOWS
+    #if KMP_ARCH_X86 || KMP_ARCH_X86_64
         __kmp_initialize_system_tick();
     #endif
     __kmp_read_system_time( & time.dtime );
     __kmp_registration_flag = 0xCAFE0000L | ( time.ltime & 0x0000FFFFL );
     __kmp_registration_str =
         __kmp_str_format(
             "%p-%lx-%s",
             & __kmp_registration_flag,
#endif
     __kmp_init_atomic_lock( & __kmp_atomic_lock_8c  );
     __kmp_init_atomic_lock( & __kmp_atomic_lock_10r );
     __kmp_init_atomic_lock( & __kmp_atomic_lock_16r );
     __kmp_init_atomic_lock( & __kmp_atomic_lock_16c );
     __kmp_init_atomic_lock( & __kmp_atomic_lock_20c );
     __kmp_init_atomic_lock( & __kmp_atomic_lock_32c );
     __kmp_init_bootstrap_lock( & __kmp_forkjoin_lock  );
     __kmp_init_bootstrap_lock( & __kmp_exit_lock      );
+#if KMP_USE_MONITOR
     __kmp_init_bootstrap_lock( & __kmp_monitor_lock   );
+#endif
     __kmp_init_bootstrap_lock( & __kmp_tp_cached_lock );
 
     /* conduct initialization and initial setup of configuration */
 
     __kmp_runtime_initialize();
 
 #if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
     __kmp_check_mic_type();

openmp/trunk/runtime/src/kmp_settings.c

if ( wait->omp ) {
         }; // switch
     }; // if
     if ( value != NULL ) {
         __kmp_stg_print_str( buffer, name, value );
     }; // if
 
 } // __kmp_stg_print_wait_policy
 
+#if KMP_USE_MONITOR
 // -------------------------------------------------------------------------------------------------
 // KMP_MONITOR_STACKSIZE
 // -------------------------------------------------------------------------------------------------
 
 static void
 __kmp_stg_parse_monitor_stacksize( char const * name, char const * value, void * data ) {
     __kmp_stg_parse_size(
         name,
__kmp_stg_print_monitor_stacksize( kmp_str_buf_t * buffer, char const * name, void * data ) {
     } else {
         __kmp_str_buf_print( buffer, ": %s\n", KMP_I18N_STR( NotDefined ) );
     }
     if( __kmp_env_format && __kmp_monitor_stksize ) {
             __kmp_str_buf_print( buffer, "'\n");
     }
 
 } // __kmp_stg_print_monitor_stacksize
+#endif // KMP_USE_MONITOR
 
 // -------------------------------------------------------------------------------------------------
 // KMP_SETTINGS
 // -------------------------------------------------------------------------------------------------
 
 static void
 __kmp_stg_parse_settings( char const * name, char const * value, void * data ) {
     __kmp_stg_parse_bool( name, value, & __kmp_settings );

 
 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

 
 static kmp_setting_t __kmp_stg_table[] = {
 
     { "KMP_ALL_THREADS",                   __kmp_stg_parse_all_threads,        __kmp_stg_print_all_threads,        NULL, 0, 0 },
     { "KMP_BLOCKTIME",                     __kmp_stg_parse_blocktime,          __kmp_stg_print_blocktime,          NULL, 0, 0 },
     { "KMP_DUPLICATE_LIB_OK",              __kmp_stg_parse_duplicate_lib_ok,   __kmp_stg_print_duplicate_lib_ok,   NULL, 0, 0 },
     { "KMP_LIBRARY",                       __kmp_stg_parse_wait_policy,        __kmp_stg_print_wait_policy,        NULL, 0, 0 },
     { "KMP_MAX_THREADS",                   __kmp_stg_parse_all_threads,        NULL,                               NULL, 0, 0 }, // For backward compatibility
+#if KMP_USE_MONITOR
     { "KMP_MONITOR_STACKSIZE",             __kmp_stg_parse_monitor_stacksize,  __kmp_stg_print_monitor_stacksize,  NULL, 0, 0 },
+#endif
     { "KMP_SETTINGS",                      __kmp_stg_parse_settings,           __kmp_stg_print_settings,           NULL, 0, 0 },
     { "KMP_STACKOFFSET",                   __kmp_stg_parse_stackoffset,        __kmp_stg_print_stackoffset,        NULL, 0, 0 },
     { "KMP_STACKSIZE",                     __kmp_stg_parse_stacksize,          __kmp_stg_print_stacksize,          NULL, 0, 0 },
     { "KMP_STACKPAD",                      __kmp_stg_parse_stackpad,           __kmp_stg_print_stackpad,           NULL, 0, 0 },
     { "KMP_VERSION",                       __kmp_stg_parse_version,            __kmp_stg_print_version,            NULL, 0, 0 },
     { "KMP_WARNINGS",                      __kmp_stg_parse_warnings,           __kmp_stg_print_warnings,           NULL, 0, 0 },
 
     { "OMP_NESTED",                        __kmp_stg_parse_nested,             __kmp_stg_print_nested,             NULL, 0, 0 },
#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/kmp_wait_release.h

public:
     bool is_sleeping();
     bool is_any_sleeping();
     bool is_sleeping_val(P old_loc);
     int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
                       USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained);
     */
 };
 
+#if ! KMP_USE_MONITOR
+# 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_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_BLOCKTIME_INTERVAL() (__kmp_dflt_blocktime * KMP_USEC_PER_SEC)
+#  define KMP_BLOCKING(goal, count) ((count) % 1000 != 0 || (goal) > KMP_NOW())
+# endif
+#endif
+
 /* Spin wait loop that first does pause, then yield, then sleep. A thread that calls __kmp_wait_*
    must make certain that another thread calls __kmp_release to wake it back up to prevent deadlocks!  */
 template <class C>
 static inline void
 __kmp_wait_template(kmp_info_t *this_thr, C *flag, int final_spin
                     USE_ITT_BUILD_ARG(void * itt_sync_obj) )
 {
     // NOTE: We may not belong to a team at this point.
     volatile typename C::flag_t *spin = flag->get();
     kmp_uint32 spins;
     kmp_uint32 hibernate;
     int th_gtid;
     int tasks_completed = FALSE;
     int oversubscribed;
+#if ! KMP_USE_MONITOR
+    kmp_uint64 poll_count;
+    kmp_uint64 hibernate_goal;
+#endif
 
     KMP_FSYNC_SPIN_INIT(spin, NULL);
     if (flag->done_check()) {
         KMP_FSYNC_SPIN_ACQUIRED(spin);
         return;
     }
     th_gtid = this_thr->th.th_info.ds.ds_gtid;
     KA_TRACE(20, ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
if (ompt_enabled &&
         }
     }
 #endif
 
     // Setup for waiting
     KMP_INIT_YIELD(spins);
 
     if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
+#if KMP_USE_MONITOR
         // The worker threads cannot rely on the team struct existing at this point.
         // Use the bt values cached in the thread struct instead.
 #ifdef KMP_ADJUST_BLOCKTIME
         if (__kmp_zero_bt && !this_thr->th.th_team_bt_set)
             // Force immediate suspend if not set by user and more threads than available procs
             hibernate = 0;
         else
             hibernate = this_thr->th.th_team_bt_intervals;
 #else
         hibernate = this_thr->th.th_team_bt_intervals;
 #endif /* KMP_ADJUST_BLOCKTIME */
 
         /* If the blocktime is nonzero, we want to make sure that we spin wait for the entirety
            of the specified #intervals, plus up to one interval more.  This increment make
            certain that this thread doesn't go to sleep too soon.  */
         if (hibernate != 0)
             hibernate++;
 
         // Add in the current time value.
         hibernate += TCR_4(__kmp_global.g.g_time.dt.t_value);
         KF_TRACE(20, ("__kmp_wait_sleep: T#%d now=%d, hibernate=%d, intervals=%d\n",
                       th_gtid, __kmp_global.g.g_time.dt.t_value, hibernate,
                       hibernate - __kmp_global.g.g_time.dt.t_value));
+#else
+        hibernate_goal = KMP_NOW() + KMP_BLOCKTIME_INTERVAL();
+        poll_count = 0;
+#endif // KMP_USE_MONITOR
     }
 
     oversubscribed = (TCR_4(__kmp_nth) > __kmp_avail_proc);
     KMP_MB();
 
     // Main wait spin loop
     while (flag->notdone_check()) {
         int in_pool;
#endif
         // Don't suspend if KMP_BLOCKTIME is set to "infinite"
         if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME)
             continue;
 
         // Don't suspend if there is a likelihood of new tasks being spawned.
         if ((task_team != NULL) && TCR_4(task_team->tt.tt_found_tasks))
             continue;
 
+#if KMP_USE_MONITOR
         // If we have waited a bit more, fall asleep
         if (TCR_4(__kmp_global.g.g_time.dt.t_value) < hibernate)
             continue;
+#else
+        if (KMP_BLOCKING(hibernate_goal, poll_count++))
+            continue;
+#endif
 
         KF_TRACE(50, ("__kmp_wait_sleep: T#%d suspend time reached\n", th_gtid));
 
         flag->suspend(th_gtid);
 
         if (TCR_4(__kmp_global.g.g_done)) {
             if (__kmp_global.g.g_abort)
                 __kmp_abort_thread();

openmp/trunk/runtime/src/z_Linux_util.c

 static int __kmp_fork_count = 0;
 
 static pthread_condattr_t  __kmp_suspend_cond_attr;
 static pthread_mutexattr_t __kmp_suspend_mutex_attr;
 
 static kmp_cond_align_t    __kmp_wait_cv;
 static kmp_mutex_align_t   __kmp_wait_mx;
 
+double __kmp_ticks_per_nsec;
+
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 #ifdef DEBUG_SUSPEND
 static void
 __kmp_print_cond( char *buffer, kmp_cond_align_t *cond )
 {
     KMP_SNPRINTF( buffer, 128, "(cond (lock (%ld, %d)), (descr (%p)))",

 #ifdef KMP_BLOCK_SIGNALS
     status = pthread_sigmask( SIG_SETMASK, & old_set, NULL );
     KMP_CHECK_SYSFAIL( "pthread_sigmask", status );
 #endif /* KMP_BLOCK_SIGNALS */
 
     return exit_val;
 }
 
+#if KMP_USE_MONITOR
 /* The monitor thread controls all of the threads in the complex */
 
 static void*
 __kmp_launch_monitor( void *thr )
 {
     int         status, old_type, old_state;
 #ifdef KMP_BLOCK_SIGNALS
     sigset_t    new_set;
if( __kmp_global.g.g_abort != 0 ) {
             raise( __kmp_global.g.g_abort );
 
     }
 
     KA_TRACE( 10, ("__kmp_launch_monitor: #7 exit\n" ) );
 
     return thr;
 }
+#endif // KMP_USE_MONITOR
 
 void
 __kmp_create_worker( int gtid, kmp_info_t *th, size_t stack_size )
 {
     pthread_t      handle;
     pthread_attr_t thread_attr;
     int            status;
 
#endif /* KMP_THREAD_ATTR */
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 10, ("__kmp_create_worker: done creating thread (%d)\n", gtid ) );
 
 } // __kmp_create_worker
 
 
+#if KMP_USE_MONITOR
 void
 __kmp_create_monitor( kmp_info_t *th )
 {
     pthread_t           handle;
     pthread_attr_t      thread_attr;
     size_t              size;
     int                 status;
     int                 auto_adj_size = FALSE;
#ifdef KMP_THREAD_ATTR
         }; // if
     #endif
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 10, ( "__kmp_create_monitor: monitor created %#.8lx\n", th->th.th_info.ds.ds_thread ) );
 
 } // __kmp_create_monitor
+#endif // KMP_USE_MONITOR
 
 void
 __kmp_exit_thread(
     int exit_status
 ) {
     pthread_exit( (void *)(intptr_t) exit_status );
 } // __kmp_exit_thread
 
+#if KMP_USE_MONITOR
 void __kmp_resume_monitor();
 
 void
 __kmp_reap_monitor( kmp_info_t *th )
 {
     int          status;
     void        *exit_val;
 
__kmp_reap_monitor( kmp_info_t *th )
     th->th.th_info.ds.ds_gtid = KMP_GTID_DNE;
 
     KA_TRACE( 10, ("__kmp_reap_monitor: done reaping monitor thread with handle %#.8lx\n",
                    th->th.th_info.ds.ds_thread ) );
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
 }
+#endif // KMP_USE_MONITOR
 
 void
 __kmp_reap_worker( kmp_info_t *th )
 {
     int          status;
     void        *exit_val;
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */

 {
     /* TODO make sure this is done right for nested/sibling */
     // ATT:  Memory leaks are here? TODO: Check it and fix.
     /* KMP_ASSERT( 0 ); */
 
     ++__kmp_fork_count;
 
     __kmp_init_runtime = FALSE;
+#if KMP_USE_MONITOR
     __kmp_init_monitor = 0;
+#endif
     __kmp_init_parallel = FALSE;
     __kmp_init_middle = FALSE;
     __kmp_init_serial = FALSE;
     TCW_4(__kmp_init_gtid, FALSE);
     __kmp_init_common = FALSE;
 
     TCW_4(__kmp_init_user_locks, FALSE);
 #if ! KMP_USE_DYNAMIC_LOCK

 }
 void __kmp_resume_64(int target_gtid, kmp_flag_64 *flag) {
     __kmp_resume_template(target_gtid, flag);
 }
 void __kmp_resume_oncore(int target_gtid, kmp_flag_oncore *flag) {
     __kmp_resume_template(target_gtid, flag);
 }
 
+#if KMP_USE_MONITOR
 void
 __kmp_resume_monitor()
 {
     KMP_TIME_DEVELOPER_BLOCK(USER_resume);
     int status;
 #ifdef KMP_DEBUG
     int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
     KF_TRACE( 30, ( "__kmp_resume_monitor: T#%d wants to wakeup T#%d enter\n",

 #endif
     status = pthread_cond_signal( &__kmp_wait_cv.c_cond );
     KMP_CHECK_SYSFAIL( "pthread_cond_signal", status );
     status = pthread_mutex_unlock( &__kmp_wait_mx.m_mutex );
     KMP_CHECK_SYSFAIL( "pthread_mutex_unlock", status );
     KF_TRACE( 30, ( "__kmp_resume_monitor: T#%d exiting after signaling wake up for T#%d\n",
                     gtid, KMP_GTID_MONITOR ) );
 }
+#endif // KMP_USE_MONITOR
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 void
 __kmp_yield( int cond )
 {
-    if (cond && __kmp_yielding_on) {
+    if (cond
+#if KMP_USE_MONITOR
+        && __kmp_yielding_on
+#endif
+    ) {
         sched_yield();
     }
 }
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 void

 kmp_uint64
 __kmp_now_nsec()
 {
     struct timeval t;
     gettimeofday(&t, NULL);
     return KMP_NSEC_PER_SEC*t.tv_sec + 1000*t.tv_usec;
 }
 
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+/* Measure clock tick per nanosecond */
+void
+__kmp_initialize_system_tick()
+{
+    kmp_uint64 delay = 100000; // 50~100 usec on most machines.
+    kmp_uint64 nsec = __kmp_now_nsec();
+    kmp_uint64 goal = __kmp_hardware_timestamp() + delay;
+    kmp_uint64 now;
+    while ((now = __kmp_hardware_timestamp()) < goal);
+    __kmp_ticks_per_nsec = 1.0 * (delay + (now - goal)) / (__kmp_now_nsec() - nsec);
+}
+#endif
+
 /*
     Determine whether the given address is mapped into the current address space.
 */
 
 int
 __kmp_is_address_mapped( void * addr ) {
 
     int found = 0;

openmp/trunk/runtime/src/z_Windows_NT_util.c

 /* ----------------------------------------------------------------------------------- */
 
 #if KMP_HANDLE_SIGNALS
     typedef void    (* sig_func_t )( int );
     static sig_func_t  __kmp_sighldrs[ NSIG ];
     static int         __kmp_siginstalled[ NSIG ];
 #endif
 
+#if KMP_USE_MONITOR
 static HANDLE   __kmp_monitor_ev;
+#endif
 static kmp_int64 __kmp_win32_time;
 double __kmp_win32_tick;
 
 int __kmp_init_runtime = FALSE;
 CRITICAL_SECTION __kmp_win32_section;
 
 void
 __kmp_win32_mutex_init( kmp_win32_mutex_t *mx )
if (delta != NULL) {
 
         status = QueryPerformanceCounter( & now );
 
         *delta = ((double) (((kmp_int64) now.QuadPart) - __kmp_win32_time))
     * __kmp_win32_tick;
     }
 }
 
+/* Return the current time stamp in nsec */
+kmp_uint64
+__kmp_now_nsec()
+{
+    LARGE_INTEGER now;
+    QueryPerformanceCounter(&now);
+    return 1e9 * __kmp_win32_tick * now.QuadPart;
+}
+
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 void * __stdcall
 __kmp_launch_worker( void *arg )
 {
     volatile void *stack_data;
     void *exit_val;
#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
     KMP_MB();
     exit_val = __kmp_launch_thread( this_thr );
     KMP_FSYNC_RELEASING( &this_thr -> th.th_info.ds.ds_alive );
     TCW_4( this_thr -> th.th_info.ds.ds_alive, FALSE );
     KMP_MB();
     return exit_val;
 }
 
+#if KMP_USE_MONITOR
 /* The monitor thread controls all of the threads in the complex */
 
 void * __stdcall
 __kmp_launch_monitor( void *arg )
 {
     DWORD        wait_status;
     kmp_thread_t monitor;
     int          status;
if (__kmp_global.g.g_abort != 0) {
         }
     }
 
     TCW_4( this_thr -> th.th_info.ds.ds_alive, FALSE );
 
     KMP_MB();
     return arg;
 }
+#endif
 
 void
 __kmp_create_worker( int gtid, kmp_info_t *th, size_t stack_size )
 {
     kmp_thread_t   handle;
     DWORD          idThread;
 
     KA_TRACE( 10, ("__kmp_create_worker: try to create thread (%d)\n", gtid ) );
__kmp_create_worker( int gtid, kmp_info_t *th, size_t stack_size )
     KA_TRACE( 10, ("__kmp_create_worker: done creating thread (%d)\n", gtid ) );
 }
 
 int
 __kmp_still_running(kmp_info_t *th) {
     return (WAIT_TIMEOUT == WaitForSingleObject( th->th.th_info.ds.ds_thread, 0));
 }
 
+#if KMP_USE_MONITOR
 void
 __kmp_create_monitor( kmp_info_t *th )
 {
     kmp_thread_t        handle;
     DWORD               idThread;
     int                 ideal, new_ideal;
 
     if( __kmp_dflt_blocktime == KMP_MAX_BLOCKTIME ) {
#endif /* USE_ITT_BUILD */
     else
         th->th.th_info.ds.ds_thread = handle;
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 10, ("__kmp_create_monitor: monitor created %p\n",
                    (void *) th->th.th_info.ds.ds_thread ) );
 }
+#endif
 
 /*
   Check to see if thread is still alive.
 
   NOTE:  The ExitProcess(code) system call causes all threads to Terminate
          with a exit_val = code.  Because of this we can not rely on
          exit_val having any particular value.  So this routine may
          return STILL_ALIVE in exit_val even after the thread is dead.
#endif /* USE_ITT_BUILD */
     th->th.th_info.ds.ds_thread    = 0;
     th->th.th_info.ds.ds_tid       = KMP_GTID_DNE;
     th->th.th_info.ds.ds_gtid      = KMP_GTID_DNE;
     th->th.th_info.ds.ds_thread_id = 0;
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 }
 
+#if KMP_USE_MONITOR
 void
 __kmp_reap_monitor( kmp_info_t *th )
 {
     int status;
 
     KA_TRACE( 10, ("__kmp_reap_monitor: try to reap %p\n",
                    (void *) th->th.th_info.ds.ds_thread ) );
 
__kmp_reap_monitor( kmp_info_t *th )
     }
     KA_TRACE( 10, ( "__kmp_reap_monitor: reaping thread (%d)\n", th->th.th_info.ds.ds_gtid ) );
     __kmp_reap_common( th );
 
     __kmp_free_handle( __kmp_monitor_ev );
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 }
+#endif
 
 void
 __kmp_reap_worker( kmp_info_t * th )
 {
     KA_TRACE( 10, ( "__kmp_reap_worker: reaping thread (%d)\n", th->th.th_info.ds.ds_gtid ) );
     __kmp_reap_common( th );
 }