[OpenMP] Add ident_t flags for compiler OpenMP version

[jlpeyton]

Summary

This patch adds the mask and ident_t function to get the
openmp version. It also adds logic to force monotonic:dynamic
behavior when OpenMP version less than 5.0.

The OpenMP version is stored in the format:
major*10+minor e.g., OpenMP 5.0 = 50

[jdoerfert]

LGTM

openmp/runtime/src/kmp.h

/*! Atomic hint; bottom four bits as omp_sync_hint_t. Top four reserved and
       not currently used. If one day we need more bits, then we can use
       an invalid combination of hints to mean that another, larger field
       should be used in a different flag. */
   KMP_IDENT_ATOMIC_HINT_MASK = 0xFF0000,
   KMP_IDENT_ATOMIC_HINT_UNCONTENDED = 0x010000,
   KMP_IDENT_ATOMIC_HINT_CONTENDED = 0x020000,
   KMP_IDENT_ATOMIC_HINT_NONSPECULATIVE = 0x040000,
   KMP_IDENT_ATOMIC_HINT_SPECULATIVE = 0x080000,
+  KMP_IDENT_OPENMP_SPEC_VERSION_MASK = 0xFF000000
 };
 
 /*!
  * The ident structure that describes a source location.
  */
 typedef struct ident {
   kmp_int32 reserved_1; /**<  might be used in Fortran; see above  */
   kmp_int32 flags; /**<  also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
                       identifies this union member  */
   kmp_int32 reserved_2; /**<  not really used in Fortran any more; see above */
 #if USE_ITT_BUILD
 /*  but currently used for storing region-specific ITT */
 /*  contextual information. */
 #endif /* USE_ITT_BUILD */
   kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for C++  */
   char const *psource; /**< String describing the source location.
                        The string is composed of semi-colon separated fields
                        which describe the source file, the function and a pair
                        of line numbers that delimit the construct. */
+  // Returns the OpenMP version in form major*10+minor (e.g., 50 for 5.0)
+  kmp_int32 get_openmp_version() {
+    return (((flags & KMP_IDENT_OPENMP_SPEC_VERSION_MASK) >> 24) & 0xFF);
+  }
 } ident_t;
 /*!
 @}
 */
 
 // Some forward declarations.
 typedef union kmp_team kmp_team_t;
 typedef struct kmp_taskdata kmp_taskdata_t;

openmp/runtime/src/kmp_dispatch.cpp

if (__kmp_env_consistency_check) {
     th = __kmp_threads[*gtid_ref];
     if (th->th.th_dispatch->th_dispatch_pr_current->pushed_ws != ct_none) {
       __kmp_pop_sync(*gtid_ref, ct_ordered_in_pdo, loc_ref);
     }
   }
 }
 
 // Returns either SCHEDULE_MONOTONIC or SCHEDULE_NONMONOTONIC
-static inline int __kmp_get_monotonicity(enum sched_type schedule,
+static inline int __kmp_get_monotonicity(ident_t *loc, enum sched_type schedule,
                                          bool use_hier = false) {
   // Pick up the nonmonotonic/monotonic bits from the scheduling type
-  int monotonicity;
-  // default to monotonic
+  // 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 (SCHEDULE_HAS_NONMONOTONIC(schedule))
+
+  if (use_hier)
+    monotonicity = SCHEDULE_MONOTONIC;
+  else if (SCHEDULE_HAS_NONMONOTONIC(schedule))
     monotonicity = SCHEDULE_NONMONOTONIC;
   else if (SCHEDULE_HAS_MONOTONIC(schedule))
     monotonicity = SCHEDULE_MONOTONIC;
+
   return monotonicity;
 }
 
 // Initialize a dispatch_private_info_template<T> buffer for a particular
 // type of schedule,chunk.  The loop description is found in lb (lower bound),
 // ub (upper bound), and st (stride).  nproc is the number of threads relevant
 // to the scheduling (often the number of threads in a team, but not always if
 // hierarchical scheduling is used).  tid is the id of the thread calling

 
 #if KMP_USE_HIER_SCHED
   use_hier = pr->flags.use_hier;
 #else
   use_hier = false;
 #endif
 
   /* Pick up the nonmonotonic/monotonic bits from the scheduling type */
-  monotonicity = __kmp_get_monotonicity(schedule, use_hier);
+  monotonicity = __kmp_get_monotonicity(loc, schedule, use_hier);
   schedule = SCHEDULE_WITHOUT_MODIFIERS(schedule);
 
   /* Pick up the nomerge/ordered bits from the scheduling type */
   if ((schedule >= kmp_nm_lower) && (schedule < kmp_nm_upper)) {
     pr->flags.nomerge = TRUE;
     schedule =
         (enum sched_type)(((int)schedule) - (kmp_nm_lower - kmp_sch_lower));
   } else {
#endif
 
   if (schedule == kmp_sch_static) {
     schedule = __kmp_static;
   } else {
     if (schedule == kmp_sch_runtime) {
       // Use the scheduling specified by OMP_SCHEDULE (or __kmp_sch_default if
       // not specified)
       schedule = team->t.t_sched.r_sched_type;
-      monotonicity = __kmp_get_monotonicity(schedule, use_hier);
+      monotonicity = __kmp_get_monotonicity(loc, schedule, use_hier);
       schedule = SCHEDULE_WITHOUT_MODIFIERS(schedule);
       // Detail the schedule if needed (global controls are differentiated
       // appropriately)
       if (schedule == kmp_sch_guided_chunked) {
         schedule = __kmp_guided;
       } else if (schedule == kmp_sch_static) {
         schedule = __kmp_static;
       }
#endif
     /* guided analytical not safe for too many threads */
     if (schedule == kmp_sch_guided_analytical_chunked && nproc > 1 << 20) {
       schedule = kmp_sch_guided_iterative_chunked;
       KMP_WARNING(DispatchManyThreads);
     }
     if (schedule == kmp_sch_runtime_simd) {
       // compiler provides simd_width in the chunk parameter
       schedule = team->t.t_sched.r_sched_type;
-      monotonicity = __kmp_get_monotonicity(schedule, use_hier);
+      monotonicity = __kmp_get_monotonicity(loc, schedule, use_hier);
       schedule = SCHEDULE_WITHOUT_MODIFIERS(schedule);
       // Detail the schedule if needed (global controls are differentiated
       // appropriately)
       if (schedule == kmp_sch_static || schedule == kmp_sch_auto ||
           schedule == __kmp_static) {
         schedule = kmp_sch_static_balanced_chunked;
       } else {
         if (schedule == kmp_sch_guided_chunked || schedule == __kmp_guided) {