Mercurial > hg > CbC > CbC_gcc
annotate libgomp/env.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 145 | 1 /* Copyright (C) 2005-2020 Free Software Foundation, Inc. |
| 0 | 2 Contributed by Richard Henderson <rth@redhat.com>. |
| 3 | |
| 111 | 4 This file is part of the GNU Offloading and Multi Processing Library |
| 5 (libgomp). | |
| 0 | 6 |
| 7 Libgomp is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by | |
| 9 the Free Software Foundation; either version 3, or (at your option) | |
| 10 any later version. | |
| 11 | |
| 12 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | |
| 14 FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
| 15 more details. | |
| 16 | |
| 17 Under Section 7 of GPL version 3, you are granted additional | |
| 18 permissions described in the GCC Runtime Library Exception, version | |
| 19 3.1, as published by the Free Software Foundation. | |
| 20 | |
| 21 You should have received a copy of the GNU General Public License and | |
| 22 a copy of the GCC Runtime Library Exception along with this program; | |
| 23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
| 24 <http://www.gnu.org/licenses/>. */ | |
| 25 | |
| 111 | 26 /* This file defines the OpenMP internal control variables and arranges |
| 0 | 27 for them to be initialized from environment variables at startup. */ |
| 28 | |
| 111 | 29 #define _GNU_SOURCE |
| 0 | 30 #include "libgomp.h" |
| 111 | 31 #include "gomp-constants.h" |
| 32 #include <limits.h> | |
| 33 #ifndef LIBGOMP_OFFLOADED_ONLY | |
| 0 | 34 #include "libgomp_f.h" |
| 111 | 35 #include "oacc-int.h" |
| 0 | 36 #include <ctype.h> |
| 37 #include <stdlib.h> | |
| 111 | 38 #include <stdio.h> |
| 39 #ifdef HAVE_INTTYPES_H | |
| 40 # include <inttypes.h> /* For PRIu64. */ | |
| 41 #endif | |
| 0 | 42 #ifdef STRING_WITH_STRINGS |
| 43 # include <string.h> | |
| 44 # include <strings.h> | |
| 45 #else | |
| 46 # ifdef HAVE_STRING_H | |
| 47 # include <string.h> | |
| 48 # else | |
| 49 # ifdef HAVE_STRINGS_H | |
| 50 # include <strings.h> | |
| 51 # endif | |
| 52 # endif | |
| 53 #endif | |
| 54 #include <errno.h> | |
| 111 | 55 #include "thread-stacksize.h" |
| 0 | 56 |
| 57 #ifndef HAVE_STRTOULL | |
| 58 # define strtoull(ptr, eptr, base) strtoul (ptr, eptr, base) | |
| 59 #endif | |
| 111 | 60 #endif /* LIBGOMP_OFFLOADED_ONLY */ |
| 61 | |
| 62 #include "secure_getenv.h" | |
| 0 | 63 |
| 64 struct gomp_task_icv gomp_global_icv = { | |
| 65 .nthreads_var = 1, | |
| 111 | 66 .thread_limit_var = UINT_MAX, |
| 0 | 67 .run_sched_var = GFS_DYNAMIC, |
| 111 | 68 .run_sched_chunk_size = 1, |
| 69 .default_device_var = 0, | |
| 0 | 70 .dyn_var = false, |
| 111 | 71 .nest_var = false, |
| 72 .bind_var = omp_proc_bind_false, | |
| 73 .target_data = NULL | |
| 0 | 74 }; |
| 75 | |
| 76 unsigned long gomp_max_active_levels_var = INT_MAX; | |
| 111 | 77 bool gomp_cancel_var = false; |
| 78 int gomp_max_task_priority_var = 0; | |
| 0 | 79 #ifndef HAVE_SYNC_BUILTINS |
| 111 | 80 gomp_mutex_t gomp_managed_threads_lock; |
| 0 | 81 #endif |
| 82 unsigned long gomp_available_cpus = 1, gomp_managed_threads = 1; | |
| 83 unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var; | |
| 111 | 84 unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len; |
| 85 char *gomp_bind_var_list; | |
| 86 unsigned long gomp_bind_var_list_len; | |
| 87 void **gomp_places_list; | |
| 88 unsigned long gomp_places_list_len; | |
| 89 int gomp_debug_var; | |
| 90 unsigned int gomp_num_teams_var; | |
| 145 | 91 bool gomp_display_affinity_var; |
| 92 char *gomp_affinity_format_var = "level %L thread %i affinity %A"; | |
| 93 size_t gomp_affinity_format_len; | |
| 111 | 94 char *goacc_device_type; |
| 95 int goacc_device_num; | |
| 131 | 96 int goacc_default_dims[GOMP_DIM_MAX]; |
| 111 | 97 |
| 98 #ifndef LIBGOMP_OFFLOADED_ONLY | |
| 0 | 99 |
| 100 /* Parse the OMP_SCHEDULE environment variable. */ | |
| 101 | |
| 102 static void | |
| 103 parse_schedule (void) | |
| 104 { | |
| 105 char *env, *end; | |
| 106 unsigned long value; | |
| 145 | 107 int monotonic = 0; |
| 0 | 108 |
| 109 env = getenv ("OMP_SCHEDULE"); | |
| 110 if (env == NULL) | |
| 111 return; | |
| 112 | |
| 113 while (isspace ((unsigned char) *env)) | |
| 114 ++env; | |
| 145 | 115 if (strncasecmp (env, "monotonic", 9) == 0) |
| 116 { | |
| 117 monotonic = 1; | |
| 118 env += 9; | |
| 119 } | |
| 120 else if (strncasecmp (env, "nonmonotonic", 12) == 0) | |
| 121 { | |
| 122 monotonic = -1; | |
| 123 env += 12; | |
| 124 } | |
| 125 if (monotonic) | |
| 126 { | |
| 127 while (isspace ((unsigned char) *env)) | |
| 128 ++env; | |
| 129 if (*env != ':') | |
| 130 goto unknown; | |
| 131 ++env; | |
| 132 while (isspace ((unsigned char) *env)) | |
| 133 ++env; | |
| 134 } | |
| 0 | 135 if (strncasecmp (env, "static", 6) == 0) |
| 136 { | |
| 137 gomp_global_icv.run_sched_var = GFS_STATIC; | |
| 138 env += 6; | |
| 139 } | |
| 140 else if (strncasecmp (env, "dynamic", 7) == 0) | |
| 141 { | |
| 142 gomp_global_icv.run_sched_var = GFS_DYNAMIC; | |
| 143 env += 7; | |
| 144 } | |
| 145 else if (strncasecmp (env, "guided", 6) == 0) | |
| 146 { | |
| 147 gomp_global_icv.run_sched_var = GFS_GUIDED; | |
| 148 env += 6; | |
| 149 } | |
| 150 else if (strncasecmp (env, "auto", 4) == 0) | |
| 151 { | |
| 152 gomp_global_icv.run_sched_var = GFS_AUTO; | |
| 153 env += 4; | |
| 154 } | |
| 155 else | |
| 156 goto unknown; | |
| 157 | |
| 145 | 158 if (monotonic == 1 |
| 159 || (monotonic == 0 && gomp_global_icv.run_sched_var == GFS_STATIC)) | |
| 160 gomp_global_icv.run_sched_var |= GFS_MONOTONIC; | |
| 161 | |
| 0 | 162 while (isspace ((unsigned char) *env)) |
| 163 ++env; | |
| 164 if (*env == '\0') | |
| 111 | 165 { |
| 166 gomp_global_icv.run_sched_chunk_size | |
| 145 | 167 = (gomp_global_icv.run_sched_var & ~GFS_MONOTONIC) != GFS_STATIC; |
| 111 | 168 return; |
| 169 } | |
| 0 | 170 if (*env++ != ',') |
| 171 goto unknown; | |
| 172 while (isspace ((unsigned char) *env)) | |
| 173 ++env; | |
| 174 if (*env == '\0') | |
| 175 goto invalid; | |
| 176 | |
| 177 errno = 0; | |
| 178 value = strtoul (env, &end, 10); | |
| 179 if (errno) | |
| 180 goto invalid; | |
| 181 | |
| 182 while (isspace ((unsigned char) *end)) | |
| 183 ++end; | |
| 184 if (*end != '\0') | |
| 185 goto invalid; | |
| 186 | |
| 187 if ((int)value != value) | |
| 188 goto invalid; | |
| 189 | |
| 145 | 190 if (value == 0 |
| 191 && (gomp_global_icv.run_sched_var & ~GFS_MONOTONIC) != GFS_STATIC) | |
| 111 | 192 value = 1; |
| 193 gomp_global_icv.run_sched_chunk_size = value; | |
| 0 | 194 return; |
| 195 | |
| 196 unknown: | |
| 197 gomp_error ("Unknown value for environment variable OMP_SCHEDULE"); | |
| 198 return; | |
| 199 | |
| 200 invalid: | |
| 201 gomp_error ("Invalid value for chunk size in " | |
| 202 "environment variable OMP_SCHEDULE"); | |
| 203 return; | |
| 204 } | |
| 205 | |
| 206 /* Parse an unsigned long environment variable. Return true if one was | |
| 111 | 207 present and it was successfully parsed. If SECURE, use secure_getenv to the |
| 208 environment variable. */ | |
| 0 | 209 |
| 210 static bool | |
| 111 | 211 parse_unsigned_long_1 (const char *name, unsigned long *pvalue, bool allow_zero, |
| 212 bool secure) | |
| 0 | 213 { |
| 214 char *env, *end; | |
| 215 unsigned long value; | |
| 216 | |
| 111 | 217 env = (secure ? secure_getenv (name) : getenv (name)); |
| 0 | 218 if (env == NULL) |
| 219 return false; | |
| 220 | |
| 221 while (isspace ((unsigned char) *env)) | |
| 222 ++env; | |
| 223 if (*env == '\0') | |
| 224 goto invalid; | |
| 225 | |
| 226 errno = 0; | |
| 227 value = strtoul (env, &end, 10); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
228 if (errno || (long) value <= 0 - allow_zero) |
| 0 | 229 goto invalid; |
| 230 | |
| 231 while (isspace ((unsigned char) *end)) | |
| 232 ++end; | |
| 233 if (*end != '\0') | |
| 234 goto invalid; | |
| 235 | |
| 236 *pvalue = value; | |
| 237 return true; | |
| 238 | |
| 239 invalid: | |
| 240 gomp_error ("Invalid value for environment variable %s", name); | |
| 241 return false; | |
| 242 } | |
| 243 | |
| 111 | 244 /* As parse_unsigned_long_1, but always use getenv. */ |
| 245 | |
| 246 static bool | |
| 247 parse_unsigned_long (const char *name, unsigned long *pvalue, bool allow_zero) | |
| 248 { | |
| 249 return parse_unsigned_long_1 (name, pvalue, allow_zero, false); | |
| 250 } | |
| 251 | |
| 252 /* Parse a positive int environment variable. Return true if one was | |
| 253 present and it was successfully parsed. If SECURE, use secure_getenv to the | |
| 254 environment variable. */ | |
| 255 | |
| 256 static bool | |
| 257 parse_int_1 (const char *name, int *pvalue, bool allow_zero, bool secure) | |
| 258 { | |
| 259 unsigned long value; | |
| 260 if (!parse_unsigned_long_1 (name, &value, allow_zero, secure)) | |
| 261 return false; | |
| 262 if (value > INT_MAX) | |
| 263 { | |
| 264 gomp_error ("Invalid value for environment variable %s", name); | |
| 265 return false; | |
| 266 } | |
| 267 *pvalue = (int) value; | |
| 268 return true; | |
| 269 } | |
| 270 | |
| 271 /* As parse_int_1, but use getenv. */ | |
| 272 | |
| 273 static bool | |
| 274 parse_int (const char *name, int *pvalue, bool allow_zero) | |
| 275 { | |
| 276 return parse_int_1 (name, pvalue, allow_zero, false); | |
| 277 } | |
| 278 | |
| 279 /* As parse_int_1, but use getenv_secure. */ | |
| 280 | |
| 281 static bool | |
| 282 parse_int_secure (const char *name, int *pvalue, bool allow_zero) | |
| 283 { | |
| 284 return parse_int_1 (name, pvalue, allow_zero, true); | |
| 285 } | |
| 286 | |
| 287 /* Parse an unsigned long list environment variable. Return true if one was | |
| 288 present and it was successfully parsed. */ | |
| 289 | |
| 290 static bool | |
| 291 parse_unsigned_long_list (const char *name, unsigned long *p1stvalue, | |
| 292 unsigned long **pvalues, | |
| 293 unsigned long *pnvalues) | |
| 294 { | |
| 295 char *env, *end; | |
| 296 unsigned long value, *values = NULL; | |
| 297 | |
| 298 env = getenv (name); | |
| 299 if (env == NULL) | |
| 300 return false; | |
| 301 | |
| 302 while (isspace ((unsigned char) *env)) | |
| 303 ++env; | |
| 304 if (*env == '\0') | |
| 305 goto invalid; | |
| 306 | |
| 307 errno = 0; | |
| 308 value = strtoul (env, &end, 10); | |
| 309 if (errno || (long) value <= 0) | |
| 310 goto invalid; | |
| 311 | |
| 312 while (isspace ((unsigned char) *end)) | |
| 313 ++end; | |
| 314 if (*end != '\0') | |
| 315 { | |
| 316 if (*end == ',') | |
| 317 { | |
| 318 unsigned long nvalues = 0, nalloced = 0; | |
| 319 | |
| 320 do | |
| 321 { | |
| 322 env = end + 1; | |
| 323 if (nvalues == nalloced) | |
| 324 { | |
| 325 unsigned long *n; | |
| 326 nalloced = nalloced ? nalloced * 2 : 16; | |
| 327 n = realloc (values, nalloced * sizeof (unsigned long)); | |
| 328 if (n == NULL) | |
| 329 { | |
| 330 free (values); | |
| 331 gomp_error ("Out of memory while trying to parse" | |
| 332 " environment variable %s", name); | |
| 333 return false; | |
| 334 } | |
| 335 values = n; | |
| 336 if (nvalues == 0) | |
| 337 values[nvalues++] = value; | |
| 338 } | |
| 339 | |
| 340 while (isspace ((unsigned char) *env)) | |
| 341 ++env; | |
| 342 if (*env == '\0') | |
| 343 goto invalid; | |
| 344 | |
| 345 errno = 0; | |
| 346 value = strtoul (env, &end, 10); | |
| 347 if (errno || (long) value <= 0) | |
| 348 goto invalid; | |
| 349 | |
| 350 values[nvalues++] = value; | |
| 351 while (isspace ((unsigned char) *end)) | |
| 352 ++end; | |
| 353 if (*end == '\0') | |
| 354 break; | |
| 355 if (*end != ',') | |
| 356 goto invalid; | |
| 357 } | |
| 358 while (1); | |
| 359 *p1stvalue = values[0]; | |
| 360 *pvalues = values; | |
| 361 *pnvalues = nvalues; | |
| 362 return true; | |
| 363 } | |
| 364 goto invalid; | |
| 365 } | |
| 366 | |
| 367 *p1stvalue = value; | |
| 368 return true; | |
| 369 | |
| 370 invalid: | |
| 371 free (values); | |
| 372 gomp_error ("Invalid value for environment variable %s", name); | |
| 373 return false; | |
| 374 } | |
| 375 | |
| 376 /* Parse environment variable set to a boolean or list of omp_proc_bind_t | |
| 377 enum values. Return true if one was present and it was successfully | |
| 378 parsed. */ | |
| 379 | |
| 380 static bool | |
| 381 parse_bind_var (const char *name, char *p1stvalue, | |
| 382 char **pvalues, unsigned long *pnvalues) | |
| 383 { | |
| 384 char *env; | |
| 385 char value = omp_proc_bind_false, *values = NULL; | |
| 386 int i; | |
| 387 static struct proc_bind_kinds | |
| 388 { | |
| 389 const char name[7]; | |
| 390 const char len; | |
| 391 omp_proc_bind_t kind; | |
| 392 } kinds[] = | |
| 393 { | |
| 394 { "false", 5, omp_proc_bind_false }, | |
| 395 { "true", 4, omp_proc_bind_true }, | |
| 396 { "master", 6, omp_proc_bind_master }, | |
| 397 { "close", 5, omp_proc_bind_close }, | |
| 398 { "spread", 6, omp_proc_bind_spread } | |
| 399 }; | |
| 400 | |
| 401 env = getenv (name); | |
| 402 if (env == NULL) | |
| 403 return false; | |
| 404 | |
| 405 while (isspace ((unsigned char) *env)) | |
| 406 ++env; | |
| 407 if (*env == '\0') | |
| 408 goto invalid; | |
| 409 | |
| 410 for (i = 0; i < 5; i++) | |
| 411 if (strncasecmp (env, kinds[i].name, kinds[i].len) == 0) | |
| 412 { | |
| 413 value = kinds[i].kind; | |
| 414 env += kinds[i].len; | |
| 415 break; | |
| 416 } | |
| 417 if (i == 5) | |
| 418 goto invalid; | |
| 419 | |
| 420 while (isspace ((unsigned char) *env)) | |
| 421 ++env; | |
| 422 if (*env != '\0') | |
| 423 { | |
| 424 if (*env == ',') | |
| 425 { | |
| 426 unsigned long nvalues = 0, nalloced = 0; | |
| 427 | |
| 428 if (value == omp_proc_bind_false | |
| 429 || value == omp_proc_bind_true) | |
| 430 goto invalid; | |
| 431 | |
| 432 do | |
| 433 { | |
| 434 env++; | |
| 435 if (nvalues == nalloced) | |
| 436 { | |
| 437 char *n; | |
| 438 nalloced = nalloced ? nalloced * 2 : 16; | |
| 439 n = realloc (values, nalloced); | |
| 440 if (n == NULL) | |
| 441 { | |
| 442 free (values); | |
| 443 gomp_error ("Out of memory while trying to parse" | |
| 444 " environment variable %s", name); | |
| 445 return false; | |
| 446 } | |
| 447 values = n; | |
| 448 if (nvalues == 0) | |
| 449 values[nvalues++] = value; | |
| 450 } | |
| 451 | |
| 452 while (isspace ((unsigned char) *env)) | |
| 453 ++env; | |
| 454 if (*env == '\0') | |
| 455 goto invalid; | |
| 456 | |
| 457 for (i = 2; i < 5; i++) | |
| 458 if (strncasecmp (env, kinds[i].name, kinds[i].len) == 0) | |
| 459 { | |
| 460 value = kinds[i].kind; | |
| 461 env += kinds[i].len; | |
| 462 break; | |
| 463 } | |
| 464 if (i == 5) | |
| 465 goto invalid; | |
| 466 | |
| 467 values[nvalues++] = value; | |
| 468 while (isspace ((unsigned char) *env)) | |
| 469 ++env; | |
| 470 if (*env == '\0') | |
| 471 break; | |
| 472 if (*env != ',') | |
| 473 goto invalid; | |
| 474 } | |
| 475 while (1); | |
| 476 *p1stvalue = values[0]; | |
| 477 *pvalues = values; | |
| 478 *pnvalues = nvalues; | |
| 479 return true; | |
| 480 } | |
| 481 goto invalid; | |
| 482 } | |
| 483 | |
| 484 *p1stvalue = value; | |
| 485 return true; | |
| 486 | |
| 487 invalid: | |
| 488 free (values); | |
| 489 gomp_error ("Invalid value for environment variable %s", name); | |
| 490 return false; | |
| 491 } | |
| 492 | |
| 493 static bool | |
| 494 parse_one_place (char **envp, bool *negatep, unsigned long *lenp, | |
| 495 long *stridep) | |
| 496 { | |
| 497 char *env = *envp, *start; | |
| 498 void *p = gomp_places_list ? gomp_places_list[gomp_places_list_len] : NULL; | |
| 499 unsigned long len = 1; | |
| 500 long stride = 1; | |
| 501 int pass; | |
| 502 bool any_negate = false; | |
| 503 *negatep = false; | |
| 504 while (isspace ((unsigned char) *env)) | |
| 505 ++env; | |
| 506 if (*env == '!') | |
| 507 { | |
| 508 *negatep = true; | |
| 509 ++env; | |
| 510 while (isspace ((unsigned char) *env)) | |
| 511 ++env; | |
| 512 } | |
| 513 if (*env != '{') | |
| 514 return false; | |
| 515 ++env; | |
| 516 while (isspace ((unsigned char) *env)) | |
| 517 ++env; | |
| 518 start = env; | |
| 519 for (pass = 0; pass < (any_negate ? 2 : 1); pass++) | |
| 520 { | |
| 521 env = start; | |
| 522 do | |
| 523 { | |
| 524 unsigned long this_num, this_len = 1; | |
| 525 long this_stride = 1; | |
| 526 bool this_negate = (*env == '!'); | |
| 527 if (this_negate) | |
| 528 { | |
| 529 if (gomp_places_list) | |
| 530 any_negate = true; | |
| 531 ++env; | |
| 532 while (isspace ((unsigned char) *env)) | |
| 533 ++env; | |
| 534 } | |
| 535 | |
| 536 errno = 0; | |
| 537 this_num = strtoul (env, &env, 10); | |
| 538 if (errno) | |
| 539 return false; | |
| 540 while (isspace ((unsigned char) *env)) | |
| 541 ++env; | |
| 542 if (*env == ':') | |
| 543 { | |
| 544 ++env; | |
| 545 while (isspace ((unsigned char) *env)) | |
| 546 ++env; | |
| 547 errno = 0; | |
| 548 this_len = strtoul (env, &env, 10); | |
| 549 if (errno || this_len == 0) | |
| 550 return false; | |
| 551 while (isspace ((unsigned char) *env)) | |
| 552 ++env; | |
| 553 if (*env == ':') | |
| 554 { | |
| 555 ++env; | |
| 556 while (isspace ((unsigned char) *env)) | |
| 557 ++env; | |
| 558 errno = 0; | |
| 559 this_stride = strtol (env, &env, 10); | |
| 560 if (errno) | |
| 561 return false; | |
| 562 while (isspace ((unsigned char) *env)) | |
| 563 ++env; | |
| 564 } | |
| 565 } | |
| 566 if (this_negate && this_len != 1) | |
| 567 return false; | |
| 568 if (gomp_places_list && pass == this_negate) | |
| 569 { | |
| 570 if (this_negate) | |
| 571 { | |
| 572 if (!gomp_affinity_remove_cpu (p, this_num)) | |
| 573 return false; | |
| 574 } | |
| 575 else if (!gomp_affinity_add_cpus (p, this_num, this_len, | |
| 576 this_stride, false)) | |
| 577 return false; | |
| 578 } | |
| 579 if (*env == '}') | |
| 580 break; | |
| 581 if (*env != ',') | |
| 582 return false; | |
| 583 ++env; | |
| 584 } | |
| 585 while (1); | |
| 586 } | |
| 587 | |
| 588 ++env; | |
| 589 while (isspace ((unsigned char) *env)) | |
| 590 ++env; | |
| 591 if (*env == ':') | |
| 592 { | |
| 593 ++env; | |
| 594 while (isspace ((unsigned char) *env)) | |
| 595 ++env; | |
| 596 errno = 0; | |
| 597 len = strtoul (env, &env, 10); | |
| 598 if (errno || len == 0 || len >= 65536) | |
| 599 return false; | |
| 600 while (isspace ((unsigned char) *env)) | |
| 601 ++env; | |
| 602 if (*env == ':') | |
| 603 { | |
| 604 ++env; | |
| 605 while (isspace ((unsigned char) *env)) | |
| 606 ++env; | |
| 607 errno = 0; | |
| 608 stride = strtol (env, &env, 10); | |
| 609 if (errno) | |
| 610 return false; | |
| 611 while (isspace ((unsigned char) *env)) | |
| 612 ++env; | |
| 613 } | |
| 614 } | |
| 615 if (*negatep && len != 1) | |
| 616 return false; | |
| 617 *envp = env; | |
| 618 *lenp = len; | |
| 619 *stridep = stride; | |
| 620 return true; | |
| 621 } | |
| 622 | |
| 623 static bool | |
| 624 parse_places_var (const char *name, bool ignore) | |
| 625 { | |
| 626 char *env = getenv (name), *end; | |
| 627 bool any_negate = false; | |
| 628 int level = 0; | |
| 629 unsigned long count = 0; | |
| 630 if (env == NULL) | |
| 631 return false; | |
| 632 | |
| 633 while (isspace ((unsigned char) *env)) | |
| 634 ++env; | |
| 635 if (*env == '\0') | |
| 636 goto invalid; | |
| 637 | |
| 638 if (strncasecmp (env, "threads", 7) == 0) | |
| 639 { | |
| 640 env += 7; | |
| 641 level = 1; | |
| 642 } | |
| 643 else if (strncasecmp (env, "cores", 5) == 0) | |
| 644 { | |
| 645 env += 5; | |
| 646 level = 2; | |
| 647 } | |
| 648 else if (strncasecmp (env, "sockets", 7) == 0) | |
| 649 { | |
| 650 env += 7; | |
| 651 level = 3; | |
| 652 } | |
| 653 if (level) | |
| 654 { | |
| 655 count = ULONG_MAX; | |
| 656 while (isspace ((unsigned char) *env)) | |
| 657 ++env; | |
| 658 if (*env != '\0') | |
| 659 { | |
| 660 if (*env++ != '(') | |
| 661 goto invalid; | |
| 662 while (isspace ((unsigned char) *env)) | |
| 663 ++env; | |
| 664 | |
| 665 errno = 0; | |
| 666 count = strtoul (env, &end, 10); | |
| 667 if (errno) | |
| 668 goto invalid; | |
| 669 env = end; | |
| 670 while (isspace ((unsigned char) *env)) | |
| 671 ++env; | |
| 672 if (*env != ')') | |
| 673 goto invalid; | |
| 674 ++env; | |
| 675 while (isspace ((unsigned char) *env)) | |
| 676 ++env; | |
| 677 if (*env != '\0') | |
| 678 goto invalid; | |
| 679 } | |
| 680 | |
| 681 if (ignore) | |
| 682 return false; | |
| 683 | |
| 684 return gomp_affinity_init_level (level, count, false); | |
| 685 } | |
| 686 | |
| 687 count = 0; | |
| 688 end = env; | |
| 689 do | |
| 690 { | |
| 691 bool negate; | |
| 692 unsigned long len; | |
| 693 long stride; | |
| 694 if (!parse_one_place (&end, &negate, &len, &stride)) | |
| 695 goto invalid; | |
| 696 if (negate) | |
| 697 { | |
| 698 if (!any_negate) | |
| 699 count++; | |
| 700 any_negate = true; | |
| 701 } | |
| 702 else | |
| 703 count += len; | |
| 704 if (count > 65536) | |
| 705 goto invalid; | |
| 706 if (*end == '\0') | |
| 707 break; | |
| 708 if (*end != ',') | |
| 709 goto invalid; | |
| 710 end++; | |
| 711 } | |
| 712 while (1); | |
| 713 | |
| 714 if (ignore) | |
| 715 return false; | |
| 716 | |
| 717 gomp_places_list_len = 0; | |
| 718 gomp_places_list = gomp_affinity_alloc (count, false); | |
| 719 if (gomp_places_list == NULL) | |
| 720 return false; | |
| 721 | |
| 722 do | |
| 723 { | |
| 724 bool negate; | |
| 725 unsigned long len; | |
| 726 long stride; | |
| 727 gomp_affinity_init_place (gomp_places_list[gomp_places_list_len]); | |
| 728 if (!parse_one_place (&env, &negate, &len, &stride)) | |
| 729 goto invalid; | |
| 730 if (negate) | |
| 731 { | |
| 732 void *p; | |
| 733 for (count = 0; count < gomp_places_list_len; count++) | |
| 734 if (gomp_affinity_same_place | |
| 735 (gomp_places_list[count], | |
| 736 gomp_places_list[gomp_places_list_len])) | |
| 737 break; | |
| 738 if (count == gomp_places_list_len) | |
| 739 { | |
| 740 gomp_error ("Trying to remove a non-existing place from list " | |
| 741 "of places"); | |
| 742 goto invalid; | |
| 743 } | |
| 744 p = gomp_places_list[count]; | |
| 745 memmove (&gomp_places_list[count], | |
| 746 &gomp_places_list[count + 1], | |
| 747 (gomp_places_list_len - count - 1) * sizeof (void *)); | |
| 748 --gomp_places_list_len; | |
| 749 gomp_places_list[gomp_places_list_len] = p; | |
| 750 } | |
| 751 else if (len == 1) | |
| 752 ++gomp_places_list_len; | |
| 753 else | |
| 754 { | |
| 755 for (count = 0; count < len - 1; count++) | |
| 756 if (!gomp_affinity_copy_place | |
| 757 (gomp_places_list[gomp_places_list_len + count + 1], | |
| 758 gomp_places_list[gomp_places_list_len + count], | |
| 759 stride)) | |
| 760 goto invalid; | |
| 761 gomp_places_list_len += len; | |
| 762 } | |
| 763 if (*env == '\0') | |
| 764 break; | |
| 765 env++; | |
| 766 } | |
| 767 while (1); | |
| 768 | |
| 769 if (gomp_places_list_len == 0) | |
| 770 { | |
| 771 gomp_error ("All places have been removed"); | |
| 772 goto invalid; | |
| 773 } | |
| 774 if (!gomp_affinity_finalize_place_list (false)) | |
| 775 goto invalid; | |
| 776 return true; | |
| 777 | |
| 778 invalid: | |
| 779 free (gomp_places_list); | |
| 780 gomp_places_list = NULL; | |
| 781 gomp_places_list_len = 0; | |
| 782 gomp_error ("Invalid value for environment variable %s", name); | |
| 783 return false; | |
| 784 } | |
| 785 | |
| 0 | 786 /* Parse the OMP_STACKSIZE environment varible. Return true if one was |
| 787 present and it was successfully parsed. */ | |
| 788 | |
| 789 static bool | |
| 790 parse_stacksize (const char *name, unsigned long *pvalue) | |
| 791 { | |
| 792 char *env, *end; | |
| 793 unsigned long value, shift = 10; | |
| 794 | |
| 795 env = getenv (name); | |
| 796 if (env == NULL) | |
| 797 return false; | |
| 798 | |
| 799 while (isspace ((unsigned char) *env)) | |
| 800 ++env; | |
| 801 if (*env == '\0') | |
| 802 goto invalid; | |
| 803 | |
| 804 errno = 0; | |
| 805 value = strtoul (env, &end, 10); | |
| 806 if (errno) | |
| 807 goto invalid; | |
| 808 | |
| 809 while (isspace ((unsigned char) *end)) | |
| 810 ++end; | |
| 811 if (*end != '\0') | |
| 812 { | |
| 813 switch (tolower ((unsigned char) *end)) | |
| 814 { | |
| 815 case 'b': | |
| 816 shift = 0; | |
| 817 break; | |
| 818 case 'k': | |
| 819 break; | |
| 820 case 'm': | |
| 821 shift = 20; | |
| 822 break; | |
| 823 case 'g': | |
| 824 shift = 30; | |
| 825 break; | |
| 826 default: | |
| 827 goto invalid; | |
| 828 } | |
| 829 ++end; | |
| 830 while (isspace ((unsigned char) *end)) | |
| 831 ++end; | |
| 832 if (*end != '\0') | |
| 833 goto invalid; | |
| 834 } | |
| 835 | |
| 836 if (((value << shift) >> shift) != value) | |
| 837 goto invalid; | |
| 838 | |
| 839 *pvalue = value << shift; | |
| 840 return true; | |
| 841 | |
| 842 invalid: | |
| 843 gomp_error ("Invalid value for environment variable %s", name); | |
| 844 return false; | |
| 845 } | |
| 846 | |
| 847 /* Parse the GOMP_SPINCOUNT environment varible. Return true if one was | |
| 848 present and it was successfully parsed. */ | |
| 849 | |
| 850 static bool | |
| 851 parse_spincount (const char *name, unsigned long long *pvalue) | |
| 852 { | |
| 853 char *env, *end; | |
| 854 unsigned long long value, mult = 1; | |
| 855 | |
| 856 env = getenv (name); | |
| 857 if (env == NULL) | |
| 858 return false; | |
| 859 | |
| 860 while (isspace ((unsigned char) *env)) | |
| 861 ++env; | |
| 862 if (*env == '\0') | |
| 863 goto invalid; | |
| 864 | |
| 865 if (strncasecmp (env, "infinite", 8) == 0 | |
| 866 || strncasecmp (env, "infinity", 8) == 0) | |
| 867 { | |
| 868 value = ~0ULL; | |
| 869 end = env + 8; | |
| 870 goto check_tail; | |
| 871 } | |
| 872 | |
| 873 errno = 0; | |
| 874 value = strtoull (env, &end, 10); | |
| 875 if (errno) | |
| 876 goto invalid; | |
| 877 | |
| 878 while (isspace ((unsigned char) *end)) | |
| 879 ++end; | |
| 880 if (*end != '\0') | |
| 881 { | |
| 882 switch (tolower ((unsigned char) *end)) | |
| 883 { | |
| 884 case 'k': | |
| 885 mult = 1000LL; | |
| 886 break; | |
| 887 case 'm': | |
| 888 mult = 1000LL * 1000LL; | |
| 889 break; | |
| 890 case 'g': | |
| 891 mult = 1000LL * 1000LL * 1000LL; | |
| 892 break; | |
| 893 case 't': | |
| 894 mult = 1000LL * 1000LL * 1000LL * 1000LL; | |
| 895 break; | |
| 896 default: | |
| 897 goto invalid; | |
| 898 } | |
| 899 ++end; | |
| 900 check_tail: | |
| 901 while (isspace ((unsigned char) *end)) | |
| 902 ++end; | |
| 903 if (*end != '\0') | |
| 904 goto invalid; | |
| 905 } | |
| 906 | |
| 907 if (value > ~0ULL / mult) | |
| 908 value = ~0ULL; | |
| 909 else | |
| 910 value *= mult; | |
| 911 | |
| 912 *pvalue = value; | |
| 913 return true; | |
| 914 | |
| 915 invalid: | |
| 916 gomp_error ("Invalid value for environment variable %s", name); | |
| 917 return false; | |
| 918 } | |
| 919 | |
| 920 /* Parse a boolean value for environment variable NAME and store the | |
| 921 result in VALUE. */ | |
| 922 | |
| 923 static void | |
| 924 parse_boolean (const char *name, bool *value) | |
| 925 { | |
| 926 const char *env; | |
| 927 | |
| 928 env = getenv (name); | |
| 929 if (env == NULL) | |
| 930 return; | |
| 931 | |
| 932 while (isspace ((unsigned char) *env)) | |
| 933 ++env; | |
| 934 if (strncasecmp (env, "true", 4) == 0) | |
| 935 { | |
| 936 *value = true; | |
| 937 env += 4; | |
| 938 } | |
| 939 else if (strncasecmp (env, "false", 5) == 0) | |
| 940 { | |
| 941 *value = false; | |
| 942 env += 5; | |
| 943 } | |
| 944 else | |
| 945 env = "X"; | |
| 946 while (isspace ((unsigned char) *env)) | |
| 947 ++env; | |
| 948 if (*env != '\0') | |
| 949 gomp_error ("Invalid value for environment variable %s", name); | |
| 950 } | |
| 951 | |
| 952 /* Parse the OMP_WAIT_POLICY environment variable and store the | |
| 953 result in gomp_active_wait_policy. */ | |
| 954 | |
| 955 static int | |
| 956 parse_wait_policy (void) | |
| 957 { | |
| 958 const char *env; | |
| 959 int ret = -1; | |
| 960 | |
| 961 env = getenv ("OMP_WAIT_POLICY"); | |
| 962 if (env == NULL) | |
| 963 return -1; | |
| 964 | |
| 965 while (isspace ((unsigned char) *env)) | |
| 966 ++env; | |
| 967 if (strncasecmp (env, "active", 6) == 0) | |
| 968 { | |
| 969 ret = 1; | |
| 970 env += 6; | |
| 971 } | |
| 972 else if (strncasecmp (env, "passive", 7) == 0) | |
| 973 { | |
| 974 ret = 0; | |
| 975 env += 7; | |
| 976 } | |
| 977 else | |
| 978 env = "X"; | |
| 979 while (isspace ((unsigned char) *env)) | |
| 980 ++env; | |
| 981 if (*env == '\0') | |
| 982 return ret; | |
| 983 gomp_error ("Invalid value for environment variable OMP_WAIT_POLICY"); | |
| 984 return -1; | |
| 985 } | |
| 986 | |
| 987 /* Parse the GOMP_CPU_AFFINITY environment varible. Return true if one was | |
| 988 present and it was successfully parsed. */ | |
| 989 | |
| 990 static bool | |
| 111 | 991 parse_affinity (bool ignore) |
| 0 | 992 { |
| 111 | 993 char *env, *end, *start; |
| 994 int pass; | |
| 0 | 995 unsigned long cpu_beg, cpu_end, cpu_stride; |
| 111 | 996 size_t count = 0, needed; |
| 0 | 997 |
| 998 env = getenv ("GOMP_CPU_AFFINITY"); | |
| 999 if (env == NULL) | |
| 1000 return false; | |
| 1001 | |
| 111 | 1002 start = env; |
| 1003 for (pass = 0; pass < 2; pass++) | |
| 0 | 1004 { |
| 111 | 1005 env = start; |
| 1006 if (pass == 1) | |
| 1007 { | |
| 1008 if (ignore) | |
| 1009 return false; | |
| 0 | 1010 |
| 111 | 1011 gomp_places_list_len = 0; |
| 1012 gomp_places_list = gomp_affinity_alloc (count, true); | |
| 1013 if (gomp_places_list == NULL) | |
| 1014 return false; | |
| 1015 } | |
| 1016 do | |
| 1017 { | |
| 1018 while (isspace ((unsigned char) *env)) | |
| 1019 ++env; | |
| 0 | 1020 |
| 111 | 1021 errno = 0; |
| 1022 cpu_beg = strtoul (env, &end, 0); | |
| 1023 if (errno || cpu_beg >= 65536) | |
| 0 | 1024 goto invalid; |
| 111 | 1025 cpu_end = cpu_beg; |
| 1026 cpu_stride = 1; | |
| 0 | 1027 |
| 1028 env = end; | |
| 111 | 1029 if (*env == '-') |
| 0 | 1030 { |
| 111 | 1031 errno = 0; |
| 1032 cpu_end = strtoul (++env, &end, 0); | |
| 1033 if (errno || cpu_end >= 65536 || cpu_end < cpu_beg) | |
| 0 | 1034 goto invalid; |
| 1035 | |
| 1036 env = end; | |
| 111 | 1037 if (*env == ':') |
| 1038 { | |
| 1039 errno = 0; | |
| 1040 cpu_stride = strtoul (++env, &end, 0); | |
| 1041 if (errno || cpu_stride == 0 || cpu_stride >= 65536) | |
| 1042 goto invalid; | |
| 0 | 1043 |
| 111 | 1044 env = end; |
| 1045 } | |
| 0 | 1046 } |
| 1047 | |
| 111 | 1048 needed = (cpu_end - cpu_beg) / cpu_stride + 1; |
| 1049 if (pass == 0) | |
| 1050 count += needed; | |
| 1051 else | |
| 1052 { | |
| 1053 while (needed--) | |
| 1054 { | |
| 1055 void *p = gomp_places_list[gomp_places_list_len]; | |
| 1056 gomp_affinity_init_place (p); | |
| 1057 if (gomp_affinity_add_cpus (p, cpu_beg, 1, 0, true)) | |
| 1058 ++gomp_places_list_len; | |
| 1059 cpu_beg += cpu_stride; | |
| 1060 } | |
| 1061 } | |
| 0 | 1062 |
| 111 | 1063 while (isspace ((unsigned char) *env)) |
| 1064 ++env; | |
| 0 | 1065 |
| 111 | 1066 if (*env == ',') |
| 1067 env++; | |
| 1068 else if (*env == '\0') | |
| 1069 break; | |
| 1070 } | |
| 1071 while (1); | |
| 0 | 1072 } |
| 1073 | |
| 111 | 1074 if (gomp_places_list_len == 0) |
| 1075 { | |
| 1076 free (gomp_places_list); | |
| 1077 gomp_places_list = NULL; | |
| 1078 return false; | |
| 1079 } | |
| 0 | 1080 return true; |
| 1081 | |
| 1082 invalid: | |
| 1083 gomp_error ("Invalid value for enviroment variable GOMP_CPU_AFFINITY"); | |
| 1084 return false; | |
| 1085 } | |
| 1086 | |
| 111 | 1087 static void |
| 1088 parse_acc_device_type (void) | |
| 1089 { | |
| 1090 const char *env = getenv ("ACC_DEVICE_TYPE"); | |
| 1091 | |
| 1092 if (env && *env != '\0') | |
| 1093 goacc_device_type = strdup (env); | |
| 1094 else | |
| 1095 goacc_device_type = NULL; | |
| 1096 } | |
| 1097 | |
| 1098 static void | |
| 131 | 1099 parse_gomp_openacc_dim (void) |
| 1100 { | |
| 1101 /* The syntax is the same as for the -fopenacc-dim compilation option. */ | |
| 1102 const char *var_name = "GOMP_OPENACC_DIM"; | |
| 1103 const char *env_var = getenv (var_name); | |
| 1104 if (!env_var) | |
| 1105 return; | |
| 1106 | |
| 1107 const char *pos = env_var; | |
| 1108 int i; | |
| 1109 for (i = 0; *pos && i != GOMP_DIM_MAX; i++) | |
| 1110 { | |
| 1111 if (i && *pos++ != ':') | |
| 1112 break; | |
| 1113 | |
| 1114 if (*pos == ':') | |
| 1115 continue; | |
| 1116 | |
| 1117 const char *eptr; | |
| 1118 errno = 0; | |
| 1119 long val = strtol (pos, (char **)&eptr, 10); | |
| 1120 if (errno || val < 0 || (unsigned)val != val) | |
| 1121 break; | |
| 1122 | |
| 1123 goacc_default_dims[i] = (int)val; | |
| 1124 pos = eptr; | |
| 1125 } | |
| 1126 } | |
| 1127 | |
| 1128 static void | |
| 111 | 1129 handle_omp_display_env (unsigned long stacksize, int wait_policy) |
| 1130 { | |
| 1131 const char *env; | |
| 1132 bool display = false; | |
| 1133 bool verbose = false; | |
| 1134 int i; | |
| 1135 | |
| 1136 env = getenv ("OMP_DISPLAY_ENV"); | |
| 1137 if (env == NULL) | |
| 1138 return; | |
| 1139 | |
| 1140 while (isspace ((unsigned char) *env)) | |
| 1141 ++env; | |
| 1142 if (strncasecmp (env, "true", 4) == 0) | |
| 1143 { | |
| 1144 display = true; | |
| 1145 env += 4; | |
| 1146 } | |
| 1147 else if (strncasecmp (env, "false", 5) == 0) | |
| 1148 { | |
| 1149 display = false; | |
| 1150 env += 5; | |
| 1151 } | |
| 1152 else if (strncasecmp (env, "verbose", 7) == 0) | |
| 1153 { | |
| 1154 display = true; | |
| 1155 verbose = true; | |
| 1156 env += 7; | |
| 1157 } | |
| 1158 else | |
| 1159 env = "X"; | |
| 1160 while (isspace ((unsigned char) *env)) | |
| 1161 ++env; | |
| 1162 if (*env != '\0') | |
| 1163 gomp_error ("Invalid value for environment variable OMP_DISPLAY_ENV"); | |
| 1164 | |
| 1165 if (!display) | |
| 1166 return; | |
| 1167 | |
| 1168 fputs ("\nOPENMP DISPLAY ENVIRONMENT BEGIN\n", stderr); | |
| 1169 | |
| 1170 fputs (" _OPENMP = '201511'\n", stderr); | |
| 1171 fprintf (stderr, " OMP_DYNAMIC = '%s'\n", | |
| 1172 gomp_global_icv.dyn_var ? "TRUE" : "FALSE"); | |
| 1173 fprintf (stderr, " OMP_NESTED = '%s'\n", | |
| 1174 gomp_global_icv.nest_var ? "TRUE" : "FALSE"); | |
| 1175 | |
| 1176 fprintf (stderr, " OMP_NUM_THREADS = '%lu", gomp_global_icv.nthreads_var); | |
| 1177 for (i = 1; i < gomp_nthreads_var_list_len; i++) | |
| 1178 fprintf (stderr, ",%lu", gomp_nthreads_var_list[i]); | |
| 1179 fputs ("'\n", stderr); | |
| 1180 | |
| 1181 fprintf (stderr, " OMP_SCHEDULE = '"); | |
| 145 | 1182 if ((gomp_global_icv.run_sched_var & GFS_MONOTONIC)) |
| 1183 { | |
| 1184 if (gomp_global_icv.run_sched_var != (GFS_MONOTONIC | GFS_STATIC)) | |
| 1185 fputs ("MONOTONIC:", stderr); | |
| 1186 } | |
| 1187 else if (gomp_global_icv.run_sched_var == GFS_STATIC) | |
| 1188 fputs ("NONMONOTONIC:", stderr); | |
| 1189 switch (gomp_global_icv.run_sched_var & ~GFS_MONOTONIC) | |
| 111 | 1190 { |
| 1191 case GFS_RUNTIME: | |
| 1192 fputs ("RUNTIME", stderr); | |
| 145 | 1193 if (gomp_global_icv.run_sched_chunk_size != 1) |
| 1194 fprintf (stderr, ",%d", gomp_global_icv.run_sched_chunk_size); | |
| 111 | 1195 break; |
| 1196 case GFS_STATIC: | |
| 1197 fputs ("STATIC", stderr); | |
| 145 | 1198 if (gomp_global_icv.run_sched_chunk_size != 0) |
| 1199 fprintf (stderr, ",%d", gomp_global_icv.run_sched_chunk_size); | |
| 111 | 1200 break; |
| 1201 case GFS_DYNAMIC: | |
| 1202 fputs ("DYNAMIC", stderr); | |
| 145 | 1203 if (gomp_global_icv.run_sched_chunk_size != 1) |
| 1204 fprintf (stderr, ",%d", gomp_global_icv.run_sched_chunk_size); | |
| 111 | 1205 break; |
| 1206 case GFS_GUIDED: | |
| 1207 fputs ("GUIDED", stderr); | |
| 145 | 1208 if (gomp_global_icv.run_sched_chunk_size != 1) |
| 1209 fprintf (stderr, ",%d", gomp_global_icv.run_sched_chunk_size); | |
| 111 | 1210 break; |
| 1211 case GFS_AUTO: | |
| 1212 fputs ("AUTO", stderr); | |
| 1213 break; | |
| 1214 } | |
| 1215 fputs ("'\n", stderr); | |
| 1216 | |
| 1217 fputs (" OMP_PROC_BIND = '", stderr); | |
| 1218 switch (gomp_global_icv.bind_var) | |
| 1219 { | |
| 1220 case omp_proc_bind_false: | |
| 1221 fputs ("FALSE", stderr); | |
| 1222 break; | |
| 1223 case omp_proc_bind_true: | |
| 1224 fputs ("TRUE", stderr); | |
| 1225 break; | |
| 1226 case omp_proc_bind_master: | |
| 1227 fputs ("MASTER", stderr); | |
| 1228 break; | |
| 1229 case omp_proc_bind_close: | |
| 1230 fputs ("CLOSE", stderr); | |
| 1231 break; | |
| 1232 case omp_proc_bind_spread: | |
| 1233 fputs ("SPREAD", stderr); | |
| 1234 break; | |
| 1235 } | |
| 1236 for (i = 1; i < gomp_bind_var_list_len; i++) | |
| 1237 switch (gomp_bind_var_list[i]) | |
| 1238 { | |
| 1239 case omp_proc_bind_master: | |
| 1240 fputs (",MASTER", stderr); | |
| 1241 break; | |
| 1242 case omp_proc_bind_close: | |
| 1243 fputs (",CLOSE", stderr); | |
| 1244 break; | |
| 1245 case omp_proc_bind_spread: | |
| 1246 fputs (",SPREAD", stderr); | |
| 1247 break; | |
| 1248 } | |
| 1249 fputs ("'\n", stderr); | |
| 1250 fputs (" OMP_PLACES = '", stderr); | |
| 1251 for (i = 0; i < gomp_places_list_len; i++) | |
| 1252 { | |
| 1253 fputs ("{", stderr); | |
| 1254 gomp_affinity_print_place (gomp_places_list[i]); | |
| 1255 fputs (i + 1 == gomp_places_list_len ? "}" : "},", stderr); | |
| 1256 } | |
| 1257 fputs ("'\n", stderr); | |
| 1258 | |
| 1259 fprintf (stderr, " OMP_STACKSIZE = '%lu'\n", stacksize); | |
| 1260 | |
| 1261 /* GOMP's default value is actually neither active nor passive. */ | |
| 1262 fprintf (stderr, " OMP_WAIT_POLICY = '%s'\n", | |
| 1263 wait_policy > 0 ? "ACTIVE" : "PASSIVE"); | |
| 1264 fprintf (stderr, " OMP_THREAD_LIMIT = '%u'\n", | |
| 1265 gomp_global_icv.thread_limit_var); | |
| 1266 fprintf (stderr, " OMP_MAX_ACTIVE_LEVELS = '%lu'\n", | |
| 1267 gomp_max_active_levels_var); | |
| 1268 | |
| 1269 fprintf (stderr, " OMP_CANCELLATION = '%s'\n", | |
| 1270 gomp_cancel_var ? "TRUE" : "FALSE"); | |
| 1271 fprintf (stderr, " OMP_DEFAULT_DEVICE = '%d'\n", | |
| 1272 gomp_global_icv.default_device_var); | |
| 1273 fprintf (stderr, " OMP_MAX_TASK_PRIORITY = '%d'\n", | |
| 1274 gomp_max_task_priority_var); | |
| 145 | 1275 fprintf (stderr, " OMP_DISPLAY_AFFINITY = '%s'\n", |
| 1276 gomp_display_affinity_var ? "TRUE" : "FALSE"); | |
| 1277 fprintf (stderr, " OMP_AFFINITY_FORMAT = '%s'\n", | |
| 1278 gomp_affinity_format_var); | |
| 111 | 1279 |
| 1280 if (verbose) | |
| 1281 { | |
| 1282 fputs (" GOMP_CPU_AFFINITY = ''\n", stderr); | |
| 1283 fprintf (stderr, " GOMP_STACKSIZE = '%lu'\n", stacksize); | |
| 1284 #ifdef HAVE_INTTYPES_H | |
| 1285 fprintf (stderr, " GOMP_SPINCOUNT = '%"PRIu64"'\n", | |
| 1286 (uint64_t) gomp_spin_count_var); | |
| 1287 #else | |
| 1288 fprintf (stderr, " GOMP_SPINCOUNT = '%lu'\n", | |
| 1289 (unsigned long) gomp_spin_count_var); | |
| 1290 #endif | |
| 1291 } | |
| 1292 | |
| 1293 fputs ("OPENMP DISPLAY ENVIRONMENT END\n", stderr); | |
| 1294 } | |
| 1295 | |
| 1296 | |
| 0 | 1297 static void __attribute__((constructor)) |
| 1298 initialize_env (void) | |
| 1299 { | |
| 111 | 1300 unsigned long thread_limit_var, stacksize = GOMP_DEFAULT_STACKSIZE; |
| 0 | 1301 int wait_policy; |
| 1302 | |
| 1303 /* Do a compile time check that mkomp_h.pl did good job. */ | |
| 1304 omp_check_defines (); | |
| 1305 | |
| 1306 parse_schedule (); | |
| 1307 parse_boolean ("OMP_DYNAMIC", &gomp_global_icv.dyn_var); | |
| 1308 parse_boolean ("OMP_NESTED", &gomp_global_icv.nest_var); | |
| 111 | 1309 parse_boolean ("OMP_CANCELLATION", &gomp_cancel_var); |
| 145 | 1310 parse_boolean ("OMP_DISPLAY_AFFINITY", &gomp_display_affinity_var); |
| 111 | 1311 parse_int ("OMP_DEFAULT_DEVICE", &gomp_global_icv.default_device_var, true); |
| 1312 parse_int ("OMP_MAX_TASK_PRIORITY", &gomp_max_task_priority_var, true); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1313 parse_unsigned_long ("OMP_MAX_ACTIVE_LEVELS", &gomp_max_active_levels_var, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1314 true); |
| 111 | 1315 if (parse_unsigned_long ("OMP_THREAD_LIMIT", &thread_limit_var, false)) |
| 1316 { | |
| 1317 gomp_global_icv.thread_limit_var | |
| 1318 = thread_limit_var > INT_MAX ? UINT_MAX : thread_limit_var; | |
| 1319 } | |
| 1320 parse_int_secure ("GOMP_DEBUG", &gomp_debug_var, true); | |
| 0 | 1321 #ifndef HAVE_SYNC_BUILTINS |
| 111 | 1322 gomp_mutex_init (&gomp_managed_threads_lock); |
| 0 | 1323 #endif |
| 1324 gomp_init_num_threads (); | |
| 1325 gomp_available_cpus = gomp_global_icv.nthreads_var; | |
| 111 | 1326 if (!parse_unsigned_long_list ("OMP_NUM_THREADS", |
| 1327 &gomp_global_icv.nthreads_var, | |
| 1328 &gomp_nthreads_var_list, | |
| 1329 &gomp_nthreads_var_list_len)) | |
| 0 | 1330 gomp_global_icv.nthreads_var = gomp_available_cpus; |
| 111 | 1331 bool ignore = false; |
| 1332 if (parse_bind_var ("OMP_PROC_BIND", | |
| 1333 &gomp_global_icv.bind_var, | |
| 1334 &gomp_bind_var_list, | |
| 1335 &gomp_bind_var_list_len) | |
| 1336 && gomp_global_icv.bind_var == omp_proc_bind_false) | |
| 1337 ignore = true; | |
| 1338 /* Make sure OMP_PLACES and GOMP_CPU_AFFINITY env vars are always | |
| 1339 parsed if present in the environment. If OMP_PROC_BIND was set | |
| 145 | 1340 explicitly to false, don't populate places list though. If places |
| 111 | 1341 list was successfully set from OMP_PLACES, only parse but don't process |
| 1342 GOMP_CPU_AFFINITY. If OMP_PROC_BIND was not set in the environment, | |
| 1343 default to OMP_PROC_BIND=true if OMP_PLACES or GOMP_CPU_AFFINITY | |
| 1344 was successfully parsed into a places list, otherwise to | |
| 1345 OMP_PROC_BIND=false. */ | |
| 1346 if (parse_places_var ("OMP_PLACES", ignore)) | |
| 1347 { | |
| 1348 if (gomp_global_icv.bind_var == omp_proc_bind_false) | |
| 1349 gomp_global_icv.bind_var = true; | |
| 1350 ignore = true; | |
| 1351 } | |
| 1352 if (parse_affinity (ignore)) | |
| 1353 { | |
| 1354 if (gomp_global_icv.bind_var == omp_proc_bind_false) | |
| 1355 gomp_global_icv.bind_var = true; | |
| 1356 ignore = true; | |
| 1357 } | |
| 1358 if (gomp_global_icv.bind_var != omp_proc_bind_false) | |
| 0 | 1359 gomp_init_affinity (); |
| 145 | 1360 |
| 1361 { | |
| 1362 const char *env = getenv ("OMP_AFFINITY_FORMAT"); | |
| 1363 if (env != NULL) | |
| 1364 gomp_set_affinity_format (env, strlen (env)); | |
| 1365 } | |
| 1366 | |
| 0 | 1367 wait_policy = parse_wait_policy (); |
| 1368 if (!parse_spincount ("GOMP_SPINCOUNT", &gomp_spin_count_var)) | |
| 1369 { | |
| 1370 /* Using a rough estimation of 100000 spins per msec, | |
| 1371 use 5 min blocking for OMP_WAIT_POLICY=active, | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1372 3 msec blocking when OMP_WAIT_POLICY is not specificed |
| 0 | 1373 and 0 when OMP_WAIT_POLICY=passive. |
| 1374 Depending on the CPU speed, this can be e.g. 5 times longer | |
| 1375 or 5 times shorter. */ | |
| 1376 if (wait_policy > 0) | |
| 1377 gomp_spin_count_var = 30000000000LL; | |
| 1378 else if (wait_policy < 0) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1379 gomp_spin_count_var = 300000LL; |
| 0 | 1380 } |
| 1381 /* gomp_throttled_spin_count_var is used when there are more libgomp | |
| 1382 managed threads than available CPUs. Use very short spinning. */ | |
| 1383 if (wait_policy > 0) | |
| 1384 gomp_throttled_spin_count_var = 1000LL; | |
| 1385 else if (wait_policy < 0) | |
| 1386 gomp_throttled_spin_count_var = 100LL; | |
| 1387 if (gomp_throttled_spin_count_var > gomp_spin_count_var) | |
| 1388 gomp_throttled_spin_count_var = gomp_spin_count_var; | |
| 1389 | |
| 1390 /* Not strictly environment related, but ordering constructors is tricky. */ | |
| 1391 pthread_attr_init (&gomp_thread_attr); | |
| 1392 | |
| 1393 if (parse_stacksize ("OMP_STACKSIZE", &stacksize) | |
| 111 | 1394 || parse_stacksize ("GOMP_STACKSIZE", &stacksize) |
| 1395 || GOMP_DEFAULT_STACKSIZE) | |
| 0 | 1396 { |
| 1397 int err; | |
| 1398 | |
| 1399 err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize); | |
| 1400 | |
| 1401 #ifdef PTHREAD_STACK_MIN | |
| 1402 if (err == EINVAL) | |
| 1403 { | |
| 1404 if (stacksize < PTHREAD_STACK_MIN) | |
| 1405 gomp_error ("Stack size less than minimum of %luk", | |
| 1406 PTHREAD_STACK_MIN / 1024ul | |
| 1407 + (PTHREAD_STACK_MIN % 1024 != 0)); | |
| 1408 else | |
| 1409 gomp_error ("Stack size larger than system limit"); | |
| 1410 } | |
| 1411 else | |
| 1412 #endif | |
| 1413 if (err != 0) | |
| 1414 gomp_error ("Stack size change failed: %s", strerror (err)); | |
| 1415 } | |
| 1416 | |
| 111 | 1417 handle_omp_display_env (stacksize, wait_policy); |
| 0 | 1418 |
| 111 | 1419 /* OpenACC. */ |
| 0 | 1420 |
| 111 | 1421 if (!parse_int ("ACC_DEVICE_NUM", &goacc_device_num, true)) |
| 1422 goacc_device_num = 0; | |
| 0 | 1423 |
| 111 | 1424 parse_acc_device_type (); |
| 131 | 1425 parse_gomp_openacc_dim (); |
| 0 | 1426 |
| 111 | 1427 goacc_runtime_initialize (); |
| 145 | 1428 |
| 1429 goacc_profiling_initialize (); | |
| 0 | 1430 } |
| 111 | 1431 #endif /* LIBGOMP_OFFLOADED_ONLY */ |