libgomp/env.c

   1 /* Copyright (C) 2005, 2006 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 Lesser General Public License as published by
   8    the Free Software Foundation; either version 2.1 of the License, or
   9    (at your option) 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 Lesser General Public License for
  14    more details.
  15
  16    You should have received a copy of the GNU Lesser General Public License
  17    along with libgomp; see the file COPYING.LIB.  If not, write to the
  18    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 /* As a special exception, if you link this library with other files, some
  22    of which are compiled with GCC, to produce an executable, this library
  23    does not by itself cause the resulting executable to be covered by the
  24    GNU General Public License.  This exception does not however invalidate
  25    any other reasons why the executable file might be covered by the GNU
  26    General Public License.  */
  27
  28 /* This file defines the OpenMP internal control variables, and arranges
  29    for them to be initialized from environment variables at startup.  */
  30
  31 #include "libgomp.h"
  32 #include "libgomp_f.h"
  33 #include <ctype.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <limits.h>
  37 #include <errno.h>
  38
  39
  40 unsigned long gomp_nthreads_var = 1;
  41 bool gomp_dyn_var = false;
  42 bool gomp_nest_var = false;
  43 enum gomp_schedule_type gomp_run_sched_var = GFS_DYNAMIC;
  44 unsigned long gomp_run_sched_chunk = 1;
  45
  46 /* Parse the OMP_SCHEDULE environment variable.  */
  47
  48 static void
  49 parse_schedule (void)
  50 {
  51   char *env, *end;
  52   unsigned long value;
  53
  54   env = getenv ("OMP_SCHEDULE");
  55   if (env == NULL)
  56     return;
  57
  58   while (isspace ((unsigned char) *env))
  59     ++env;
  60   if (strncasecmp (env, "static", 6) == 0)
  61     {
  62       gomp_run_sched_var = GFS_STATIC;
  63       env += 6;
  64     }
  65   else if (strncasecmp (env, "dynamic", 7) == 0)
  66     {
  67       gomp_run_sched_var = GFS_DYNAMIC;
  68       env += 7;
  69     }
  70   else if (strncasecmp (env, "guided", 6) == 0)
  71     {
  72       gomp_run_sched_var = GFS_GUIDED;
  73       env += 6;
  74     }
  75   else
  76     goto unknown;
  77
  78   while (isspace ((unsigned char) *env))
  79     ++env;
  80   if (*env == '\0')
  81     return;
  82   if (*env++ != ',')
  83     goto unknown;
  84   while (isspace ((unsigned char) *env))
  85     ++env;
  86   if (*env == '\0')
  87     goto invalid;
  88
  89   errno = 0;
  90   value = strtoul (env, &end, 10);
  91   if (errno)
  92     goto invalid;
  93
  94   while (isspace ((unsigned char) *end))
  95     ++end;
  96   if (*end != '\0')
  97     goto invalid;
  98
  99   gomp_run_sched_chunk = value;
 100   return;
 101
 102  unknown:
 103   gomp_error ("Unknown value for environment variable OMP_SCHEDULE");
 104   return;
 105
 106  invalid:
 107   gomp_error ("Invalid value for chunk size in "
 108               "environment variable OMP_SCHEDULE");
 109   return;
 110 }
 111
 112 /* Parse an unsigned long environment varible.  Return true if one was
 113    present and it was successfully parsed.  */
 114
 115 static bool
 116 parse_unsigned_long (const char *name, unsigned long *pvalue)
 117 {
 118   char *env, *end;
 119   unsigned long value;
 120
 121   env = getenv (name);
 122   if (env == NULL)
 123     return false;
 124
 125   while (isspace ((unsigned char) *env))
 126     ++env;
 127   if (*env == '\0')
 128     goto invalid;
 129
 130   errno = 0;
 131   value = strtoul (env, &end, 10);
 132   if (errno || (long) value <= 0)
 133     goto invalid;
 134
 135   while (isspace ((unsigned char) *end))
 136     ++end;
 137   if (*end != '\0')
 138     goto invalid;
 139
 140   *pvalue = value;
 141   return true;
 142
 143  invalid:
 144   gomp_error ("Invalid value for environment variable %s", name);
 145   return false;
 146 }
 147
 148 /* Parse a boolean value for environment variable NAME and store the
 149    result in VALUE.  */
 150
 151 static void
 152 parse_boolean (const char *name, bool *value)
 153 {
 154   const char *env;
 155
 156   env = getenv (name);
 157   if (env == NULL)
 158     return;
 159
 160   while (isspace ((unsigned char) *env))
 161     ++env;
 162   if (strncasecmp (env, "true", 4) == 0)
 163     {
 164       *value = true;
 165       env += 4;
 166     }
 167   else if (strncasecmp (env, "false", 5) == 0)
 168     {
 169       *value = false;
 170       env += 5;
 171     }
 172   else
 173     env = "X";
 174   while (isspace ((unsigned char) *env))
 175     ++env;
 176   if (*env != '\0')
 177     gomp_error ("Invalid value for environment variable %s", name);
 178 }
 179
 180 static void __attribute__((constructor))
 181 initialize_env (void)
 182 {
 183   unsigned long stacksize;
 184
 185   /* Do a compile time check that mkomp_h.pl did good job.  */
 186   omp_check_defines ();
 187
 188   parse_schedule ();
 189   parse_boolean ("OMP_DYNAMIC", &gomp_dyn_var);
 190   parse_boolean ("OMP_NESTED", &gomp_nest_var);
 191   if (!parse_unsigned_long ("OMP_NUM_THREADS", &gomp_nthreads_var))
 192     gomp_init_num_threads ();
 193
 194   /* Not strictly environment related, but ordering constructors is tricky.  */
 195   pthread_attr_init (&gomp_thread_attr);
 196   pthread_attr_setdetachstate (&gomp_thread_attr, PTHREAD_CREATE_DETACHED);
 197
 198   if (parse_unsigned_long ("GOMP_STACKSIZE", &stacksize))
 199     {
 200       int err;
 201
 202       stacksize *= 1024;
 203       err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize);
 204
 205 #ifdef PTHREAD_STACK_MIN
 206       if (err == EINVAL)
 207         {
 208           if (stacksize < PTHREAD_STACK_MIN)
 209             gomp_error ("Stack size less than minimum of %luk",
 210                         PTHREAD_STACK_MIN / 1024ul
 211                         + (PTHREAD_STACK_MIN % 1024 != 0));
 212           else
 213             gomp_error ("Stack size larger than system limit");
 214         }
 215       else
 216 #endif
 217       if (err != 0)
 218         gomp_error ("Stack size change failed: %s", strerror (err));
 219     }
 220 }
 221
 222 \f
 223 /* The public OpenMP API routines that access these variables.  */
 224
 225 void
 226 omp_set_num_threads (int n)
 227 {
 228   gomp_nthreads_var = (n > 0 ? n : 1);
 229 }
 230
 231 void
 232 omp_set_dynamic (int val)
 233 {
 234   gomp_dyn_var = val;
 235 }
 236
 237 int
 238 omp_get_dynamic (void)
 239 {
 240   return gomp_dyn_var;
 241 }
 242
 243 void
 244 omp_set_nested (int val)
 245 {
 246   gomp_nest_var = val;
 247 }
 248
 249 int
 250 omp_get_nested (void)
 251 {
 252   return gomp_nest_var;
 253 }
 254
 255 ialias (omp_set_dynamic)
 256 ialias (omp_set_nested)
 257 ialias (omp_set_num_threads)
 258 ialias (omp_get_dynamic)
 259 ialias (omp_get_nested)