[OpenMP] Add environment variable to force monotonic dynamic scheduling

[tlwilmar]

Summary

This patch introduces a new environment variable to force monotonic behavior for users that absolutely need it. This is in anticipation of a 5.0 spec change that uses non-monotonic behavior for dynamic scheduling by default. Fixes for that and the actual switch are coming soon.

Patch by Johnny Peyton.

[Nawrin]

openmp/runtime/src/kmp_settings.cpp

4156

Could you please change the comment from hand_thread to force_monotonic?

4161

Same as above

[tlwilmar]

Addressed Nawrin's comment fixes.

[Nawrin]

LGTM

openmp/runtime/src/kmp.h

 
 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 int __kmp_force_monotonic; /* whether monotonic scheduling forced */
 
 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 */
 

openmp/runtime/src/kmp_dispatch.cpp

static inline int __kmp_get_monotonicity(ident_t *loc, enum sched_type schedule,
   // TODO: make nonmonotonic when static_steal is fixed
   int monotonicity = SCHEDULE_MONOTONIC;
 
   // Let default be monotonic for executables
   // compiled with OpenMP* 4.5 or less compilers
   if (loc->get_openmp_version() < 50)
     monotonicity = SCHEDULE_MONOTONIC;
 
-  if (use_hier)
+  if (use_hier || __kmp_force_monotonic)
     monotonicity = SCHEDULE_MONOTONIC;
   else if (SCHEDULE_HAS_NONMONOTONIC(schedule))
     monotonicity = SCHEDULE_NONMONOTONIC;
   else if (SCHEDULE_HAS_MONOTONIC(schedule))
     monotonicity = SCHEDULE_MONOTONIC;
 
   return monotonicity;
 }

openmp/runtime/src/kmp_global.cpp

 #endif
 #ifdef KMP_ADJUST_BLOCKTIME
 int __kmp_zero_bt = FALSE;
 #endif /* KMP_ADJUST_BLOCKTIME */
 #ifdef KMP_DFLT_NTH_CORES
 int __kmp_ncores = 0;
 #endif
 int __kmp_chunk = 0;
+int __kmp_force_monotonic = 0;
 int __kmp_abort_delay = 0;
 #if KMP_OS_LINUX && defined(KMP_TDATA_GTID)
 int __kmp_gtid_mode = 3; /* use __declspec(thread) TLS to store gtid */
 int __kmp_adjust_gtid_mode = FALSE;
 #elif KMP_OS_WINDOWS
 int __kmp_gtid_mode = 2; /* use TLS functions to store gtid */
 int __kmp_adjust_gtid_mode = FALSE;
 #else

openmp/runtime/src/kmp_settings.cpp

 
 static void __kmp_stg_print_kmp_hand_thread(kmp_str_buf_t *buffer,
                                             char const *name, void *data) {
   __kmp_stg_print_bool(buffer, name, __kmp_dispatch_hand_threading);
 } // __kmp_stg_print_kmp_hand_thread
 #endif
 
 // -----------------------------------------------------------------------------
+// KMP_FORCE_MONOTONIC_DYNAMIC_SCHEDULE
+static void __kmp_stg_parse_kmp_force_monotonic(char const *name,
+                                                char const *value, void *data) {
+  __kmp_stg_parse_bool(name, value, &(__kmp_force_monotonic));
+} // __kmp_stg_parse_kmp_force_monotonic
+
+static void __kmp_stg_print_kmp_force_monotonic(kmp_str_buf_t *buffer,
+                                                char const *name, void *data) {
+  __kmp_stg_print_bool(buffer, name, __kmp_force_monotonic);
+} // __kmp_stg_print_kmp_force_monotonic
+
+// -----------------------------------------------------------------------------
 // KMP_ATOMIC_MODE
 
 static void __kmp_stg_parse_atomic_mode(char const *name, char const *value,
                                         void *data) {
   // Modes: 0 -- do not change default; 1 -- Intel perf mode, 2 -- GOMP
   // compatibility mode.
   int mode = 0;
   int max = 1;
 #ifdef KMP_GOMP_COMPAT
   max = 2;
 #endif /* KMP_GOMP_COMPAT */
   __kmp_stg_parse_int(name, value, 0, max, &mode);
   // TODO; parse_int is not very suitable for this case. In case of overflow it
   // is better to use
   // 0 rather that max value.
   if (mode > 0) {
     __kmp_atomic_mode = mode;
   }
#endif // KMP_AFFINITY_SUPPORTED
     {"KMP_SCHEDULE", __kmp_stg_parse_schedule, __kmp_stg_print_schedule, NULL,
      0, 0},
     {"OMP_SCHEDULE", __kmp_stg_parse_omp_schedule, __kmp_stg_print_omp_schedule,
      NULL, 0, 0},
 #if KMP_USE_HIER_SCHED
     {"KMP_DISP_HAND_THREAD", __kmp_stg_parse_kmp_hand_thread,
      __kmp_stg_print_kmp_hand_thread, NULL, 0, 0},
 #endif
+    {"KMP_FORCE_MONOTONIC_DYNAMIC_SCHEDULE",
+     __kmp_stg_parse_kmp_force_monotonic, __kmp_stg_print_kmp_force_monotonic,
+     NULL, 0, 0},
     {"KMP_ATOMIC_MODE", __kmp_stg_parse_atomic_mode,
      __kmp_stg_print_atomic_mode, NULL, 0, 0},
     {"KMP_CONSISTENCY_CHECK", __kmp_stg_parse_consistency_check,
      __kmp_stg_print_consistency_check, NULL, 0, 0},
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
     {"KMP_ITT_PREPARE_DELAY", __kmp_stg_parse_itt_prepare_delay,
      __kmp_stg_print_itt_prepare_delay, NULL, 0, 0},