OSDN Git Service

* gcse.c (gcse_main): Do jump bypassing in CPROP2.
[pf3gnuchains/gcc-fork.git] / libgomp / env.c
1 /* Copyright (C) 2005, 2006, 2007 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 unsigned short *gomp_cpu_affinity;
46 size_t gomp_cpu_affinity_len;
47
48 /* Parse the OMP_SCHEDULE environment variable.  */
49
50 static void
51 parse_schedule (void)
52 {
53   char *env, *end;
54   unsigned long value;
55
56   env = getenv ("OMP_SCHEDULE");
57   if (env == NULL)
58     return;
59
60   while (isspace ((unsigned char) *env))
61     ++env;
62   if (strncasecmp (env, "static", 6) == 0)
63     {
64       gomp_run_sched_var = GFS_STATIC;
65       env += 6;
66     }
67   else if (strncasecmp (env, "dynamic", 7) == 0)
68     {
69       gomp_run_sched_var = GFS_DYNAMIC;
70       env += 7;
71     }
72   else if (strncasecmp (env, "guided", 6) == 0)
73     {
74       gomp_run_sched_var = GFS_GUIDED;
75       env += 6;
76     }
77   else
78     goto unknown;
79
80   while (isspace ((unsigned char) *env))
81     ++env;
82   if (*env == '\0')
83     return;
84   if (*env++ != ',')
85     goto unknown;
86   while (isspace ((unsigned char) *env))
87     ++env;
88   if (*env == '\0')
89     goto invalid;
90
91   errno = 0;
92   value = strtoul (env, &end, 10);
93   if (errno)
94     goto invalid;
95
96   while (isspace ((unsigned char) *end))
97     ++end;
98   if (*end != '\0')
99     goto invalid;
100
101   gomp_run_sched_chunk = value;
102   return;
103
104  unknown:
105   gomp_error ("Unknown value for environment variable OMP_SCHEDULE");
106   return;
107
108  invalid:
109   gomp_error ("Invalid value for chunk size in "
110               "environment variable OMP_SCHEDULE");
111   return;
112 }
113
114 /* Parse an unsigned long environment varible.  Return true if one was
115    present and it was successfully parsed.  */
116
117 static bool
118 parse_unsigned_long (const char *name, unsigned long *pvalue)
119 {
120   char *env, *end;
121   unsigned long value;
122
123   env = getenv (name);
124   if (env == NULL)
125     return false;
126
127   while (isspace ((unsigned char) *env))
128     ++env;
129   if (*env == '\0')
130     goto invalid;
131
132   errno = 0;
133   value = strtoul (env, &end, 10);
134   if (errno || (long) value <= 0)
135     goto invalid;
136
137   while (isspace ((unsigned char) *end))
138     ++end;
139   if (*end != '\0')
140     goto invalid;
141
142   *pvalue = value;
143   return true;
144
145  invalid:
146   gomp_error ("Invalid value for environment variable %s", name);
147   return false;
148 }
149
150 /* Parse a boolean value for environment variable NAME and store the 
151    result in VALUE.  */
152
153 static void
154 parse_boolean (const char *name, bool *value)
155 {
156   const char *env;
157
158   env = getenv (name);
159   if (env == NULL)
160     return;
161
162   while (isspace ((unsigned char) *env))
163     ++env;
164   if (strncasecmp (env, "true", 4) == 0)
165     {
166       *value = true;
167       env += 4;
168     }
169   else if (strncasecmp (env, "false", 5) == 0)
170     {
171       *value = false;
172       env += 5;
173     }
174   else
175     env = "X";
176   while (isspace ((unsigned char) *env))
177     ++env;
178   if (*env != '\0')
179     gomp_error ("Invalid value for environment variable %s", name);
180 }
181
182 /* Parse the GOMP_CPU_AFFINITY environment varible.  Return true if one was
183    present and it was successfully parsed.  */
184
185 static bool
186 parse_affinity (void)
187 {
188   char *env, *end;
189   unsigned long cpu_beg, cpu_end, cpu_stride;
190   unsigned short *cpus = NULL;
191   size_t allocated = 0, used = 0, needed;
192
193   env = getenv ("GOMP_CPU_AFFINITY");
194   if (env == NULL)
195     return false;
196
197   do
198     {
199       while (*env == ' ' || *env == '\t')
200         env++;
201
202       cpu_beg = strtoul (env, &end, 0);
203       cpu_end = cpu_beg;
204       cpu_stride = 1;
205       if (env == end || cpu_beg >= 65536)
206         goto invalid;
207
208       env = end;
209       if (*env == '-')
210         {
211           cpu_end = strtoul (++env, &end, 0);
212           if (env == end || cpu_end >= 65536 || cpu_end < cpu_beg)
213             goto invalid;
214
215           env = end;
216           if (*env == ':')
217             {
218               cpu_stride = strtoul (++env, &end, 0);
219               if (env == end || cpu_stride == 0 || cpu_stride >= 65536)
220                 goto invalid;
221
222               env = end;
223             }
224         }
225
226       needed = (cpu_end - cpu_beg) / cpu_stride + 1;
227       if (used + needed >= allocated)
228         {
229           unsigned short *new_cpus;
230
231           if (allocated < 64)
232             allocated = 64;
233           if (allocated > needed)
234             allocated <<= 1;
235           else
236             allocated += 2 * needed;
237           new_cpus = realloc (cpus, allocated * sizeof (unsigned short));
238           if (new_cpus == NULL)
239             {
240               free (cpus);
241               gomp_error ("not enough memory to store GOMP_CPU_AFFINITY list");
242               return false;
243             }
244
245           cpus = new_cpus;
246         }
247
248       while (needed--)
249         {
250           cpus[used++] = cpu_beg;
251           cpu_beg += cpu_stride;
252         }
253
254       while (*env == ' ' || *env == '\t')
255         env++;
256
257       if (*env == ',')
258         env++;
259       else if (*env == '\0')
260         break;
261     }
262   while (1);
263
264   gomp_cpu_affinity = cpus;
265   gomp_cpu_affinity_len = used;
266   return true;
267
268  invalid:
269   gomp_error ("Invalid value for enviroment variable GOMP_CPU_AFFINITY");
270   return false;
271 }
272
273 static void __attribute__((constructor))
274 initialize_env (void)
275 {
276   unsigned long stacksize;
277
278   /* Do a compile time check that mkomp_h.pl did good job.  */
279   omp_check_defines ();
280
281   parse_schedule ();
282   parse_boolean ("OMP_DYNAMIC", &gomp_dyn_var);
283   parse_boolean ("OMP_NESTED", &gomp_nest_var);
284   if (!parse_unsigned_long ("OMP_NUM_THREADS", &gomp_nthreads_var))
285     gomp_init_num_threads ();
286   if (parse_affinity ())
287     gomp_init_affinity ();
288
289   /* Not strictly environment related, but ordering constructors is tricky.  */
290   pthread_attr_init (&gomp_thread_attr);
291   pthread_attr_setdetachstate (&gomp_thread_attr, PTHREAD_CREATE_DETACHED);
292
293   if (parse_unsigned_long ("GOMP_STACKSIZE", &stacksize))
294     {
295       int err;
296
297       stacksize *= 1024;
298       err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize);
299
300 #ifdef PTHREAD_STACK_MIN
301       if (err == EINVAL)
302         {
303           if (stacksize < PTHREAD_STACK_MIN)
304             gomp_error ("Stack size less than minimum of %luk",
305                         PTHREAD_STACK_MIN / 1024ul
306                         + (PTHREAD_STACK_MIN % 1024 != 0));
307           else
308             gomp_error ("Stack size larger than system limit");
309         }
310       else
311 #endif
312       if (err != 0)
313         gomp_error ("Stack size change failed: %s", strerror (err));
314     }
315 }
316
317 \f
318 /* The public OpenMP API routines that access these variables.  */
319
320 void
321 omp_set_num_threads (int n)
322 {
323   gomp_nthreads_var = (n > 0 ? n : 1);
324 }
325
326 void
327 omp_set_dynamic (int val)
328 {
329   gomp_dyn_var = val;
330 }
331
332 int
333 omp_get_dynamic (void)
334 {
335   return gomp_dyn_var;
336 }
337
338 void
339 omp_set_nested (int val)
340 {
341   gomp_nest_var = val;
342 }
343
344 int
345 omp_get_nested (void)
346 {
347   return gomp_nest_var;
348 }
349
350 ialias (omp_set_dynamic)
351 ialias (omp_set_nested)
352 ialias (omp_set_num_threads)
353 ialias (omp_get_dynamic)
354 ialias (omp_get_nested)