Lines Matching +full:scan +full:- +full:count
2 * kmp_settings.cpp -- Initialize environment variables
5 //===----------------------------------------------------------------------===//
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
11 //===----------------------------------------------------------------------===//
29 #include "ompd-specific.h"
34 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
36 // -----------------------------------------------------------------------------
78 ca -= 'a' - 'A'; in __kmp_match_with_sentinel()
80 cb -= 'a' - 'A'; in __kmp_match_with_sentinel()
124 ct -= 'a' - 'A'; in __kmp_match_str()
126 cb -= 'a' - 'A'; in __kmp_match_str()
142 if (size & (_4k - 1)) { in __kmp_round4k()
143 size &= ~(_4k - 1); in __kmp_round4k()
144 if (size <= KMP_SIZE_T_MAX - _4k) { in __kmp_round4k()
162 ca -= 'a' - 'A'; in __kmp_strcasecmp_with_sentinel()
164 cb -= 'a' - 'A'; in __kmp_strcasecmp_with_sentinel()
166 return (int)(unsigned char)*a - (int)(unsigned char)*b; in __kmp_strcasecmp_with_sentinel()
171 ? (int)(unsigned char)*a - (int)(unsigned char)*b in __kmp_strcasecmp_with_sentinel()
173 : (*b && *b != sentinel) ? -1 in __kmp_strcasecmp_with_sentinel()
206 int omp; // 0 -- KMP_LIBRARY, 1 -- OMP_WAIT_POLICY.
211 int force; // 0 -- KMP_DETERMINISTIC_REDUCTION, 1 -- KMP_FORCE_REDUCTION.
215 static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found.
230 const char *end = str + KMP_STRLEN(str) - 1; in kmp_trimmed_str_t()
233 end--; in kmp_trimmed_str_t()
234 __kmp_str_buf_cat(&buf, begin, end - begin + 1); in kmp_trimmed_str_t()
240 // -----------------------------------------------------------------------------
412 KMP_PAR_RANGE_ROUTINE_LEN - 1, ','); in __kmp_stg_parse_par_range()
428 KMP_PAR_RANGE_FILENAME_LEN - 1, ','); in __kmp_stg_parse_par_range()
462 *out_range = -1; in __kmp_stg_parse_par_range()
518 // -----------------------------------------------------------------------------
574 // -----------------------------------------------------------------------------
604 // -----------------------------------------------------------------------------
618 // -----------------------------------------------------------------------------
631 // -----------------------------------------------------------------------------
645 // -----------------------------------------------------------------------------
657 // -----------------------------------------------------------------------------
670 // -----------------------------------------------------------------------------
691 num = -1; in __kmp_stg_parse_blocktime()
774 // -----------------------------------------------------------------------------
789 // -----------------------------------------------------------------------------
811 // -----------------------------------------------------------------------------
820 rc = __kmp_stg_check_rivals(name, value, wait->rivals); in __kmp_stg_parse_wait_policy()
825 if (wait->omp) { in __kmp_stg_parse_wait_policy()
873 if (wait->omp) { in __kmp_stg_print_wait_policy()
909 // -----------------------------------------------------------------------------
939 // -----------------------------------------------------------------------------
952 // -----------------------------------------------------------------------------
970 // -----------------------------------------------------------------------------
989 // -----------------------------------------------------------------------------
998 rc = __kmp_stg_check_rivals(name, value, stacksize->rivals); in __kmp_stg_parse_stacksize()
1008 stacksize->factor); in __kmp_stg_parse_stacksize()
1022 ? __kmp_stksize / stacksize->factor in __kmp_stg_print_stacksize()
1028 ? __kmp_stksize / stacksize->factor in __kmp_stg_print_stacksize()
1034 // -----------------------------------------------------------------------------
1047 // -----------------------------------------------------------------------------
1066 // -----------------------------------------------------------------------------
1088 // -----------------------------------------------------------------------------
1112 __kmp_str_buf_print(buffer, ": deprecated; max-active-levels-var=%d\n", in __kmp_stg_print_nested()
1119 const char *scan = next; in __kmp_parse_nested_num_threads() local
1121 int total = 0; // Count elements that were set. It'll be used as an array size in __kmp_parse_nested_num_threads()
1124 // Count the number of values in the env. var string in __kmp_parse_nested_num_threads()
1168 if (!nth_array->nth) { in __kmp_parse_nested_num_threads()
1170 nth_array->nth = (int *)KMP_INTERNAL_MALLOC(sizeof(int) * total * 2); in __kmp_parse_nested_num_threads()
1171 if (nth_array->nth == NULL) { in __kmp_parse_nested_num_threads()
1174 nth_array->size = total * 2; in __kmp_parse_nested_num_threads()
1176 if (nth_array->size < total) { in __kmp_parse_nested_num_threads()
1179 nth_array->size *= 2; in __kmp_parse_nested_num_threads()
1180 } while (nth_array->size < total); in __kmp_parse_nested_num_threads()
1182 nth_array->nth = (int *)KMP_INTERNAL_REALLOC( in __kmp_parse_nested_num_threads()
1183 nth_array->nth, sizeof(int) * nth_array->size); in __kmp_parse_nested_num_threads()
1184 if (nth_array->nth == NULL) { in __kmp_parse_nested_num_threads()
1189 nth_array->used = total; in __kmp_parse_nested_num_threads()
1196 SKIP_WS(scan); in __kmp_parse_nested_num_threads()
1197 if (*scan == '\0') { in __kmp_parse_nested_num_threads()
1201 if (*scan == ',') { in __kmp_parse_nested_num_threads()
1207 nth_array->nth[i++] = 0; in __kmp_parse_nested_num_threads()
1211 nth_array->nth[i] = nth_array->nth[i - 1]; in __kmp_parse_nested_num_threads()
1216 scan++; // skip ',' in __kmp_parse_nested_num_threads()
1217 SKIP_WS(scan); in __kmp_parse_nested_num_threads()
1220 if (*scan >= '0' && *scan <= '9') { in __kmp_parse_nested_num_threads()
1222 const char *buf = scan; in __kmp_parse_nested_num_threads()
1225 SKIP_DIGITS(scan); in __kmp_parse_nested_num_threads()
1228 num = __kmp_str_to_int(buf, *scan); in __kmp_parse_nested_num_threads()
1241 nth_array->nth[i++] = num; in __kmp_parse_nested_num_threads()
1314 __kmp_stg_print_int(buffer, name, __kmp_hidden_helper_threads_num - 1); in __kmp_stg_print_num_hidden_helper_threads()
1325 "non-Linux platform although it is enabled by user explicitly.\n")); in __kmp_stg_parse_use_hidden_helper()
1346 if (i < __kmp_nested_nth.used - 1) { in __kmp_stg_print_num_threads()
1357 // -----------------------------------------------------------------------------
1407 // -----------------------------------------------------------------------------
1420 // -----------------------------------------------------------------------------
1425 const char *scan = value_str.get(); in __kmp_stg_parse_target_offload() local
1428 if (*scan == '\0') in __kmp_stg_parse_target_offload()
1431 if (!__kmp_strcasecmp_with_sentinel("mandatory", scan, 0)) { in __kmp_stg_parse_target_offload()
1433 } else if (!__kmp_strcasecmp_with_sentinel("disabled", scan, 0)) { in __kmp_stg_parse_target_offload()
1435 } else if (!__kmp_strcasecmp_with_sentinel("default", scan, 0)) { in __kmp_stg_parse_target_offload()
1460 // -----------------------------------------------------------------------------
1487 // -----------------------------------------------------------------------------
1505 // -----------------------------------------------------------------------------
1540 // -----------------------------------------------------------------------------
1557 // -----------------------------------------------------------------------------
1674 // -----------------------------------------------------------------------------
1688 // -----------------------------------------------------------------------------
1698 /* ---------- Barrier branch bit control ------------ */ in __kmp_stg_parse_barrier_branch_bit()
1752 // ----------------------------------------------------------------------------
1762 /* ---------- Barrier method control ------------ */ in __kmp_stg_parse_barrier_pattern()
1852 // -----------------------------------------------------------------------------
1869 // -----------------------------------------------------------------------------
1896 // -----------------------------------------------------------------------------
1904 rc = __kmp_stg_check_rivals(name, value, reduction->rivals); in __kmp_stg_parse_force_reduction()
1908 if (reduction->force) { in __kmp_stg_parse_force_reduction()
1936 if (reduction->force) { in __kmp_stg_print_force_reduction()
1957 // -----------------------------------------------------------------------------
1982 // -----------------------------------------------------------------------------
1997 // -----------------------------------------------------------------------------
2012 // -----------------------------------------------------------------------------
2037 const char *scan = env; in __kmp_parse_affinity_proc_id_list() local
2038 const char *next = scan; in __kmp_parse_affinity_proc_id_list()
2046 SKIP_WS(scan); in __kmp_parse_affinity_proc_id_list()
2047 next = scan; in __kmp_parse_affinity_proc_id_list()
2056 scan = next; in __kmp_parse_affinity_proc_id_list()
2064 num = __kmp_str_to_int(scan, *next); in __kmp_parse_affinity_proc_id_list()
2082 scan = next; in __kmp_parse_affinity_proc_id_list()
2089 num = __kmp_str_to_int(scan, *next); in __kmp_parse_affinity_proc_id_list()
2098 scan = next; in __kmp_parse_affinity_proc_id_list()
2113 start = __kmp_str_to_int(scan, *next); in __kmp_parse_affinity_proc_id_list()
2118 if (*next != '-') { in __kmp_parse_affinity_proc_id_list()
2125 scan = next; in __kmp_parse_affinity_proc_id_list()
2129 // This is a range. Skip over the '-' and read in the 2nd int. in __kmp_parse_affinity_proc_id_list()
2130 next++; // skip '-' in __kmp_parse_affinity_proc_id_list()
2132 scan = next; in __kmp_parse_affinity_proc_id_list()
2138 end = __kmp_str_to_int(scan, *next); in __kmp_parse_affinity_proc_id_list()
2149 scan = next; in __kmp_parse_affinity_proc_id_list()
2150 if (*next == '-') { in __kmp_parse_affinity_proc_id_list()
2151 sign = -1; in __kmp_parse_affinity_proc_id_list()
2154 scan = next; in __kmp_parse_affinity_proc_id_list()
2161 stride = __kmp_str_to_int(scan, *next); in __kmp_parse_affinity_proc_id_list()
2182 if ((end - start) / stride > 65536) { in __kmp_parse_affinity_proc_id_list()
2194 scan = next; in __kmp_parse_affinity_proc_id_list()
2200 ptrdiff_t len = next - env; in __kmp_parse_affinity_proc_id_list()
2219 int count = 0; // Counter of parsed integer numbers. in __kmp_parse_affinity_env() local
2249 // If we see a parse error, emit a warning and scan to the next ",". in __kmp_parse_affinity_env()
2251 // FIXME - there's got to be a better way to print an error in __kmp_parse_affinity_env()
2280 #define set_type(val) _set_param(type, out_affinity->type, val) in __kmp_parse_affinity_env()
2281 #define set_verbose(val) _set_param(verbose, out_affinity->flags.verbose, val) in __kmp_parse_affinity_env()
2283 _set_param(warnings, out_affinity->flags.warnings, val) in __kmp_parse_affinity_env()
2284 #define set_respect(val) _set_param(respect, out_affinity->flags.respect, val) in __kmp_parse_affinity_env()
2285 #define set_dups(val) _set_param(dups, out_affinity->flags.dups, val) in __kmp_parse_affinity_env()
2286 #define set_proclist(val) _set_param(proclist, out_affinity->proclist, val) in __kmp_parse_affinity_env()
2287 #define set_reset(val) _set_param(reset, out_affinity->flags.reset, val) in __kmp_parse_affinity_env()
2292 out_affinity->gran = val; \ in __kmp_parse_affinity_env()
2293 out_affinity->gran_levels = levels; \ in __kmp_parse_affinity_env()
2389 set_gran(KMP_HW_CORE, -1); in __kmp_parse_affinity_env()
2390 out_affinity->flags.core_types_gran = 1; in __kmp_parse_affinity_env()
2397 set_gran(KMP_HW_CORE, -1); in __kmp_parse_affinity_env()
2398 out_affinity->flags.core_effs_gran = 1; in __kmp_parse_affinity_env()
2407 set_gran(type, -1); in __kmp_parse_affinity_env()
2417 set_gran(KMP_HW_THREAD, -1); in __kmp_parse_affinity_env()
2422 set_gran(KMP_HW_SOCKET, -1); in __kmp_parse_affinity_env()
2426 set_gran(KMP_HW_NUMA, -1); in __kmp_parse_affinity_env()
2431 set_gran(KMP_HW_PROC_GROUP, -1); in __kmp_parse_affinity_env()
2484 // Parse integer numbers -- permute and offset. in __kmp_parse_affinity_env()
2491 if (count < 2) { in __kmp_parse_affinity_env()
2492 number[count] = n; in __kmp_parse_affinity_env()
2496 ++count; in __kmp_parse_affinity_env()
2528 out_affinity->type = affinity_explicit; in __kmp_parse_affinity_env()
2530 } else if (out_affinity->type != affinity_explicit) { in __kmp_parse_affinity_env()
2532 KMP_ASSERT(out_affinity->proclist != NULL); in __kmp_parse_affinity_env()
2533 KMP_INTERNAL_FREE(out_affinity->proclist); in __kmp_parse_affinity_env()
2534 out_affinity->proclist = NULL; in __kmp_parse_affinity_env()
2537 switch (out_affinity->type) { in __kmp_parse_affinity_env()
2540 if (count > 0) { in __kmp_parse_affinity_env()
2541 out_affinity->offset = number[0]; in __kmp_parse_affinity_env()
2543 if (count > 1) { in __kmp_parse_affinity_env()
2548 if (count > 0) { in __kmp_parse_affinity_env()
2549 out_affinity->compact = number[0]; in __kmp_parse_affinity_env()
2551 if (count > 1) { in __kmp_parse_affinity_env()
2552 out_affinity->offset = number[1]; in __kmp_parse_affinity_env()
2556 int verbose = out_affinity->flags.verbose; in __kmp_parse_affinity_env()
2557 int warnings = out_affinity->flags.warnings; in __kmp_parse_affinity_env()
2561 KMP_WARNING(AffGranUsing, out_affinity->env_var, "fine"); in __kmp_parse_affinity_env()
2563 out_affinity->gran = KMP_HW_THREAD; in __kmp_parse_affinity_env()
2568 KMP_WARNING(AffGranUsing, out_affinity->env_var, "core"); in __kmp_parse_affinity_env()
2570 out_affinity->gran = KMP_HW_CORE; in __kmp_parse_affinity_env()
2576 if (count > 0) { in __kmp_parse_affinity_env()
2577 out_affinity->compact = number[0]; in __kmp_parse_affinity_env()
2579 if (count > 1) { in __kmp_parse_affinity_env()
2580 out_affinity->offset = number[1]; in __kmp_parse_affinity_env()
2584 if (out_affinity->proclist == NULL) { in __kmp_parse_affinity_env()
2586 out_affinity->type = affinity_none; in __kmp_parse_affinity_env()
2588 if (count > 0) { in __kmp_parse_affinity_env()
2593 if (count > 0) { in __kmp_parse_affinity_env()
2598 if (count > 0) { in __kmp_parse_affinity_env()
2603 if (count > 0) { in __kmp_parse_affinity_env()
2777 /*-----------------------------------------------------------------------------
2794 signed := - signed
2795 -----------------------------------------------------------------------------*/
2798 static int __kmp_parse_subplace_list(const char *var, const char **scan) { in __kmp_parse_subplace_list() argument
2802 int start, count, stride; in __kmp_parse_subplace_list() local
2807 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2808 if ((**scan < '0') || (**scan > '9')) { in __kmp_parse_subplace_list()
2811 next = *scan; in __kmp_parse_subplace_list()
2813 start = __kmp_str_to_int(*scan, *next); in __kmp_parse_subplace_list()
2815 *scan = next; in __kmp_parse_subplace_list()
2818 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2819 if (**scan == '}') { in __kmp_parse_subplace_list()
2822 if (**scan == ',') { in __kmp_parse_subplace_list()
2823 (*scan)++; // skip ',' in __kmp_parse_subplace_list()
2826 if (**scan != ':') { in __kmp_parse_subplace_list()
2829 (*scan)++; // skip ':' in __kmp_parse_subplace_list()
2831 // Read count parameter in __kmp_parse_subplace_list()
2832 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2833 if ((**scan < '0') || (**scan > '9')) { in __kmp_parse_subplace_list()
2836 next = *scan; in __kmp_parse_subplace_list()
2838 count = __kmp_str_to_int(*scan, *next); in __kmp_parse_subplace_list()
2839 KMP_ASSERT(count >= 0); in __kmp_parse_subplace_list()
2840 *scan = next; in __kmp_parse_subplace_list()
2843 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2844 if (**scan == '}') { in __kmp_parse_subplace_list()
2847 if (**scan == ',') { in __kmp_parse_subplace_list()
2848 (*scan)++; // skip ',' in __kmp_parse_subplace_list()
2851 if (**scan != ':') { in __kmp_parse_subplace_list()
2854 (*scan)++; // skip ':' in __kmp_parse_subplace_list()
2859 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2860 if (**scan == '+') { in __kmp_parse_subplace_list()
2861 (*scan)++; // skip '+' in __kmp_parse_subplace_list()
2864 if (**scan == '-') { in __kmp_parse_subplace_list()
2865 sign *= -1; in __kmp_parse_subplace_list()
2866 (*scan)++; // skip '-' in __kmp_parse_subplace_list()
2871 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2872 if ((**scan < '0') || (**scan > '9')) { in __kmp_parse_subplace_list()
2875 next = *scan; in __kmp_parse_subplace_list()
2877 stride = __kmp_str_to_int(*scan, *next); in __kmp_parse_subplace_list()
2879 *scan = next; in __kmp_parse_subplace_list()
2883 SKIP_WS(*scan); in __kmp_parse_subplace_list()
2884 if (**scan == '}') { in __kmp_parse_subplace_list()
2887 if (**scan == ',') { in __kmp_parse_subplace_list()
2888 (*scan)++; // skip ',' in __kmp_parse_subplace_list()
2897 static int __kmp_parse_place(const char *var, const char **scan) { in __kmp_parse_place() argument
2901 SKIP_WS(*scan); in __kmp_parse_place()
2902 if (**scan == '{') { in __kmp_parse_place()
2903 (*scan)++; // skip '{' in __kmp_parse_place()
2904 if (!__kmp_parse_subplace_list(var, scan)) { in __kmp_parse_place()
2907 if (**scan != '}') { in __kmp_parse_place()
2910 (*scan)++; // skip '}' in __kmp_parse_place()
2911 } else if (**scan == '!') { in __kmp_parse_place()
2912 (*scan)++; // skip '!' in __kmp_parse_place()
2913 return __kmp_parse_place(var, scan); //'!' has lower precedence than ':' in __kmp_parse_place()
2914 } else if ((**scan >= '0') && (**scan <= '9')) { in __kmp_parse_place()
2915 next = *scan; in __kmp_parse_place()
2917 int proc = __kmp_str_to_int(*scan, *next); in __kmp_parse_place()
2919 *scan = next; in __kmp_parse_place()
2929 const char *scan = env; in __kmp_parse_place_list() local
2930 const char *next = scan; in __kmp_parse_place_list()
2933 int count, stride; in __kmp_parse_place_list() local
2935 if (!__kmp_parse_place(var, &scan)) { in __kmp_parse_place_list()
2940 SKIP_WS(scan); in __kmp_parse_place_list()
2941 if (*scan == '\0') { in __kmp_parse_place_list()
2944 if (*scan == ',') { in __kmp_parse_place_list()
2945 scan++; // skip ',' in __kmp_parse_place_list()
2948 if (*scan != ':') { in __kmp_parse_place_list()
2951 scan++; // skip ':' in __kmp_parse_place_list()
2953 // Read count parameter in __kmp_parse_place_list()
2954 SKIP_WS(scan); in __kmp_parse_place_list()
2955 if ((*scan < '0') || (*scan > '9')) { in __kmp_parse_place_list()
2958 next = scan; in __kmp_parse_place_list()
2960 count = __kmp_str_to_int(scan, *next); in __kmp_parse_place_list()
2961 KMP_ASSERT(count >= 0); in __kmp_parse_place_list()
2962 scan = next; in __kmp_parse_place_list()
2965 SKIP_WS(scan); in __kmp_parse_place_list()
2966 if (*scan == '\0') { in __kmp_parse_place_list()
2969 if (*scan == ',') { in __kmp_parse_place_list()
2970 scan++; // skip ',' in __kmp_parse_place_list()
2973 if (*scan != ':') { in __kmp_parse_place_list()
2976 scan++; // skip ':' in __kmp_parse_place_list()
2981 SKIP_WS(scan); in __kmp_parse_place_list()
2982 if (*scan == '+') { in __kmp_parse_place_list()
2983 scan++; // skip '+' in __kmp_parse_place_list()
2986 if (*scan == '-') { in __kmp_parse_place_list()
2987 sign *= -1; in __kmp_parse_place_list()
2988 scan++; // skip '-' in __kmp_parse_place_list()
2993 SKIP_WS(scan); in __kmp_parse_place_list()
2994 if ((*scan < '0') || (*scan > '9')) { in __kmp_parse_place_list()
2997 next = scan; in __kmp_parse_place_list()
2999 stride = __kmp_str_to_int(scan, *next); in __kmp_parse_place_list()
3001 scan = next; in __kmp_parse_place_list()
3005 SKIP_WS(scan); in __kmp_parse_place_list()
3006 if (*scan == '\0') { in __kmp_parse_place_list()
3009 if (*scan == ',') { in __kmp_parse_place_list()
3010 scan++; // skip ',' in __kmp_parse_place_list()
3018 ptrdiff_t len = scan - env; in __kmp_parse_place_list()
3049 int count; in __kmp_stg_parse_places() local
3051 const char *scan = value; in __kmp_stg_parse_places() local
3052 const char *next = scan; in __kmp_stg_parse_places()
3069 if (__kmp_match_str(place.name, scan, &next)) { in __kmp_stg_parse_places()
3070 scan = next; in __kmp_stg_parse_places()
3075 SKIP_WS(scan); in __kmp_stg_parse_places()
3076 if (*scan == ':') { in __kmp_stg_parse_places()
3081 scan++; // skip ':' in __kmp_stg_parse_places()
3082 SKIP_WS(scan); in __kmp_stg_parse_places()
3084 if (__kmp_match_str("intel_core", scan, &next)) { in __kmp_stg_parse_places()
3087 scan = next; in __kmp_stg_parse_places()
3088 } else if (__kmp_match_str("intel_atom", scan, &next)) { in __kmp_stg_parse_places()
3091 scan = next; in __kmp_stg_parse_places()
3094 if (__kmp_match_str("eff", scan, &next)) { in __kmp_stg_parse_places()
3100 scan = next; in __kmp_stg_parse_places()
3102 eff = __kmp_str_to_int(scan, *next); in __kmp_stg_parse_places()
3108 eff = KMP_HW_MAX_NUM_CORE_EFFS - 1; in __kmp_stg_parse_places()
3111 scan = next; in __kmp_stg_parse_places()
3126 if (__kmp_match_str("unknowns", scan, &next)) in __kmp_stg_parse_places()
3128 if (__kmp_match_str(name, scan, &next)) { in __kmp_stg_parse_places()
3129 scan = next; in __kmp_stg_parse_places()
3138 if (__kmp_match_str("core_types", scan, &next)) { in __kmp_stg_parse_places()
3139 scan = next; in __kmp_stg_parse_places()
3140 if (*scan != '\0') { in __kmp_stg_parse_places()
3141 KMP_WARNING(ParseExtraCharsWarn, name, scan); in __kmp_stg_parse_places()
3146 } else if (__kmp_match_str("core_effs", scan, &next) || in __kmp_stg_parse_places()
3147 __kmp_match_str("core_efficiencies", scan, &next)) { in __kmp_stg_parse_places()
3148 scan = next; in __kmp_stg_parse_places()
3149 if (*scan != '\0') { in __kmp_stg_parse_places()
3150 KMP_WARNING(ParseExtraCharsWarn, name, scan); in __kmp_stg_parse_places()
3186 SKIP_WS(scan); in __kmp_stg_parse_places()
3187 if (*scan == '\0') { in __kmp_stg_parse_places()
3191 // Parse option count parameter in parentheses in __kmp_stg_parse_places()
3192 if (*scan != '(') { in __kmp_stg_parse_places()
3196 scan++; // skip '(' in __kmp_stg_parse_places()
3198 SKIP_WS(scan); in __kmp_stg_parse_places()
3199 next = scan; in __kmp_stg_parse_places()
3201 count = __kmp_str_to_int(scan, *next); in __kmp_stg_parse_places()
3202 KMP_ASSERT(count >= 0); in __kmp_stg_parse_places()
3203 scan = next; in __kmp_stg_parse_places()
3205 SKIP_WS(scan); in __kmp_stg_parse_places()
3206 if (*scan != ')') { in __kmp_stg_parse_places()
3210 scan++; // skip ')' in __kmp_stg_parse_places()
3212 SKIP_WS(scan); in __kmp_stg_parse_places()
3213 if (*scan != '\0') { in __kmp_stg_parse_places()
3214 KMP_WARNING(ParseExtraCharsWarn, name, scan); in __kmp_stg_parse_places()
3216 __kmp_affinity_num_places = count; in __kmp_stg_parse_places()
3312 __kmp_str_match("x2apic-id", 9, value) || in __kmp_stg_parse_topology_method()
3316 __kmp_str_match("cpuid-leaf-11", 13, value) || in __kmp_stg_parse_topology_method()
3319 __kmp_str_match("cpuid-leaf11", 12, value) || in __kmp_stg_parse_topology_method()
3322 __kmp_str_match("cpuidleaf-11", 12, value) || in __kmp_stg_parse_topology_method()
3326 __kmp_str_match("cpuid-11", 8, value) || in __kmp_stg_parse_topology_method()
3330 __kmp_str_match("leaf-11", 7, value) || in __kmp_stg_parse_topology_method()
3335 __kmp_str_match("apic-id", 7, value) || in __kmp_stg_parse_topology_method()
3339 __kmp_str_match("cpuid-leaf-4", 12, value) || in __kmp_stg_parse_topology_method()
3342 __kmp_str_match("cpuid-leaf4", 11, value) || in __kmp_stg_parse_topology_method()
3345 __kmp_str_match("cpuidleaf-4", 11, value) || in __kmp_stg_parse_topology_method()
3349 __kmp_str_match("cpuid-4", 7, value) || in __kmp_stg_parse_topology_method()
3353 __kmp_str_match("leaf-4", 6, value) || in __kmp_stg_parse_topology_method()
3437 // teams-bind = false means "replicate the primary thread's affinity"
3471 // OMP_PROC_BIND / bind-var is functional on all 4.0 builds, including OS X*
3472 // OMP_PLACES / place-partition-var is not.
3499 num = -1; in __kmp_stg_parse_proc_bind()
3527 // Count the number of values in the env var string in __kmp_stg_parse_proc_bind()
3528 const char *scan; in __kmp_stg_parse_proc_bind() local
3530 for (scan = buf; *scan != '\0'; scan++) { in __kmp_stg_parse_proc_bind()
3531 if (*scan == ',') { in __kmp_stg_parse_proc_bind()
3597 num = -1; in __kmp_stg_parse_proc_bind()
3650 if (i < nelem - 1) { in __kmp_stg_print_proc_bind()
3682 /*-----------------------------------------------------------------------------
3685 <allocator> |= <predef-allocator> | <predef-mem-space> |
3686 <predef-mem-space>:<traits>
3688 <predef-allocator> |= omp_default_mem_alloc | omp_large_cap_mem_alloc |
3692 <predef-mem-space> |= omp_default_mem_space | omp_large_cap_mem_space |
3698 non-negative integer | <predef-allocator>
3699 -----------------------------------------------------------------------------*/
3704 const char *next, *scan, *start; in __kmp_stg_parse_allocator() local
3709 int ntraits = 0, count = 0; in __kmp_stg_parse_allocator() local
3718 // Count the number of traits in the env var string in __kmp_stg_parse_allocator()
3721 for (scan = buf; *scan != '\0'; scan++) { in __kmp_stg_parse_allocator()
3722 if (*scan == ',') in __kmp_stg_parse_allocator()
3730 #define IS_POWER_OF_TWO(n) (((n) & ((n)-1)) == 0) in __kmp_stg_parse_allocator()
3738 scan = next; \ in __kmp_stg_parse_allocator()
3744 char *value = __kmp_str_token(CCAST(char *, scan), str_delimiter, \ in __kmp_stg_parse_allocator()
3747 ntraits--; \ in __kmp_stg_parse_allocator()
3749 scan = next; \ in __kmp_stg_parse_allocator()
3757 scan = next; \ in __kmp_stg_parse_allocator()
3760 scan = next; in __kmp_stg_parse_allocator()
3763 __kmp_match_str("fb_data", scan, &next)) { // allocator check in __kmp_stg_parse_allocator()
3764 start = scan; in __kmp_stg_parse_allocator()
3766 // check HBW and LCAP first as the only non-default supported in __kmp_stg_parse_allocator()
3767 if (__kmp_match_str("omp_high_bw_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3777 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3778 traits[count].value = RCAST(omp_uintptr_t, omp_high_bw_mem_alloc); in __kmp_stg_parse_allocator()
3780 } else if (__kmp_match_str("omp_large_cap_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3790 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3791 traits[count].value = RCAST(omp_uintptr_t, omp_large_cap_mem_alloc); in __kmp_stg_parse_allocator()
3793 } else if (__kmp_match_str("omp_default_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3797 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3798 traits[count].value = RCAST(omp_uintptr_t, omp_default_mem_alloc); in __kmp_stg_parse_allocator()
3800 } else if (__kmp_match_str("omp_const_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3805 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3806 traits[count].value = RCAST(omp_uintptr_t, omp_const_mem_alloc); in __kmp_stg_parse_allocator()
3808 } else if (__kmp_match_str("omp_low_lat_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3813 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3814 traits[count].value = RCAST(omp_uintptr_t, omp_low_lat_mem_alloc); in __kmp_stg_parse_allocator()
3816 } else if (__kmp_match_str("omp_cgroup_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3821 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3822 traits[count].value = RCAST(omp_uintptr_t, omp_cgroup_mem_alloc); in __kmp_stg_parse_allocator()
3824 } else if (__kmp_match_str("omp_pteam_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3829 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3830 traits[count].value = RCAST(omp_uintptr_t, omp_pteam_mem_alloc); in __kmp_stg_parse_allocator()
3832 } else if (__kmp_match_str("omp_thread_mem_alloc", scan, &next)) { in __kmp_stg_parse_allocator()
3837 traits[count].key = omp_atk_fb_data; in __kmp_stg_parse_allocator()
3838 traits[count].value = RCAST(omp_uintptr_t, omp_thread_mem_alloc); in __kmp_stg_parse_allocator()
3855 ++count; in __kmp_stg_parse_allocator()
3856 if (count == ntraits) in __kmp_stg_parse_allocator()
3862 if (__kmp_match_str("omp_default_mem_space", scan, &next)) { in __kmp_stg_parse_allocator()
3865 } else if (__kmp_match_str("omp_large_cap_mem_space", scan, &next)) { in __kmp_stg_parse_allocator()
3868 } else if (__kmp_match_str("omp_const_mem_space", scan, &next)) { in __kmp_stg_parse_allocator()
3871 } else if (__kmp_match_str("omp_high_bw_mem_space", scan, &next)) { in __kmp_stg_parse_allocator()
3874 } else if (__kmp_match_str("omp_low_lat_mem_space", scan, &next)) { in __kmp_stg_parse_allocator()
3889 start = scan; in __kmp_stg_parse_allocator()
3890 if (__kmp_match_str("sync_hint", scan, &next)) { in __kmp_stg_parse_allocator()
3892 traits[count].key = omp_atk_sync_hint; in __kmp_stg_parse_allocator()
3893 if (__kmp_match_str("contended", scan, &next)) { in __kmp_stg_parse_allocator()
3894 traits[count].value = omp_atv_contended; in __kmp_stg_parse_allocator()
3895 } else if (__kmp_match_str("uncontended", scan, &next)) { in __kmp_stg_parse_allocator()
3896 traits[count].value = omp_atv_uncontended; in __kmp_stg_parse_allocator()
3897 } else if (__kmp_match_str("serialized", scan, &next)) { in __kmp_stg_parse_allocator()
3898 traits[count].value = omp_atv_serialized; in __kmp_stg_parse_allocator()
3899 } else if (__kmp_match_str("private", scan, &next)) { in __kmp_stg_parse_allocator()
3900 traits[count].value = omp_atv_private; in __kmp_stg_parse_allocator()
3906 } else if (__kmp_match_str("alignment", scan, &next)) { in __kmp_stg_parse_allocator()
3914 int n = __kmp_str_to_int(scan, ','); in __kmp_stg_parse_allocator()
3920 traits[count].key = omp_atk_alignment; in __kmp_stg_parse_allocator()
3921 traits[count].value = n; in __kmp_stg_parse_allocator()
3922 } else if (__kmp_match_str("access", scan, &next)) { in __kmp_stg_parse_allocator()
3924 traits[count].key = omp_atk_access; in __kmp_stg_parse_allocator()
3925 if (__kmp_match_str("all", scan, &next)) { in __kmp_stg_parse_allocator()
3926 traits[count].value = omp_atv_all; in __kmp_stg_parse_allocator()
3927 } else if (__kmp_match_str("cgroup", scan, &next)) { in __kmp_stg_parse_allocator()
3928 traits[count].value = omp_atv_cgroup; in __kmp_stg_parse_allocator()
3929 } else if (__kmp_match_str("pteam", scan, &next)) { in __kmp_stg_parse_allocator()
3930 traits[count].value = omp_atv_pteam; in __kmp_stg_parse_allocator()
3931 } else if (__kmp_match_str("thread", scan, &next)) { in __kmp_stg_parse_allocator()
3932 traits[count].value = omp_atv_thread; in __kmp_stg_parse_allocator()
3938 } else if (__kmp_match_str("pool_size", scan, &next)) { in __kmp_stg_parse_allocator()
3946 int n = __kmp_str_to_int(scan, ','); in __kmp_stg_parse_allocator()
3952 traits[count].key = omp_atk_pool_size; in __kmp_stg_parse_allocator()
3953 traits[count].value = n; in __kmp_stg_parse_allocator()
3954 } else if (__kmp_match_str("fallback", scan, &next)) { in __kmp_stg_parse_allocator()
3956 traits[count].key = omp_atk_fallback; in __kmp_stg_parse_allocator()
3957 if (__kmp_match_str("default_mem_fb", scan, &next)) { in __kmp_stg_parse_allocator()
3958 traits[count].value = omp_atv_default_mem_fb; in __kmp_stg_parse_allocator()
3959 } else if (__kmp_match_str("null_fb", scan, &next)) { in __kmp_stg_parse_allocator()
3960 traits[count].value = omp_atv_null_fb; in __kmp_stg_parse_allocator()
3961 } else if (__kmp_match_str("abort_fb", scan, &next)) { in __kmp_stg_parse_allocator()
3962 traits[count].value = omp_atv_abort_fb; in __kmp_stg_parse_allocator()
3963 } else if (__kmp_match_str("allocator_fb", scan, &next)) { in __kmp_stg_parse_allocator()
3964 traits[count].value = omp_atv_allocator_fb; in __kmp_stg_parse_allocator()
3970 } else if (__kmp_match_str("pinned", scan, &next)) { in __kmp_stg_parse_allocator()
3972 traits[count].key = omp_atk_pinned; in __kmp_stg_parse_allocator()
3974 traits[count].value = omp_atv_true; in __kmp_stg_parse_allocator()
3976 traits[count].value = omp_atv_false; in __kmp_stg_parse_allocator()
3982 } else if (__kmp_match_str("partition", scan, &next)) { in __kmp_stg_parse_allocator()
3984 traits[count].key = omp_atk_partition; in __kmp_stg_parse_allocator()
3985 if (__kmp_match_str("environment", scan, &next)) { in __kmp_stg_parse_allocator()
3986 traits[count].value = omp_atv_environment; in __kmp_stg_parse_allocator()
3987 } else if (__kmp_match_str("nearest", scan, &next)) { in __kmp_stg_parse_allocator()
3988 traits[count].value = omp_atv_nearest; in __kmp_stg_parse_allocator()
3989 } else if (__kmp_match_str("blocked", scan, &next)) { in __kmp_stg_parse_allocator()
3990 traits[count].value = omp_atv_blocked; in __kmp_stg_parse_allocator()
3991 } else if (__kmp_match_str("interleaved", scan, &next)) { in __kmp_stg_parse_allocator()
3992 traits[count].value = omp_atv_interleaved; in __kmp_stg_parse_allocator()
4004 ++count; in __kmp_stg_parse_allocator()
4005 if (count == ntraits) in __kmp_stg_parse_allocator()
4036 // -----------------------------------------------------------------------------
4059 __kmp_str_match("load-balance", 2, value) || in __kmp_stg_parse_kmp_dynamic_mode()
4067 __kmp_str_match("thread-limit", 1, value) || in __kmp_stg_parse_kmp_dynamic_mode()
4101 // -----------------------------------------------------------------------------
4124 // -----------------------------------------------------------------------------
4140 // -----------------------------------------------------------------------------
4152 if (value[length - 1] == '"' || value[length - 1] == '\'') in __kmp_stg_parse_schedule()
4215 // -----------------------------------------------------------------------------
4380 if (value[length - 1] == '"' || value[length - 1] == '\'') in __kmp_stg_parse_omp_schedule()
4483 // -----------------------------------------------------------------------------
4496 // -----------------------------------------------------------------------------
4508 // -----------------------------------------------------------------------------
4513 // Modes: 0 -- do not change default; 1 -- Intel perf mode, 2 -- GOMP in __kmp_stg_parse_atomic_mode()
4534 // -----------------------------------------------------------------------------
4571 // -----------------------------------------------------------------------------
4594 // -----------------------------------------------------------------------------
4612 // -----------------------------------------------------------------------------
4631 // -----------------------------------------------------------------------------
4637 // 0 -- do not change default in __kmp_stg_parse_gtid_mode()
4638 // 1 -- sp search in __kmp_stg_parse_gtid_mode()
4639 // 2 -- use "keyed" TLS var, i.e. in __kmp_stg_parse_gtid_mode()
4641 // 3 -- __declspec(thread) TLS var in tdata section in __kmp_stg_parse_gtid_mode()
4667 // -----------------------------------------------------------------------------
4680 // -----------------------------------------------------------------------------
4699 __kmp_str_match("test-and-set", 2, value) || in __kmp_stg_parse_lock_kind()
4702 __kmp_str_match("test-andset", 2, value) || in __kmp_stg_parse_lock_kind()
4705 __kmp_str_match("testand-set", 2, value) || in __kmp_stg_parse_lock_kind()
4729 __kmp_str_match("drdpa-ticket", 1, value) || in __kmp_stg_parse_lock_kind()
4832 // -----------------------------------------------------------------------------
4841 int total = 0; // Count elements that were set. It'll be used as an array size in __kmp_stg_parse_spin_backoff_params()
4927 // -----------------------------------------------------------------------------
4939 int total = 0; // Count elements that were set. It'll be used as an array size in __kmp_stg_parse_adaptive_lock_props()
5034 if (__kmp_str_match("-", 0, __kmp_speculative_statsfile)) { in __kmp_stg_print_speculative_statsfile()
5046 // -----------------------------------------------------------------------------
5104 num_possible--; in __kmp_stg_parse_hw_subset_name()
5168 mlen--; in __kmp_stg_parse_hw_subset()
5187 __kmp_hw_subset->set_absolute(); in __kmp_stg_parse_hw_subset()
5209 // components may begin with an optional count of the number of resources in __kmp_stg_parse_hw_subset()
5213 goto err; // only positive integers are valid for count in __kmp_stg_parse_hw_subset()
5235 if (__kmp_str_match("intel_core", -1, attr_ptr + 1)) { in __kmp_stg_parse_hw_subset()
5237 } else if (__kmp_str_match("intel_atom", -1, attr_ptr + 1)) { in __kmp_stg_parse_hw_subset()
5265 if (type != KMP_HW_CORE && __kmp_hw_subset->specified(type)) { in __kmp_stg_parse_hw_subset()
5268 __kmp_hw_subset->push_back(num, type, offset, attr); in __kmp_stg_parse_hw_subset()
5293 depth = __kmp_hw_subset->get_depth(); in __kmp_stg_print_hw_subset()
5295 const auto &item = __kmp_hw_subset->at(i); in __kmp_stg_print_hw_subset()
5316 // -----------------------------------------------------------------------------
5329 // -----------------------------------------------------------------------------
5344 // -----------------------------------------------------------------------------
5358 // -----------------------------------------------------------------------------
5371 // -----------------------------------------------------------------------------
5387 // -----------------------------------------------------------------------------
5407 // -----------------------------------------------------------------------------
5675 // OMP_PROC_BIND and proc-bind-var are supported, however.
5808 if (strcmp(a->name, "KMP_AFFINITY") == 0) { in __kmp_stg_cmp()
5809 if (strcmp(b->name, "KMP_AFFINITY") == 0) { in __kmp_stg_cmp()
5813 } else if (strcmp(b->name, "KMP_AFFINITY") == 0) { in __kmp_stg_cmp()
5814 return -1; in __kmp_stg_cmp()
5816 return strcmp(a->name, b->name); in __kmp_stg_cmp()
5826 qsort(__kmp_stg_table, __kmp_stg_count - 1, sizeof(kmp_setting_t), in __kmp_stg_init()
5862 kmp_stacksize->data = &kmp_data; in __kmp_stg_init()
5865 gomp_stacksize->data = &gomp_data; in __kmp_stg_init()
5868 omp_stacksize->data = &omp_data; in __kmp_stg_init()
5889 kmp_library->data = &kmp_data; in __kmp_stg_init()
5891 omp_wait_policy->data = &omp_data; in __kmp_stg_init()
5909 kmp_device_thread_limit->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5910 kmp_all_threads->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5927 kmp_hw_subset->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5928 kmp_place_threads->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5955 gomp_cpu_affinity->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5959 omp_proc_bind->data = CCAST(kmp_setting_t **, rivals); in __kmp_stg_init()
5973 omp_places->data = CCAST(kmp_setting_t **, places_rivals); in __kmp_stg_init()
6001 kmp_force_red->data = &force_data; in __kmp_stg_init()
6003 kmp_determ_red->data = &determ_data; in __kmp_stg_init()
6029 setting->parse(name, value, setting->data); in __kmp_stg_parse()
6030 setting->defined = 1; in __kmp_stg_parse()
6036 static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found. in __kmp_stg_check_rivals()
6048 for (; strcmp(rivals[i]->name, name) != 0; i++) { in __kmp_stg_check_rivals()
6059 if (rivals[i]->set) { in __kmp_stg_check_rivals()
6060 KMP_WARNING(StgIgnored, name, rivals[i]->name); in __kmp_stg_check_rivals()
6074 rc = setting->defined; in __kmp_env_toPrint()
6076 setting->defined = flag; in __kmp_env_toPrint()
6084 K_DIAG(1, ("%s:\n", affinity->env_var)); in __kmp_print_affinity_settings()
6085 K_DIAG(1, (" type : %d\n", affinity->type)); in __kmp_print_affinity_settings()
6086 K_DIAG(1, (" compact : %d\n", affinity->compact)); in __kmp_print_affinity_settings()
6087 K_DIAG(1, (" offset : %d\n", affinity->offset)); in __kmp_print_affinity_settings()
6088 K_DIAG(1, (" verbose : %u\n", affinity->flags.verbose)); in __kmp_print_affinity_settings()
6089 K_DIAG(1, (" warnings : %u\n", affinity->flags.warnings)); in __kmp_print_affinity_settings()
6090 K_DIAG(1, (" respect : %u\n", affinity->flags.respect)); in __kmp_print_affinity_settings()
6091 K_DIAG(1, (" reset : %u\n", affinity->flags.reset)); in __kmp_print_affinity_settings()
6092 K_DIAG(1, (" dups : %u\n", affinity->flags.dups)); in __kmp_print_affinity_settings()
6093 K_DIAG(1, (" gran : %d\n", (int)affinity->gran)); in __kmp_print_affinity_settings()
6094 KMP_DEBUG_ASSERT(affinity->type != affinity_default); in __kmp_print_affinity_settings()
6149 for (i = 0; i < block.count; ++i) { in __kmp_env_initialize()
6158 setting->set = 1; in __kmp_env_initialize()
6189 // I can't find a case-insensitive version of strstr on Windows* OS. in __kmp_env_initialize()
6190 // Use the case-sensitive version for now. AIX does the same. in __kmp_env_initialize()
6261 for (i = 0; i < block.count; ++i) { in __kmp_env_initialize()
6298 if (__kmp_hw_subset->specified(KMP_HW_NUMA) || in __kmp_env_initialize()
6299 __kmp_hw_subset->specified(KMP_HW_TILE) || in __kmp_env_initialize()
6317 __kmp_affinity_dispatch->get_api_type() != KMPAffinity::HWLOC) { in __kmp_env_initialize()
6325 __kmp_affinity_dispatch->determine_capable(var); in __kmp_env_initialize()
6370 for (int bit = init_mask->begin(); bit != init_mask->end(); in __kmp_env_initialize()
6371 bit = init_mask->next(bit)) in __kmp_env_initialize()
6497 // Post-initialization step: some env. vars need their value's further in __kmp_env_initialize()
6523 for (i = 0; i < block.count; ++i) { in __kmp_env_print()
6623 __kmp_str_buf_cat(&buffer, env.str + 3, env.used - 3); in __kmp_env_dump()