38 #include "kmp_wrapper_getpid.h"
39 #include "kmp_environment.h"
40 #include "kmp_atomic.h"
43 #include "kmp_settings.h"
48 #define KMP_MAX( x, y ) ( (x) > (y) ? (x) : (y) )
49 #define KMP_MIN( x, y ) ( (x) < (y) ? (x) : (y) )
51 static int __kmp_env_isDefined(
char const * name );
52 static int __kmp_env_toPrint(
char const * name,
int flag );
54 bool __kmp_env_format = 0;
60 __kmp_convert_to_double(
char const * s )
64 if ( sscanf( s,
"%lf", &result ) < 1 ) {
72 __kmp_readstr_with_sentinel(
char *dest,
char const * src,
size_t len,
char sentinel) {
74 for (i = 0; i < len; i++) {
75 if ((*src ==
'\0') || (*src == sentinel)) {
85 __kmp_match_with_sentinel(
char const * a,
char const * b,
size_t len,
char sentinel ) {
92 while(*a && *b && *b != sentinel) {
93 char ca = *a, cb = *b;
95 if(ca >=
'a' && ca <=
'z')
97 if(cb >=
'a' && cb <=
'z')
135 __kmp_match_str(
char const *token,
char const *buf,
const char **end) {
137 KMP_ASSERT(token != NULL);
138 KMP_ASSERT(buf != NULL);
139 KMP_ASSERT(end != NULL);
141 while (*token && *buf) {
142 char ct = *token, cb = *buf;
144 if(ct >=
'a' && ct <=
'z')
146 if(cb >=
'a' && cb <=
'z')
161 __kmp_strip_quotes(
char *target,
int len) {
162 char *end = target + len - 1;
164 while(*target ==
'"' || *target ==
'\'') {
165 if(end <= target || (*end !=
'"' && *end !=
'\''))
177 __kmp_round4k(
size_t size ) {
178 size_t _4k = 4 * 1024;
179 if ( size & ( _4k - 1 ) ) {
180 size &= ~ ( _4k - 1 );
181 if ( size <= KMP_SIZE_T_MAX - _4k ) {
190 __kmp_convert_to_seconds(
char const * data )
192 int nvalues, value, factor;
195 if (data == NULL)
return (0);
198 nvalues = sscanf (data,
"%d%c%c", &value, &mult, &extra);
199 if (nvalues < 1)
return (0);
200 if (nvalues == 1) mult =
'\0';
201 if (nvalues == 3)
return (-1);
217 factor = 24 * 60 * 60;
223 if (value > (INT_MAX / factor))
238 __kmp_convert_to_milliseconds(
char const * data )
240 int ret, nvalues, factor;
244 if (data == NULL)
return (-1);
245 if ( __kmp_str_match(
"infinit", -1, data))
return (INT_MAX);
246 value = (double) 0.0;
248 nvalues = sscanf (data,
"%lf%c%c", &value, &mult, &extra);
249 if (nvalues < 1)
return (-1);
250 if (nvalues == 1) mult =
'\0';
251 if (nvalues == 3)
return (-1);
253 if (value < 0)
return (-1);
267 factor = 1000 * 60 * 60;
270 factor = 1000 * 24 * 60 * 60;
276 if ( value >= ( (INT_MAX-1) / factor) )
279 ret = (int) (value * (
double) factor);
285 __kmp_convert_to_nanoseconds(
296 if ( str == NULL || str[ 0 ] == 0 ) {
299 rc = sscanf( str,
"%lf%c%c", &value, &unit, &extra );
331 result = (kmp_uint64)( value * factor );
338 __kmp_strcasecmp_with_sentinel(
char const * a,
char const * b,
char sentinel ) {
343 while(*a && *b && *b != sentinel) {
344 char ca = *a, cb = *b;
346 if(ca >=
'a' && ca <=
'z')
348 if(cb >=
'a' && cb <=
'z')
351 return (
int)(
unsigned char)*a - (
int)(
unsigned char)*b;
356 (*b && *b != sentinel) ? (
int)(
unsigned char)*a - (
int)(
unsigned char)*b : 1 :
357 (*b && *b != sentinel) ? -1 : 0;
365 typedef struct __kmp_setting kmp_setting_t;
366 typedef struct __kmp_stg_ss_data kmp_stg_ss_data_t;
367 typedef struct __kmp_stg_wp_data kmp_stg_wp_data_t;
368 typedef struct __kmp_stg_fr_data kmp_stg_fr_data_t;
370 typedef void ( * kmp_stg_parse_func_t )(
char const * name,
char const * value,
void * data );
371 typedef void ( * kmp_stg_print_func_t )( kmp_str_buf_t * buffer,
char const * name,
void * data );
373 struct __kmp_setting {
375 kmp_stg_parse_func_t parse;
376 kmp_stg_print_func_t print;
383 struct __kmp_stg_ss_data {
385 kmp_setting_t * * rivals;
388 struct __kmp_stg_wp_data {
390 kmp_setting_t * * rivals;
393 struct __kmp_stg_fr_data {
395 kmp_setting_t * * rivals;
399 __kmp_stg_check_rivals(
402 kmp_setting_t * * rivals
411 __kmp_stg_parse_bool(
416 if ( __kmp_str_match_true( value ) ) {
418 }
else if (__kmp_str_match_false( value ) ) {
423 KMP_MSG( BadBoolValue, name, value ),
424 KMP_HNT( ValidBoolValues ),
431 __kmp_stg_parse_size(
440 char const * msg = NULL;
442 size_min = __kmp_round4k( size_min );
443 size_max = __kmp_round4k( size_max );
444 #endif // KMP_OS_DARWIN
446 if ( is_specified != NULL ) {
449 __kmp_str_to_size( value, out, factor, & msg );
451 if ( * out > size_max ) {
453 msg = KMP_I18N_STR( ValueTooLarge );
454 }
else if ( * out < size_min ) {
456 msg = KMP_I18N_STR( ValueTooSmall );
459 size_t round4k = __kmp_round4k( * out );
460 if ( * out != round4k ) {
462 msg = KMP_I18N_STR( NotMultiple4K );
468 if ( * out < size_min ) {
471 else if ( * out > size_max ) {
478 __kmp_str_buf_init( & buf );
479 __kmp_str_buf_print_size( & buf, * out );
480 KMP_WARNING( ParseSizeIntWarn, name, value, msg );
481 KMP_INFORM( Using_str_Value, name, buf.str );
482 __kmp_str_buf_free( & buf );
493 KMP_INTERNAL_FREE( (
void *) * out );
494 * out = __kmp_str_format(
"%s", value );
506 char const * msg = NULL;
507 kmp_uint64 uint = * out;
508 __kmp_str_to_uint( value, & uint, & msg );
510 if ( uint < (
unsigned int)min ) {
511 msg = KMP_I18N_STR( ValueTooSmall );
513 }
else if ( uint > (
unsigned int)max ) {
514 msg = KMP_I18N_STR( ValueTooLarge );
520 if ( uint < (
unsigned int)min ) {
523 else if ( uint > (
unsigned int)max ) {
530 KMP_WARNING( ParseSizeIntWarn, name, value, msg );
531 __kmp_str_buf_init( & buf );
532 __kmp_str_buf_print( &buf,
"%" KMP_UINT64_SPEC
"", uint );
533 KMP_INFORM( Using_uint64_Value, name, buf.str );
534 __kmp_str_buf_free( &buf );
541 __kmp_stg_parse_file(
550 KMP_INTERNAL_FREE( (
void *) * out );
551 t = (
char *) strrchr(value,
'.');
552 hasSuffix = t && __kmp_str_eqf( t, suffix );
553 t = __kmp_str_format(
"%s%s", value, hasSuffix ?
"" : suffix );
554 __kmp_expand_file_name( buffer,
sizeof(buffer), t);
555 KMP_INTERNAL_FREE(t);
556 * out = __kmp_str_format(
"%s", buffer );
559 static char * par_range_to_print = NULL;
562 __kmp_stg_parse_par_range(
571 size_t len = strlen( value + 1 );
572 par_range_to_print = (
char *) KMP_INTERNAL_MALLOC( len +1 );
573 strncpy( par_range_to_print, value, len + 1);
574 __kmp_par_range = +1;
575 __kmp_par_range_lb = 0;
576 __kmp_par_range_ub = INT_MAX;
579 if (( value == NULL ) || ( *value ==
'\0' )) {
582 if ( ! __kmp_strcasecmp_with_sentinel(
"routine", value,
'=' )) {
583 value = strchr( value,
'=' ) + 1;
584 len = __kmp_readstr_with_sentinel( out_routine,
585 value, KMP_PAR_RANGE_ROUTINE_LEN - 1,
',' );
587 goto par_range_error;
589 value = strchr( value,
',' );
590 if ( value != NULL ) {
595 if ( ! __kmp_strcasecmp_with_sentinel(
"filename", value,
'=' )) {
596 value = strchr( value,
'=' ) + 1;
597 len = __kmp_readstr_with_sentinel( out_file,
598 value, KMP_PAR_RANGE_FILENAME_LEN - 1,
',' );
600 goto par_range_error;
602 value = strchr( value,
',' );
603 if ( value != NULL ) {
608 if (( ! __kmp_strcasecmp_with_sentinel(
"range", value,
'=' ))
609 || ( ! __kmp_strcasecmp_with_sentinel(
"incl_range", value,
'=' ))) {
610 value = strchr( value,
'=' ) + 1;
611 if ( sscanf( value,
"%d:%d", out_lb, out_ub ) != 2 ) {
612 goto par_range_error;
615 value = strchr( value,
',' );
616 if ( value != NULL ) {
621 if ( ! __kmp_strcasecmp_with_sentinel(
"excl_range", value,
'=' )) {
622 value = strchr( value,
'=' ) + 1;
623 if ( sscanf( value,
"%d:%d", out_lb, out_ub) != 2 ) {
624 goto par_range_error;
627 value = strchr( value,
',' );
628 if ( value != NULL ) {
634 KMP_WARNING( ParRangeSyntax, name );
642 __kmp_initial_threads_capacity(
int req_nproc )
647 if (nth < (4 * req_nproc))
648 nth = (4 * req_nproc);
649 if (nth < (4 * __kmp_xproc))
650 nth = (4 * __kmp_xproc);
652 if (nth > __kmp_max_nth)
660 __kmp_default_tp_capacity(
int req_nproc,
int max_nth,
int all_threads_specified) {
663 if(all_threads_specified)
666 if (nth < (4 * req_nproc))
667 nth = (4 * req_nproc);
668 if (nth < (4 * __kmp_xproc))
669 nth = (4 * __kmp_xproc);
671 if (nth > __kmp_max_nth)
683 __kmp_stg_print_bool( kmp_str_buf_t * buffer,
char const * name,
int value ) {
684 if( __kmp_env_format ) {
685 KMP_STR_BUF_PRINT_BOOL;
687 __kmp_str_buf_print( buffer,
" %s=%s\n", name, value ?
"true" :
"false" );
692 __kmp_stg_print_int( kmp_str_buf_t * buffer,
char const * name,
int value ) {
693 if( __kmp_env_format ) {
694 KMP_STR_BUF_PRINT_INT;
696 __kmp_str_buf_print( buffer,
" %s=%d\n", name, value );
701 __kmp_stg_print_uint64( kmp_str_buf_t * buffer,
char const * name, kmp_uint64 value ) {
702 if( __kmp_env_format ) {
703 KMP_STR_BUF_PRINT_UINT64;
705 __kmp_str_buf_print( buffer,
" %s=%" KMP_UINT64_SPEC
"\n", name, value );
710 __kmp_stg_print_str( kmp_str_buf_t * buffer,
char const * name,
char const * value ) {
711 if( __kmp_env_format ) {
712 KMP_STR_BUF_PRINT_STR;
714 __kmp_str_buf_print( buffer,
" %s=%s\n", name, value );
719 __kmp_stg_print_size( kmp_str_buf_t * buffer,
char const * name,
size_t value ) {
720 if( __kmp_env_format ) {
721 KMP_STR_BUF_PRINT_NAME_EX(name);
722 __kmp_str_buf_print_size( buffer, value );
723 __kmp_str_buf_print( buffer,
"'\n" );
725 __kmp_str_buf_print( buffer,
" %s=", name );
726 __kmp_str_buf_print_size( buffer, value );
727 __kmp_str_buf_print( buffer,
"\n" );
742 __kmp_stg_parse_all_threads(
char const * name,
char const * value,
void * data ) {
744 kmp_setting_t * * rivals = (kmp_setting_t * *) data;
746 rc = __kmp_stg_check_rivals( name, value, rivals );
750 if ( ! __kmp_strcasecmp_with_sentinel(
"all", value, 0 ) ) {
751 __kmp_max_nth = __kmp_xproc;
752 __kmp_allThreadsSpecified = 1;
754 __kmp_stg_parse_int( name, value, 1, __kmp_sys_max_nth, & __kmp_max_nth );
755 __kmp_allThreadsSpecified = 0;
757 K_DIAG( 1, (
"__kmp_max_nth == %d\n", __kmp_max_nth ) );
762 __kmp_stg_print_all_threads( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
763 __kmp_stg_print_int( buffer, name, __kmp_max_nth );
771 __kmp_stg_parse_blocktime(
char const * name,
char const * value,
void * data ) {
772 __kmp_dflt_blocktime = __kmp_convert_to_milliseconds( value );
773 if ( __kmp_dflt_blocktime < 0 ) {
774 __kmp_dflt_blocktime = KMP_DEFAULT_BLOCKTIME;
775 __kmp_msg( kmp_ms_warning, KMP_MSG( InvalidValue, name, value ), __kmp_msg_null );
776 KMP_INFORM( Using_int_Value, name, __kmp_dflt_blocktime );
777 __kmp_env_blocktime = FALSE;
779 if ( __kmp_dflt_blocktime < KMP_MIN_BLOCKTIME ) {
780 __kmp_dflt_blocktime = KMP_MIN_BLOCKTIME;
781 __kmp_msg( kmp_ms_warning, KMP_MSG( SmallValue, name, value ), __kmp_msg_null );
782 KMP_INFORM( MinValueUsing, name, __kmp_dflt_blocktime );
783 }
else if ( __kmp_dflt_blocktime > KMP_MAX_BLOCKTIME ) {
784 __kmp_dflt_blocktime = KMP_MAX_BLOCKTIME;
785 __kmp_msg( kmp_ms_warning, KMP_MSG( LargeValue, name, value ), __kmp_msg_null );
786 KMP_INFORM( MaxValueUsing, name, __kmp_dflt_blocktime );
788 __kmp_env_blocktime = TRUE;
791 __kmp_monitor_wakeups = KMP_WAKEUPS_FROM_BLOCKTIME( __kmp_dflt_blocktime, __kmp_monitor_wakeups );
792 __kmp_bt_intervals = KMP_INTERVALS_FROM_BLOCKTIME( __kmp_dflt_blocktime, __kmp_monitor_wakeups );
793 K_DIAG( 1, (
"__kmp_env_blocktime == %d\n", __kmp_env_blocktime ) );
794 if ( __kmp_env_blocktime ) {
795 K_DIAG( 1, (
"__kmp_dflt_blocktime == %d\n", __kmp_dflt_blocktime ) );
800 __kmp_stg_print_blocktime( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
801 __kmp_stg_print_int( buffer, name, __kmp_dflt_blocktime );
809 __kmp_stg_parse_duplicate_lib_ok(
char const * name,
char const * value,
void * data ) {
812 __kmp_stg_parse_bool( name, value, & __kmp_duplicate_library_ok );
816 __kmp_stg_print_duplicate_lib_ok( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
817 __kmp_stg_print_bool( buffer, name, __kmp_duplicate_library_ok );
824 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
827 __kmp_stg_parse_inherit_fp_control(
char const * name,
char const * value,
void * data ) {
828 __kmp_stg_parse_bool( name, value, & __kmp_inherit_fp_control );
832 __kmp_stg_print_inherit_fp_control( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
834 __kmp_stg_print_bool( buffer, name, __kmp_inherit_fp_control );
845 __kmp_stg_parse_wait_policy(
char const * name,
char const * value,
void * data ) {
847 kmp_stg_wp_data_t * wait = (kmp_stg_wp_data_t *) data;
850 rc = __kmp_stg_check_rivals( name, value, wait->rivals );
856 if ( __kmp_str_match(
"ACTIVE", 1, value ) ) {
857 __kmp_library = library_turnaround;
858 }
else if ( __kmp_str_match(
"PASSIVE", 1, value ) ) {
859 __kmp_library = library_throughput;
861 KMP_WARNING( StgInvalidValue, name, value );
864 if ( __kmp_str_match(
"serial", 1, value ) ) {
865 __kmp_library = library_serial;
866 }
else if ( __kmp_str_match(
"throughput", 2, value ) ) {
867 __kmp_library = library_throughput;
868 }
else if ( __kmp_str_match(
"turnaround", 2, value ) ) {
869 __kmp_library = library_turnaround;
870 }
else if ( __kmp_str_match(
"dedicated", 1, value ) ) {
871 __kmp_library = library_turnaround;
872 }
else if ( __kmp_str_match(
"multiuser", 1, value ) ) {
873 __kmp_library = library_throughput;
875 KMP_WARNING( StgInvalidValue, name, value );
878 __kmp_aux_set_library( __kmp_library );
883 __kmp_stg_print_wait_policy( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
885 kmp_stg_wp_data_t * wait = (kmp_stg_wp_data_t *) data;
886 char const * value = NULL;
889 switch ( __kmp_library ) {
890 case library_turnaround : {
893 case library_throughput : {
898 switch ( __kmp_library ) {
899 case library_serial : {
902 case library_turnaround : {
903 value =
"turnaround";
905 case library_throughput : {
906 value =
"throughput";
910 if ( value != NULL ) {
911 __kmp_stg_print_str( buffer, name, value );
921 __kmp_stg_parse_monitor_stacksize(
char const * name,
char const * value,
void * data ) {
922 __kmp_stg_parse_size(
925 __kmp_sys_min_stksize,
928 & __kmp_monitor_stksize,
934 __kmp_stg_print_monitor_stacksize( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
935 if( __kmp_env_format ) {
936 if ( __kmp_monitor_stksize > 0 )
937 KMP_STR_BUF_PRINT_NAME_EX(name);
939 KMP_STR_BUF_PRINT_NAME;
941 __kmp_str_buf_print( buffer,
" %s", name );
943 if ( __kmp_monitor_stksize > 0 ) {
944 __kmp_str_buf_print_size( buffer, __kmp_monitor_stksize );
946 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
948 if( __kmp_env_format && __kmp_monitor_stksize ) {
949 __kmp_str_buf_print( buffer,
"'\n");
959 __kmp_stg_parse_settings(
char const * name,
char const * value,
void * data ) {
960 __kmp_stg_parse_bool( name, value, & __kmp_settings );
964 __kmp_stg_print_settings( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
965 __kmp_stg_print_bool( buffer, name, __kmp_settings );
973 __kmp_stg_parse_stackoffset(
char const * name,
char const * value,
void * data ) {
974 __kmp_stg_parse_size(
986 __kmp_stg_print_stackoffset( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
987 __kmp_stg_print_size( buffer, name, __kmp_stkoffset );
995 __kmp_stg_parse_stacksize(
char const * name,
char const * value,
void * data ) {
997 kmp_stg_ss_data_t * stacksize = (kmp_stg_ss_data_t *) data;
1000 rc = __kmp_stg_check_rivals( name, value, stacksize->rivals );
1004 __kmp_stg_parse_size(
1007 __kmp_sys_min_stksize,
1009 & __kmp_env_stksize,
1020 __kmp_stg_print_stacksize( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1021 kmp_stg_ss_data_t * stacksize = (kmp_stg_ss_data_t *) data;
1022 if( __kmp_env_format ) {
1023 KMP_STR_BUF_PRINT_NAME_EX(name);
1024 __kmp_str_buf_print_size( buffer, (__kmp_stksize % 1024) ? __kmp_stksize / stacksize->factor : __kmp_stksize );
1025 __kmp_str_buf_print( buffer,
"'\n" );
1027 __kmp_str_buf_print( buffer,
" %s=", name );
1028 __kmp_str_buf_print_size( buffer, (__kmp_stksize % 1024) ? __kmp_stksize / stacksize->factor : __kmp_stksize );
1029 __kmp_str_buf_print( buffer,
"\n" );
1038 __kmp_stg_parse_version(
char const * name,
char const * value,
void * data ) {
1039 __kmp_stg_parse_bool( name, value, & __kmp_version );
1043 __kmp_stg_print_version( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1044 __kmp_stg_print_bool( buffer, name, __kmp_version );
1052 __kmp_stg_parse_warnings(
char const * name,
char const * value,
void * data ) {
1053 __kmp_stg_parse_bool( name, value, & __kmp_generate_warnings );
1054 if (__kmp_generate_warnings != kmp_warnings_off) {
1055 __kmp_generate_warnings = kmp_warnings_explicit;
1060 __kmp_stg_print_warnings( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1061 __kmp_stg_print_bool( buffer, name, __kmp_generate_warnings );
1069 __kmp_stg_parse_nested(
char const * name,
char const * value,
void * data ) {
1070 __kmp_stg_parse_bool( name, value, & __kmp_dflt_nested );
1074 __kmp_stg_print_nested( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1075 __kmp_stg_print_bool( buffer, name, __kmp_dflt_nested );
1079 __kmp_parse_nested_num_threads(
const char *var,
const char *env, kmp_nested_nthreads_t *nth_array )
1081 const char *next = env;
1082 const char *scan = next;
1085 int prev_comma = FALSE;
1091 if ( *next ==
'\0' ) {
1095 if ( ( ( *next <
'0' ) || ( *next >
'9' ) ) && ( *next !=
',') ) {
1096 KMP_WARNING( NthSyntaxError, var, env );
1100 if ( *next ==
',' ) {
1102 if ( total == 0 || prev_comma ) {
1110 if ( *next >=
'0' && *next <=
'9' ) {
1112 SKIP_DIGITS( next );
1114 const char *tmp = next;
1116 if ( ( *next ==
' ' || *next ==
'\t' ) && ( *tmp >=
'0' && *tmp <=
'9' ) ) {
1117 KMP_WARNING( NthSpacesNotAllowed, var, env );
1122 KMP_DEBUG_ASSERT( total > 0 );
1124 KMP_WARNING( NthSyntaxError, var, env );
1129 if ( ! nth_array->nth ) {
1131 nth_array->nth = (
int * )KMP_INTERNAL_MALLOC(
sizeof(
int ) * total * 2 );
1132 if ( nth_array->nth == NULL ) {
1133 KMP_FATAL( MemoryAllocFailed );
1135 nth_array->size = total * 2;
1137 if ( nth_array->size < total ) {
1140 nth_array->size *= 2;
1141 }
while ( nth_array->size < total );
1143 nth_array->nth = (
int *) KMP_INTERNAL_REALLOC(
1144 nth_array->nth,
sizeof(
int ) * nth_array->size );
1145 if ( nth_array->nth == NULL ) {
1146 KMP_FATAL( MemoryAllocFailed );
1150 nth_array->used = total;
1158 if ( *scan ==
'\0' ) {
1162 if ( *scan ==
',' ) {
1167 nth_array->nth[i++] = 0;
1169 }
else if ( prev_comma ) {
1171 nth_array->nth[i] = nth_array->nth[i - 1];
1180 if ( *scan >=
'0' && *scan <=
'9' ) {
1182 const char *buf = scan;
1183 char const * msg = NULL;
1185 SKIP_DIGITS( scan );
1188 num = __kmp_str_to_int( buf, *scan );
1189 if ( num < KMP_MIN_NTH ) {
1190 msg = KMP_I18N_STR( ValueTooSmall );
1192 }
else if ( num > __kmp_sys_max_nth ) {
1193 msg = KMP_I18N_STR( ValueTooLarge );
1194 num = __kmp_sys_max_nth;
1196 if ( msg != NULL ) {
1198 KMP_WARNING( ParseSizeIntWarn, var, env, msg );
1199 KMP_INFORM( Using_int_Value, var, num );
1201 nth_array->nth[i++] = num;
1207 __kmp_stg_parse_num_threads(
char const * name,
char const * value,
void * data ) {
1209 if ( ! __kmp_strcasecmp_with_sentinel(
"all", value, 0 ) ) {
1211 __kmp_nested_nth.nth = (
int* )KMP_INTERNAL_MALLOC(
sizeof(
int ) );
1212 __kmp_nested_nth.size = __kmp_nested_nth.used = 1;
1213 __kmp_nested_nth.nth[0] = __kmp_dflt_team_nth = __kmp_dflt_team_nth_ub = __kmp_xproc;
1215 __kmp_parse_nested_num_threads( name, value, & __kmp_nested_nth );
1216 if ( __kmp_nested_nth.nth ) {
1217 __kmp_dflt_team_nth = __kmp_nested_nth.nth[0];
1218 if ( __kmp_dflt_team_nth_ub < __kmp_dflt_team_nth ) {
1219 __kmp_dflt_team_nth_ub = __kmp_dflt_team_nth;
1223 K_DIAG( 1, (
"__kmp_dflt_team_nth == %d\n", __kmp_dflt_team_nth ) );
1227 __kmp_stg_print_num_threads( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1228 if( __kmp_env_format ) {
1229 KMP_STR_BUF_PRINT_NAME;
1231 __kmp_str_buf_print( buffer,
" %s", name );
1233 if ( __kmp_nested_nth.used ) {
1235 __kmp_str_buf_init( &buf );
1236 for (
int i = 0; i < __kmp_nested_nth.used; i++) {
1237 __kmp_str_buf_print( &buf,
"%d", __kmp_nested_nth.nth[i] );
1238 if ( i < __kmp_nested_nth.used - 1 ) {
1239 __kmp_str_buf_print( &buf,
"," );
1242 __kmp_str_buf_print( buffer,
"='%s'\n", buf.str );
1243 __kmp_str_buf_free(&buf);
1245 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
1255 __kmp_stg_parse_tasking(
char const * name,
char const * value,
void * data ) {
1256 __kmp_stg_parse_int( name, value, 0, (
int)tskm_max, (
int *)&__kmp_tasking_mode );
1260 __kmp_stg_print_tasking( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1261 __kmp_stg_print_int( buffer, name, __kmp_tasking_mode );
1265 __kmp_stg_parse_task_stealing(
char const * name,
char const * value,
void * data ) {
1266 __kmp_stg_parse_int( name, value, 0, 1, (
int *)&__kmp_task_stealing_constraint );
1270 __kmp_stg_print_task_stealing( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1271 __kmp_stg_print_int( buffer, name, __kmp_task_stealing_constraint );
1275 __kmp_stg_parse_max_active_levels(
char const * name,
char const * value,
void * data ) {
1276 __kmp_stg_parse_int( name, value, 0, KMP_MAX_ACTIVE_LEVELS_LIMIT, & __kmp_dflt_max_active_levels );
1280 __kmp_stg_print_max_active_levels( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1281 __kmp_stg_print_int( buffer, name, __kmp_dflt_max_active_levels );
1283 #endif // OMP_30_ENABLED
1289 #if KMP_HANDLE_SIGNALS
1292 __kmp_stg_parse_handle_signals(
char const * name,
char const * value,
void * data ) {
1293 __kmp_stg_parse_bool( name, value, & __kmp_handle_signals );
1297 __kmp_stg_print_handle_signals( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1298 __kmp_stg_print_bool( buffer, name, __kmp_handle_signals );
1301 #endif // KMP_HANDLE_SIGNALS
1309 #define KMP_STG_X_DEBUG( x ) \
1310 static void __kmp_stg_parse_##x##_debug( char const * name, char const * value, void * data ) { \
1311 __kmp_stg_parse_int( name, value, 0, INT_MAX, & kmp_##x##_debug ); \
1313 static void __kmp_stg_print_##x##_debug( kmp_str_buf_t * buffer, char const * name, void * data ) { \
1314 __kmp_stg_print_int( buffer, name, kmp_##x##_debug ); \
1317 KMP_STG_X_DEBUG( a )
1318 KMP_STG_X_DEBUG( b )
1319 KMP_STG_X_DEBUG( c )
1320 KMP_STG_X_DEBUG( d )
1321 KMP_STG_X_DEBUG( e )
1322 KMP_STG_X_DEBUG( f )
1324 #undef KMP_STG_X_DEBUG
1327 __kmp_stg_parse_debug(
char const * name,
char const * value,
void * data ) {
1329 __kmp_stg_parse_int( name, value, 0, INT_MAX, & debug );
1330 if ( kmp_a_debug < debug ) {
1331 kmp_a_debug = debug;
1333 if ( kmp_b_debug < debug ) {
1334 kmp_b_debug = debug;
1336 if ( kmp_c_debug < debug ) {
1337 kmp_c_debug = debug;
1339 if ( kmp_d_debug < debug ) {
1340 kmp_d_debug = debug;
1342 if ( kmp_e_debug < debug ) {
1343 kmp_e_debug = debug;
1345 if ( kmp_f_debug < debug ) {
1346 kmp_f_debug = debug;
1351 __kmp_stg_parse_debug_buf(
char const * name,
char const * value,
void * data ) {
1352 __kmp_stg_parse_bool( name, value, & __kmp_debug_buf );
1355 if ( __kmp_debug_buf ) {
1357 int elements = __kmp_debug_buf_lines * __kmp_debug_buf_chars;
1360 __kmp_debug_buffer = (
char *) __kmp_page_allocate( elements *
sizeof(
char ) );
1361 for ( i = 0; i < elements; i += __kmp_debug_buf_chars )
1362 __kmp_debug_buffer[i] =
'\0';
1364 __kmp_debug_count = 0;
1366 K_DIAG( 1, (
"__kmp_debug_buf = %d\n", __kmp_debug_buf ) );
1370 __kmp_stg_print_debug_buf( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1371 __kmp_stg_print_bool( buffer, name, __kmp_debug_buf );
1375 __kmp_stg_parse_debug_buf_atomic(
char const * name,
char const * value,
void * data ) {
1376 __kmp_stg_parse_bool( name, value, & __kmp_debug_buf_atomic );
1380 __kmp_stg_print_debug_buf_atomic( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1381 __kmp_stg_print_bool( buffer, name, __kmp_debug_buf_atomic );
1385 __kmp_stg_parse_debug_buf_chars(
char const * name,
char const * value,
void * data ) {
1386 __kmp_stg_parse_int(
1389 KMP_DEBUG_BUF_CHARS_MIN,
1391 & __kmp_debug_buf_chars
1396 __kmp_stg_print_debug_buf_chars( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1397 __kmp_stg_print_int( buffer, name, __kmp_debug_buf_chars );
1401 __kmp_stg_parse_debug_buf_lines(
char const * name,
char const * value,
void * data ) {
1402 __kmp_stg_parse_int(
1405 KMP_DEBUG_BUF_LINES_MIN,
1407 & __kmp_debug_buf_lines
1412 __kmp_stg_print_debug_buf_lines( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1413 __kmp_stg_print_int( buffer, name, __kmp_debug_buf_lines );
1417 __kmp_stg_parse_diag(
char const * name,
char const * value,
void * data ) {
1418 __kmp_stg_parse_int( name, value, 0, INT_MAX, & kmp_diag );
1422 __kmp_stg_print_diag( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1423 __kmp_stg_print_int( buffer, name, kmp_diag );
1433 __kmp_stg_parse_align_alloc(
char const * name,
char const * value,
void * data ) {
1434 __kmp_stg_parse_size(
1440 & __kmp_align_alloc,
1446 __kmp_stg_print_align_alloc( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1447 __kmp_stg_print_size( buffer, name, __kmp_align_alloc );
1458 __kmp_stg_parse_barrier_branch_bit(
char const * name,
char const * value,
void * data ) {
1463 for (
int i=bs_plain_barrier; i<bs_last_barrier; i++ ) {
1464 var = __kmp_barrier_branch_bit_env_name[ i ];
1466 if ( ( strcmp( var, name) == 0 ) && ( value != 0 ) ) {
1469 comma = (
char *) strchr( value,
',' );
1470 __kmp_barrier_gather_branch_bits[ i ] = ( kmp_uint32 ) __kmp_str_to_int( value,
',' );
1472 if ( comma == NULL ) {
1473 __kmp_barrier_release_branch_bits[ i ] = __kmp_barrier_release_bb_dflt;
1475 __kmp_barrier_release_branch_bits[ i ] = (kmp_uint32) __kmp_str_to_int( comma + 1, 0 );
1477 if ( __kmp_barrier_release_branch_bits[ i ] > KMP_MAX_BRANCH_BITS ) {
1478 __kmp_msg( kmp_ms_warning, KMP_MSG( BarrReleaseValueInvalid, name, comma + 1 ), __kmp_msg_null );
1480 __kmp_barrier_release_branch_bits[ i ] = __kmp_barrier_release_bb_dflt;
1483 if ( __kmp_barrier_gather_branch_bits[ i ] > KMP_MAX_BRANCH_BITS ) {
1484 KMP_WARNING( BarrGatherValueInvalid, name, value );
1485 KMP_INFORM( Using_uint_Value, name, __kmp_barrier_gather_bb_dflt );
1486 __kmp_barrier_gather_branch_bits[ i ] = __kmp_barrier_gather_bb_dflt;
1489 K_DIAG(1, (
"%s == %d,%d\n", __kmp_barrier_branch_bit_env_name[ i ], \
1490 __kmp_barrier_gather_branch_bits [ i ], \
1491 __kmp_barrier_release_branch_bits [ i ]))
1496 __kmp_stg_print_barrier_branch_bit( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1498 for (
int i=bs_plain_barrier; i<bs_last_barrier; i++ ) {
1499 var = __kmp_barrier_branch_bit_env_name[ i ];
1500 if ( strcmp( var, name) == 0 ) {
1501 if( __kmp_env_format ) {
1502 KMP_STR_BUF_PRINT_NAME_EX(__kmp_barrier_branch_bit_env_name[ i ]);
1504 __kmp_str_buf_print( buffer,
" %s='", __kmp_barrier_branch_bit_env_name[ i ] );
1506 __kmp_str_buf_print( buffer,
"%d,%d'\n", __kmp_barrier_gather_branch_bits [ i ], __kmp_barrier_release_branch_bits [ i ]);
1520 __kmp_stg_parse_barrier_pattern(
char const * name,
char const * value,
void * data ) {
1524 for (
int i=bs_plain_barrier; i<bs_last_barrier; i++ ) {
1525 var = __kmp_barrier_pattern_env_name[ i ];
1527 if ( ( strcmp ( var, name ) == 0 ) && ( value != 0 ) ) {
1529 char *comma = (
char *) strchr( value,
',' );
1532 for ( j = bp_linear_bar; j<bp_last_bar; j++ ) {
1533 if (__kmp_match_with_sentinel( __kmp_barrier_pattern_name[j], value, 1,
',' )) {
1534 __kmp_barrier_gather_pattern[ i ] = (kmp_bar_pat_e) j;
1538 if ( j == bp_last_bar ) {
1539 KMP_WARNING( BarrGatherValueInvalid, name, value );
1540 KMP_INFORM( Using_str_Value, name, __kmp_barrier_pattern_name[ bp_linear_bar ] );
1544 if ( comma != NULL ) {
1545 for ( j = bp_linear_bar; j < bp_last_bar; j++ ) {
1546 if ( __kmp_str_match( __kmp_barrier_pattern_name[j], 1, comma + 1 ) ) {
1547 __kmp_barrier_release_pattern[ i ] = (kmp_bar_pat_e) j;
1551 if (j == bp_last_bar) {
1552 __kmp_msg( kmp_ms_warning, KMP_MSG( BarrReleaseValueInvalid, name, comma + 1 ), __kmp_msg_null );
1553 KMP_INFORM( Using_str_Value, name, __kmp_barrier_pattern_name[ bp_linear_bar ] );
1561 __kmp_stg_print_barrier_pattern( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1563 for (
int i=bs_plain_barrier; i<bs_last_barrier; i++ ) {
1564 var = __kmp_barrier_pattern_env_name[ i ];
1565 if ( strcmp ( var, name ) == 0 ) {
1566 int j = __kmp_barrier_gather_pattern [ i ];
1567 int k = __kmp_barrier_release_pattern [ i ];
1568 if( __kmp_env_format ) {
1569 KMP_STR_BUF_PRINT_NAME_EX(__kmp_barrier_pattern_env_name[ i ]);
1571 __kmp_str_buf_print( buffer,
" %s='", __kmp_barrier_pattern_env_name[ i ] );
1573 __kmp_str_buf_print( buffer,
"%s,%s'\n", __kmp_barrier_pattern_name [ j ], __kmp_barrier_pattern_name [ k ]);
1583 __kmp_stg_parse_abort_delay(
char const * name,
char const * value,
void * data ) {
1585 int delay = __kmp_abort_delay / 1000;
1586 __kmp_stg_parse_int( name, value, 0, INT_MAX / 1000, & delay );
1587 __kmp_abort_delay = delay * 1000;
1591 __kmp_stg_print_abort_delay( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1592 __kmp_stg_print_int( buffer, name, __kmp_abort_delay );
1600 __kmp_stg_parse_cpuinfo_file(
char const * name,
char const * value,
void * data ) {
1601 #if KMP_OS_LINUX || KMP_OS_WINDOWS
1602 __kmp_stg_parse_str( name, value, & __kmp_cpuinfo_file );
1603 K_DIAG( 1, (
"__kmp_cpuinfo_file == %s\n", __kmp_cpuinfo_file ) );
1607 #error "Unknown or unsupported OS"
1612 __kmp_stg_print_cpuinfo_file( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1613 #if KMP_OS_LINUX || KMP_OS_WINDOWS
1614 if( __kmp_env_format ) {
1615 KMP_STR_BUF_PRINT_NAME;
1617 __kmp_str_buf_print( buffer,
" %s", name );
1619 if ( __kmp_cpuinfo_file ) {
1620 __kmp_str_buf_print( buffer,
"='%s'\n", __kmp_cpuinfo_file );
1622 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
1632 __kmp_stg_parse_force_reduction(
char const * name,
char const * value,
void * data )
1634 kmp_stg_fr_data_t * reduction = (kmp_stg_fr_data_t *) data;
1637 rc = __kmp_stg_check_rivals( name, value, reduction->rivals );
1641 if ( reduction->force ) {
1643 if( __kmp_str_match(
"critical", 0, value ) )
1644 __kmp_force_reduction_method = critical_reduce_block;
1645 else if( __kmp_str_match(
"atomic", 0, value ) )
1646 __kmp_force_reduction_method = atomic_reduce_block;
1647 else if( __kmp_str_match(
"tree", 0, value ) )
1648 __kmp_force_reduction_method = tree_reduce_block;
1650 KMP_FATAL( UnknownForceReduction, name, value );
1654 __kmp_stg_parse_bool( name, value, & __kmp_determ_red );
1655 if( __kmp_determ_red ) {
1656 __kmp_force_reduction_method = tree_reduce_block;
1658 __kmp_force_reduction_method = reduction_method_not_defined;
1661 K_DIAG( 1, (
"__kmp_force_reduction_method == %d\n", __kmp_force_reduction_method ) );
1665 __kmp_stg_print_force_reduction( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1667 kmp_stg_fr_data_t * reduction = (kmp_stg_fr_data_t *) data;
1668 char const * value = NULL;
1669 if ( reduction->force ) {
1670 if( __kmp_force_reduction_method == critical_reduce_block) {
1671 __kmp_stg_print_str( buffer, name,
"critical");
1672 }
else if ( __kmp_force_reduction_method == atomic_reduce_block ) {
1673 __kmp_stg_print_str( buffer, name,
"atomic");
1674 }
else if ( __kmp_force_reduction_method == tree_reduce_block ) {
1675 __kmp_stg_print_str( buffer, name,
"tree");
1677 if( __kmp_env_format ) {
1678 KMP_STR_BUF_PRINT_NAME;
1680 __kmp_str_buf_print( buffer,
" %s", name );
1682 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
1685 __kmp_stg_print_bool( buffer, name, __kmp_determ_red );
1696 __kmp_stg_parse_storage_map(
char const * name,
char const * value,
void * data ) {
1697 if ( __kmp_str_match(
"verbose", 1, value ) ) {
1698 __kmp_storage_map = TRUE;
1699 __kmp_storage_map_verbose = TRUE;
1700 __kmp_storage_map_verbose_specified = TRUE;
1703 __kmp_storage_map_verbose = FALSE;
1704 __kmp_stg_parse_bool( name, value, & __kmp_storage_map );
1709 __kmp_stg_print_storage_map( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1710 if ( __kmp_storage_map_verbose || __kmp_storage_map_verbose_specified ) {
1711 __kmp_stg_print_str( buffer, name,
"verbose" );
1713 __kmp_stg_print_bool( buffer, name, __kmp_storage_map );
1722 __kmp_stg_parse_all_threadprivate(
char const * name,
char const * value,
void * data ) {
1723 __kmp_stg_parse_int( name, value, __kmp_allThreadsSpecified ? __kmp_max_nth : 1, __kmp_max_nth,
1724 & __kmp_tp_capacity );
1728 __kmp_stg_print_all_threadprivate( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1729 __kmp_stg_print_int( buffer, name, __kmp_tp_capacity );
1738 __kmp_stg_parse_foreign_threads_threadprivate(
char const * name,
char const * value,
void * data ) {
1739 __kmp_stg_parse_bool( name, value, & __kmp_foreign_tp );
1743 __kmp_stg_print_foreign_threads_threadprivate( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
1744 __kmp_stg_print_bool( buffer, name, __kmp_foreign_tp );
1752 #if KMP_OS_LINUX || KMP_OS_WINDOWS
1757 __kmp_parse_affinity_proc_id_list(
const char *var,
const char *env,
1758 const char **nextEnv,
char **proclist )
1760 const char *scan = env;
1761 const char *next = scan;
1767 int start, end, stride;
1771 if (*next ==
'\0') {
1784 if ((*next <
'0') || (*next >
'9')) {
1785 KMP_WARNING( AffSyntaxError, var );
1789 num = __kmp_str_to_int(scan, *next);
1790 KMP_ASSERT(num >= 0);
1814 if ((*next <
'0') || (*next >
'9')) {
1815 KMP_WARNING( AffSyntaxError, var );
1820 num = __kmp_str_to_int(scan, *next);
1821 KMP_ASSERT(num >= 0);
1836 if ((*next <
'0') || (*next >
'9')) {
1838 KMP_WARNING( AffSyntaxError, var );
1848 start = __kmp_str_to_int(scan, *next);
1849 KMP_ASSERT(start >= 0);
1874 if ((*next <
'0') || (*next >
'9')) {
1875 KMP_WARNING( AffSyntaxError, var );
1879 end = __kmp_str_to_int(scan, *next);
1880 KMP_ASSERT(end >= 0);
1901 if ((*next <
'0') || (*next >
'9')) {
1902 KMP_WARNING( AffSyntaxError, var );
1906 stride = __kmp_str_to_int(scan, *next);
1907 KMP_ASSERT(stride >= 0);
1915 KMP_WARNING( AffZeroStride, var );
1920 KMP_WARNING( AffStartGreaterEnd, var, start, end );
1926 KMP_WARNING( AffStrideLessZero, var, start, end );
1930 if ((end - start) / stride > 65536 ) {
1931 KMP_WARNING( AffRangeTooBig, var, end, start, stride );
1950 int len = next - env;
1951 char *retlist = (
char *)__kmp_allocate((len + 1) *
sizeof(char));
1952 memcpy(retlist, env, len *
sizeof(
char));
1953 retlist[len] =
'\0';
1954 *proclist = retlist;
1964 static kmp_setting_t *__kmp_affinity_notype = NULL;
1967 __kmp_parse_affinity_env(
char const * name,
char const * value,
1968 enum affinity_type * out_type,
1969 char ** out_proclist,
1973 enum affinity_gran * out_gran,
1974 int * out_gran_levels,
1980 char * buffer = NULL;
1990 int max_proclist = 0;
1997 KMP_ASSERT( value != NULL );
1999 if ( TCR_4(__kmp_init_middle) ) {
2000 KMP_WARNING( EnvMiddleWarn, name );
2001 __kmp_env_toPrint( name, 0 );
2004 __kmp_env_toPrint( name, 1 );
2006 buffer = __kmp_str_format(
"%s", value );
2018 #define EMIT_WARN(skip,errlist) \
2022 SKIP_TO(next, ','); \
2026 KMP_WARNING errlist; \
2029 if (ch == ',') next++; \
2034 #define _set_param(_guard,_var,_val) \
2036 if ( _guard == 0 ) { \
2039 EMIT_WARN( FALSE, ( AffParamDefined, name, start ) ); \
2044 #define set_type(val) _set_param( type, *out_type, val )
2045 #define set_verbose(val) _set_param( verbose, *out_verbose, val )
2046 #define set_warnings(val) _set_param( warnings, *out_warn, val )
2047 #define set_respect(val) _set_param( respect, *out_respect, val )
2048 #define set_dups(val) _set_param( dups, *out_dups, val )
2049 #define set_proclist(val) _set_param( proclist, *out_proclist, val )
2051 #define set_gran(val,levels) \
2053 if ( gran == 0 ) { \
2055 *out_gran_levels = levels; \
2057 EMIT_WARN( FALSE, ( AffParamDefined, name, start ) ); \
2063 KMP_DEBUG_ASSERT( ( __kmp_nested_proc_bind.bind_types != NULL )
2064 && ( __kmp_nested_proc_bind.used > 0 ) );
2065 if ( ( __kmp_affinity_notype != NULL )
2066 && ( ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_default )
2067 || ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_intel ) ) ) {
2072 while ( *buf !=
'\0' ) {
2075 if (__kmp_match_str(
"none", buf, (
const char **)&next)) {
2076 set_type( affinity_none );
2078 }
else if (__kmp_match_str(
"scatter", buf, (
const char **)&next)) {
2079 set_type( affinity_scatter );
2081 }
else if (__kmp_match_str(
"compact", buf, (
const char **)&next)) {
2082 set_type( affinity_compact );
2084 }
else if (__kmp_match_str(
"logical", buf, (
const char **)&next)) {
2085 set_type( affinity_logical );
2087 }
else if (__kmp_match_str(
"physical", buf, (
const char **)&next)) {
2088 set_type( affinity_physical );
2090 }
else if (__kmp_match_str(
"explicit", buf, (
const char **)&next)) {
2091 set_type( affinity_explicit );
2094 }
else if (__kmp_match_str(
"balanced", buf, (
const char **)&next)) {
2095 set_type( affinity_balanced );
2098 }
else if (__kmp_match_str(
"disabled", buf, (
const char **)&next)) {
2099 set_type( affinity_disabled );
2101 }
else if (__kmp_match_str(
"verbose", buf, (
const char **)&next)) {
2102 set_verbose( TRUE );
2104 }
else if (__kmp_match_str(
"noverbose", buf, (
const char **)&next)) {
2105 set_verbose( FALSE );
2107 }
else if (__kmp_match_str(
"warnings", buf, (
const char **)&next)) {
2108 set_warnings( TRUE );
2110 }
else if (__kmp_match_str(
"nowarnings", buf, (
const char **)&next)) {
2111 set_warnings( FALSE );
2113 }
else if (__kmp_match_str(
"respect", buf, (
const char **)&next)) {
2114 set_respect( TRUE );
2116 }
else if (__kmp_match_str(
"norespect", buf, (
const char **)&next)) {
2117 set_respect( FALSE );
2119 }
else if (__kmp_match_str(
"duplicates", buf, (
const char **)&next)
2120 || __kmp_match_str(
"dups", buf, (
const char **)&next)) {
2123 }
else if (__kmp_match_str(
"noduplicates", buf, (
const char **)&next)
2124 || __kmp_match_str(
"nodups", buf, (
const char **)&next)) {
2127 }
else if (__kmp_match_str(
"granularity", buf, (
const char **)&next)
2128 || __kmp_match_str(
"gran", buf, (
const char **)&next)) {
2131 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2138 if (__kmp_match_str(
"fine", buf, (
const char **)&next)) {
2139 set_gran( affinity_gran_fine, -1 );
2141 }
else if (__kmp_match_str(
"thread", buf, (
const char **)&next)) {
2142 set_gran( affinity_gran_thread, -1 );
2144 }
else if (__kmp_match_str(
"core", buf, (
const char **)&next)) {
2145 set_gran( affinity_gran_core, -1 );
2147 }
else if (__kmp_match_str(
"package", buf, (
const char **)&next)) {
2148 set_gran( affinity_gran_package, -1 );
2150 }
else if (__kmp_match_str(
"node", buf, (
const char **)&next)) {
2151 set_gran( affinity_gran_node, -1 );
2153 # if KMP_OS_WINDOWS && KMP_ARCH_X86_64
2154 }
else if (__kmp_match_str(
"group", buf, (
const char **)&next)) {
2155 set_gran( affinity_gran_group, -1 );
2158 }
else if ((*buf >=
'0') && (*buf <=
'9')) {
2162 n = __kmp_str_to_int( buf, *next );
2165 set_gran( affinity_gran_default, n );
2167 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2170 }
else if (__kmp_match_str(
"proclist", buf, (
const char **)&next)) {
2171 char *temp_proclist;
2175 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2181 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2186 if (! __kmp_parse_affinity_proc_id_list(name, buf,
2187 (
const char **)&next, &temp_proclist)) {
2192 if (*next ==
']') next++;
2194 if (*next ==
',') next++;
2199 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2203 set_proclist( temp_proclist );
2204 }
else if ((*buf >=
'0') && (*buf <=
'9')) {
2209 n = __kmp_str_to_int( buf, *next );
2213 number[ count ] = n;
2215 KMP_WARNING( AffManyParams, name, start );
2219 EMIT_WARN( TRUE, ( AffInvalidParam, name, start ) );
2228 else if (*next !=
'\0') {
2229 const char *temp = next;
2230 EMIT_WARN( TRUE, ( ParseExtraCharsWarn, name, temp ) );
2242 #undef set_granularity
2244 KMP_INTERNAL_FREE( buffer );
2248 KMP_WARNING( AffProcListNoType, name );
2249 __kmp_affinity_type = affinity_explicit;
2251 else if ( __kmp_affinity_type != affinity_explicit ) {
2252 KMP_WARNING( AffProcListNotExplicit, name );
2253 KMP_ASSERT( *out_proclist != NULL );
2254 KMP_INTERNAL_FREE( *out_proclist );
2255 *out_proclist = NULL;
2258 switch ( *out_type ) {
2259 case affinity_logical:
2260 case affinity_physical: {
2262 *out_offset = number[ 0 ];
2265 KMP_WARNING( AffManyParamsForLogic, name, number[ 1 ] );
2269 case affinity_balanced: {
2271 *out_compact = number[ 0 ];
2274 *out_offset = number[ 1 ];
2278 if( __kmp_affinity_gran != affinity_gran_default && __kmp_affinity_gran != affinity_gran_fine
2279 && __kmp_affinity_gran != affinity_gran_thread && __kmp_affinity_gran != affinity_gran_core ) {
2280 if( __kmp_affinity_verbose || __kmp_affinity_warnings ) {
2281 KMP_WARNING( AffGranUsing,
"KMP_AFFINITY",
"core" );
2283 __kmp_affinity_gran = affinity_gran_fine;
2287 case affinity_scatter:
2288 case affinity_compact: {
2290 *out_compact = number[ 0 ];
2293 *out_offset = number[ 1 ];
2296 case affinity_explicit: {
2297 if ( *out_proclist == NULL ) {
2298 KMP_WARNING( AffNoProcList, name );
2299 __kmp_affinity_type = affinity_none;
2302 KMP_WARNING( AffNoParam, name,
"explicit" );
2305 case affinity_none: {
2307 KMP_WARNING( AffNoParam, name,
"none" );
2310 case affinity_disabled: {
2312 KMP_WARNING( AffNoParam, name,
"disabled" );
2315 case affinity_default: {
2317 KMP_WARNING( AffNoParam, name,
"default" );
2327 __kmp_stg_parse_affinity(
char const * name,
char const * value,
void * data )
2329 kmp_setting_t **rivals = (kmp_setting_t **) data;
2332 rc = __kmp_stg_check_rivals( name, value, rivals );
2337 __kmp_parse_affinity_env( name, value, & __kmp_affinity_type,
2338 & __kmp_affinity_proclist, & __kmp_affinity_verbose,
2339 & __kmp_affinity_warnings, & __kmp_affinity_respect_mask,
2340 & __kmp_affinity_gran, & __kmp_affinity_gran_levels,
2341 & __kmp_affinity_dups, & __kmp_affinity_compact,
2342 & __kmp_affinity_offset );
2347 __kmp_stg_print_affinity( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
2348 if( __kmp_env_format ) {
2349 KMP_STR_BUF_PRINT_NAME_EX(name);
2351 __kmp_str_buf_print( buffer,
" %s='", name );
2353 if ( __kmp_affinity_verbose ) {
2354 __kmp_str_buf_print( buffer,
"%s,",
"verbose");
2356 __kmp_str_buf_print( buffer,
"%s,",
"noverbose");
2358 if ( __kmp_affinity_warnings ) {
2359 __kmp_str_buf_print( buffer,
"%s,",
"warnings");
2361 __kmp_str_buf_print( buffer,
"%s,",
"nowarnings");
2363 if ( KMP_AFFINITY_CAPABLE() ) {
2364 if ( __kmp_affinity_respect_mask ) {
2365 __kmp_str_buf_print( buffer,
"%s,",
"respect");
2367 __kmp_str_buf_print( buffer,
"%s,",
"norespect");
2369 switch ( __kmp_affinity_gran ) {
2370 case affinity_gran_default:
2371 __kmp_str_buf_print( buffer,
"%s",
"granularity=default,");
2373 case affinity_gran_fine:
2374 __kmp_str_buf_print( buffer,
"%s",
"granularity=fine,");
2376 case affinity_gran_thread:
2377 __kmp_str_buf_print( buffer,
"%s",
"granularity=thread,");
2379 case affinity_gran_core:
2380 __kmp_str_buf_print( buffer,
"%s",
"granularity=core,");
2382 case affinity_gran_package:
2383 __kmp_str_buf_print( buffer,
"%s",
"granularity=package,");
2385 case affinity_gran_node:
2386 __kmp_str_buf_print( buffer,
"%s",
"granularity=node,");
2388 # if KMP_OS_WINDOWS && KMP_ARCH_X86_64
2389 case affinity_gran_group:
2390 __kmp_str_buf_print( buffer,
"%s",
"granularity=group,");
2394 if ( __kmp_affinity_dups ) {
2395 __kmp_str_buf_print( buffer,
"%s,",
"duplicates");
2397 __kmp_str_buf_print( buffer,
"%s,",
"noduplicates");
2400 if ( ! KMP_AFFINITY_CAPABLE() ) {
2401 __kmp_str_buf_print( buffer,
"%s",
"disabled" );
2403 else switch ( __kmp_affinity_type ){
2405 __kmp_str_buf_print( buffer,
"%s",
"none");
2407 case affinity_physical:
2408 __kmp_str_buf_print( buffer,
"%s,%d",
"physical",
2409 __kmp_affinity_offset );
2411 case affinity_logical:
2412 __kmp_str_buf_print( buffer,
"%s,%d",
"logical",
2413 __kmp_affinity_offset );
2415 case affinity_compact:
2416 __kmp_str_buf_print( buffer,
"%s,%d,%d",
"compact",
2417 __kmp_affinity_compact, __kmp_affinity_offset );
2419 case affinity_scatter:
2420 __kmp_str_buf_print( buffer,
"%s,%d,%d",
"scatter",
2421 __kmp_affinity_compact, __kmp_affinity_offset );
2423 case affinity_explicit:
2424 __kmp_str_buf_print( buffer,
"%s=[%s],%s",
"proclist",
2425 __kmp_affinity_proclist,
"explicit" );
2428 case affinity_balanced:
2429 __kmp_str_buf_print( buffer,
"%s,%d,%d",
"balanced",
2430 __kmp_affinity_compact, __kmp_affinity_offset );
2433 case affinity_disabled:
2434 __kmp_str_buf_print( buffer,
"%s",
"disabled");
2436 case affinity_default:
2437 __kmp_str_buf_print( buffer,
"%s",
"default");
2440 __kmp_str_buf_print( buffer,
"%s",
"<unknown>");
2443 __kmp_str_buf_print( buffer,
"'\n" );
2446 # ifdef KMP_GOMP_COMPAT
2449 __kmp_stg_parse_gomp_cpu_affinity(
char const * name,
char const * value,
void * data )
2451 const char * next = NULL;
2452 char * temp_proclist;
2453 kmp_setting_t **rivals = (kmp_setting_t **) data;
2456 rc = __kmp_stg_check_rivals( name, value, rivals );
2461 if ( TCR_4(__kmp_init_middle) ) {
2462 KMP_WARNING( EnvMiddleWarn, name );
2463 __kmp_env_toPrint( name, 0 );
2467 __kmp_env_toPrint( name, 1 );
2469 if ( __kmp_parse_affinity_proc_id_list( name, value, &next,
2472 if (*next ==
'\0') {
2476 __kmp_affinity_proclist = temp_proclist;
2477 __kmp_affinity_type = affinity_explicit;
2478 __kmp_affinity_gran = affinity_gran_fine;
2481 KMP_WARNING( AffSyntaxError, name );
2482 if (temp_proclist != NULL) {
2483 KMP_INTERNAL_FREE((
void *)temp_proclist);
2491 __kmp_affinity_type = affinity_none;
2523 __kmp_parse_subplace_list(
const char *var,
const char **scan )
2528 int start, count, stride;
2534 if ((**scan <
'0') || (**scan >
'9')) {
2535 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2540 start = __kmp_str_to_int(*scan, *next);
2541 KMP_ASSERT(start >= 0);
2548 if (**scan ==
'}') {
2551 if (**scan ==
',') {
2555 if (**scan !=
':') {
2556 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2565 if ((**scan <
'0') || (**scan >
'9')) {
2566 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2571 count = __kmp_str_to_int(*scan, *next);
2572 KMP_ASSERT(count >= 0);
2579 if (**scan ==
'}') {
2582 if (**scan ==
',') {
2586 if (**scan !=
':') {
2587 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2598 if (**scan ==
'+') {
2602 if (**scan ==
'-') {
2610 if ((**scan <
'0') || (**scan >
'9')) {
2611 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2616 stride = __kmp_str_to_int(*scan, *next);
2617 KMP_ASSERT(stride >= 0);
2625 if (**scan ==
'}') {
2628 if (**scan ==
',') {
2633 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2640 __kmp_parse_place(
const char *var,
const char ** scan )
2648 if (**scan ==
'{') {
2650 if (! __kmp_parse_subplace_list(var, scan)) {
2653 if (**scan !=
'}') {
2654 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2659 else if (**scan ==
'!') {
2661 return __kmp_parse_place(var, scan);
2663 else if ((**scan >=
'0') && (**scan <=
'9')) {
2666 int proc = __kmp_str_to_int(*scan, *next);
2667 KMP_ASSERT(proc >= 0);
2671 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2678 __kmp_parse_place_list(
const char *var,
const char *env,
char **place_list )
2680 const char *scan = env;
2681 const char *next = scan;
2684 int start, count, stride;
2686 if (! __kmp_parse_place(var, &scan)) {
2694 if (*scan ==
'\0') {
2702 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2711 if ((*scan <
'0') || (*scan >
'9')) {
2712 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2717 count = __kmp_str_to_int(scan, *next);
2718 KMP_ASSERT(count >= 0);
2725 if (*scan ==
'\0') {
2733 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2756 if ((*scan <
'0') || (*scan >
'9')) {
2757 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2762 stride = __kmp_str_to_int(scan, *next);
2763 KMP_ASSERT(stride >= 0);
2771 if (*scan ==
'\0') {
2779 KMP_WARNING( SyntaxErrorUsing, var,
"\"threads\"" );
2784 int len = scan - env;
2785 char *retlist = (
char *)__kmp_allocate((len + 1) *
sizeof(char));
2786 memcpy(retlist, env, len *
sizeof(
char));
2787 retlist[len] =
'\0';
2788 *place_list = retlist;
2794 __kmp_stg_parse_places(
char const * name,
char const * value,
void * data )
2797 const char *scan = value;
2798 const char *next = scan;
2799 const char *kind =
"\"threads\"";
2803 if ( __kmp_match_str(
"threads", scan, &next ) ) {
2805 __kmp_affinity_type = affinity_compact;
2806 __kmp_affinity_gran = affinity_gran_thread;
2807 __kmp_affinity_dups = FALSE;
2808 kind =
"\"threads\"";
2810 else if ( __kmp_match_str(
"cores", scan, &next ) ) {
2812 __kmp_affinity_type = affinity_compact;
2813 __kmp_affinity_gran = affinity_gran_core;
2814 __kmp_affinity_dups = FALSE;
2817 else if ( __kmp_match_str(
"sockets", scan, &next ) ) {
2819 __kmp_affinity_type = affinity_compact;
2820 __kmp_affinity_gran = affinity_gran_package;
2821 __kmp_affinity_dups = FALSE;
2822 kind =
"\"sockets\"";
2825 if ( __kmp_affinity_proclist != NULL ) {
2826 KMP_INTERNAL_FREE( (
void *)__kmp_affinity_proclist );
2827 __kmp_affinity_proclist = NULL;
2829 if ( __kmp_parse_place_list( name, value, &__kmp_affinity_proclist ) ) {
2830 __kmp_affinity_type = affinity_explicit;
2831 __kmp_affinity_gran = affinity_gran_fine;
2832 __kmp_affinity_dups = FALSE;
2838 if ( *scan ==
'\0' ) {
2845 if ( *scan !=
'(' ) {
2846 KMP_WARNING( SyntaxErrorUsing, name, kind );
2854 count = __kmp_str_to_int(scan, *next);
2855 KMP_ASSERT(count >= 0);
2859 if ( *scan !=
')' ) {
2860 KMP_WARNING( SyntaxErrorUsing, name, kind );
2866 if ( *scan !=
'\0' ) {
2867 KMP_WARNING( ParseExtraCharsWarn, name, scan );
2869 __kmp_affinity_num_places = count;
2873 __kmp_stg_print_places( kmp_str_buf_t * buffer,
char const * name,
2876 if( __kmp_env_format ) {
2877 KMP_STR_BUF_PRINT_NAME;
2879 __kmp_str_buf_print( buffer,
" %s", name );
2881 if ( ( __kmp_nested_proc_bind.used == 0 )
2882 || ( __kmp_nested_proc_bind.bind_types == NULL )
2883 || ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_false )
2884 || ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_intel ) ) {
2885 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
2887 else if ( __kmp_affinity_type == affinity_explicit ) {
2888 if ( __kmp_affinity_proclist != NULL ) {
2889 __kmp_str_buf_print( buffer,
"='%s'\n", __kmp_affinity_proclist );
2892 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
2895 else if ( __kmp_affinity_type == affinity_compact ) {
2897 if ( __kmp_affinity_num_masks > 0 ) {
2898 num = __kmp_affinity_num_masks;
2900 else if ( __kmp_affinity_num_places > 0 ) {
2901 num = __kmp_affinity_num_places;
2906 if ( __kmp_affinity_gran == affinity_gran_thread ) {
2908 __kmp_str_buf_print( buffer,
"='threads(%d)'\n", num );
2911 __kmp_str_buf_print( buffer,
"='threads'\n" );
2914 else if ( __kmp_affinity_gran == affinity_gran_core ) {
2916 __kmp_str_buf_print( buffer,
"='cores(%d)' \n", num );
2919 __kmp_str_buf_print( buffer,
"='cores'\n" );
2922 else if ( __kmp_affinity_gran == affinity_gran_package ) {
2924 __kmp_str_buf_print( buffer,
"='sockets(%d)'\n", num );
2927 __kmp_str_buf_print( buffer,
"='sockets'\n" );
2931 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
2935 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
2941 # if OMP_30_ENABLED && (! OMP_40_ENABLED)
2944 __kmp_stg_parse_proc_bind(
char const * name,
char const * value,
void * data )
2947 kmp_setting_t **rivals = (kmp_setting_t **) data;
2950 rc = __kmp_stg_check_rivals( name, value, rivals );
2958 __kmp_stg_parse_bool( name, value, & enabled );
2963 __kmp_affinity_type = affinity_scatter;
2964 __kmp_affinity_gran = affinity_gran_core;
2967 __kmp_affinity_type = affinity_none;
2975 __kmp_stg_parse_topology_method(
char const * name,
char const * value,
2977 if ( __kmp_str_match(
"all", 1, value ) ) {
2978 __kmp_affinity_top_method = affinity_top_method_all;
2980 # if KMP_ARCH_X86 || KMP_ARCH_X86_64
2981 else if ( __kmp_str_match(
"x2apic id", 9, value )
2982 || __kmp_str_match(
"x2apic_id", 9, value )
2983 || __kmp_str_match(
"x2apic-id", 9, value )
2984 || __kmp_str_match(
"x2apicid", 8, value )
2985 || __kmp_str_match(
"cpuid leaf 11", 13, value )
2986 || __kmp_str_match(
"cpuid_leaf_11", 13, value )
2987 || __kmp_str_match(
"cpuid-leaf-11", 13, value )
2988 || __kmp_str_match(
"cpuid leaf11", 12, value )
2989 || __kmp_str_match(
"cpuid_leaf11", 12, value )
2990 || __kmp_str_match(
"cpuid-leaf11", 12, value )
2991 || __kmp_str_match(
"cpuidleaf 11", 12, value )
2992 || __kmp_str_match(
"cpuidleaf_11", 12, value )
2993 || __kmp_str_match(
"cpuidleaf-11", 12, value )
2994 || __kmp_str_match(
"cpuidleaf11", 11, value )
2995 || __kmp_str_match(
"cpuid 11", 8, value )
2996 || __kmp_str_match(
"cpuid_11", 8, value )
2997 || __kmp_str_match(
"cpuid-11", 8, value )
2998 || __kmp_str_match(
"cpuid11", 7, value )
2999 || __kmp_str_match(
"leaf 11", 7, value )
3000 || __kmp_str_match(
"leaf_11", 7, value )
3001 || __kmp_str_match(
"leaf-11", 7, value )
3002 || __kmp_str_match(
"leaf11", 6, value ) ) {
3003 __kmp_affinity_top_method = affinity_top_method_x2apicid;
3005 else if ( __kmp_str_match(
"apic id", 7, value )
3006 || __kmp_str_match(
"apic_id", 7, value )
3007 || __kmp_str_match(
"apic-id", 7, value )
3008 || __kmp_str_match(
"apicid", 6, value )
3009 || __kmp_str_match(
"cpuid leaf 4", 12, value )
3010 || __kmp_str_match(
"cpuid_leaf_4", 12, value )
3011 || __kmp_str_match(
"cpuid-leaf-4", 12, value )
3012 || __kmp_str_match(
"cpuid leaf4", 11, value )
3013 || __kmp_str_match(
"cpuid_leaf4", 11, value )
3014 || __kmp_str_match(
"cpuid-leaf4", 11, value )
3015 || __kmp_str_match(
"cpuidleaf 4", 11, value )
3016 || __kmp_str_match(
"cpuidleaf_4", 11, value )
3017 || __kmp_str_match(
"cpuidleaf-4", 11, value )
3018 || __kmp_str_match(
"cpuidleaf4", 10, value )
3019 || __kmp_str_match(
"cpuid 4", 7, value )
3020 || __kmp_str_match(
"cpuid_4", 7, value )
3021 || __kmp_str_match(
"cpuid-4", 7, value )
3022 || __kmp_str_match(
"cpuid4", 6, value )
3023 || __kmp_str_match(
"leaf 4", 6, value )
3024 || __kmp_str_match(
"leaf_4", 6, value )
3025 || __kmp_str_match(
"leaf-4", 6, value )
3026 || __kmp_str_match(
"leaf4", 5, value ) ) {
3027 __kmp_affinity_top_method = affinity_top_method_apicid;
3030 else if ( __kmp_str_match(
"/proc/cpuinfo", 2, value )
3031 || __kmp_str_match(
"cpuinfo", 5, value )) {
3032 __kmp_affinity_top_method = affinity_top_method_cpuinfo;
3034 # if KMP_OS_WINDOWS && KMP_ARCH_X86_64
3035 else if ( __kmp_str_match(
"group", 1, value ) ) {
3036 __kmp_affinity_top_method = affinity_top_method_group;
3039 else if ( __kmp_str_match(
"flat", 1, value ) ) {
3040 __kmp_affinity_top_method = affinity_top_method_flat;
3043 KMP_WARNING( StgInvalidValue, name, value );
3048 __kmp_stg_print_topology_method( kmp_str_buf_t * buffer,
char const * name,
3051 char const * value = NULL;
3053 switch ( __kmp_affinity_top_method ) {
3054 case affinity_top_method_default:
3058 case affinity_top_method_all:
3062 # if KMP_ARCH_X86 || KMP_ARCH_X86_64
3063 case affinity_top_method_x2apicid:
3064 value =
"x2APIC id";
3067 case affinity_top_method_apicid:
3072 case affinity_top_method_cpuinfo:
3076 # if KMP_OS_WINDOWS && KMP_ARCH_X86_64
3077 case affinity_top_method_group:
3082 case affinity_top_method_flat:
3087 if ( value != NULL ) {
3088 __kmp_stg_print_str( buffer, name, value );
3096 #error "Unknown or unsupported OS"
3107 __kmp_stg_parse_proc_bind(
char const * name,
char const * value,
void * data )
3109 kmp_setting_t **rivals = (kmp_setting_t **) data;
3112 rc = __kmp_stg_check_rivals( name, value, rivals );
3120 KMP_DEBUG_ASSERT( (__kmp_nested_proc_bind.bind_types != NULL)
3121 && ( __kmp_nested_proc_bind.used > 0 ) );
3123 const char *buf = value;
3127 if ( (*buf >=
'0') && (*buf <=
'9') ) {
3129 SKIP_DIGITS( next );
3130 num = __kmp_str_to_int( buf, *next );
3131 KMP_ASSERT( num >= 0 );
3140 if ( __kmp_match_str(
"disabled", buf, &next ) ) {
3143 # if KMP_OS_LINUX || KMP_OS_WINDOWS
3144 __kmp_affinity_type = affinity_disabled;
3146 __kmp_nested_proc_bind.used = 1;
3147 __kmp_nested_proc_bind.bind_types[0] = proc_bind_disabled;
3149 else if ( ( num == (
int)proc_bind_false )
3150 || __kmp_match_str(
"false", buf, &next ) ) {
3153 # if KMP_OS_LINUX || KMP_OS_WINDOWS
3154 __kmp_affinity_type = affinity_none;
3156 __kmp_nested_proc_bind.used = 1;
3157 __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
3159 else if ( ( num == (
int)proc_bind_true )
3160 || __kmp_match_str(
"true", buf, &next ) ) {
3163 __kmp_nested_proc_bind.used = 1;
3168 __kmp_nested_proc_bind.bind_types[0] = proc_bind_spread;
3176 for ( scan = buf; *scan !=
'\0'; scan++ ) {
3177 if ( *scan ==
',' ) {
3185 if ( __kmp_nested_proc_bind.size < nelem ) {
3186 __kmp_nested_proc_bind.bind_types = (kmp_proc_bind_t *)
3187 KMP_INTERNAL_REALLOC( __kmp_nested_proc_bind.bind_types,
3188 sizeof(kmp_proc_bind_t) * nelem );
3189 if ( __kmp_nested_proc_bind.bind_types == NULL ) {
3190 KMP_FATAL( MemoryAllocFailed );
3192 __kmp_nested_proc_bind.size = nelem;
3194 __kmp_nested_proc_bind.used = nelem;
3201 enum kmp_proc_bind_t bind;
3203 if ( ( num == (
int)proc_bind_master )
3204 || __kmp_match_str(
"master", buf, &next ) ) {
3207 bind = proc_bind_master;
3209 else if ( ( num == (
int)proc_bind_close )
3210 || __kmp_match_str(
"close", buf, &next ) ) {
3213 bind = proc_bind_close;
3215 else if ( ( num == (
int)proc_bind_spread )
3216 || __kmp_match_str(
"spread", buf, &next ) ) {
3219 bind = proc_bind_spread;
3222 KMP_WARNING( StgInvalidValue, name, value );
3223 __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
3224 __kmp_nested_proc_bind.used = 1;
3228 __kmp_nested_proc_bind.bind_types[i++] = bind;
3232 KMP_DEBUG_ASSERT( *buf ==
',' );
3239 if ( (*buf >=
'0') && (*buf <=
'9') ) {
3241 SKIP_DIGITS( next );
3242 num = __kmp_str_to_int( buf, *next );
3243 KMP_ASSERT( num >= 0 );
3253 if ( *buf !=
'\0' ) {
3254 KMP_WARNING( ParseExtraCharsWarn, name, buf );
3260 __kmp_stg_print_proc_bind( kmp_str_buf_t * buffer,
char const * name,
3263 int nelem = __kmp_nested_proc_bind.used;
3264 if( __kmp_env_format ) {
3265 KMP_STR_BUF_PRINT_NAME;
3267 __kmp_str_buf_print( buffer,
" %s", name );
3270 __kmp_str_buf_print( buffer,
": %s\n", KMP_I18N_STR( NotDefined ) );
3274 __kmp_str_buf_print( buffer,
"='", name );
3275 for ( i = 0; i < nelem; i++ ) {
3276 switch ( __kmp_nested_proc_bind.bind_types[i] ) {
3277 case proc_bind_false:
3278 __kmp_str_buf_print( buffer,
"false" );
3281 case proc_bind_true:
3282 __kmp_str_buf_print( buffer,
"true" );
3285 case proc_bind_master:
3286 __kmp_str_buf_print( buffer,
"master" );
3289 case proc_bind_close:
3290 __kmp_str_buf_print( buffer,
"close" );
3293 case proc_bind_spread:
3294 __kmp_str_buf_print( buffer,
"spread" );
3297 case proc_bind_disabled:
3298 __kmp_str_buf_print( buffer,
"disabled" );
3301 case proc_bind_intel:
3302 __kmp_str_buf_print( buffer,
"intel" );
3305 case proc_bind_default:
3306 __kmp_str_buf_print( buffer,
"default" );
3309 if ( i < nelem - 1 ) {
3310 __kmp_str_buf_print( buffer,
"," );
3313 __kmp_str_buf_print( buffer,
"'\n" );
3325 __kmp_stg_parse_omp_dynamic(
char const * name,
char const * value,
void * data )
3327 __kmp_stg_parse_bool( name, value, & (__kmp_global.g.g_dynamic) );
3331 __kmp_stg_print_omp_dynamic( kmp_str_buf_t * buffer,
char const * name,
void * data )
3333 __kmp_stg_print_bool( buffer, name, __kmp_global.g.g_dynamic );
3337 __kmp_stg_parse_kmp_dynamic_mode(
char const * name,
char const * value,
void * data )
3339 if ( TCR_4(__kmp_init_parallel) ) {
3340 KMP_WARNING( EnvParallelWarn, name );
3341 __kmp_env_toPrint( name, 0 );
3344 #ifdef USE_LOAD_BALANCE
3345 else if ( __kmp_str_match(
"load balance", 2, value )
3346 || __kmp_str_match(
"load_balance", 2, value )
3347 || __kmp_str_match(
"load-balance", 2, value )
3348 || __kmp_str_match(
"loadbalance", 2, value )
3349 || __kmp_str_match(
"balance", 1, value ) ) {
3350 __kmp_global.g.g_dynamic_mode = dynamic_load_balance;
3353 else if ( __kmp_str_match(
"thread limit", 1, value )
3354 || __kmp_str_match(
"thread_limit", 1, value )
3355 || __kmp_str_match(
"thread-limit", 1, value )
3356 || __kmp_str_match(
"threadlimit", 1, value )
3357 || __kmp_str_match(
"limit", 2, value ) ) {
3358 __kmp_global.g.g_dynamic_mode = dynamic_thread_limit;
3360 else if ( __kmp_str_match(
"random", 1, value ) ) {
3361 __kmp_global.g.g_dynamic_mode = dynamic_random;
3364 KMP_WARNING( StgInvalidValue, name, value );
3369 __kmp_stg_print_kmp_dynamic_mode( kmp_str_buf_t * buffer,
char const * name,
void * data )
3372 if ( __kmp_global.g.g_dynamic_mode == dynamic_default ) {
3373 __kmp_str_buf_print( buffer,
" %s: %s \n", name, KMP_I18N_STR( NotDefined ) );
3375 # ifdef USE_LOAD_BALANCE
3376 else if ( __kmp_global.g.g_dynamic_mode == dynamic_load_balance ) {
3377 __kmp_stg_print_str( buffer, name,
"load balance" );
3380 else if ( __kmp_global.g.g_dynamic_mode == dynamic_thread_limit ) {
3381 __kmp_stg_print_str( buffer, name,
"thread limit" );
3383 else if ( __kmp_global.g.g_dynamic_mode == dynamic_random ) {
3384 __kmp_stg_print_str( buffer, name,
"random" );
3393 #ifdef USE_LOAD_BALANCE
3400 __kmp_stg_parse_ld_balance_interval(
char const * name,
char const * value,
void * data )
3402 double interval = __kmp_convert_to_double( value );
3403 if ( interval >= 0 ) {
3404 __kmp_load_balance_interval = interval;
3406 KMP_WARNING( StgInvalidValue, name, value );
3411 __kmp_stg_print_ld_balance_interval( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3413 __kmp_str_buf_print( buffer,
" %s=%8.6f\n", name, __kmp_load_balance_interval );
3426 __kmp_stg_parse_init_at_fork(
char const * name,
char const * value,
void * data ) {
3427 __kmp_stg_parse_bool( name, value, & __kmp_need_register_atfork );
3428 if ( __kmp_need_register_atfork ) {
3429 __kmp_need_register_atfork_specified = TRUE;
3434 __kmp_stg_print_init_at_fork( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3435 __kmp_stg_print_bool( buffer, name, __kmp_need_register_atfork_specified );
3443 __kmp_stg_parse_schedule(
char const * name,
char const * value,
void * data ) {
3445 if ( value != NULL ) {
3446 size_t length = strlen( value );
3447 if ( length > INT_MAX ) {
3448 KMP_WARNING( LongValue, name );
3451 if( value[ length - 1 ] ==
'"' || value[ length -1 ] ==
'\'' )
3452 KMP_WARNING( UnbalancedQuotes, name );
3456 semicolon = (
char *) strchr( value,
';' );
3457 if( *value && semicolon != value ) {
3458 char *comma = (
char *) strchr( value,
',' );
3465 if ( !__kmp_strcasecmp_with_sentinel(
"static", value, sentinel ) ) {
3466 if( !__kmp_strcasecmp_with_sentinel(
"greedy", comma,
';' ) ) {
3467 __kmp_static = kmp_sch_static_greedy;
3469 }
else if( !__kmp_strcasecmp_with_sentinel(
"balanced", comma,
';' ) ) {
3470 __kmp_static = kmp_sch_static_balanced;
3473 }
else if ( !__kmp_strcasecmp_with_sentinel(
"guided", value, sentinel ) ) {
3474 if ( !__kmp_strcasecmp_with_sentinel(
"iterative", comma,
';' ) ) {
3475 __kmp_guided = kmp_sch_guided_iterative_chunked;
3477 }
else if ( !__kmp_strcasecmp_with_sentinel(
"analytical", comma,
';' ) ) {
3479 __kmp_guided = kmp_sch_guided_analytical_chunked;
3483 KMP_WARNING( InvalidClause, name, value );
3485 KMP_WARNING( EmptyClause, name );
3486 }
while ( value = semicolon ? semicolon + 1 : NULL );
3493 __kmp_stg_print_schedule( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3494 if( __kmp_env_format ) {
3495 KMP_STR_BUF_PRINT_NAME_EX(name);
3497 __kmp_str_buf_print( buffer,
" %s='", name );
3499 if ( __kmp_static == kmp_sch_static_greedy ) {
3500 __kmp_str_buf_print( buffer,
"%s",
"static,greedy");
3501 }
else if ( __kmp_static == kmp_sch_static_balanced ) {
3502 __kmp_str_buf_print ( buffer,
"%s",
"static,balanced");
3504 if ( __kmp_guided == kmp_sch_guided_iterative_chunked ) {
3505 __kmp_str_buf_print( buffer,
";%s'\n",
"guided,iterative");
3506 }
else if ( __kmp_guided == kmp_sch_guided_analytical_chunked ) {
3507 __kmp_str_buf_print( buffer,
";%s'\n",
"guided,analytical");
3516 __kmp_stg_parse_omp_schedule(
char const * name,
char const * value,
void * data )
3520 length = strlen( value );
3522 char *comma = (
char *) strchr( value,
',' );
3523 if( value[ length - 1 ] ==
'"' || value[ length -1 ] ==
'\'')
3524 KMP_WARNING( UnbalancedQuotes, name );
3526 if (!__kmp_strcasecmp_with_sentinel(
"dynamic", value,
','))
3527 __kmp_sched = kmp_sch_dynamic_chunked;
3528 else if (!__kmp_strcasecmp_with_sentinel(
"guided", value,
','))
3532 else if (!__kmp_strcasecmp_with_sentinel(
"auto", value,
',')) {
3535 __kmp_msg( kmp_ms_warning, KMP_MSG( IgnoreChunk, name, comma ), __kmp_msg_null );
3539 #endif // OMP_30_ENABLED
3540 else if (!__kmp_strcasecmp_with_sentinel(
"trapezoidal", value,
','))
3541 __kmp_sched = kmp_sch_trapezoidal;
3542 else if (!__kmp_strcasecmp_with_sentinel(
"static", value,
','))
3544 #ifdef KMP_STATIC_STEAL_ENABLED
3545 else if (KMP_ARCH_X86_64 &&
3546 !__kmp_strcasecmp_with_sentinel(
"static_steal", value,
','))
3550 KMP_WARNING( StgInvalidValue, name, value );
3553 if( value && comma ) {
3554 __kmp_env_chunk = TRUE;
3557 __kmp_sched = kmp_sch_static_chunked;
3559 __kmp_chunk = __kmp_str_to_int( comma, 0 );
3560 if ( __kmp_chunk < 1 ) {
3561 __kmp_chunk = KMP_DEFAULT_CHUNK;
3562 __kmp_msg( kmp_ms_warning, KMP_MSG( InvalidChunk, name, comma ), __kmp_msg_null );
3563 KMP_INFORM( Using_int_Value, name, __kmp_chunk );
3569 }
else if ( __kmp_chunk > KMP_MAX_CHUNK ) {
3570 __kmp_chunk = KMP_MAX_CHUNK;
3571 __kmp_msg( kmp_ms_warning, KMP_MSG( LargeChunk, name, comma ), __kmp_msg_null );
3572 KMP_INFORM( Using_int_Value, name, __kmp_chunk );
3575 __kmp_env_chunk = FALSE;
3577 KMP_WARNING( EmptyString, name );
3579 K_DIAG(1, (
"__kmp_static == %d\n", __kmp_static))
3580 K_DIAG(1, ("__kmp_guided == %d\n", __kmp_guided))
3581 K_DIAG(1, ("__kmp_sched == %d\n", __kmp_sched))
3582 K_DIAG(1, ("__kmp_chunk == %d\n", __kmp_chunk))
3586 __kmp_stg_print_omp_schedule( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3587 if( __kmp_env_format ) {
3588 KMP_STR_BUF_PRINT_NAME_EX(name);
3590 __kmp_str_buf_print( buffer,
" %s='", name );
3592 if ( __kmp_chunk ) {
3593 switch ( __kmp_sched ) {
3594 case kmp_sch_dynamic_chunked:
3595 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"dynamic", __kmp_chunk);
3597 case kmp_sch_guided_iterative_chunked:
3598 case kmp_sch_guided_analytical_chunked:
3599 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"guided", __kmp_chunk);
3601 case kmp_sch_trapezoidal:
3602 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"trapezoidal", __kmp_chunk);
3605 case kmp_sch_static_chunked:
3606 case kmp_sch_static_balanced:
3607 case kmp_sch_static_greedy:
3608 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"static", __kmp_chunk);
3611 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"static_steal", __kmp_chunk);
3614 __kmp_str_buf_print( buffer,
"%s,%d'\n",
"auto", __kmp_chunk);
3618 switch ( __kmp_sched ) {
3619 case kmp_sch_dynamic_chunked:
3620 __kmp_str_buf_print( buffer,
"%s'\n",
"dynamic");
3622 case kmp_sch_guided_iterative_chunked:
3623 case kmp_sch_guided_analytical_chunked:
3624 __kmp_str_buf_print( buffer,
"%s'\n",
"guided");
3626 case kmp_sch_trapezoidal:
3627 __kmp_str_buf_print( buffer,
"%s'\n",
"trapezoidal");
3630 case kmp_sch_static_chunked:
3631 case kmp_sch_static_balanced:
3632 case kmp_sch_static_greedy:
3633 __kmp_str_buf_print( buffer,
"%s'\n",
"static");
3636 __kmp_str_buf_print( buffer,
"%s'\n",
"static_steal");
3639 __kmp_str_buf_print( buffer,
"%s'\n",
"auto");
3650 __kmp_stg_parse_atomic_mode(
char const * name,
char const * value,
void * data ) {
3654 #ifdef KMP_GOMP_COMPAT
3657 __kmp_stg_parse_int( name, value, 0, max, & mode );
3661 __kmp_atomic_mode = mode;
3666 __kmp_stg_print_atomic_mode( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3667 __kmp_stg_print_int( buffer, name, __kmp_atomic_mode );
3676 __kmp_stg_parse_consistency_check(
char const * name,
char const * value,
void * data ) {
3677 if ( ! __kmp_strcasecmp_with_sentinel(
"all", value, 0 ) ) {
3681 __kmp_env_consistency_check = TRUE;
3682 }
else if ( ! __kmp_strcasecmp_with_sentinel(
"none", value, 0 ) ) {
3683 __kmp_env_consistency_check = FALSE;
3685 KMP_WARNING( StgInvalidValue, name, value );
3690 __kmp_stg_print_consistency_check( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3692 const char *value = NULL;
3694 if ( __kmp_env_consistency_check ) {
3700 if ( value != NULL ) {
3701 __kmp_stg_print_str( buffer, name, value );
3715 __kmp_stg_parse_itt_prepare_delay(
char const * name,
char const * value,
void * data )
3719 __kmp_stg_parse_int( name, value, 0, INT_MAX, & delay );
3720 __kmp_itt_prepare_delay = delay;
3724 __kmp_stg_print_itt_prepare_delay( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3725 __kmp_stg_print_uint64( buffer, name, __kmp_itt_prepare_delay );
3729 #endif // USE_ITT_NOTIFY
3737 __kmp_stg_parse_malloc_pool_incr(
char const * name,
char const * value,
void * data ) {
3738 __kmp_stg_parse_size(
3741 KMP_MIN_MALLOC_POOL_INCR,
3742 KMP_MAX_MALLOC_POOL_INCR,
3744 & __kmp_malloc_pool_incr,
3750 __kmp_stg_print_malloc_pool_incr( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3751 __kmp_stg_print_size( buffer, name, __kmp_malloc_pool_incr );
3763 __kmp_stg_parse_par_range_env(
char const * name,
char const * value,
void * data ) {
3764 __kmp_stg_parse_par_range(
3768 __kmp_par_range_routine,
3769 __kmp_par_range_filename,
3770 & __kmp_par_range_lb,
3771 & __kmp_par_range_ub
3776 __kmp_stg_print_par_range_env( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3777 if (__kmp_par_range != 0) {
3778 __kmp_stg_print_str( buffer, name, par_range_to_print );
3787 __kmp_stg_parse_yield_cycle(
char const * name,
char const * value,
void * data ) {
3788 int flag = __kmp_yield_cycle;
3789 __kmp_stg_parse_bool( name, value, & flag );
3790 __kmp_yield_cycle = flag;
3794 __kmp_stg_print_yield_cycle( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3795 __kmp_stg_print_bool( buffer, name, __kmp_yield_cycle );
3799 __kmp_stg_parse_yield_on(
char const * name,
char const * value,
void * data ) {
3800 __kmp_stg_parse_int( name, value, 2, INT_MAX, & __kmp_yield_on_count );
3804 __kmp_stg_print_yield_on( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3805 __kmp_stg_print_int( buffer, name, __kmp_yield_on_count );
3809 __kmp_stg_parse_yield_off(
char const * name,
char const * value,
void * data ) {
3810 __kmp_stg_parse_int( name, value, 2, INT_MAX, & __kmp_yield_off_count );
3814 __kmp_stg_print_yield_off( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3815 __kmp_stg_print_int( buffer, name, __kmp_yield_off_count );
3825 __kmp_stg_parse_init_wait(
char const * name,
char const * value,
void * data ) {
3827 KMP_ASSERT( ( __kmp_init_wait & 1 ) == 0 );
3828 wait = __kmp_init_wait / 2;
3829 __kmp_stg_parse_int( name, value, KMP_MIN_INIT_WAIT, KMP_MAX_INIT_WAIT, & wait );
3830 __kmp_init_wait = wait * 2;
3831 KMP_ASSERT( ( __kmp_init_wait & 1 ) == 0 );
3832 __kmp_yield_init = __kmp_init_wait;
3836 __kmp_stg_print_init_wait( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3837 __kmp_stg_print_int( buffer, name, __kmp_init_wait );
3841 __kmp_stg_parse_next_wait(
char const * name,
char const * value,
void * data ) {
3843 KMP_ASSERT( ( __kmp_next_wait & 1 ) == 0 );
3844 wait = __kmp_next_wait / 2;
3845 __kmp_stg_parse_int( name, value, KMP_MIN_NEXT_WAIT, KMP_MAX_NEXT_WAIT, & wait );
3846 __kmp_next_wait = wait * 2;
3847 KMP_ASSERT( ( __kmp_next_wait & 1 ) == 0 );
3848 __kmp_yield_next = __kmp_next_wait;
3852 __kmp_stg_print_next_wait( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3853 __kmp_stg_print_int( buffer, name, __kmp_next_wait );
3862 __kmp_stg_parse_gtid_mode(
char const * name,
char const * value,
void * data ) {
3873 #ifdef KMP_TDATA_GTID
3876 __kmp_stg_parse_int( name, value, 0, max, & mode );
3880 __kmp_adjust_gtid_mode = TRUE;
3883 __kmp_gtid_mode = mode;
3884 __kmp_adjust_gtid_mode = FALSE;
3889 __kmp_stg_print_gtid_mode( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3890 if ( __kmp_adjust_gtid_mode ) {
3891 __kmp_stg_print_int( buffer, name, 0 );
3894 __kmp_stg_print_int( buffer, name, __kmp_gtid_mode );
3904 __kmp_stg_parse_lock_block(
char const * name,
char const * value,
void * data ) {
3905 __kmp_stg_parse_int( name, value, 0, KMP_INT_MAX, & __kmp_num_locks_in_block );
3909 __kmp_stg_print_lock_block( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3910 __kmp_stg_print_int( buffer, name, __kmp_num_locks_in_block );
3918 __kmp_stg_parse_lock_kind(
char const * name,
char const * value,
void * data ) {
3919 if ( __kmp_init_user_locks ) {
3920 KMP_WARNING( EnvLockWarn, name );
3924 if ( __kmp_str_match(
"tas", 2, value )
3925 || __kmp_str_match(
"test and set", 2, value )
3926 || __kmp_str_match(
"test_and_set", 2, value )
3927 || __kmp_str_match(
"test-and-set", 2, value )
3928 || __kmp_str_match(
"test andset", 2, value )
3929 || __kmp_str_match(
"test_andset", 2, value )
3930 || __kmp_str_match(
"test-andset", 2, value )
3931 || __kmp_str_match(
"testand set", 2, value )
3932 || __kmp_str_match(
"testand_set", 2, value )
3933 || __kmp_str_match(
"testand-set", 2, value )
3934 || __kmp_str_match(
"testandset", 2, value ) ) {
3935 __kmp_user_lock_kind = lk_tas;
3937 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
3938 else if ( __kmp_str_match(
"futex", 1, value ) ) {
3939 if ( __kmp_futex_determine_capable() ) {
3940 __kmp_user_lock_kind = lk_futex;
3943 KMP_WARNING( FutexNotSupported, name, value );
3947 else if ( __kmp_str_match(
"ticket", 2, value ) ) {
3948 __kmp_user_lock_kind = lk_ticket;
3950 else if ( __kmp_str_match(
"queuing", 1, value )
3951 || __kmp_str_match(
"queue", 1, value ) ) {
3952 __kmp_user_lock_kind = lk_queuing;
3954 else if ( __kmp_str_match(
"drdpa ticket", 1, value )
3955 || __kmp_str_match(
"drdpa_ticket", 1, value )
3956 || __kmp_str_match(
"drdpa-ticket", 1, value )
3957 || __kmp_str_match(
"drdpaticket", 1, value )
3958 || __kmp_str_match(
"drdpa", 1, value ) ) {
3959 __kmp_user_lock_kind = lk_drdpa;
3961 #if KMP_USE_ADAPTIVE_LOCKS
3962 else if ( __kmp_str_match(
"adaptive", 1, value ) ) {
3963 if( __kmp_cpuinfo.rtm ) {
3964 __kmp_user_lock_kind = lk_adaptive;
3966 KMP_WARNING( AdaptiveNotSupported, name, value );
3967 __kmp_user_lock_kind = lk_queuing;
3970 #endif // KMP_USE_ADAPTIVE_LOCKS
3972 KMP_WARNING( StgInvalidValue, name, value );
3977 __kmp_stg_print_lock_kind( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
3978 const char *value = NULL;
3980 switch ( __kmp_user_lock_kind ) {
3989 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
4006 #if KMP_USE_ADAPTIVE_LOCKS
4013 if ( value != NULL ) {
4014 __kmp_stg_print_str( buffer, name, value );
4018 #if KMP_USE_ADAPTIVE_LOCKS
4027 __kmp_stg_parse_adaptive_lock_props(
const char *name,
const char *value,
void *data )
4029 int max_retries = 0;
4030 int max_badness = 0;
4032 const char *next = value;
4033 const char *scan = next;
4036 int prev_comma = FALSE;
4041 for ( i = 0; i < 3 ; i++) {
4044 if ( *next ==
'\0' ) {
4048 if ( ( ( *next <
'0' ) || ( *next >
'9' ) ) && ( *next !=
',') || ( total > 2 ) ) {
4049 KMP_WARNING( EnvSyntaxError, name, value );
4053 if ( *next ==
',' ) {
4055 if ( total == 0 || prev_comma ) {
4063 if ( *next >=
'0' && *next <=
'9' ) {
4065 const char *buf = next;
4066 char const * msg = NULL;
4068 SKIP_DIGITS( next );
4071 const char *tmp = next;
4073 if ( ( *next ==
' ' || *next ==
'\t' ) && ( *tmp >=
'0' && *tmp <=
'9' ) ) {
4074 KMP_WARNING( EnvSpacesNotAllowed, name, value );
4078 num = __kmp_str_to_int( buf, *next );
4080 msg = KMP_I18N_STR( ValueTooSmall );
4082 }
else if ( num > KMP_INT_MAX ) {
4083 msg = KMP_I18N_STR( ValueTooLarge );
4086 if ( msg != NULL ) {
4088 KMP_WARNING( ParseSizeIntWarn, name, value, msg );
4089 KMP_INFORM( Using_int_Value, name, num );
4093 }
else if( total == 2 ) {
4098 KMP_DEBUG_ASSERT( total > 0 );
4100 KMP_WARNING( EnvSyntaxError, name, value );
4103 if( max_retries != 0 ) {
4104 __kmp_adaptive_backoff_params.max_soft_retries = max_retries;
4106 if( max_badness != 0 ) {
4107 __kmp_adaptive_backoff_params.max_badness = max_badness;
4113 __kmp_stg_print_adaptive_lock_props(kmp_str_buf_t * buffer,
char const * name,
void * data )
4115 if( __kmp_env_format ) {
4116 KMP_STR_BUF_PRINT_NAME_EX(name);
4118 __kmp_str_buf_print( buffer,
" %s='", name );
4120 __kmp_str_buf_print( buffer,
"%d,%d'\n", __kmp_adaptive_backoff_params.max_soft_retries,
4121 __kmp_adaptive_backoff_params.max_badness );
4124 #if KMP_DEBUG_ADAPTIVE_LOCKS
4127 __kmp_stg_parse_speculative_statsfile(
char const * name,
char const * value,
void * data ) {
4128 __kmp_stg_parse_file( name, value,
"", & __kmp_speculative_statsfile );
4132 __kmp_stg_print_speculative_statsfile( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
4133 if ( __kmp_str_match(
"-", 0, __kmp_speculative_statsfile ) ) {
4134 __kmp_stg_print_str( buffer, name,
"stdout" );
4136 __kmp_stg_print_str( buffer, name, __kmp_speculative_statsfile );
4141 #endif // KMP_DEBUG_ADAPTIVE_LOCKS
4143 #endif // KMP_USE_ADAPTIVE_LOCKS
4151 __kmp_stg_parse_place_threads(
char const * name,
char const * value,
void * data ) {
4157 const char *next = value;
4161 if ( *next ==
'\0' ) {
4166 if ( *next >=
'0' && *next <=
'9' ) {
4168 SKIP_DIGITS( next );
4169 num = __kmp_str_to_int( prev, *next );
4171 if ( *next ==
'C' || *next ==
'c' ) {
4172 __kmp_place_num_cores = num;
4174 }
else if ( *next ==
',' || *next ==
'x' ) {
4175 __kmp_place_num_cores = num;
4178 }
else if ( *next ==
'T' || *next ==
't' ) {
4179 __kmp_place_num_threads_per_core = num;
4181 }
else if ( *next ==
'\0' ) {
4182 __kmp_place_num_cores = num;
4185 KMP_WARNING( AffThrPlaceInvalid, name, value );
4188 }
else if ( *next ==
',' || *next ==
'x' ) {
4193 KMP_WARNING( AffThrPlaceInvalid, name, value );
4197 if ( *next ==
'\0' ) {
4200 if ( ( *next ==
',' || *next ==
'x' ) && !prev_delim ) {
4207 if ( *next >=
'0' && *next <=
'9' ) {
4210 SKIP_DIGITS( next );
4211 num = __kmp_str_to_int( prev, *next );
4213 if ( *next ==
'T' || *next ==
't' ) {
4214 __kmp_place_num_threads_per_core = num;
4216 }
else if ( *next ==
',' || *next ==
'x' ) {
4217 __kmp_place_num_threads_per_core = num;
4220 }
else if ( *next ==
'O' || *next ==
'o' ) {
4221 __kmp_place_core_offset = num;
4223 }
else if ( *next ==
'\0' ) {
4224 __kmp_place_num_threads_per_core = num;
4227 KMP_WARNING( AffThrPlaceInvalid, name, value );
4230 }
else if ( *next ==
',' || *next ==
'x' ) {
4231 if ( prev_delim == 2 ) {
4234 KMP_DEBUG_ASSERT( prev_delim == 1 );
4237 KMP_WARNING( AffThrPlaceInvalid, name, value );
4241 if ( *next ==
'\0' ) {
4244 if ( ( *next ==
',' || *next ==
'x' ) && !prev_delim ) {
4252 if ( *next >=
'0' && *next <=
'9' ) {
4254 SKIP_DIGITS( next );
4255 num = __kmp_str_to_int( prev, *next );
4256 __kmp_place_core_offset = num;
4261 __kmp_stg_print_place_threads( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
4262 if ( __kmp_place_num_cores + __kmp_place_num_threads_per_core ) {
4264 __kmp_str_buf_init( &buf );
4265 if( __kmp_env_format ) {
4266 KMP_STR_BUF_PRINT_NAME_EX(name);
4268 __kmp_str_buf_print( buffer,
" %s='", name );
4270 __kmp_str_buf_print( &buf,
"%dC", __kmp_place_num_cores );
4271 __kmp_str_buf_print( &buf,
"x%dT", __kmp_place_num_threads_per_core );
4272 if ( __kmp_place_core_offset ) {
4273 __kmp_str_buf_print( &buf,
",%dO", __kmp_place_core_offset );
4275 __kmp_str_buf_print(buffer,
"%s'\n", buf.str );
4276 __kmp_str_buf_free(&buf);
4291 __kmp_stg_parse_forkjoin_frames(
char const * name,
char const * value,
void * data ) {
4292 __kmp_stg_parse_bool( name, value, & __kmp_forkjoin_frames );
4296 __kmp_stg_print_forkjoin_frames( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
4297 __kmp_stg_print_bool( buffer, name, __kmp_forkjoin_frames );
4305 __kmp_stg_parse_forkjoin_frames_mode(
char const * name,
char const * value,
void * data ) {
4306 __kmp_stg_parse_int( name, value, 0, 3, & __kmp_forkjoin_frames_mode );
4310 __kmp_stg_print_forkjoin_frames_mode( kmp_str_buf_t * buffer,
char const * name,
void * data ) {
4311 __kmp_stg_print_int( buffer, name, __kmp_forkjoin_frames_mode );
4322 __kmp_stg_parse_omp_display_env(
char const * name,
char const * value,
void * data )
4324 if ( __kmp_str_match(
"VERBOSE", 1, value ) )
4326 __kmp_display_env_verbose = TRUE;
4328 __kmp_stg_parse_bool( name, value, & __kmp_display_env );
4334 __kmp_stg_print_omp_display_env( kmp_str_buf_t * buffer,
char const * name,
void * data )
4336 if ( __kmp_display_env_verbose )
4338 __kmp_stg_print_str( buffer, name,
"VERBOSE" );
4340 __kmp_stg_print_bool( buffer, name, __kmp_display_env );
4351 static kmp_setting_t __kmp_stg_table[] = {
4353 {
"KMP_ALL_THREADS", __kmp_stg_parse_all_threads, __kmp_stg_print_all_threads, NULL, 0, 0 },
4354 {
"KMP_BLOCKTIME", __kmp_stg_parse_blocktime, __kmp_stg_print_blocktime, NULL, 0, 0 },
4355 {
"KMP_DUPLICATE_LIB_OK", __kmp_stg_parse_duplicate_lib_ok, __kmp_stg_print_duplicate_lib_ok, NULL, 0, 0 },
4356 {
"KMP_LIBRARY", __kmp_stg_parse_wait_policy, __kmp_stg_print_wait_policy, NULL, 0, 0 },
4357 {
"KMP_MAX_THREADS", __kmp_stg_parse_all_threads, NULL, NULL, 0, 0 },
4358 {
"KMP_MONITOR_STACKSIZE", __kmp_stg_parse_monitor_stacksize, __kmp_stg_print_monitor_stacksize, NULL, 0, 0 },
4359 {
"KMP_SETTINGS", __kmp_stg_parse_settings, __kmp_stg_print_settings, NULL, 0, 0 },
4360 {
"KMP_STACKOFFSET", __kmp_stg_parse_stackoffset, __kmp_stg_print_stackoffset, NULL, 0, 0 },
4361 {
"KMP_STACKSIZE", __kmp_stg_parse_stacksize, __kmp_stg_print_stacksize, NULL, 0, 0 },
4362 {
"KMP_VERSION", __kmp_stg_parse_version, __kmp_stg_print_version, NULL, 0, 0 },
4363 {
"KMP_WARNINGS", __kmp_stg_parse_warnings, __kmp_stg_print_warnings, NULL, 0, 0 },
4365 {
"OMP_NESTED", __kmp_stg_parse_nested, __kmp_stg_print_nested, NULL, 0, 0 },
4366 {
"OMP_NUM_THREADS", __kmp_stg_parse_num_threads, __kmp_stg_print_num_threads, NULL, 0, 0 },
4367 {
"OMP_STACKSIZE", __kmp_stg_parse_stacksize, __kmp_stg_print_stacksize, NULL, 0, 0 },
4370 {
"KMP_TASKING", __kmp_stg_parse_tasking, __kmp_stg_print_tasking, NULL, 0, 0 },
4371 {
"KMP_TASK_STEALING_CONSTRAINT", __kmp_stg_parse_task_stealing, __kmp_stg_print_task_stealing, NULL, 0, 0 },
4372 {
"OMP_MAX_ACTIVE_LEVELS", __kmp_stg_parse_max_active_levels, __kmp_stg_print_max_active_levels, NULL, 0, 0 },
4373 {
"OMP_THREAD_LIMIT", __kmp_stg_parse_all_threads, __kmp_stg_print_all_threads, NULL, 0, 0 },
4374 {
"OMP_WAIT_POLICY", __kmp_stg_parse_wait_policy, __kmp_stg_print_wait_policy, NULL, 0, 0 },
4375 #endif // OMP_30_ENABLED
4377 #if KMP_HANDLE_SIGNALS
4378 {
"KMP_HANDLE_SIGNALS", __kmp_stg_parse_handle_signals, __kmp_stg_print_handle_signals, NULL, 0, 0 },
4381 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
4382 {
"KMP_INHERIT_FP_CONTROL", __kmp_stg_parse_inherit_fp_control, __kmp_stg_print_inherit_fp_control, NULL, 0, 0 },
4385 #ifdef KMP_GOMP_COMPAT
4386 {
"GOMP_STACKSIZE", __kmp_stg_parse_stacksize, NULL, NULL, 0, 0 },
4390 {
"KMP_A_DEBUG", __kmp_stg_parse_a_debug, __kmp_stg_print_a_debug, NULL, 0, 0 },
4391 {
"KMP_B_DEBUG", __kmp_stg_parse_b_debug, __kmp_stg_print_b_debug, NULL, 0, 0 },
4392 {
"KMP_C_DEBUG", __kmp_stg_parse_c_debug, __kmp_stg_print_c_debug, NULL, 0, 0 },
4393 {
"KMP_D_DEBUG", __kmp_stg_parse_d_debug, __kmp_stg_print_d_debug, NULL, 0, 0 },
4394 {
"KMP_E_DEBUG", __kmp_stg_parse_e_debug, __kmp_stg_print_e_debug, NULL, 0, 0 },
4395 {
"KMP_F_DEBUG", __kmp_stg_parse_f_debug, __kmp_stg_print_f_debug, NULL, 0, 0 },
4396 {
"KMP_DEBUG", __kmp_stg_parse_debug, NULL, NULL, 0, 0 },
4397 {
"KMP_DEBUG_BUF", __kmp_stg_parse_debug_buf, __kmp_stg_print_debug_buf, NULL, 0, 0 },
4398 {
"KMP_DEBUG_BUF_ATOMIC", __kmp_stg_parse_debug_buf_atomic, __kmp_stg_print_debug_buf_atomic, NULL, 0, 0 },
4399 {
"KMP_DEBUG_BUF_CHARS", __kmp_stg_parse_debug_buf_chars, __kmp_stg_print_debug_buf_chars, NULL, 0, 0 },
4400 {
"KMP_DEBUG_BUF_LINES", __kmp_stg_parse_debug_buf_lines, __kmp_stg_print_debug_buf_lines, NULL, 0, 0 },
4401 {
"KMP_DIAG", __kmp_stg_parse_diag, __kmp_stg_print_diag, NULL, 0, 0 },
4403 {
"KMP_PAR_RANGE", __kmp_stg_parse_par_range_env, __kmp_stg_print_par_range_env, NULL, 0, 0 },
4404 {
"KMP_YIELD_CYCLE", __kmp_stg_parse_yield_cycle, __kmp_stg_print_yield_cycle, NULL, 0, 0 },
4405 {
"KMP_YIELD_ON", __kmp_stg_parse_yield_on, __kmp_stg_print_yield_on, NULL, 0, 0 },
4406 {
"KMP_YIELD_OFF", __kmp_stg_parse_yield_off, __kmp_stg_print_yield_off, NULL, 0, 0 },
4409 {
"KMP_ALIGN_ALLOC", __kmp_stg_parse_align_alloc, __kmp_stg_print_align_alloc, NULL, 0, 0 },
4411 {
"KMP_PLAIN_BARRIER", __kmp_stg_parse_barrier_branch_bit, __kmp_stg_print_barrier_branch_bit, NULL, 0, 0 },
4412 {
"KMP_PLAIN_BARRIER_PATTERN", __kmp_stg_parse_barrier_pattern, __kmp_stg_print_barrier_pattern, NULL, 0, 0 },
4413 {
"KMP_FORKJOIN_BARRIER", __kmp_stg_parse_barrier_branch_bit, __kmp_stg_print_barrier_branch_bit, NULL, 0, 0 },
4414 {
"KMP_FORKJOIN_BARRIER_PATTERN", __kmp_stg_parse_barrier_pattern, __kmp_stg_print_barrier_pattern, NULL, 0, 0 },
4415 #if KMP_FAST_REDUCTION_BARRIER
4416 {
"KMP_REDUCTION_BARRIER", __kmp_stg_parse_barrier_branch_bit, __kmp_stg_print_barrier_branch_bit, NULL, 0, 0 },
4417 {
"KMP_REDUCTION_BARRIER_PATTERN", __kmp_stg_parse_barrier_pattern, __kmp_stg_print_barrier_pattern, NULL, 0, 0 },
4420 {
"KMP_ABORT_DELAY", __kmp_stg_parse_abort_delay, __kmp_stg_print_abort_delay, NULL, 0, 0 },
4421 {
"KMP_CPUINFO_FILE", __kmp_stg_parse_cpuinfo_file, __kmp_stg_print_cpuinfo_file, NULL, 0, 0 },
4422 {
"KMP_FORCE_REDUCTION", __kmp_stg_parse_force_reduction, __kmp_stg_print_force_reduction, NULL, 0, 0 },
4423 {
"KMP_DETERMINISTIC_REDUCTION", __kmp_stg_parse_force_reduction, __kmp_stg_print_force_reduction, NULL, 0, 0 },
4424 {
"KMP_STORAGE_MAP", __kmp_stg_parse_storage_map, __kmp_stg_print_storage_map, NULL, 0, 0 },
4425 {
"KMP_ALL_THREADPRIVATE", __kmp_stg_parse_all_threadprivate, __kmp_stg_print_all_threadprivate, NULL, 0, 0 },
4426 {
"KMP_FOREIGN_THREADS_THREADPRIVATE", __kmp_stg_parse_foreign_threads_threadprivate, __kmp_stg_print_foreign_threads_threadprivate, NULL, 0, 0 },
4428 #if KMP_OS_LINUX || KMP_OS_WINDOWS
4429 {
"KMP_AFFINITY", __kmp_stg_parse_affinity, __kmp_stg_print_affinity, NULL, 0, 0 },
4430 # ifdef KMP_GOMP_COMPAT
4431 {
"GOMP_CPU_AFFINITY", __kmp_stg_parse_gomp_cpu_affinity, NULL, NULL, 0, 0 },
4435 {
"OMP_PROC_BIND", __kmp_stg_parse_proc_bind, __kmp_stg_print_proc_bind, NULL, 0, 0 },
4436 {
"OMP_PLACES", __kmp_stg_parse_places, __kmp_stg_print_places, NULL, 0, 0 },
4438 {
"OMP_PROC_BIND", __kmp_stg_parse_proc_bind, NULL, NULL, 0, 0 },
4442 {
"KMP_TOPOLOGY_METHOD", __kmp_stg_parse_topology_method, __kmp_stg_print_topology_method, NULL, 0, 0 },
4451 {
"OMP_PROC_BIND", __kmp_stg_parse_proc_bind, __kmp_stg_print_proc_bind, NULL, 0, 0 },
4455 #error "Unknown or unsupported OS"
4456 #endif // KMP_OS_LINUX || KMP_OS_WINDOWS
4458 {
"KMP_INIT_AT_FORK", __kmp_stg_parse_init_at_fork, __kmp_stg_print_init_at_fork, NULL, 0, 0 },
4459 {
"KMP_SCHEDULE", __kmp_stg_parse_schedule, __kmp_stg_print_schedule, NULL, 0, 0 },
4460 {
"OMP_SCHEDULE", __kmp_stg_parse_omp_schedule, __kmp_stg_print_omp_schedule, NULL, 0, 0 },
4461 {
"KMP_ATOMIC_MODE", __kmp_stg_parse_atomic_mode, __kmp_stg_print_atomic_mode, NULL, 0, 0 },
4462 {
"KMP_CONSISTENCY_CHECK", __kmp_stg_parse_consistency_check, __kmp_stg_print_consistency_check, NULL, 0, 0 },
4464 #if USE_ITT_BUILD && USE_ITT_NOTIFY
4465 {
"KMP_ITT_PREPARE_DELAY", __kmp_stg_parse_itt_prepare_delay, __kmp_stg_print_itt_prepare_delay, NULL, 0, 0 },
4467 {
"KMP_MALLOC_POOL_INCR", __kmp_stg_parse_malloc_pool_incr, __kmp_stg_print_malloc_pool_incr, NULL, 0, 0 },
4468 {
"KMP_INIT_WAIT", __kmp_stg_parse_init_wait, __kmp_stg_print_init_wait, NULL, 0, 0 },
4469 {
"KMP_NEXT_WAIT", __kmp_stg_parse_next_wait, __kmp_stg_print_next_wait, NULL, 0, 0 },
4470 {
"KMP_GTID_MODE", __kmp_stg_parse_gtid_mode, __kmp_stg_print_gtid_mode, NULL, 0, 0 },
4471 {
"OMP_DYNAMIC", __kmp_stg_parse_omp_dynamic, __kmp_stg_print_omp_dynamic, NULL, 0, 0 },
4472 {
"KMP_DYNAMIC_MODE", __kmp_stg_parse_kmp_dynamic_mode, __kmp_stg_print_kmp_dynamic_mode, NULL, 0, 0 },
4474 #ifdef USE_LOAD_BALANCE
4475 {
"KMP_LOAD_BALANCE_INTERVAL", __kmp_stg_parse_ld_balance_interval,__kmp_stg_print_ld_balance_interval,NULL, 0, 0 },
4480 {
"KMP_NUM_LOCKS_IN_BLOCK", __kmp_stg_parse_lock_block, __kmp_stg_print_lock_block, NULL, 0, 0 },
4481 {
"KMP_LOCK_KIND", __kmp_stg_parse_lock_kind, __kmp_stg_print_lock_kind, NULL, 0, 0 },
4482 #if KMP_USE_ADAPTIVE_LOCKS
4483 {
"KMP_ADAPTIVE_LOCK_PROPS", __kmp_stg_parse_adaptive_lock_props,__kmp_stg_print_adaptive_lock_props, NULL, 0, 0 },
4484 #if KMP_DEBUG_ADAPTIVE_LOCKS
4485 {
"KMP_SPECULATIVE_STATSFILE", __kmp_stg_parse_speculative_statsfile,__kmp_stg_print_speculative_statsfile, NULL, 0, 0 },
4487 #endif // KMP_USE_ADAPTIVE_LOCKS
4489 {
"KMP_PLACE_THREADS", __kmp_stg_parse_place_threads, __kmp_stg_print_place_threads, NULL, 0, 0 },
4492 {
"KMP_FORKJOIN_FRAMES", __kmp_stg_parse_forkjoin_frames, __kmp_stg_print_forkjoin_frames, NULL, 0, 0 },
4493 {
"KMP_FORKJOIN_FRAMES_MODE", __kmp_stg_parse_forkjoin_frames_mode,__kmp_stg_print_forkjoin_frames_mode, NULL, 0, 0 },
4497 {
"OMP_DISPLAY_ENV", __kmp_stg_parse_omp_display_env, __kmp_stg_print_omp_display_env, NULL, 0, 0 },
4499 {
"", NULL, NULL, NULL, 0, 0 }
4502 static int const __kmp_stg_count =
sizeof( __kmp_stg_table ) /
sizeof( kmp_setting_t );
4506 __kmp_stg_find(
char const * name ) {
4509 if ( name != NULL ) {
4510 for ( i = 0; i < __kmp_stg_count; ++ i ) {
4511 if ( strcmp( __kmp_stg_table[ i ].name, name ) == 0 ) {
4512 return & __kmp_stg_table[ i ];
4522 __kmp_stg_cmp(
void const * _a,
void const * _b ) {
4523 kmp_setting_t * a = (kmp_setting_t *) _a;
4524 kmp_setting_t * b = (kmp_setting_t *) _b;
4530 if ( strcmp( a->name,
"KMP_AFFINITY" ) == 0 ) {
4531 if ( strcmp( b->name,
"KMP_AFFINITY" ) == 0 ) {
4536 else if ( strcmp( b->name,
"KMP_AFFINITY" ) == 0 ) {
4539 return strcmp( a->name, b->name );
4544 __kmp_stg_init(
void
4547 static int initialized = 0;
4549 if ( ! initialized ) {
4552 qsort( __kmp_stg_table, __kmp_stg_count - 1,
sizeof( kmp_setting_t ), __kmp_stg_cmp );
4556 kmp_setting_t * kmp_stacksize = __kmp_stg_find(
"KMP_STACKSIZE" );
4557 #ifdef KMP_GOMP_COMPAT
4558 kmp_setting_t * gomp_stacksize = __kmp_stg_find(
"GOMP_STACKSIZE" );
4560 kmp_setting_t * omp_stacksize = __kmp_stg_find(
"OMP_STACKSIZE" );
4565 static kmp_setting_t *
volatile rivals[ 4 ];
4566 static kmp_stg_ss_data_t kmp_data = { 1, (kmp_setting_t **)rivals };
4567 #ifdef KMP_GOMP_COMPAT
4568 static kmp_stg_ss_data_t gomp_data = { 1024, (kmp_setting_t **)rivals };
4570 static kmp_stg_ss_data_t omp_data = { 1024, (kmp_setting_t **)rivals };
4573 rivals[ i ++ ] = kmp_stacksize;
4574 #ifdef KMP_GOMP_COMPAT
4575 if ( gomp_stacksize != NULL ) {
4576 rivals[ i ++ ] = gomp_stacksize;
4579 rivals[ i ++ ] = omp_stacksize;
4580 rivals[ i ++ ] = NULL;
4582 kmp_stacksize->data = & kmp_data;
4583 #ifdef KMP_GOMP_COMPAT
4584 if ( gomp_stacksize != NULL ) {
4585 gomp_stacksize->data = & gomp_data;
4588 omp_stacksize->data = & omp_data;
4595 kmp_setting_t * kmp_library = __kmp_stg_find(
"KMP_LIBRARY" );
4596 kmp_setting_t * omp_wait_policy = __kmp_stg_find(
"OMP_WAIT_POLICY" );
4599 static kmp_setting_t *
volatile rivals[ 3 ];
4600 static kmp_stg_wp_data_t kmp_data = { 0, (kmp_setting_t **)rivals };
4601 static kmp_stg_wp_data_t omp_data = { 1, (kmp_setting_t **)rivals };
4604 rivals[ i ++ ] = kmp_library;
4605 if ( omp_wait_policy != NULL ) {
4606 rivals[ i ++ ] = omp_wait_policy;
4608 rivals[ i ++ ] = NULL;
4610 kmp_library->data = & kmp_data;
4611 if ( omp_wait_policy != NULL ) {
4612 omp_wait_policy->data = & omp_data;
4618 kmp_setting_t * kmp_library = __kmp_stg_find(
"KMP_LIBRARY" );
4619 static kmp_stg_wp_data_t kmp_data = { 0, NULL };
4620 kmp_library->data = & kmp_data;
4626 kmp_setting_t * kmp_all_threads = __kmp_stg_find(
"KMP_ALL_THREADS" );
4627 kmp_setting_t * kmp_max_threads = __kmp_stg_find(
"KMP_MAX_THREADS" );
4629 kmp_setting_t * omp_thread_limit = __kmp_stg_find(
"OMP_THREAD_LIMIT" );
4633 static kmp_setting_t *
volatile rivals[ 4 ];
4636 rivals[ i ++ ] = kmp_all_threads;
4637 rivals[ i ++ ] = kmp_max_threads;
4639 if ( omp_thread_limit != NULL ) {
4640 rivals[ i ++ ] = omp_thread_limit;
4643 rivals[ i ++ ] = NULL;
4645 kmp_all_threads->data = (
void*)& rivals;
4646 kmp_max_threads->data = (
void*)& rivals;
4648 if ( omp_thread_limit != NULL ) {
4649 omp_thread_limit->data = (
void*)& rivals;
4655 #if KMP_OS_LINUX || KMP_OS_WINDOWS
4658 kmp_setting_t * kmp_affinity = __kmp_stg_find(
"KMP_AFFINITY" );
4659 KMP_DEBUG_ASSERT( kmp_affinity != NULL );
4661 # ifdef KMP_GOMP_COMPAT
4662 kmp_setting_t * gomp_cpu_affinity = __kmp_stg_find(
"GOMP_CPU_AFFINITY" );
4663 KMP_DEBUG_ASSERT( gomp_cpu_affinity != NULL );
4667 kmp_setting_t * omp_proc_bind = __kmp_stg_find(
"OMP_PROC_BIND" );
4668 KMP_DEBUG_ASSERT( omp_proc_bind != NULL );
4672 kmp_setting_t * omp_places = __kmp_stg_find(
"OMP_PLACES" );
4673 KMP_DEBUG_ASSERT( omp_places != NULL );
4677 static kmp_setting_t *
volatile rivals[ 5 ];
4680 rivals[ i ++ ] = kmp_affinity;
4682 # ifdef KMP_GOMP_COMPAT
4683 rivals[ i ++ ] = gomp_cpu_affinity;
4684 gomp_cpu_affinity->data = (
void*)& rivals;
4688 rivals[ i ++ ] = omp_proc_bind;
4689 omp_proc_bind->data = (
void*)& rivals;
4693 rivals[ i ++ ] = omp_places;
4694 omp_places->data = (
void*)& rivals;
4697 rivals[ i ++ ] = NULL;
4704 #error "Unknown or unsupported OS"
4709 kmp_setting_t * kmp_force_red = __kmp_stg_find(
"KMP_FORCE_REDUCTION" );
4710 kmp_setting_t * kmp_determ_red = __kmp_stg_find(
"KMP_DETERMINISTIC_REDUCTION" );
4713 static kmp_setting_t *
volatile rivals[ 3 ];
4714 static kmp_stg_fr_data_t force_data = { 1, (kmp_setting_t **)rivals };
4715 static kmp_stg_fr_data_t determ_data = { 0, (kmp_setting_t **)rivals };
4718 rivals[ i ++ ] = kmp_force_red;
4719 if ( kmp_determ_red != NULL ) {
4720 rivals[ i ++ ] = kmp_determ_red;
4722 rivals[ i ++ ] = NULL;
4724 kmp_force_red->data = & force_data;
4725 if ( kmp_determ_red != NULL ) {
4726 kmp_determ_red->data = & determ_data;
4736 for ( i = 0; i < __kmp_stg_count; ++ i ) {
4737 __kmp_stg_table[ i ].set = 0;
4751 if ( name[ 0 ] == 0 ) {
4755 if ( value != NULL ) {
4756 kmp_setting_t * setting = __kmp_stg_find( name );
4757 if ( setting != NULL ) {
4758 setting->parse( name, value, setting->data );
4759 setting->defined = 1;
4767 __kmp_stg_check_rivals(
4770 kmp_setting_t * * rivals
4773 if ( rivals == NULL ) {
4779 for ( ; strcmp( rivals[ i ]->name, name ) != 0; i++ ) {
4780 KMP_DEBUG_ASSERT( rivals[ i ] != NULL );
4782 #if KMP_OS_LINUX || KMP_OS_WINDOWS
4783 if ( rivals[ i ] == __kmp_affinity_notype ) {
4792 if ( rivals[ i ]->set ) {
4793 KMP_WARNING( StgIgnored, name, value, rivals[ i ]->name );
4806 __kmp_env_isDefined(
char const * name ) {
4808 kmp_setting_t * setting = __kmp_stg_find( name );
4809 if ( setting != NULL ) {
4816 __kmp_env_toPrint(
char const * name,
int flag ) {
4818 kmp_setting_t * setting = __kmp_stg_find( name );
4819 if ( setting != NULL ) {
4820 rc = setting->defined;
4822 setting->defined = flag;
4830 __kmp_aux_env_initialize( kmp_env_blk_t* block ) {
4835 value = __kmp_env_blk_var( block,
"OMP_NUM_THREADS" );
4837 ompc_set_num_threads( __kmp_dflt_team_nth );
4841 value = __kmp_env_blk_var( block,
"KMP_BLOCKTIME" );
4843 kmpc_set_blocktime( __kmp_dflt_blocktime );
4847 value = __kmp_env_blk_var( block,
"OMP_NESTED" );
4849 ompc_set_nested( __kmp_dflt_nested );
4853 value = __kmp_env_blk_var( block,
"OMP_DYNAMIC" );
4855 ompc_set_dynamic( __kmp_global.g.g_dynamic );
4861 __kmp_env_initialize(
char const *
string ) {
4863 kmp_env_blk_t block;
4869 if (
string == NULL ) {
4871 __kmp_threads_capacity = __kmp_initial_threads_capacity( __kmp_dflt_team_nth_ub );
4873 __kmp_env_blk_init( & block,
string );
4878 for ( i = 0; i < block.count; ++ i ) {
4879 if (( block.vars[ i ].name == NULL )
4880 || ( *block.vars[ i ].name ==
'\0')) {
4883 if ( block.vars[ i ].value == NULL ) {
4886 kmp_setting_t * setting = __kmp_stg_find( block.vars[ i ].name );
4887 if ( setting != NULL ) {
4893 if (
string == NULL ) {
4894 char const * name =
"KMP_WARNINGS";
4895 char const * value = __kmp_env_blk_var( & block, name );
4896 __kmp_stg_parse( name, value );
4899 #if KMP_OS_LINUX || KMP_OS_WINDOWS
4907 __kmp_affinity_notype = NULL;
4908 char const *aff_str = __kmp_env_blk_var( & block,
"KMP_AFFINITY" );
4909 if ( aff_str != NULL ) {
4923 # define FIND strstr
4925 # define FIND strcasestr
4928 if ( ( FIND( aff_str,
"none" ) == NULL )
4929 && ( FIND( aff_str,
"physical" ) == NULL )
4930 && ( FIND( aff_str,
"logical" ) == NULL )
4931 && ( FIND( aff_str,
"compact" ) == NULL )
4932 && ( FIND( aff_str,
"scatter" ) == NULL )
4933 && ( FIND( aff_str,
"explicit" ) == NULL )
4935 && ( FIND( aff_str,
"balanced" ) == NULL )
4937 && ( FIND( aff_str,
"disabled" ) == NULL ) ) {
4938 __kmp_affinity_notype = __kmp_stg_find(
"KMP_AFFINITY" );
4948 if ( __kmp_nested_proc_bind.bind_types == NULL ) {
4949 __kmp_nested_proc_bind.bind_types = (kmp_proc_bind_t *)
4950 KMP_INTERNAL_MALLOC(
sizeof(kmp_proc_bind_t) );
4951 if ( __kmp_nested_proc_bind.bind_types == NULL ) {
4952 KMP_FATAL( MemoryAllocFailed );
4954 __kmp_nested_proc_bind.size = 1;
4955 __kmp_nested_proc_bind.used = 1;
4956 __kmp_nested_proc_bind.bind_types[0] = proc_bind_default;
4963 for ( i = 0; i < block.count; ++ i ) {
4964 __kmp_stg_parse( block.vars[ i ].name, block.vars[ i ].value );
4970 if ( ! __kmp_init_user_locks ) {
4971 if ( __kmp_user_lock_kind == lk_default ) {
4972 __kmp_user_lock_kind = lk_queuing;
4974 __kmp_set_user_lock_vptrs( __kmp_user_lock_kind );
4977 KMP_DEBUG_ASSERT(
string != NULL);
4978 KMP_DEBUG_ASSERT( __kmp_user_lock_kind != lk_default );
4981 #if KMP_OS_LINUX || KMP_OS_WINDOWS
4982 if ( ! TCR_4(__kmp_init_middle) ) {
4987 const char *var =
"KMP_AFFINITY";
4988 if ( __kmp_affinity_type == affinity_disabled ) {
4989 __kmp_affin_mask_size = 0;
4991 else if ( ! KMP_AFFINITY_CAPABLE() ) {
4992 __kmp_affinity_determine_capable( var );
4993 if ( ! KMP_AFFINITY_CAPABLE() ) {
4994 if ( __kmp_affinity_verbose || ( __kmp_affinity_warnings
4995 && ( __kmp_affinity_type != affinity_default )
4996 && ( __kmp_affinity_type != affinity_none )
4997 && ( __kmp_affinity_type != affinity_disabled ) ) ) {
4998 KMP_WARNING( AffNotSupported, var );
5000 __kmp_affinity_type = affinity_disabled;
5001 __kmp_affinity_respect_mask = 0;
5002 __kmp_affinity_gran = affinity_gran_fine;
5008 if ( __kmp_affinity_type == affinity_disabled ) {
5009 __kmp_nested_proc_bind.bind_types[0] = proc_bind_disabled;
5011 else if ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_default ) {
5016 # if KMP_OS_WINDOWS || KMP_OS_LINUX
5017 __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
5019 __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
5028 if ( __kmp_nested_proc_bind.bind_types[0] == proc_bind_intel ) {
5029 if ( ( __kmp_affinity_type == affinity_none )
5031 || ( __kmp_affinity_type == affinity_default )
5034 __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
5037 else if ( ( __kmp_nested_proc_bind.bind_types[0] != proc_bind_false )
5038 && ( __kmp_nested_proc_bind.bind_types[0] != proc_bind_disabled ) ) {
5039 if ( __kmp_affinity_type == affinity_default ) {
5040 __kmp_affinity_type = affinity_compact;
5041 __kmp_affinity_dups = FALSE;
5043 if ( __kmp_affinity_gran == affinity_gran_default ) {
5044 __kmp_affinity_gran = affinity_gran_fine;
5047 # endif // OMP_40_ENABLED
5049 if ( KMP_AFFINITY_CAPABLE() ) {
5051 # if KMP_OS_WINDOWS && KMP_ARCH_X86_64
5053 if ( __kmp_num_proc_groups > 1 ) {
5054 if ( __kmp_affinity_respect_mask == affinity_respect_mask_default ) {
5055 __kmp_affinity_respect_mask = FALSE;
5058 if ( ( __kmp_affinity_type == affinity_default )
5059 || ( __kmp_affinity_type == affinity_none ) ) {
5060 if ( __kmp_affinity_type == affinity_none ) {
5061 if ( __kmp_affinity_verbose || ( __kmp_affinity_warnings
5062 && ( __kmp_affinity_type != affinity_none ) ) ) {
5063 KMP_WARNING( AffTypeCantUseMultGroups,
"none",
"compact" );
5066 __kmp_affinity_type = affinity_compact;
5067 if ( __kmp_affinity_top_method == affinity_top_method_default ) {
5068 __kmp_affinity_top_method = affinity_top_method_group;
5071 else if ( __kmp_affinity_top_method == affinity_top_method_default ) {
5072 __kmp_affinity_top_method = affinity_top_method_all;
5075 if ( __kmp_affinity_gran_levels < 0 ) {
5076 if ( __kmp_affinity_top_method == affinity_top_method_group ) {
5077 if ( __kmp_affinity_gran == affinity_gran_default ) {
5078 __kmp_affinity_gran = affinity_gran_group;
5080 else if ( __kmp_affinity_gran == affinity_gran_core ) {
5081 if ( __kmp_affinity_verbose || ( __kmp_affinity_warnings
5082 && ( __kmp_affinity_type != affinity_none ) ) ) {
5083 KMP_WARNING( AffGranCantUseMultGroups,
"core",
"thread" );
5085 __kmp_affinity_gran = affinity_gran_thread;
5087 else if ( __kmp_affinity_gran == affinity_gran_package ) {
5088 if ( __kmp_affinity_verbose || ( __kmp_affinity_warnings
5089 && ( __kmp_affinity_type != affinity_none ) ) ) {
5090 KMP_WARNING( AffGranCantUseMultGroups,
"package",
"group" );
5092 __kmp_affinity_gran = affinity_gran_group;
5094 else if ( __kmp_affinity_gran == affinity_gran_node ) {
5095 if ( __kmp_affinity_verbose || ( __kmp_affinity_warnings
5096 && ( __kmp_affinity_type != affinity_none ) ) ) {
5097 KMP_WARNING( AffGranCantUseMultGroups,
"node",
"group" );
5099 __kmp_affinity_gran = affinity_gran_group;
5102 else if ( __kmp_affinity_gran == affinity_gran_default ) {
5103 __kmp_affinity_gran = affinity_gran_core;
5111 if ( __kmp_affinity_respect_mask == affinity_respect_mask_default ) {
5112 __kmp_affinity_respect_mask = TRUE;
5114 if ( __kmp_affinity_type == affinity_default ) {
5116 __kmp_affinity_type = affinity_scatter;
5118 __kmp_affinity_type = affinity_none;
5121 if ( ( __kmp_affinity_gran == affinity_gran_default )
5122 && ( __kmp_affinity_gran_levels < 0 ) ) {
5124 __kmp_affinity_gran = affinity_gran_fine;
5126 __kmp_affinity_gran = affinity_gran_core;
5129 if ( __kmp_affinity_top_method == affinity_top_method_default ) {
5130 __kmp_affinity_top_method = affinity_top_method_all;
5135 K_DIAG( 1, (
"__kmp_affinity_type == %d\n", __kmp_affinity_type ) );
5136 K_DIAG( 1, (
"__kmp_affinity_compact == %d\n", __kmp_affinity_compact ) );
5137 K_DIAG( 1, (
"__kmp_affinity_offset == %d\n", __kmp_affinity_offset ) );
5138 K_DIAG( 1, (
"__kmp_affinity_verbose == %d\n", __kmp_affinity_verbose ) );
5139 K_DIAG( 1, (
"__kmp_affinity_warnings == %d\n", __kmp_affinity_warnings ) );
5140 K_DIAG( 1, (
"__kmp_affinity_respect_mask == %d\n", __kmp_affinity_respect_mask ) );
5141 K_DIAG( 1, (
"__kmp_affinity_gran == %d\n", __kmp_affinity_gran ) );
5143 KMP_DEBUG_ASSERT( __kmp_affinity_type != affinity_default);
5145 KMP_DEBUG_ASSERT( __kmp_nested_proc_bind.bind_types[0]
5146 != proc_bind_default );
5153 #error "Unknown or unsupported OS"
5156 if ( __kmp_version ) {
5157 __kmp_print_version_1();
5161 if (
string != NULL) {
5162 __kmp_aux_env_initialize( &block );
5165 __kmp_env_blk_free( & block );
5175 kmp_env_blk_t block;
5177 kmp_str_buf_t buffer;
5180 __kmp_str_buf_init( & buffer );
5182 __kmp_env_blk_init( & block, NULL );
5183 __kmp_env_blk_sort( & block );
5186 __kmp_str_buf_print( & buffer,
"\n%s\n\n", KMP_I18N_STR( UserSettings ) );
5187 for ( i = 0; i < block.count; ++ i ) {
5188 char const * name = block.vars[ i ].name;
5189 char const * value = block.vars[ i ].value;
5193 ( strncmp( name,
"KMP_", 4 ) == 0 ) || strncmp( name,
"OMP_", 4 ) == 0
5194 #ifdef KMP_GOMP_COMPAT
5195 || strncmp( name,
"GOMP_", 5 ) == 0
5198 __kmp_str_buf_print( & buffer,
" %s=%s\n", name, value );
5201 __kmp_str_buf_print( & buffer,
"\n" );
5204 __kmp_str_buf_print( & buffer,
"%s\n\n", KMP_I18N_STR( EffectiveSettings ) );
5205 for (
int i = 0; i < __kmp_stg_count; ++ i ) {
5206 if ( __kmp_stg_table[ i ].print != NULL ) {
5207 __kmp_stg_table[ i ].print( & buffer, __kmp_stg_table[ i ].name, __kmp_stg_table[ i ].data );
5211 __kmp_printf(
"%s", buffer.str );
5213 __kmp_env_blk_free( & block );
5214 __kmp_str_buf_free( & buffer );
5223 __kmp_env_print_2() {
5225 kmp_env_blk_t block;
5227 kmp_str_buf_t buffer;
5229 __kmp_env_format = 1;
5232 __kmp_str_buf_init( & buffer );
5234 __kmp_env_blk_init( & block, NULL );
5235 __kmp_env_blk_sort( & block );
5237 __kmp_str_buf_print( & buffer,
"\n%s\n", KMP_I18N_STR( DisplayEnvBegin ) );
5238 __kmp_str_buf_print( & buffer,
" _OPENMP='%d'\n", __kmp_openmp_version );
5240 for (
int i = 0; i < __kmp_stg_count; ++ i ) {
5241 if ( __kmp_stg_table[ i ].print != NULL &&
5242 ( ( __kmp_display_env && strncmp( __kmp_stg_table[ i ].name,
"OMP_", 4 ) == 0 ) || __kmp_display_env_verbose ) ) {
5243 __kmp_stg_table[ i ].print( & buffer, __kmp_stg_table[ i ].name, __kmp_stg_table[ i ].data );
5247 __kmp_str_buf_print( & buffer,
"%s\n", KMP_I18N_STR( DisplayEnvEnd ) );
5248 __kmp_str_buf_print( & buffer,
"\n" );
5250 __kmp_printf(
"%s", buffer.str );
5252 __kmp_env_blk_free( & block );
5253 __kmp_str_buf_free( & buffer );
5258 #endif // OMP_40_ENABLED