libgomp/env.c

   1 /* Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU OpenMP Library (libgomp).
   5
   6    Libgomp is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14    more details.
  15
  16    Under Section 7 of GPL version 3, you are granted additional
  17    permissions described in the GCC Runtime Library Exception, version
  18    3.1, as published by the Free Software Foundation.
  19
  20    You should have received a copy of the GNU General Public License and
  21    a copy of the GCC Runtime Library Exception along with this program;
  22    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23    <http://www.gnu.org/licenses/>.  */
  24
  25 /* This file defines the OpenMP internal control variables, and arranges
  26    for them to be initialized from environment variables at startup.  */
  27
  28 #include "libgomp.h"
  29 #include "libgomp_f.h"
  30 #include <ctype.h>
  31 #include <stdlib.h>
  32 #ifdef STRING_WITH_STRINGS
  33 # include <string.h>
  34 # include <strings.h>
  35 #else
  36 # ifdef HAVE_STRING_H
  37 #  include <string.h>
  38 # else
  39 #  ifdef HAVE_STRINGS_H
  40 #   include <strings.h>
  41 #  endif
  42 # endif
  43 #endif
  44 #include <limits.h>
  45 #include <errno.h>
  46
  47 #ifndef HAVE_STRTOULL
  48 # define strtoull(ptr, eptr, base) strtoul (ptr, eptr, base)
  49 #endif
  50
  51 struct gomp_task_icv gomp_global_icv = {
  52   .nthreads_var = 1,
  53   .run_sched_var = GFS_DYNAMIC,
  54   .run_sched_modifier = 1,
  55   .dyn_var = false,
  56   .nest_var = false
  57 };
  58
  59 unsigned short *gomp_cpu_affinity;
  60 size_t gomp_cpu_affinity_len;
  61 unsigned long gomp_max_active_levels_var = INT_MAX;
  62 unsigned long gomp_thread_limit_var = ULONG_MAX;
  63 unsigned long gomp_remaining_threads_count;
  64 #ifndef HAVE_SYNC_BUILTINS
  65 gomp_mutex_t gomp_remaining_threads_lock;
  66 #endif
  67 unsigned long gomp_available_cpus = 1, gomp_managed_threads = 1;
  68 unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;
  69
  70 /* Parse the OMP_SCHEDULE environment variable.  */
  71
  72 static void
  73 parse_schedule (void)
  74 {
  75   char *env, *end;
  76   unsigned long value;
  77
  78   env = getenv ("OMP_SCHEDULE");
  79   if (env == NULL)
  80     return;
  81
  82   while (isspace ((unsigned char) *env))
  83     ++env;
  84   if (strncasecmp (env, "static", 6) == 0)
  85     {
  86       gomp_global_icv.run_sched_var = GFS_STATIC;
  87       env += 6;
  88     }
  89   else if (strncasecmp (env, "dynamic", 7) == 0)
  90     {
  91       gomp_global_icv.run_sched_var = GFS_DYNAMIC;
  92       env += 7;
  93     }
  94   else if (strncasecmp (env, "guided", 6) == 0)
  95     {
  96       gomp_global_icv.run_sched_var = GFS_GUIDED;
  97       env += 6;
  98     }
  99   else if (strncasecmp (env, "auto", 4) == 0)
 100     {
 101       gomp_global_icv.run_sched_var = GFS_AUTO;
 102       env += 4;
 103     }
 104   else
 105     goto unknown;
 106
 107   while (isspace ((unsigned char) *env))
 108     ++env;
 109   if (*env == '\0')
 110     return;
 111   if (*env++ != ',')
 112     goto unknown;
 113   while (isspace ((unsigned char) *env))
 114     ++env;
 115   if (*env == '\0')
 116     goto invalid;
 117
 118   errno = 0;
 119   value = strtoul (env, &end, 10);
 120   if (errno)
 121     goto invalid;
 122
 123   while (isspace ((unsigned char) *end))
 124     ++end;
 125   if (*end != '\0')
 126     goto invalid;
 127
 128   if ((int)value != value)
 129     goto invalid;
 130
 131   gomp_global_icv.run_sched_modifier = value;
 132   return;
 133
 134  unknown:
 135   gomp_error ("Unknown value for environment variable OMP_SCHEDULE");
 136   return;
 137
 138  invalid:
 139   gomp_error ("Invalid value for chunk size in "
 140               "environment variable OMP_SCHEDULE");
 141   return;
 142 }
 143
 144 /* Parse an unsigned long environment variable.  Return true if one was
 145    present and it was successfully parsed.  */
 146
 147 static bool
 148 parse_unsigned_long (const char *name, unsigned long *pvalue)
 149 {
 150   char *env, *end;
 151   unsigned long value;
 152
 153   env = getenv (name);
 154   if (env == NULL)
 155     return false;
 156
 157   while (isspace ((unsigned char) *env))
 158     ++env;
 159   if (*env == '\0')
 160     goto invalid;
 161
 162   errno = 0;
 163   value = strtoul (env, &end, 10);
 164   if (errno || (long) value <= 0)
 165     goto invalid;
 166
 167   while (isspace ((unsigned char) *end))
 168     ++end;
 169   if (*end != '\0')
 170     goto invalid;
 171
 172   *pvalue = value;
 173   return true;
 174
 175  invalid:
 176   gomp_error ("Invalid value for environment variable %s", name);
 177   return false;
 178 }
 179
 180 /* Parse the OMP_STACKSIZE environment varible.  Return true if one was
 181    present and it was successfully parsed.  */
 182
 183 static bool
 184 parse_stacksize (const char *name, unsigned long *pvalue)
 185 {
 186   char *env, *end;
 187   unsigned long value, shift = 10;
 188
 189   env = getenv (name);
 190   if (env == NULL)
 191     return false;
 192
 193   while (isspace ((unsigned char) *env))
 194     ++env;
 195   if (*env == '\0')
 196     goto invalid;
 197
 198   errno = 0;
 199   value = strtoul (env, &end, 10);
 200   if (errno)
 201     goto invalid;
 202
 203   while (isspace ((unsigned char) *end))
 204     ++end;
 205   if (*end != '\0')
 206     {
 207       switch (tolower ((unsigned char) *end))
 208         {
 209         case 'b':
 210           shift = 0;
 211           break;
 212         case 'k':
 213           break;
 214         case 'm':
 215           shift = 20;
 216           break;
 217         case 'g':
 218           shift = 30;
 219           break;
 220         default:
 221           goto invalid;
 222         }
 223       ++end;
 224       while (isspace ((unsigned char) *end))
 225         ++end;
 226       if (*end != '\0')
 227         goto invalid;
 228     }
 229
 230   if (((value << shift) >> shift) != value)
 231     goto invalid;
 232
 233   *pvalue = value << shift;
 234   return true;
 235
 236  invalid:
 237   gomp_error ("Invalid value for environment variable %s", name);
 238   return false;
 239 }
 240
 241 /* Parse the GOMP_SPINCOUNT environment varible.  Return true if one was
 242    present and it was successfully parsed.  */
 243
 244 static bool
 245 parse_spincount (const char *name, unsigned long long *pvalue)
 246 {
 247   char *env, *end;
 248   unsigned long long value, mult = 1;
 249
 250   env = getenv (name);
 251   if (env == NULL)
 252     return false;
 253
 254   while (isspace ((unsigned char) *env))
 255     ++env;
 256   if (*env == '\0')
 257     goto invalid;
 258
 259   if (strncasecmp (env, "infinite", 8) == 0
 260       || strncasecmp (env, "infinity", 8) == 0)
 261     {
 262       value = ~0ULL;
 263       end = env + 8;
 264       goto check_tail;
 265     }
 266
 267   errno = 0;
 268   value = strtoull (env, &end, 10);
 269   if (errno)
 270     goto invalid;
 271
 272   while (isspace ((unsigned char) *end))
 273     ++end;
 274   if (*end != '\0')
 275     {
 276       switch (tolower ((unsigned char) *end))
 277         {
 278         case 'k':
 279           mult = 1000LL;
 280           break;
 281         case 'm':
 282           mult = 1000LL * 1000LL;
 283           break;
 284         case 'g':
 285           mult = 1000LL * 1000LL * 1000LL;
 286           break;
 287         case 't':
 288           mult = 1000LL * 1000LL * 1000LL * 1000LL;
 289           break;
 290         default:
 291           goto invalid;
 292         }
 293       ++end;
 294      check_tail:
 295       while (isspace ((unsigned char) *end))
 296         ++end;
 297       if (*end != '\0')
 298         goto invalid;
 299     }
 300
 301   if (value > ~0ULL / mult)
 302     value = ~0ULL;
 303   else
 304     value *= mult;
 305
 306   *pvalue = value;
 307   return true;
 308
 309  invalid:
 310   gomp_error ("Invalid value for environment variable %s", name);
 311   return false;
 312 }
 313
 314 /* Parse a boolean value for environment variable NAME and store the
 315    result in VALUE.  */
 316
 317 static void
 318 parse_boolean (const char *name, bool *value)
 319 {
 320   const char *env;
 321
 322   env = getenv (name);
 323   if (env == NULL)
 324     return;
 325
 326   while (isspace ((unsigned char) *env))
 327     ++env;
 328   if (strncasecmp (env, "true", 4) == 0)
 329     {
 330       *value = true;
 331       env += 4;
 332     }
 333   else if (strncasecmp (env, "false", 5) == 0)
 334     {
 335       *value = false;
 336       env += 5;
 337     }
 338   else
 339     env = "X";
 340   while (isspace ((unsigned char) *env))
 341     ++env;
 342   if (*env != '\0')
 343     gomp_error ("Invalid value for environment variable %s", name);
 344 }
 345
 346 /* Parse the OMP_WAIT_POLICY environment variable and store the
 347    result in gomp_active_wait_policy.  */
 348
 349 static int
 350 parse_wait_policy (void)
 351 {
 352   const char *env;
 353   int ret = -1;
 354
 355   env = getenv ("OMP_WAIT_POLICY");
 356   if (env == NULL)
 357     return -1;
 358
 359   while (isspace ((unsigned char) *env))
 360     ++env;
 361   if (strncasecmp (env, "active", 6) == 0)
 362     {
 363       ret = 1;
 364       env += 6;
 365     }
 366   else if (strncasecmp (env, "passive", 7) == 0)
 367     {
 368       ret = 0;
 369       env += 7;
 370     }
 371   else
 372     env = "X";
 373   while (isspace ((unsigned char) *env))
 374     ++env;
 375   if (*env == '\0')
 376     return ret;
 377   gomp_error ("Invalid value for environment variable OMP_WAIT_POLICY");
 378   return -1;
 379 }
 380
 381 /* Parse the GOMP_CPU_AFFINITY environment varible.  Return true if one was
 382    present and it was successfully parsed.  */
 383
 384 static bool
 385 parse_affinity (void)
 386 {
 387   char *env, *end;
 388   unsigned long cpu_beg, cpu_end, cpu_stride;
 389   unsigned short *cpus = NULL;
 390   size_t allocated = 0, used = 0, needed;
 391
 392   env = getenv ("GOMP_CPU_AFFINITY");
 393   if (env == NULL)
 394     return false;
 395
 396   do
 397     {
 398       while (*env == ' ' || *env == '\t')
 399         env++;
 400
 401       cpu_beg = strtoul (env, &end, 0);
 402       cpu_end = cpu_beg;
 403       cpu_stride = 1;
 404       if (env == end || cpu_beg >= 65536)
 405         goto invalid;
 406
 407       env = end;
 408       if (*env == '-')
 409         {
 410           cpu_end = strtoul (++env, &end, 0);
 411           if (env == end || cpu_end >= 65536 || cpu_end < cpu_beg)
 412             goto invalid;
 413
 414           env = end;
 415           if (*env == ':')
 416             {
 417               cpu_stride = strtoul (++env, &end, 0);
 418               if (env == end || cpu_stride == 0 || cpu_stride >= 65536)
 419                 goto invalid;
 420
 421               env = end;
 422             }
 423         }
 424
 425       needed = (cpu_end - cpu_beg) / cpu_stride + 1;
 426       if (used + needed >= allocated)
 427         {
 428           unsigned short *new_cpus;
 429
 430           if (allocated < 64)
 431             allocated = 64;
 432           if (allocated > needed)
 433             allocated <<= 1;
 434           else
 435             allocated += 2 * needed;
 436           new_cpus = realloc (cpus, allocated * sizeof (unsigned short));
 437           if (new_cpus == NULL)
 438             {
 439               free (cpus);
 440               gomp_error ("not enough memory to store GOMP_CPU_AFFINITY list");
 441               return false;
 442             }
 443
 444           cpus = new_cpus;
 445         }
 446
 447       while (needed--)
 448         {
 449           cpus[used++] = cpu_beg;
 450           cpu_beg += cpu_stride;
 451         }
 452
 453       while (*env == ' ' || *env == '\t')
 454         env++;
 455
 456       if (*env == ',')
 457         env++;
 458       else if (*env == '\0')
 459         break;
 460     }
 461   while (1);
 462
 463   gomp_cpu_affinity = cpus;
 464   gomp_cpu_affinity_len = used;
 465   return true;
 466
 467  invalid:
 468   gomp_error ("Invalid value for enviroment variable GOMP_CPU_AFFINITY");
 469   return false;
 470 }
 471
 472 static void __attribute__((constructor))
 473 initialize_env (void)
 474 {
 475   unsigned long stacksize;
 476   int wait_policy;
 477
 478   /* Do a compile time check that mkomp_h.pl did good job.  */
 479   omp_check_defines ();
 480
 481   parse_schedule ();
 482   parse_boolean ("OMP_DYNAMIC", &gomp_global_icv.dyn_var);
 483   parse_boolean ("OMP_NESTED", &gomp_global_icv.nest_var);
 484   parse_unsigned_long ("OMP_MAX_ACTIVE_LEVELS", &gomp_max_active_levels_var);
 485   parse_unsigned_long ("OMP_THREAD_LIMIT", &gomp_thread_limit_var);
 486   if (gomp_thread_limit_var != ULONG_MAX)
 487     gomp_remaining_threads_count = gomp_thread_limit_var - 1;
 488 #ifndef HAVE_SYNC_BUILTINS
 489   gomp_mutex_init (&gomp_remaining_threads_lock);
 490 #endif
 491   gomp_init_num_threads ();
 492   gomp_available_cpus = gomp_global_icv.nthreads_var;
 493   if (!parse_unsigned_long ("OMP_NUM_THREADS", &gomp_global_icv.nthreads_var))
 494     gomp_global_icv.nthreads_var = gomp_available_cpus;
 495   if (parse_affinity ())
 496     gomp_init_affinity ();
 497   wait_policy = parse_wait_policy ();
 498   if (!parse_spincount ("GOMP_SPINCOUNT", &gomp_spin_count_var))
 499     {
 500       /* Using a rough estimation of 100000 spins per msec,
 501          use 5 min blocking for OMP_WAIT_POLICY=active,
 502          200 msec blocking when OMP_WAIT_POLICY is not specificed
 503          and 0 when OMP_WAIT_POLICY=passive.
 504          Depending on the CPU speed, this can be e.g. 5 times longer
 505          or 5 times shorter.  */
 506       if (wait_policy > 0)
 507         gomp_spin_count_var = 30000000000LL;
 508       else if (wait_policy < 0)
 509         gomp_spin_count_var = 20000000LL;
 510     }
 511   /* gomp_throttled_spin_count_var is used when there are more libgomp
 512      managed threads than available CPUs.  Use very short spinning.  */
 513   if (wait_policy > 0)
 514     gomp_throttled_spin_count_var = 1000LL;
 515   else if (wait_policy < 0)
 516     gomp_throttled_spin_count_var = 100LL;
 517   if (gomp_throttled_spin_count_var > gomp_spin_count_var)
 518     gomp_throttled_spin_count_var = gomp_spin_count_var;
 519
 520   /* Not strictly environment related, but ordering constructors is tricky.  */
 521   pthread_attr_init (&gomp_thread_attr);
 522   pthread_attr_setdetachstate (&gomp_thread_attr, PTHREAD_CREATE_DETACHED);
 523
 524   if (parse_stacksize ("OMP_STACKSIZE", &stacksize)
 525       || parse_stacksize ("GOMP_STACKSIZE", &stacksize))
 526     {
 527       int err;
 528
 529       err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize);
 530
 531 #ifdef PTHREAD_STACK_MIN
 532       if (err == EINVAL)
 533         {
 534           if (stacksize < PTHREAD_STACK_MIN)
 535             gomp_error ("Stack size less than minimum of %luk",
 536                         PTHREAD_STACK_MIN / 1024ul
 537                         + (PTHREAD_STACK_MIN % 1024 != 0));
 538           else
 539             gomp_error ("Stack size larger than system limit");
 540         }
 541       else
 542 #endif
 543       if (err != 0)
 544         gomp_error ("Stack size change failed: %s", strerror (err));
 545     }
 546 }
 547
 548 \f
 549 /* The public OpenMP API routines that access these variables.  */
 550
 551 void
 552 omp_set_num_threads (int n)
 553 {
 554   struct gomp_task_icv *icv = gomp_icv (true);
 555   icv->nthreads_var = (n > 0 ? n : 1);
 556 }
 557
 558 void
 559 omp_set_dynamic (int val)
 560 {
 561   struct gomp_task_icv *icv = gomp_icv (true);
 562   icv->dyn_var = val;
 563 }
 564
 565 int
 566 omp_get_dynamic (void)
 567 {
 568   struct gomp_task_icv *icv = gomp_icv (false);
 569   return icv->dyn_var;
 570 }
 571
 572 void
 573 omp_set_nested (int val)
 574 {
 575   struct gomp_task_icv *icv = gomp_icv (true);
 576   icv->nest_var = val;
 577 }
 578
 579 int
 580 omp_get_nested (void)
 581 {
 582   struct gomp_task_icv *icv = gomp_icv (false);
 583   return icv->nest_var;
 584 }
 585
 586 void
 587 omp_set_schedule (omp_sched_t kind, int modifier)
 588 {
 589   struct gomp_task_icv *icv = gomp_icv (true);
 590   switch (kind)
 591     {
 592     case omp_sched_static:
 593       if (modifier < 1)
 594         modifier = 0;
 595       icv->run_sched_modifier = modifier;
 596       break;
 597     case omp_sched_dynamic:
 598     case omp_sched_guided:
 599       if (modifier < 1)
 600         modifier = 1;
 601       icv->run_sched_modifier = modifier;
 602       break;
 603     case omp_sched_auto:
 604       break;
 605     default:
 606       return;
 607     }
 608   icv->run_sched_var = kind;
 609 }
 610
 611 void
 612 omp_get_schedule (omp_sched_t *kind, int *modifier)
 613 {
 614   struct gomp_task_icv *icv = gomp_icv (false);
 615   *kind = icv->run_sched_var;
 616   *modifier = icv->run_sched_modifier;
 617 }
 618
 619 int
 620 omp_get_max_threads (void)
 621 {
 622   struct gomp_task_icv *icv = gomp_icv (false);
 623   return icv->nthreads_var;
 624 }
 625
 626 int
 627 omp_get_thread_limit (void)
 628 {
 629   return gomp_thread_limit_var > INT_MAX ? INT_MAX : gomp_thread_limit_var;
 630 }
 631
 632 void
 633 omp_set_max_active_levels (int max_levels)
 634 {
 635   if (max_levels > 0)
 636     gomp_max_active_levels_var = max_levels;
 637 }
 638
 639 int
 640 omp_get_max_active_levels (void)
 641 {
 642   return gomp_max_active_levels_var;
 643 }
 644
 645 ialias (omp_set_dynamic)
 646 ialias (omp_set_nested)
 647 ialias (omp_set_num_threads)
 648 ialias (omp_get_dynamic)
 649 ialias (omp_get_nested)
 650 ialias (omp_set_schedule)
 651 ialias (omp_get_schedule)
 652 ialias (omp_get_max_threads)
 653 ialias (omp_get_thread_limit)
 654 ialias (omp_set_max_active_levels)
 655 ialias (omp_get_max_active_levels)