Index: runtime/src/kmp.h =================================================================== --- runtime/src/kmp.h +++ runtime/src/kmp.h @@ -2833,16 +2833,10 @@ 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? */ Index: runtime/src/kmp_global.cpp =================================================================== --- runtime/src/kmp_global.cpp +++ runtime/src/kmp_global.cpp @@ -376,12 +376,7 @@ 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? */ Index: runtime/src/kmp_settings.cpp =================================================================== --- runtime/src/kmp_settings.cpp +++ runtime/src/kmp_settings.cpp @@ -641,6 +641,9 @@ __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 @@ -678,8 +681,6 @@ // ----------------------------------------------------------------------------- // 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) { @@ -1171,14 +1172,14 @@ // 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) { + 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) { + 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 @@ -3381,8 +3382,6 @@ 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; @@ -3406,8 +3405,7 @@ __kmp_msg_null); KMP_INFORM(Using_int_Value, name, __kmp_chunk); } - } else - __kmp_env_chunk = FALSE; + } } else KMP_WARNING(EmptyString, name); } @@ -4925,7 +4923,7 @@ } }; // for i - // We need to know if blocktime was set when processing OMP_WAIT_POLICY +// 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 Index: runtime/src/kmp_tasking.cpp =================================================================== --- runtime/src/kmp_tasking.cpp +++ runtime/src/kmp_tasking.cpp @@ -3308,8 +3308,9 @@ 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) { @@ -3331,7 +3332,7 @@ 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; @@ -3378,12 +3379,13 @@ // 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; + // 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; @@ -3395,10 +3397,11 @@ 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); @@ -3436,14 +3439,15 @@ 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_taskdata_t *current_task = thread->th.th_current_task; kmp_task_t *next_task; kmp_int32 lastpriv = 0; size_t lower_offset = @@ -3485,9 +3489,9 @@ // 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); @@ -3503,8 +3507,8 @@ // 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); @@ -3535,8 +3539,8 @@ 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); @@ -3570,8 +3574,8 @@ } 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) { @@ -3618,14 +3622,14 @@ 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); }