libgomp/env.c

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