Make kmp_r_sched_t into a union

[tlwilmar]

Summary

This change makes kmp_r_sched_t type into a union for simpler comparisons and assignments

[jlpeyton]

LGTM

openmp/trunk/runtime/src/kmp.h

#endif
   kmp_sched_default = kmp_sched_static // default scheduling
 } kmp_sched_t;
 #endif
 
 /*!
  @ingroup WORK_SHARING
  * Describes the loop schedule to be used for a parallel for loop.
  */
-enum sched_type {
+enum sched_type : kmp_int32 {
   kmp_sch_lower = 32, /**< lower bound for unordered values */
   kmp_sch_static_chunked = 33,
   kmp_sch_static = 34, /**< static unspecialized */
   kmp_sch_dynamic_chunked = 35,
   kmp_sch_guided_chunked = 36, /**< guided unspecialized */
   kmp_sch_runtime = 37,
   kmp_sch_auto = 38, /**< auto */
   kmp_sch_trapezoidal = 39,

 #define SCHEDULE_HAS_NONMONOTONIC(s) false
 #define SCHEDULE_HAS_NO_MODIFIERS(s) true
 #endif
 
   kmp_sch_default = kmp_sch_static /**< default scheduling algorithm */
 };
 
 /* Type to keep runtime schedule set via OMP_SCHEDULE or omp_set_schedule() */
-typedef struct kmp_r_sched {
+typedef union kmp_r_sched {
+  struct {
     enum sched_type r_sched_type;
     int chunk;
+  };
+  kmp_int64 sched;
 } kmp_r_sched_t;
 
 extern enum sched_type __kmp_sch_map[]; // map OMP 3.0 schedule types with our
 // internal schedule types
 
 enum library_type {
   library_none,
   library_serial,

openmp/trunk/runtime/src/kmp_runtime.cpp

#endif
     /* we have to initialize this serial team */
     KMP_DEBUG_ASSERT(serial_team->t.t_threads);
     KMP_DEBUG_ASSERT(serial_team->t.t_threads[0] == this_thr);
     KMP_DEBUG_ASSERT(this_thr->th.th_team != serial_team);
     serial_team->t.t_ident = loc;
     serial_team->t.t_serialized = 1;
     serial_team->t.t_nproc = 1;
     serial_team->t.t_parent = this_thr->th.th_team;
-    serial_team->t.t_sched = this_thr->th.th_team->t.t_sched;
+    serial_team->t.t_sched.sched = this_thr->th.th_team->t.t_sched.sched;
     this_thr->th.th_team = serial_team;
     serial_team->t.t_master_tid = this_thr->th.th_info.ds.ds_tid;
 
     KF_TRACE(10, ("__kmpc_serialized_parallel: T#d curtask=%p\n", global_tid,
                   this_thr->th.th_current_task));
     KMP_ASSERT(this_thr->th.th_current_task->td_flags.executing == 1);
     this_thr->th.th_current_task->td_flags.executing = 0;
 
#if OMP_40_ENABLED
       // AC: Do not increase parallel level at start of the teams construct
       int new_level = parent_team->t.t_level;
       KMP_CHECK_UPDATE(team->t.t_level, new_level);
       new_level = parent_team->t.t_active_level;
       KMP_CHECK_UPDATE(team->t.t_active_level, new_level);
     }
 #endif /* OMP_40_ENABLED */
     kmp_r_sched_t new_sched = get__sched_2(parent_team, master_tid);
-    if (team->t.t_sched.r_sched_type != new_sched.r_sched_type ||
-        team->t.t_sched.chunk != new_sched.chunk)
-      team->t.t_sched =
-          new_sched; // set master's schedule as new run-time schedule
+    // set master's schedule as new run-time schedule
+    KMP_CHECK_UPDATE(team->t.t_sched.sched, new_sched.sched);
 
 #if OMP_40_ENABLED
     KMP_CHECK_UPDATE(team->t.t_cancel_request, cancel_noreq);
 #endif
 
     // Update the floating point rounding in the team if required.
     propagateFPControl(team);
 
kmp_r_sched_t __kmp_get_schedule_global() {
 
   kmp_r_sched_t r_sched;
 
   // create schedule from 4 globals: __kmp_sched, __kmp_chunk, __kmp_static,
   // __kmp_guided. __kmp_sched should keep original value, so that user can set
   // KMP_SCHEDULE multiple times, and thus have different run-time schedules in
   // different roots (even in OMP 2.5)
   if (__kmp_sched == kmp_sch_static) {
-    r_sched.r_sched_type = __kmp_static; // replace STATIC with more detailed
-    // schedule (balanced or greedy)
+    // replace STATIC with more detailed schedule (balanced or greedy)
+    r_sched.r_sched_type = __kmp_static;
   } else if (__kmp_sched == kmp_sch_guided_chunked) {
-    r_sched.r_sched_type = __kmp_guided; // replace GUIDED with more detailed
-    // schedule (iterative or analytical)
-  } else {
-    r_sched.r_sched_type =
-        __kmp_sched; // (STATIC_CHUNKED), or (DYNAMIC_CHUNKED), or other
+    // replace GUIDED with more detailed schedule (iterative or analytical)
+    r_sched.r_sched_type = __kmp_guided;
+  } else { // (STATIC_CHUNKED), or (DYNAMIC_CHUNKED), or other
+    r_sched.r_sched_type = __kmp_sched;
   }
 
-  if (__kmp_chunk < KMP_DEFAULT_CHUNK) { // __kmp_chunk may be wrong here (if it
-    // was not ever set)
+  if (__kmp_chunk < KMP_DEFAULT_CHUNK) {
+    // __kmp_chunk may be wrong here (if it was not ever set)
     r_sched.chunk = KMP_DEFAULT_CHUNK;
   } else {
     r_sched.chunk = __kmp_chunk;
   }
 
   return r_sched;
 }
 
#endif
   root->r.r_root_team = root_team;
   root_team->t.t_control_stack_top = NULL;
 
   /* initialize root team */
   root_team->t.t_threads[0] = NULL;
   root_team->t.t_nproc = 1;
   root_team->t.t_serialized = 1;
   // TODO???: root_team->t.t_max_active_levels = __kmp_dflt_max_active_levels;
-  root_team->t.t_sched.r_sched_type = r_sched.r_sched_type;
-  root_team->t.t_sched.chunk = r_sched.chunk;
+  root_team->t.t_sched.sched = r_sched.sched;
   KA_TRACE(
       20,
       ("__kmp_initialize_root: init root team %d arrived: join=%u, plain=%u\n",
        root_team->t.t_id, KMP_INIT_BARRIER_STATE, KMP_INIT_BARRIER_STATE));
 
   /* setup the  hot team for this task */
   /* allocate the hot team structure */
   KF_TRACE(10, ("__kmp_initialize_root: before hot_team\n"));
#endif
 
   /* initialize hot team */
   hot_team_max_nth = hot_team->t.t_max_nproc;
   for (f = 0; f < hot_team_max_nth; ++f) {
     hot_team->t.t_threads[f] = NULL;
   }
   hot_team->t.t_nproc = 1;
   // TODO???: hot_team->t.t_max_active_levels = __kmp_dflt_max_active_levels;
-  hot_team->t.t_sched.r_sched_type = r_sched.r_sched_type;
-  hot_team->t.t_sched.chunk = r_sched.chunk;
+  hot_team->t.t_sched.sched = r_sched.sched;
   hot_team->t.t_size_changed = 0;
 }
 
 #ifdef KMP_DEBUG
 
 typedef struct kmp_team_list_item {
   kmp_team_p const *entry;
   struct kmp_team_list_item *next;
static void __kmp_initialize_team(kmp_team_t *team, int new_nproc,
   team->t.t_next_pool = NULL;
   /* memset( team->t.t_threads, 0, sizeof(kmp_info_t*)*new_nproc ); would mess
    * up hot team */
 
   TCW_SYNC_PTR(team->t.t_pkfn, NULL); /* not needed */
   team->t.t_invoke = NULL; /* not needed */
 
   // TODO???: team->t.t_max_active_levels       = new_max_active_levels;
-  team->t.t_sched = new_icvs->sched;
+  team->t.t_sched.sched = new_icvs->sched.sched;
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
   team->t.t_fp_control_saved = FALSE; /* not needed */
   team->t.t_x87_fpu_control_word = 0; /* not needed */
   team->t.t_mxcsr = 0; /* not needed */
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
   team->t.t_construct = 0;
if (team->t.t_nproc == new_nproc) { // Check changes in number of threads
       if (team->t.t_size_changed == -1) {
         team->t.t_size_changed = 1;
       } else {
         KMP_CHECK_UPDATE(team->t.t_size_changed, 0);
       }
 
       // TODO???: team->t.t_max_active_levels = new_max_active_levels;
       kmp_r_sched_t new_sched = new_icvs->sched;
-      if (team->t.t_sched.r_sched_type != new_sched.r_sched_type ||
-          team->t.t_sched.chunk != new_sched.chunk)
-        team->t.t_sched =
-            new_sched; // set master's schedule as new run-time schedule
+      // set master's schedule as new run-time schedule
+      KMP_CHECK_UPDATE(team->t.t_sched.sched, new_sched.sched);
 
       __kmp_reinitialize_team(team, new_icvs,
                               root->r.r_uber_thread->th.th_ident);
 
       KF_TRACE(10, ("__kmp_allocate_team2: T#%d, this_thread=%p team=%p\n", 0,
                     team->t.t_threads[0], team));
       __kmp_push_current_task_to_thread(team->t.t_threads[0], team, 0);
 
#if KMP_NESTED_HOT_TEAMS
             }
             KMP_CHECK_UPDATE(balign[b].bb.leaf_kids, 0);
           }
         }
       }
 #endif // KMP_NESTED_HOT_TEAMS
       team->t.t_nproc = new_nproc;
       // TODO???: team->t.t_max_active_levels = new_max_active_levels;
-      if (team->t.t_sched.r_sched_type != new_icvs->sched.r_sched_type ||
-          team->t.t_sched.chunk != new_icvs->sched.chunk)
-        team->t.t_sched = new_icvs->sched;
+      KMP_CHECK_UPDATE(team->t.t_sched.sched, new_icvs->sched.sched);
       __kmp_reinitialize_team(team, new_icvs,
                               root->r.r_uber_thread->th.th_ident);
 
       /* update the remaining threads */
       for (f = 0; f < new_nproc; ++f) {
         team->t.t_threads[f]->th.th_team_nproc = new_nproc;
       }
       // restore the current task state of the master thread: should be the