libgomp/env.c

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