Cleanup: __kmp_env_* variables

[tlwilmar]

Summary

Removed unused __kmp_env_* variables. Also clangified other people's code.

[jlpeyton]

LGTM

runtime/src/kmp.h

 #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_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;

runtime/src/kmp_global.cpp

int __kmp_storage_map_verbose =
     FALSE; /* True means storage map includes placement info */
 int __kmp_storage_map_verbose_specified = FALSE;
 /* Initialize the library data structures when we fork a child process, defaults
  * to TRUE */
 int __kmp_need_register_atfork =
     TRUE; /* At initialization, call pthread_atfork to install fork handler */
 int __kmp_need_register_atfork_specified = TRUE;
 
-int __kmp_env_chunk = FALSE; /* KMP_CHUNK specified?     */
 int __kmp_env_stksize = FALSE; /* KMP_STACKSIZE specified? */
-int __kmp_env_omp_stksize = FALSE; /* OMP_STACKSIZE specified? */
-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

runtime/src/kmp_settings.cpp

#endif
   }
 } // __kmp_stg_parse_blocktime
 
 static void __kmp_stg_print_blocktime(kmp_str_buf_t *buffer, char const *name,
                                       void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_dflt_blocktime);
 } // __kmp_stg_print_blocktime
 
+// Used for OMP_WAIT_POLICY
+static char const *blocktime_str = NULL;
+
 // -----------------------------------------------------------------------------
 // KMP_DUPLICATE_LIB_OK
 
 static void __kmp_stg_parse_duplicate_lib_ok(char const *name,
                                              char const *value, void *data) {
   /* actually this variable is not supported, put here for compatibility with
      earlier builds and for static/dynamic combination */
   __kmp_stg_parse_bool(name, value, &__kmp_duplicate_library_ok);

 #endif /* KMP_DEBUG */
 } // __kmp_stg_print_inherit_fp_control
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
 // -----------------------------------------------------------------------------
 // KMP_LIBRARY, OMP_WAIT_POLICY
 
-static char const *blocktime_str = NULL;
-
 static void __kmp_stg_parse_wait_policy(char const *name, char const *value,
                                         void *data) {
 
   kmp_stg_wp_data_t *wait = (kmp_stg_wp_data_t *)data;
   int rc;
 
   rc = __kmp_stg_check_rivals(name, value, wait->rivals);
   if (rc) {

 static void __kmp_stg_print_max_task_priority(kmp_str_buf_t *buffer,
                                               char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_max_task_priority);
 } // __kmp_stg_print_max_task_priority
 
 // KMP_TASKLOOP_MIN_TASKS
 // taskloop threashold to switch from recursive to linear tasks creation
 static void __kmp_stg_parse_taskloop_min_tasks(char const *name,
                                                char const *value, void *data) {
   int tmp;
   __kmp_stg_parse_int(name, value, 0, INT_MAX, &tmp);
   __kmp_taskloop_min_tasks = tmp;
 } // __kmp_stg_parse_taskloop_min_tasks
 
 static void __kmp_stg_print_taskloop_min_tasks(kmp_str_buf_t *buffer,
                                                char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_taskloop_min_tasks);
 } // __kmp_stg_print_taskloop_min_tasks
 #endif // OMP_45_ENABLED
 
 // -----------------------------------------------------------------------------
 // KMP_DISP_NUM_BUFFERS
 static void __kmp_stg_parse_disp_buffers(char const *name, char const *value,
                                          void *data) {
#if KMP_STATIC_STEAL_ENABLED
       else if (!__kmp_strcasecmp_with_sentinel("static_steal", value, ','))
         __kmp_sched = kmp_sch_static_steal;
 #endif
       else {
         KMP_WARNING(StgInvalidValue, name, value);
         value = NULL; /* skip processing of comma */
       }
       if (value && comma) {
-        __kmp_env_chunk = TRUE;
-
         if (__kmp_sched == kmp_sch_static)
           __kmp_sched = kmp_sch_static_chunked;
         ++comma;
         __kmp_chunk = __kmp_str_to_int(comma, 0);
         if (__kmp_chunk < 1) {
           __kmp_chunk = KMP_DEFAULT_CHUNK;
           __kmp_msg(kmp_ms_warning, KMP_MSG(InvalidChunk, name, comma),
                     __kmp_msg_null);
           KMP_INFORM(Using_int_Value, name, __kmp_chunk);
           // AC: next block commented out until KMP_DEFAULT_CHUNK !=
           // KMP_MIN_CHUNK (to improve code coverage :)
           //     The default chunk size is 1 according to standard, thus making
           //     KMP_MIN_CHUNK not 1 we would introduce mess:
           //     wrong chunk becomes 1, but it will be impossible to explicitely
           //     set 1, because it becomes KMP_MIN_CHUNK...
           //                } else if ( __kmp_chunk < KMP_MIN_CHUNK ) {
           //                    __kmp_chunk = KMP_MIN_CHUNK;
         } else if (__kmp_chunk > KMP_MAX_CHUNK) {
           __kmp_chunk = KMP_MAX_CHUNK;
           __kmp_msg(kmp_ms_warning, KMP_MSG(LargeChunk, name, comma),
                     __kmp_msg_null);
           KMP_INFORM(Using_int_Value, name, __kmp_chunk);
         }
-      } else
-        __kmp_env_chunk = FALSE;
+      }
     } else
       KMP_WARNING(EmptyString, name);
   }
   K_DIAG(1, ("__kmp_static == %d\n", __kmp_static))
   K_DIAG(1, ("__kmp_guided == %d\n", __kmp_guided))
   K_DIAG(1, ("__kmp_sched == %d\n", __kmp_sched))
   K_DIAG(1, ("__kmp_chunk == %d\n", __kmp_chunk))
 } // __kmp_stg_parse_omp_schedule
if (block.vars[i].value == NULL) {
       continue;
     }
     kmp_setting_t *setting = __kmp_stg_find(block.vars[i].name);
     if (setting != NULL) {
       setting->set = 1;
     }
   }; // for i
 
-  // We need to know if blocktime was set when processing OMP_WAIT_POLICY
   blocktime_str = __kmp_env_blk_var(&block, "KMP_BLOCKTIME");
 
   // Special case. If we parse environment, not a string, process KMP_WARNINGS
   // first.
   if (string == NULL) {
     char const *name = "KMP_WARNINGS";
     char const *value = __kmp_env_blk_var(&block, name);
     __kmp_stg_parse(name, value);

runtime/src/kmp_tasking.cpp

size_t lower_offset =
       (char *)lb - (char *)task; // remember offset of lb in the task structure
   size_t upper_offset =
       (char *)ub - (char *)task; // remember offset of ub in the task structure
 
   KMP_DEBUG_ASSERT(tc == num_tasks * grainsize + extras);
   KMP_DEBUG_ASSERT(num_tasks > extras);
   KMP_DEBUG_ASSERT(num_tasks > 0);
   KA_TRACE(20, ("__kmp_taskloop_linear: T#%d: %lld tasks, grainsize %lld, "
-                "extras %lld, i=%lld,%lld(%d)%lld, dup %p\n", gtid, num_tasks,
-                grainsize, extras, lower, upper, ub_glob, st, task_dup));
+                "extras %lld, i=%lld,%lld(%d)%lld, dup %p\n",
+                gtid, num_tasks, grainsize, extras, lower, upper, ub_glob, st,
+                task_dup));
 
   // Launch num_tasks tasks, assign grainsize iterations each task
   for (i = 0; i < num_tasks; ++i) {
     kmp_uint64 chunk_minus_1;
     if (extras == 0) {
       chunk_minus_1 = grainsize - 1;
     } else {
       chunk_minus_1 = grainsize;
       --extras; // first extras iterations get bigger chunk (grainsize+1)
     }
     upper = lower + st * chunk_minus_1;
     if (i == num_tasks - 1) {
       // schedule the last task, set lastprivate flag if needed
       if (st == 1) { // most common case
         KMP_DEBUG_ASSERT(upper == *ub);
         if (upper == ub_glob)
           lastpriv = 1;
       } else if (st > 0) { // positive loop stride
         KMP_DEBUG_ASSERT((kmp_uint64)st > *ub - upper);
         if ((kmp_uint64)st > ub_glob - upper)
           lastpriv = 1;
-      } else {  // negative loop stride
+      } else { // negative loop stride
         KMP_DEBUG_ASSERT(upper + st < *ub);
         if (upper - ub_glob < (kmp_uint64)(-st))
           lastpriv = 1;
       }
     }
     next_task = __kmp_task_dup_alloc(thread, task); // allocate new task
     // adjust task-specific bounds
     *(kmp_uint64 *)((char *)next_task + lower_offset) = lower;

 
 void __kmp_taskloop_recur(ident_t *, int, kmp_task_t *, kmp_uint64 *,
                           kmp_uint64 *, kmp_int64, kmp_uint64, kmp_uint64,
                           kmp_uint64, kmp_uint64, kmp_uint64, kmp_uint64,
                           void *);
 
 // Execute part of the the taskloop submitted as a task.
 int __kmp_taskloop_task(int gtid, void *ptask) {
-  __taskloop_params_t *p = (__taskloop_params_t*)((kmp_task_t*)ptask)->shareds;
+  __taskloop_params_t *p =
+      (__taskloop_params_t *)((kmp_task_t *)ptask)->shareds;
   kmp_task_t *task = p->task;
   kmp_uint64 *lb = p->lb;
   kmp_uint64 *ub = p->ub;
   void *task_dup = p->task_dup;
   //  p_task_dup_t ptask_dup = (p_task_dup_t)task_dup;
   kmp_int64 st = p->st;
   kmp_uint64 ub_glob = p->ub_glob;
   kmp_uint64 num_tasks = p->num_tasks;
   kmp_uint64 grainsize = p->grainsize;
   kmp_uint64 extras = p->extras;
   kmp_uint64 tc = p->tc;
   kmp_uint64 num_t_min = p->num_t_min;
 #if KMP_DEBUG
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   KMP_DEBUG_ASSERT(task != NULL);
   KA_TRACE(20, ("__kmp_taskloop_task: T#%d, task %p: %lld tasks, grainsize"
-                " %lld, extras %lld, i=%lld,%lld(%d), dup %p\n", gtid, taskdata,
-                num_tasks, grainsize, extras, *lb, *ub, st, task_dup));
+                " %lld, extras %lld, i=%lld,%lld(%d), dup %p\n",
+                gtid, taskdata, num_tasks, grainsize, extras, *lb, *ub, st,
+                task_dup));
 #endif
-  KMP_DEBUG_ASSERT(num_tasks*2+1 > num_t_min);
+  KMP_DEBUG_ASSERT(num_tasks * 2 + 1 > num_t_min);
   if (num_tasks > num_t_min)
     __kmp_taskloop_recur(NULL, gtid, task, lb, ub, st, ub_glob, num_tasks,
                          grainsize, extras, tc, num_t_min, task_dup);
   else
     __kmp_taskloop_linear(NULL, gtid, task, lb, ub, st, ub_glob, num_tasks,
                           grainsize, extras, tc, task_dup);
 
   KA_TRACE(40, ("__kmp_taskloop_task(exit): T#%d\n", gtid));
void __kmp_taskloop_recur(ident_t *loc, int gtid, kmp_task_t *task,
                           kmp_uint64 ub_glob, kmp_uint64 num_tasks,
                           kmp_uint64 grainsize, kmp_uint64 extras,
                           kmp_uint64 tc, kmp_uint64 num_t_min, void *task_dup) {
 #if KMP_DEBUG
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   KMP_DEBUG_ASSERT(task != NULL);
   KMP_DEBUG_ASSERT(num_tasks > num_t_min);
   KA_TRACE(20, ("__kmp_taskloop_recur: T#%d, task %p: %lld tasks, grainsize"
-                " %lld, extras %lld, i=%lld,%lld(%d), dup %p\n", gtid, taskdata,
-                num_tasks, grainsize, extras, *lb, *ub, st, task_dup));
+                " %lld, extras %lld, i=%lld,%lld(%d), dup %p\n",
+                gtid, taskdata, num_tasks, grainsize, extras, *lb, *ub, st,
+                task_dup));
 #endif
   p_task_dup_t ptask_dup = (p_task_dup_t)task_dup;
   kmp_uint64 lower = *lb;
   kmp_uint64 upper = *ub;
   kmp_info_t *thread = __kmp_threads[gtid];
   //  kmp_taskdata_t *current_task = thread->th.th_current_task;
   kmp_task_t *next_task;
   kmp_int32 lastpriv = 0;
   size_t lower_offset =
       (char *)lb - (char *)task; // remember offset of lb in the task structure
   size_t upper_offset =
       (char *)ub - (char *)task; // remember offset of ub in the task structure
 
   KMP_DEBUG_ASSERT(tc == num_tasks * grainsize + extras);
#endif
   // adjust lower bound (upper bound is not changed) for the 2nd half
   *(kmp_uint64 *)((char *)next_task + lower_offset) = lb1;
   if (ptask_dup != NULL) // construct fistprivates, etc.
     ptask_dup(next_task, task, 0);
   *ub = ub0; // adjust upper bound for the 1st half
 
   // create auxiliary task for 2nd half of the loop
   kmp_task_t *new_task =
-      __kmpc_omp_task_alloc(loc, gtid, 1, 3 * sizeof(void*),
+      __kmpc_omp_task_alloc(loc, gtid, 1, 3 * sizeof(void *),
                             sizeof(__taskloop_params_t), &__kmp_taskloop_task);
-  __taskloop_params_t * p = (__taskloop_params_t *)new_task->shareds;
+  __taskloop_params_t *p = (__taskloop_params_t *)new_task->shareds;
   p->task = next_task;
   p->lb = (kmp_uint64 *)((char *)next_task + lower_offset);
   p->ub = (kmp_uint64 *)((char *)next_task + upper_offset);
   p->task_dup = task_dup;
   p->st = st;
   p->ub_glob = ub_glob;
   p->num_tasks = n_tsk1;
   p->grainsize = grainsize;
   p->extras = ext1;
   p->tc = tc1;
   p->num_t_min = num_t_min;
   __kmp_omp_task(gtid, new_task, true); // schedule new task
 
   // execute the 1st half of current subrange
   if (n_tsk0 > num_t_min)
-    __kmp_taskloop_recur(loc, gtid, task, lb, ub, st, ub_glob, n_tsk0,
-                         gr_size0, ext0, tc0, num_t_min, task_dup);
+    __kmp_taskloop_recur(loc, gtid, task, lb, ub, st, ub_glob, n_tsk0, gr_size0,
+                         ext0, tc0, num_t_min, task_dup);
   else
     __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, n_tsk0,
                           gr_size0, ext0, tc0, task_dup);
 
   KA_TRACE(40, ("__kmpc_taskloop_recur(exit): T#%d\n", gtid));
 }
 
 /*!

 */
 void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val,
                      kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup,
                      int sched, kmp_uint64 grainsize, void *task_dup) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   KMP_DEBUG_ASSERT(task != NULL);
 
   KA_TRACE(20, ("__kmpc_taskloop: T#%d, task %p, lb %lld, ub %lld, st %lld, "
-                "grain %llu(%d), dup %p\n", gtid, taskdata, *lb, *ub, st,
-                grainsize, sched, task_dup));
+                "grain %llu(%d), dup %p\n",
+                gtid, taskdata, *lb, *ub, st, grainsize, sched, task_dup));
 
   if (nogroup == 0)
     __kmpc_taskgroup(loc, gtid);
 
   // =========================================================================
   // calculate loop parameters
   kmp_uint64 tc;
   kmp_uint64 lower = *lb; // compiler provides global bounds here
if (tc == 0) {
     // free the pattern task and exit
     __kmp_task_start(gtid, task, current_task);
     // do not execute anything for zero-trip loop
     __kmp_task_finish(gtid, task, current_task);
     return;
   }
   if (num_tasks_min == 0)
     // TODO: can we choose better default heuristic?
-    num_tasks_min = KMP_MIN(thread->th.th_team_nproc * 10,
-                            INITIAL_TASK_DEQUE_SIZE);
+    num_tasks_min =
+        KMP_MIN(thread->th.th_team_nproc * 10, INITIAL_TASK_DEQUE_SIZE);
 
   // compute num_tasks/grainsize based on the input provided
   switch (sched) {
   case 0: // no schedule clause specified, we can choose the default
     // let's try to schedule (team_size*10) tasks
     grainsize = thread->th.th_team_nproc * 10;
   case 2: // num_tasks provided
     if (grainsize > tc) {
void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val,
   if (if_val == 0) { // if(0) specified, mark task as serial
     taskdata->td_flags.task_serial = 1;
     taskdata->td_flags.tiedness = TASK_TIED; // AC: serial task cannot be untied
     // always start serial tasks linearly
     __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
                           grainsize, extras, tc, task_dup);
   } else if (num_tasks > num_tasks_min) {
     KA_TRACE(20, ("__kmpc_taskloop: T#%d, go recursive: tc %llu, #tasks %llu"
-                  "(%lld), grain %llu, extras %llu\n", gtid, tc, num_tasks,
-                  num_tasks_min, grainsize, extras));
+                  "(%lld), grain %llu, extras %llu\n",
+                  gtid, tc, num_tasks, num_tasks_min, grainsize, extras));
     __kmp_taskloop_recur(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
                          grainsize, extras, tc, num_tasks_min, task_dup);
   } else {
     KA_TRACE(20, ("__kmpc_taskloop: T#%d, go linear: tc %llu, #tasks %llu"
-                  "(%lld), grain %llu, extras %llu\n", gtid, tc, num_tasks,
-                  num_tasks_min, grainsize, extras));
+                  "(%lld), grain %llu, extras %llu\n",
+                  gtid, tc, num_tasks, num_tasks_min, grainsize, extras));
     __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
                           grainsize, extras, tc, task_dup);
   }
 
   if (nogroup == 0)
     __kmpc_end_taskgroup(loc, gtid);
   KA_TRACE(20, ("__kmpc_taskloop(exit): T#%d\n", gtid));
 }
 
 #endif