mirrors/gcc
1
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-11-23 19:03:59 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
4ccb3366ad
gcc/libgomp/env.c
Jakub Jelinek a945c346f5 Update copyright years.
2024-01-03 12:19:35 +01:00

2505 lines
65 KiB
C
Raw Blame History

/* Copyright (C) 2005-2024 Free Software Foundation, Inc.
Contributed by Richard Henderson <rth@redhat.com>.
This file is part of the GNU Offloading and Multi Processing Library
(libgomp).
Libgomp is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
/* This file defines the OpenMP internal control variables and arranges
for them to be initialized from environment variables at startup. */
#define _GNU_SOURCE
#include "libgomp.h"
#include "gomp-constants.h"
#include <limits.h>
#ifndef LIBGOMP_OFFLOADED_ONLY
#include "libgomp_f.h"
#include "oacc-int.h"
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef HAVE_INTTYPES_H
# include <inttypes.h> /* For PRIu64. */
#endif
#ifdef STRING_WITH_STRINGS
# include <string.h>
# include <strings.h>
#else
# ifdef HAVE_STRING_H
# include <string.h>
# else
# ifdef HAVE_STRINGS_H
# include <strings.h>
# endif
# endif
#endif
#include <errno.h>
#include "thread-stacksize.h"
#ifndef HAVE_STRTOULL
# define strtoull(ptr, eptr, base) strtoul (ptr, eptr, base)
#endif
#endif /* LIBGOMP_OFFLOADED_ONLY */
#include "secure_getenv.h"
#include "environ.h"
#include "spincount.h"
/* Default values of ICVs according to the OpenMP standard,
except for default-device-var. */
const struct gomp_default_icv gomp_default_icv_values = {
.nthreads_var = 1,
.thread_limit_var = UINT_MAX,
.run_sched_var = GFS_DYNAMIC,
.run_sched_chunk_size = 1,
.default_device_var = INT_MIN,
.max_active_levels_var = 1,
.bind_var = omp_proc_bind_false,
.nteams_var = 0,
.teams_thread_limit_var = 0,
.dyn_var = false
};
struct gomp_task_icv gomp_global_icv = {
.nthreads_var = gomp_default_icv_values.nthreads_var,
.thread_limit_var = gomp_default_icv_values.thread_limit_var,
.run_sched_var = gomp_default_icv_values.run_sched_var,
.run_sched_chunk_size = gomp_default_icv_values.run_sched_chunk_size,
.default_device_var = gomp_default_icv_values.default_device_var,
.dyn_var = gomp_default_icv_values.dyn_var,
.max_active_levels_var = gomp_default_icv_values.max_active_levels_var,
.bind_var = gomp_default_icv_values.bind_var,
.target_data = NULL
};
/* List for initial "_DEV", "_ALL", and "_DEV_X" ICVs like OMP_NUM_TEAMS_DEV,
OMP_NUM_TEAMS_ALL, or OMP_NUM_TEAMS_DEV_42. */
struct gomp_icv_list *gomp_initial_icv_list = NULL;
/* List for "_DEV_X" ICVs like OMP_NUM_TEAMS_DEV_42. This list contains all
device-specific ICVs that are copied from host to device and back. */
struct gomp_offload_icv_list *gomp_offload_icv_list = NULL;
bool gomp_cancel_var = false;
enum gomp_target_offload_t gomp_target_offload_var
= GOMP_TARGET_OFFLOAD_DEFAULT;
int gomp_max_task_priority_var = 0;
#ifndef HAVE_SYNC_BUILTINS
gomp_mutex_t gomp_managed_threads_lock;
#endif
unsigned long gomp_available_cpus = 1, gomp_managed_threads = 1;
unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;
unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;
char *gomp_bind_var_list;
unsigned long gomp_bind_var_list_len;
void **gomp_places_list;
unsigned long gomp_places_list_len;
uintptr_t gomp_def_allocator = omp_default_mem_alloc;
char *gomp_def_allocator_envvar = NULL;
int gomp_debug_var;
unsigned int gomp_num_teams_var;
int gomp_nteams_var;
int gomp_teams_thread_limit_var;
bool gomp_display_affinity_var;
char *gomp_affinity_format_var = "level %L thread %i affinity %A";
size_t gomp_affinity_format_len;
char *goacc_device_type;
int goacc_device_num;
int goacc_default_dims[GOMP_DIM_MAX];
#ifndef LIBGOMP_OFFLOADED_ONLY
static int wait_policy = -1;
static unsigned long stacksize = GOMP_DEFAULT_STACKSIZE;
static void
print_env_var_error (const char *env, const char *val)
{
gomp_error ("Invalid value for environment variable %.*s: %s",
(int) (val - env - 1), env, val);
}
/* Parse the OMP_SCHEDULE environment variable. */
static bool
parse_schedule (const char *env, const char *val, void *const params[])
{
enum gomp_schedule_type *schedule = (enum gomp_schedule_type *) params[0];
int *chunk_size = (int *) params[1];
char *end;
unsigned long value;
int monotonic = 0;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (strncasecmp (val, "monotonic", 9) == 0)
{
monotonic = 1;
val += 9;
}
else if (strncasecmp (val, "nonmonotonic", 12) == 0)
{
monotonic = -1;
val += 12;
}
if (monotonic)
{
while (isspace ((unsigned char) *val))
++val;
if (*val != ':')
goto unknown;
++val;
while (isspace ((unsigned char) *val))
++val;
}
if (strncasecmp (val, "static", 6) == 0)
{
*schedule = GFS_STATIC;
val += 6;
}
else if (strncasecmp (val, "dynamic", 7) == 0)
{
*schedule = GFS_DYNAMIC;
val += 7;
}
else if (strncasecmp (val, "guided", 6) == 0)
{
*schedule = GFS_GUIDED;
val += 6;
}
else if (strncasecmp (val, "auto", 4) == 0)
{
*schedule = GFS_AUTO;
val += 4;
}
else
goto unknown;
if (monotonic == 1
|| (monotonic == 0 && *schedule == GFS_STATIC))
*schedule |= GFS_MONOTONIC;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
{
*chunk_size = (*schedule & ~GFS_MONOTONIC) != GFS_STATIC;
return true;
}
if (*val++ != ',')
goto unknown;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
errno = 0;
value = strtoul (val, &end, 10);
if (errno || end == val)
goto invalid;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
goto invalid;
if ((int)value != value)
goto invalid;
if (value == 0 && (*schedule & ~GFS_MONOTONIC) != GFS_STATIC)
value = 1;
*chunk_size = value;
return true;
unknown:
print_env_var_error (env, val);
return false;
invalid:
char name[val - env];
memcpy (name, env, val - env - 1);
name[val - env - 1] = '\0';
gomp_error ("Invalid value for chunk size in "
"environment variable %s: %s", name, val);
return false;
}
/* Parse an unsigned long environment variable. Return true if one was
present and it was successfully parsed. If SECURE, use secure_getenv to the
environment variable. */
static bool
parse_unsigned_long_1 (const char *env, const char *val, unsigned long *pvalue,
bool allow_zero)
{
char *end;
unsigned long value;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
errno = 0;
value = strtoul (val, &end, 10);
if (errno || end == val || (long) value <= 0 - allow_zero)
goto invalid;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
goto invalid;
*pvalue = value;
return true;
invalid:
print_env_var_error (env, val);
return false;
}
/* As parse_unsigned_long_1, but always use getenv. */
static bool
parse_unsigned_long (const char *env, const char *val, void *const params[])
{
unsigned long upper = (uintptr_t) params[2];
unsigned long pvalue = 0;
bool ret = parse_unsigned_long_1 (env, val, &pvalue, (bool) params[1]);
if (!ret)
return false;
if (upper == 0)
*(unsigned long *) params[0] = pvalue;
else
{
if (pvalue > upper)
pvalue = upper;
if (upper <= UCHAR_MAX)
*(unsigned char *) params[0] = pvalue;
else if (upper <= UINT_MAX)
*(unsigned int *) params[0] = pvalue;
else
*(unsigned long *) params[0] = pvalue;
}
return ret;
}
/* Parse a positive int environment variable. Return true if one was
present and it was successfully parsed. If SECURE, use secure_getenv to the
environment variable. */
static bool
parse_int_1 (const char *env, const char *val, int *pvalue, bool allow_zero)
{
unsigned long value;
if (!parse_unsigned_long_1 (env, val, &value, allow_zero))
return false;
if (value > INT_MAX)
{
print_env_var_error (env, val);
return false;
}
*pvalue = (int) value;
return true;
}
static bool
parse_int (const char *env, const char *val, void *const params[])
{
return parse_int_1 (env, val, (int *) params[0], (bool) params[1]);
}
/* As parse_int_1, but use getenv_secure. */
static bool
parse_int_secure (const char *env, int *pvalue, bool allow_zero)
{
return parse_int_1 (env, secure_getenv (env), pvalue, allow_zero);
}
/* Parse an unsigned long list environment variable. Return true if one was
present and it was successfully parsed. */
static bool
parse_unsigned_long_list (const char *env, const char *val,
void *const params[])
{
unsigned long *p1stvalue = (unsigned long *) params[0];
unsigned long **pvalues = (unsigned long **) params[1];
unsigned long *pnvalues = (unsigned long *) params[2];
char *end;
unsigned long value, *values = NULL;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
errno = 0;
value = strtoul (val, &end, 10);
if (errno || (long) value <= 0)
goto invalid;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
{
if (*end == ',')
{
unsigned long nvalues = 0, nalloced = 0;
do
{
val = end + 1;
if (nvalues == nalloced)
{
unsigned long *n;
nalloced = nalloced ? nalloced * 2 : 16;
n = realloc (values, nalloced * sizeof (unsigned long));
if (n == NULL)
{
free (values);
char name[val - env];
memcpy (name, env, val - env - 1);
name[val - env - 1] = '\0';
gomp_error ("Out of memory while trying to parse"
" environment variable %s", name);
return false;
}
values = n;
if (nvalues == 0)
values[nvalues++] = value;
}
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
errno = 0;
value = strtoul (val, &end, 10);
if (errno || (long) value <= 0)
goto invalid;
values[nvalues++] = value;
while (isspace ((unsigned char) *end))
++end;
if (*end == '\0')
break;
if (*end != ',')
goto invalid;
}
while (1);
*p1stvalue = values[0];
*pvalues = values;
*pnvalues = nvalues;
return true;
}
goto invalid;
}
else
{
*pnvalues = 0;
*pvalues = NULL;
}
*p1stvalue = value;
return true;
invalid:
free (values);
print_env_var_error (env, val);
return false;
}
static bool
parse_target_offload (const char *env, const char *val, void *const params[])
{
int new_offload = -1;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (strncasecmp (val, "default", 7) == 0)
{
val += 7;
new_offload = GOMP_TARGET_OFFLOAD_DEFAULT;
}
else if (strncasecmp (val, "mandatory", 9) == 0)
{
val += 9;
new_offload = GOMP_TARGET_OFFLOAD_MANDATORY;
}
else if (strncasecmp (val, "disabled", 8) == 0)
{
val += 8;
new_offload = GOMP_TARGET_OFFLOAD_DISABLED;
}
while (isspace ((unsigned char) *val))
++val;
if (new_offload != -1 && *val == '\0')
{
*(enum gomp_target_offload_t *) params[0] = new_offload;
return true;
}
print_env_var_error (env, val);
return false;
}
/* Parse environment variable set to a boolean or list of omp_proc_bind_t
enum values. Return true if one was present and it was successfully
parsed. */
static bool
parse_bind_var (const char *env, const char *val, void *const params[])
{
char *p1stvalue = (char *) params[0];
char **pvalues = (char **) params[1];
unsigned long *pnvalues = (unsigned long *) params[2];
char value = omp_proc_bind_false, *values = NULL;
int i;
static struct proc_bind_kinds
{
const char name[7];
const char len;
omp_proc_bind_t kind;
} kinds[] =
{
{ "false", 5, omp_proc_bind_false },
{ "true", 4, omp_proc_bind_true },
{ "master", 6, omp_proc_bind_master },
{ "primary", 7, omp_proc_bind_primary },
{ "close", 5, omp_proc_bind_close },
{ "spread", 6, omp_proc_bind_spread }
};
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
for (i = 0; i < 6; i++)
if (strncasecmp (val, kinds[i].name, kinds[i].len) == 0)
{
value = kinds[i].kind;
val += kinds[i].len;
break;
}
if (i == 6)
goto invalid;
while (isspace ((unsigned char) *val))
++val;
if (*val != '\0')
{
if (*val == ',')
{
unsigned long nvalues = 0, nalloced = 0;
if (value == omp_proc_bind_false
|| value == omp_proc_bind_true)
goto invalid;
do
{
val++;
if (nvalues == nalloced)
{
char *n;
nalloced = nalloced ? nalloced * 2 : 16;
n = realloc (values, nalloced);
if (n == NULL)
{
free (values);
char name[val - env];
memcpy (name, env, val - env - 1);
name[val - env - 1] = '\0';
gomp_error ("Out of memory while trying to parse"
" environment variable %s", name);
return false;
}
values = n;
if (nvalues == 0)
values[nvalues++] = value;
}
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
for (i = 2; i < 6; i++)
if (strncasecmp (val, kinds[i].name, kinds[i].len) == 0)
{
value = kinds[i].kind;
val += kinds[i].len;
break;
}
if (i == 6)
goto invalid;
values[nvalues++] = value;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
break;
if (*val != ',')
goto invalid;
}
while (1);
*p1stvalue = values[0];
*pvalues = values;
*pnvalues = nvalues;
return true;
}
goto invalid;
}
*p1stvalue = value;
return true;
invalid:
free (values);
print_env_var_error (env, val);
return false;
}
static bool
parse_one_place (char **envp, bool *negatep, unsigned long *lenp,
long *stridep)
{
char *env = *envp, *start;
void *p = gomp_places_list ? gomp_places_list[gomp_places_list_len] : NULL;
unsigned long len = 1;
long stride = 1;
int pass;
bool any_negate = false;
bool has_braces = true;
*negatep = false;
while (isspace ((unsigned char) *env))
++env;
if (*env == '!')
{
*negatep = true;
++env;
while (isspace ((unsigned char) *env))
++env;
}
if (*env != '{')
{
char *end;
unsigned long this_num;
errno = 0;
this_num = strtoul (env, &end, 10);
if (errno || end == env)
return false;
env = end - 1;
has_braces = false;
if (gomp_places_list
&& !gomp_affinity_add_cpus (p, this_num, 1, 1, false))
return false;
}
else
{
++env;
while (isspace ((unsigned char) *env))
++env;
}
start = env;
for (pass = 0; pass < (any_negate ? 2 : has_braces); pass++)
{
env = start;
do
{
unsigned long this_num, this_len = 1;
long this_stride = 1;
bool this_negate = (*env == '!');
char *end;
if (this_negate)
{
if (gomp_places_list)
any_negate = true;
++env;
while (isspace ((unsigned char) *env))
++env;
}
errno = 0;
this_num = strtoul (env, &end, 10);
if (errno || end == env)
return false;
env = end;
while (isspace ((unsigned char) *env))
++env;
if (*env == ':')
{
++env;
if (this_negate)
return false;
while (isspace ((unsigned char) *env))
++env;
errno = 0;
this_len = strtoul (env, &env, 10);
if (errno || this_len == 0)
return false;
while (isspace ((unsigned char) *env))
++env;
if (*env == ':')
{
++env;
while (isspace ((unsigned char) *env))
++env;
errno = 0;
this_stride = strtol (env, &end, 10);
if (errno || end == env)
return false;
env = end;
while (isspace ((unsigned char) *env))
++env;
}
}
if (gomp_places_list && pass == this_negate)
{
if (this_negate)
{
if (!gomp_affinity_remove_cpu (p, this_num))
return false;
}
else if (!gomp_affinity_add_cpus (p, this_num, this_len,
this_stride, false))
return false;
}
if (*env == '}')
break;
if (*env != ',')
return false;
++env;
}
while (1);
}
++env;
while (isspace ((unsigned char) *env))
++env;
if (*env == ':')
{
char *end;
if (*negatep)
return false;
++env;
while (isspace ((unsigned char) *env))
++env;
errno = 0;
len = strtoul (env, &env, 10);
if (errno || len == 0 || len >= 65536)
return false;
while (isspace ((unsigned char) *env))
++env;
if (*env == ':')
{
++env;
while (isspace ((unsigned char) *env))
++env;
errno = 0;
stride = strtol (env, &end, 10);
if (errno || end == env)
return false;
env = end;
while (isspace ((unsigned char) *env))
++env;
}
}
*envp = env;
*lenp = len;
*stridep = stride;
return true;
}
static bool
parse_places_var (const char *name, bool ignore)
{
char *env = getenv (name), *end;
bool any_negate = false;
int level = 0;
unsigned long count = 0;
if (env == NULL)
return false;
while (isspace ((unsigned char) *env))
++env;
if (*env == '\0')
goto invalid;
if (strncasecmp (env, "threads", 7) == 0)
{
env += 7;
level = 1;
}
else if (strncasecmp (env, "cores", 5) == 0)
{
env += 5;
level = 2;
}
else if (strncasecmp (env, "sockets", 7) == 0)
{
env += 7;
level = 3;
}
else if (strncasecmp (env, "ll_caches", 9) == 0)
{
env += 9;
level = 4;
}
else if (strncasecmp (env, "numa_domains", 12) == 0)
{
env += 12;
level = 5;
}
if (level)
{
count = ULONG_MAX;
while (isspace ((unsigned char) *env))
++env;
if (*env != '\0')
{
if (*env++ != '(')
goto invalid;
while (isspace ((unsigned char) *env))
++env;
errno = 0;
count = strtoul (env, &end, 10);
if (errno || end == env)
goto invalid;
env = end;
while (isspace ((unsigned char) *env))
++env;
if (*env != ')')
goto invalid;
++env;
while (isspace ((unsigned char) *env))
++env;
if (*env != '\0')
goto invalid;
}
if (ignore)
return false;
return gomp_affinity_init_level (level, count, false);
}
count = 0;
end = env;
do
{
bool negate;
unsigned long len;
long stride;
if (!parse_one_place (&end, &negate, &len, &stride))
goto invalid;
if (negate)
{
if (!any_negate)
count++;
any_negate = true;
}
else
count += len;
if (count > 65536)
goto invalid;
if (*end == '\0')
break;
if (*end != ',')
goto invalid;
end++;
}
while (1);
if (ignore)
return false;
gomp_places_list_len = 0;
gomp_places_list = gomp_affinity_alloc (count, false);
if (gomp_places_list == NULL)
return false;
do
{
bool negate;
unsigned long len;
long stride;
gomp_affinity_init_place (gomp_places_list[gomp_places_list_len]);
if (!parse_one_place (&env, &negate, &len, &stride))
goto invalid;
if (negate)
{
void *p;
for (count = 0; count < gomp_places_list_len; count++)
if (gomp_affinity_same_place
(gomp_places_list[count],
gomp_places_list[gomp_places_list_len]))
break;
if (count == gomp_places_list_len)
{
gomp_error ("Trying to remove a non-existing place from list "
"of places");
goto invalid;
}
p = gomp_places_list[count];
memmove (&gomp_places_list[count],
&gomp_places_list[count + 1],
(gomp_places_list_len - count - 1) * sizeof (void *));
--gomp_places_list_len;
gomp_places_list[gomp_places_list_len] = p;
}
else if (len == 1)
++gomp_places_list_len;
else
{
for (count = 0; count < len - 1; count++)
if (!gomp_affinity_copy_place
(gomp_places_list[gomp_places_list_len + count + 1],
gomp_places_list[gomp_places_list_len + count],
stride))
goto invalid;
gomp_places_list_len += len;
}
if (*env == '\0')
break;
env++;
}
while (1);
if (gomp_places_list_len == 0)
{
gomp_error ("All places have been removed");
goto invalid;
}
if (!gomp_affinity_finalize_place_list (false))
goto invalid;
return true;
invalid:
free (gomp_places_list);
gomp_places_list = NULL;
gomp_places_list_len = 0;
gomp_error ("Invalid value for environment variable %s", name);
return false;
}
/* Parse the OMP_STACKSIZE environment varible. Return true if one was
present and it was successfully parsed. */
static bool
parse_stacksize (const char *env, const char *val, void *const params[])
{
char *end;
unsigned long value, shift = 10;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
goto invalid;
errno = 0;
value = strtoul (val, &end, 10);
if (errno || end == val)
goto invalid;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
{
switch (tolower ((unsigned char) *end))
{
case 'b':
shift = 0;
break;
case 'k':
break;
case 'm':
shift = 20;
break;
case 'g':
shift = 30;
break;
default:
goto invalid;
}
++end;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
goto invalid;
}
if (((value << shift) >> shift) != value)
goto invalid;
*(unsigned long *) params[0] = value << shift;
return true;
invalid:
print_env_var_error (env, val);
return false;
}
/* Parse the GOMP_SPINCOUNT environment varible. Return true if one was
present and it was successfully parsed. */
static bool
parse_spincount (const char *name, unsigned long long *pvalue)
{
char *env, *end;
unsigned long long value, mult = 1;
env = getenv (name);
if (env == NULL)
return false;
while (isspace ((unsigned char) *env))
++env;
if (*env == '\0')
goto invalid;
if (strncasecmp (env, "infinite", 8) == 0
|| strncasecmp (env, "infinity", 8) == 0)
{
value = ~0ULL;
end = env + 8;
goto check_tail;
}
errno = 0;
value = strtoull (env, &end, 10);
if (errno || end == env)
goto invalid;
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
{
switch (tolower ((unsigned char) *end))
{
case 'k':
mult = 1000LL;
break;
case 'm':
mult = 1000LL * 1000LL;
break;
case 'g':
mult = 1000LL * 1000LL * 1000LL;
break;
case 't':
mult = 1000LL * 1000LL * 1000LL * 1000LL;
break;
default:
goto invalid;
}
++end;
check_tail:
while (isspace ((unsigned char) *end))
++end;
if (*end != '\0')
goto invalid;
}
if (value > ~0ULL / mult)
value = ~0ULL;
else
value *= mult;
*pvalue = value;
return true;
invalid:
gomp_error ("Invalid value for environment variable %s", name);
return false;
}
/* Parse a boolean value for environment variable NAME and store the
result in VALUE. Return true if one was present and it was
successfully parsed. */
static bool
parse_boolean (const char *env, const char *val, void *const params[])
{
bool *value = (bool *) params[0];
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (strncasecmp (val, "true", 4) == 0)
{
*value = true;
val += 4;
}
else if (strncasecmp (val, "false", 5) == 0)
{
*value = false;
val += 5;
}
else
val = "X";
while (isspace ((unsigned char) *val))
++val;
if (*val != '\0')
{
print_env_var_error (env, val);
return false;
}
return true;
}
/* Parse the OMP_WAIT_POLICY environment variable and return the value. */
static bool
parse_wait_policy (const char *env, const char *val, void *const params[])
{
int *pvalue = (int *) params[0];
int ret = -1;
if (val == NULL)
{
*pvalue = -1;
return false;
}
while (isspace ((unsigned char) *val))
++val;
if (strncasecmp (val, "active", 6) == 0)
{
ret = 1;
val += 6;
}
else if (strncasecmp (val, "passive", 7) == 0)
{
ret = 0;
val += 7;
}
else
val = "X";
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
{
*pvalue = ret;
return true;
}
print_env_var_error (env, val);
*pvalue = -1;
return false;
}
/* Parse the GOMP_CPU_AFFINITY environment varible. Return true if one was
present and it was successfully parsed. */
static bool
parse_affinity (bool ignore)
{
char *env, *end, *start;
int pass;
unsigned long cpu_beg, cpu_end, cpu_stride;
size_t count = 0, needed;
env = getenv ("GOMP_CPU_AFFINITY");
if (env == NULL)
return false;
start = env;
for (pass = 0; pass < 2; pass++)
{
env = start;
if (pass == 1)
{
if (ignore)
return false;
gomp_places_list_len = 0;
gomp_places_list = gomp_affinity_alloc (count, true);
if (gomp_places_list == NULL)
return false;
}
do
{
while (isspace ((unsigned char) *env))
++env;
errno = 0;
cpu_beg = strtoul (env, &end, 0);
if (errno || end == env || cpu_beg >= 65536)
goto invalid;
cpu_end = cpu_beg;
cpu_stride = 1;
env = end;
if (*env == '-')
{
errno = 0;
cpu_end = strtoul (++env, &end, 0);
if (errno || end == env || cpu_end >= 65536 || cpu_end < cpu_beg)
goto invalid;
env = end;
if (*env == ':')
{
errno = 0;
cpu_stride = strtoul (++env, &end, 0);
if (errno || cpu_stride == 0 || cpu_stride >= 65536)
goto invalid;
env = end;
}
}
needed = (cpu_end - cpu_beg) / cpu_stride + 1;
if (pass == 0)
count += needed;
else
{
while (needed--)
{
void *p = gomp_places_list[gomp_places_list_len];
gomp_affinity_init_place (p);
if (gomp_affinity_add_cpus (p, cpu_beg, 1, 0, true))
++gomp_places_list_len;
cpu_beg += cpu_stride;
}
}
while (isspace ((unsigned char) *env))
++env;
if (*env == ',')
env++;
else if (*env == '\0')
break;
}
while (1);
}
if (gomp_places_list_len == 0)
{
free (gomp_places_list);
gomp_places_list = NULL;
return false;
}
return true;
invalid:
gomp_error ("Invalid value for enviroment variable GOMP_CPU_AFFINITY");
return false;
}
/* Parse the OMP_ALLOCATOR environment variable and return the value. */
static bool
parse_allocator (const char *env, const char *val, void *const params[])
{
const char *orig_val = val;
uintptr_t *ret = (uintptr_t *) params[0];
*ret = omp_default_mem_alloc;
bool memspace = false;
size_t ntraits = 0;
omp_alloctrait_t *traits;
if (val == NULL)
return false;
while (isspace ((unsigned char) *val))
++val;
if (0)
;
#define C(v, m) \
else if (strncasecmp (val, #v, sizeof (#v) - 1) == 0) \
{ \
*ret = v; \
val += sizeof (#v) - 1; \
memspace = m; \
}
C (omp_default_mem_alloc, false)
C (omp_large_cap_mem_alloc, false)
C (omp_const_mem_alloc, false)
C (omp_high_bw_mem_alloc, false)
C (omp_low_lat_mem_alloc, false)
C (omp_cgroup_mem_alloc, false)
C (omp_pteam_mem_alloc, false)
C (omp_thread_mem_alloc, false)
C (omp_default_mem_space, true)
C (omp_large_cap_mem_space, true)
C (omp_const_mem_space, true)
C (omp_high_bw_mem_space, true)
C (omp_low_lat_mem_space, true)
#undef C
else
goto invalid;
if (memspace && *val == ':')
{
++val;
const char *cp = val;
while (*cp != '\0')
{
if (*cp == '=')
++ntraits;
++cp;
}
traits = gomp_alloca (ntraits * sizeof (omp_alloctrait_t));
size_t n = 0;
while (*val != '\0')
{
#define C(v) \
else if (strncasecmp (val, #v "=", sizeof (#v)) == 0) \
{ \
val += sizeof (#v); \
traits[n].key = omp_atk_ ## v;
#define V(v) \
else if (strncasecmp (val, #v, sizeof (#v) - 1) == 0) \
{ \
val += sizeof (#v) - 1; \
traits[n].value = omp_atv_ ## v; \
}
if (0)
;
C (sync_hint)
if (0)
;
V (contended)
V (uncontended)
V (serialized)
V (private)
else
goto invalid;
}
C (alignment)
char *end;
errno = 0;
traits[n].value = strtol (val, &end, 10);
if (errno || end == val || traits[n].value <= 0)
goto invalid;
val = end;
}
C (access)
if (0)
;
V (all)
V (cgroup)
V (pteam)
V (thread)
else
goto invalid;
}
C (pool_size)
char *end;
errno = 0;
traits[n].value = strtol (val, &end, 10);
if (errno || end == val || traits[n].value <= 0)
goto invalid;
val = end;
}
C (fallback)
if (0)
;
V (default_mem_fb)
V (null_fb)
V (abort_fb)
V (allocator_fb)
else
goto invalid;
}
/* Ignore fb_data, which expects an allocator handle. */
C (pinned)
if (0)
;
V (true)
V (false)
else
goto invalid;
}
C (partition)
if (0)
;
V (environment)
V (nearest)
V (blocked)
V (interleaved)
else
goto invalid;
}
else
goto invalid;
if (*val != ',')
break;
++val;
++n;
if (*val == '\0')
goto invalid;
}
#undef C
#undef V
}
else if (memspace)
switch (*ret)
{
case omp_default_mem_space: *ret = omp_default_mem_alloc; break;
case omp_large_cap_mem_space: *ret = omp_large_cap_mem_alloc; break;
case omp_const_mem_space: *ret = omp_const_mem_alloc; break;
case omp_high_bw_mem_space: *ret = omp_high_bw_mem_alloc; break;
case omp_low_lat_mem_space: *ret = omp_low_lat_mem_alloc; break;
default: __builtin_unreachable ();
}
while (isspace ((unsigned char) *val))
++val;
if (*val == '\0')
{
if (ntraits)
{
*ret = omp_init_allocator (*ret, ntraits, traits);
if (*ret == omp_null_allocator)
{
gomp_error ("Allocator of environment variable %.*s cannot be "
"created, using omp_default_mem_alloc instead",
(int) (orig_val - env - 1), env);
*ret = omp_default_mem_alloc;
}
else
gomp_def_allocator_envvar = strdup (orig_val);
}
return true;
}
invalid:
int len = (orig_val - env - 1);
if (*val == '\0')
gomp_error ("Missing value at the end of environment variable %s", env);
else
gomp_error ("Invalid value for environment variable %.*s when parsing: %s",
len, env, val);
*ret = omp_default_mem_alloc;
return false;
}
static void
parse_acc_device_type (void)
{
const char *env = getenv ("ACC_DEVICE_TYPE");
if (env && *env != '\0')
goacc_device_type = strdup (env);
else
goacc_device_type = NULL;
}
static void
parse_gomp_openacc_dim (void)
{
/* The syntax is the same as for the -fopenacc-dim compilation option. */
const char *var_name = "GOMP_OPENACC_DIM";
const char *env_var = getenv (var_name);
const char *pos = env_var;
int i;
if (!env_var)
return;
for (i = 0; *pos && i != GOMP_DIM_MAX; i++)
{
char *eptr;
long val;
if (i && *pos++ != ':')
break;
if (*pos == ':')
continue;
errno = 0;
val = strtol (pos, &eptr, 10);
if (errno || eptr == pos || val < 0 || (unsigned)val != val)
break;
goacc_default_dims[i] = (int)val;
pos = (const char *) eptr;
}
}
/* Helper function for omp_display_env which prints the values of run_sched_var.
'device' can be 'host', 'dev', 'all' or a particular device number. */
static void
print_schedule (enum gomp_schedule_type run_sched_var, int run_sched_chunk_size,
const char *device)
{
fprintf (stderr, " [%s] OMP_SCHEDULE = '", device);
if ((run_sched_var & GFS_MONOTONIC))
{
if (run_sched_var != (GFS_MONOTONIC | GFS_STATIC))
fputs ("MONOTONIC:", stderr);
}
else if (run_sched_var == GFS_STATIC)
fputs ("NONMONOTONIC:", stderr);
switch (run_sched_var & ~GFS_MONOTONIC)
{
case GFS_RUNTIME:
fputs ("RUNTIME", stderr);
if (run_sched_chunk_size != 1)
fprintf (stderr, ",%d", run_sched_chunk_size);
break;
case GFS_STATIC:
fputs ("STATIC", stderr);
if (run_sched_chunk_size != 0)
fprintf (stderr, ",%d", run_sched_chunk_size);
break;
case GFS_DYNAMIC:
fputs ("DYNAMIC", stderr);
if (run_sched_chunk_size != 1)
fprintf (stderr, ",%d", run_sched_chunk_size);
break;
case GFS_GUIDED:
fputs ("GUIDED", stderr);
if (run_sched_chunk_size != 1)
fprintf (stderr, ",%d", run_sched_chunk_size);
break;
case GFS_AUTO:
fputs ("AUTO", stderr);
break;
}
fputs ("'\n", stderr);
}
/* Helper function for omp_display_env which prints the values of proc_bind_var.
'device' can be 'host', 'dev', 'all', or a particular device number. */
static void
print_proc_bind (char proc_bind_var, unsigned long len, char **list,
const char *device)
{
fprintf (stderr, " [%s] OMP_PROC_BIND = '", device);
switch (proc_bind_var)
{
case omp_proc_bind_false:
fputs ("FALSE", stderr);
break;
case omp_proc_bind_true:
fputs ("TRUE", stderr);
break;
case omp_proc_bind_master:
fputs ("MASTER", stderr); /* TODO: Change to PRIMARY for OpenMP 5.1. */
break;
case omp_proc_bind_close:
fputs ("CLOSE", stderr);
break;
case omp_proc_bind_spread:
fputs ("SPREAD", stderr);
break;
}
for (int i = 1; i < len; i++)
switch ((*list)[i])
{
case omp_proc_bind_master:
fputs (",MASTER", stderr); /* TODO: Change to PRIMARY for OpenMP 5.1. */
break;
case omp_proc_bind_close:
fputs (",CLOSE", stderr);
break;
case omp_proc_bind_spread:
fputs (",SPREAD", stderr);
break;
}
fputs ("'\n", stderr);
}
enum gomp_parse_type
{
PARSE_INT = 1,
PARSE_BOOL = 2,
PARSE_UINT = 3,
PARSE_ULONG = 4,
PARSE_UCHAR = 5,
PARSE_SCHEDULE =6,
PARSE_BIND = 7
};
/* The following table contains items that help parsing environment variables
and fill corresponding ICVs with values. FLAG_VARS contain all ICVS which
are affected by the environment variable. FLAGS determine what variant of
environment variable is allowed. */
#define ENTRY(NAME) NAME, sizeof (NAME) - 1
static const struct envvar
{
const char *name;
int name_len;
uint8_t flag_vars[3];
uint8_t flag;
bool (*parse_func) (const char *, const char *, void *const[]);
} envvars[] = {
{ ENTRY ("SCHEDULE"),
{ GOMP_ICV_SCHEDULE, GOMP_ICV_SCHEDULE_CHUNK_SIZE },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_schedule },
{ ENTRY ("NUM_TEAMS"),
{ GOMP_ICV_NTEAMS },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_int },
{ ENTRY ("DYNAMIC"),
{ GOMP_ICV_DYNAMIC },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_boolean },
{ ENTRY ("TEAMS_THREAD_LIMIT"),
{ GOMP_ICV_TEAMS_THREAD_LIMIT },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_int },
{ ENTRY ("THREAD_LIMIT"),
{ GOMP_ICV_THREAD_LIMIT },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_unsigned_long },
{ ENTRY ("NUM_THREADS"),
{ GOMP_ICV_NTHREADS, GOMP_ICV_NTHREADS_LIST, GOMP_ICV_NTHREADS_LIST_LEN },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_unsigned_long_list },
{ ENTRY ("PROC_BIND"),
{ GOMP_ICV_BIND, GOMP_ICV_BIND_LIST, GOMP_ICV_BIND_LIST_LEN },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_bind_var },
{ ENTRY ("MAX_ACTIVE_LEVELS"),
{ GOMP_ICV_MAX_ACTIVE_LEVELS },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_unsigned_long },
{ ENTRY ("WAIT_POLICY"),
{ GOMP_ICV_WAIT_POLICY },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_wait_policy },
{ ENTRY ("STACKSIZE"),
{ GOMP_ICV_STACKSIZE },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_stacksize },
{ ENTRY ("CANCELLATION"), { GOMP_ICV_CANCELLATION }, 0, &parse_boolean },
{ ENTRY ("DISPLAY_AFFINITY"), { GOMP_ICV_DISPLAY_AFFINITY }, 0,
&parse_boolean },
{ ENTRY ("TARGET_OFFLOAD"), { GOMP_ICV_TARGET_OFFLOAD }, 0,
&parse_target_offload },
{ ENTRY ("MAX_TASK_PRIORITY"), { GOMP_ICV_MAX_TASK_PRIORITY }, 0,
&parse_int },
{ ENTRY ("ALLOCATOR"), { GOMP_ICV_ALLOCATOR }, 0, &parse_allocator },
{ ENTRY ("DEFAULT_DEVICE"), { GOMP_ICV_DEFAULT_DEVICE },
GOMP_ENV_SUFFIX_DEV | GOMP_ENV_SUFFIX_ALL | GOMP_ENV_SUFFIX_DEV_X,
&parse_int }
};
#undef ENTRY
#define OMP_VAR_CNT (sizeof (envvars) / sizeof (envvars[0]))
/* The following table is used to apply the hierarchy of ICV variants for host
variables, e.g. nteams_var is set to OMP_NUM_TEAMS_ALL if OMP_NUM_TEAMS is
undefined. */
static const struct host_envvar
{
unsigned char flag_var;
void *dest[3];
int type_code;
} host_envvars[] = {
{ GOMP_ICV_NTEAMS, { &gomp_nteams_var }, PARSE_INT },
{ GOMP_ICV_DYNAMIC, { &gomp_global_icv.dyn_var }, PARSE_BOOL },
{ GOMP_ICV_DEFAULT_DEVICE, { &gomp_global_icv.default_device_var },
PARSE_INT },
{ GOMP_ICV_TEAMS_THREAD_LIMIT, { &gomp_teams_thread_limit_var }, PARSE_INT },
{ GOMP_ICV_SCHEDULE,
{ &gomp_global_icv.run_sched_var, &gomp_global_icv.run_sched_chunk_size },
PARSE_SCHEDULE },
{ GOMP_ICV_THREAD_LIMIT, { &gomp_global_icv.thread_limit_var }, PARSE_UINT },
{ GOMP_ICV_NTHREADS,
{ &gomp_global_icv.nthreads_var, &gomp_nthreads_var_list,
&gomp_nthreads_var_list_len }, PARSE_ULONG },
{ GOMP_ICV_BIND,
{ &gomp_global_icv.bind_var, &gomp_bind_var_list, &gomp_bind_var_list_len },
PARSE_BIND },
{ GOMP_ICV_MAX_ACTIVE_LEVELS, { &gomp_global_icv.max_active_levels_var },
PARSE_UCHAR },
};
#define OMP_HOST_VAR_CNT (sizeof (host_envvars) / sizeof (host_envvars[0]))
#define INT_MAX_STR_LEN 10
bool
gomp_get_icv_flag (uint32_t value, enum gomp_icvs icv)
{
return value & (1 << (icv - 1));
}
static void
gomp_set_icv_flag (uint32_t *value, enum gomp_icvs icv)
{
*value |= 1 << (icv - 1);
}
static void
print_device_specific_icvs (int icv_code)
{
struct gomp_icv_list *list = gomp_initial_icv_list;
int i;
char dev_num[INT_MAX_STR_LEN + 1];
while (list != NULL)
{
if (list->device_num < 0)
{
list = list->next;
continue;
}
switch (icv_code)
{
case GOMP_ICV_NTEAMS:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_NTEAMS))
fprintf (stderr, " [%d] OMP_NUM_TEAMS = '%d'\n",
list->device_num, list->icvs.nteams_var);
break;
case GOMP_ICV_DYNAMIC:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_DYNAMIC))
fprintf (stderr, " [%d] OMP_DYNAMIC = '%s'\n",
list->device_num, list->icvs.dyn_var ? "TRUE" : "FALSE");
break;
case GOMP_ICV_TEAMS_THREAD_LIMIT:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_TEAMS_THREAD_LIMIT))
fprintf (stderr, " [%d] OMP_TEAMS_THREAD_LIMIT = '%u'\n",
list->device_num, list->icvs.teams_thread_limit_var);
break;
case GOMP_ICV_SCHEDULE:
if (!(gomp_get_icv_flag (list->flags, GOMP_ICV_SCHEDULE)))
break;
sprintf (dev_num, "%d", list->device_num);
print_schedule (list->icvs.run_sched_var,
list->icvs.run_sched_chunk_size,
dev_num);
break;
case GOMP_ICV_THREAD_LIMIT:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_THREAD_LIMIT))
fprintf (stderr, " [%d] OMP_THREAD_LIMIT = '%d'\n",
list->device_num, list->icvs.thread_limit_var);
break;
case GOMP_ICV_NTHREADS:
if (!(gomp_get_icv_flag (list->flags, GOMP_ICV_NTHREADS)))
break;
fprintf (stderr, " [%d] OMP_NUM_THREADS = '%lu", list->device_num,
list->icvs.nthreads_var);
for (i = 1; i < list->icvs.nthreads_var_list_len; i++)
fprintf (stderr, ",%lu", list->icvs.nthreads_var_list[i]);
fputs ("'\n", stderr);
break;
case GOMP_ICV_MAX_ACTIVE_LEVELS:
fprintf (stderr, " [%d] OMP_MAX_ACTIVE_LEVELS = '%u'\n",
list->device_num, list->icvs.max_active_levels_var);
break;
case GOMP_ICV_BIND:
if (!(gomp_get_icv_flag (list->flags, GOMP_ICV_BIND)))
break;
sprintf (dev_num, "%d", list->device_num);
print_proc_bind (list->icvs.bind_var, list->icvs.bind_var_list_len,
&list->icvs.bind_var_list, dev_num);
break;
case GOMP_ICV_WAIT_POLICY:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_WAIT_POLICY))
fprintf (stderr, " [%d] OMP_WAIT_POLICY = '%s'\n",
list->device_num,
list->icvs.wait_policy > 0 ? "ACTIVE" : "PASSIVE");
break;
case GOMP_ICV_STACKSIZE:
if (gomp_get_icv_flag (list->flags, GOMP_ICV_STACKSIZE))
fprintf (stderr, " [%d] OMP_STACKSIZE = '%lu'\n",
list->device_num, list->icvs.stacksize);
break;
}
list = list->next;
}
}
void
omp_display_env (int verbose)
{
int i;
struct gomp_icv_list *dev
= gomp_get_initial_icv_item (GOMP_DEVICE_NUM_FOR_DEV);
struct gomp_icv_list *all
= gomp_get_initial_icv_item (GOMP_DEVICE_NUM_FOR_ALL);
struct gomp_icv_list *none
= gomp_get_initial_icv_item (GOMP_DEVICE_NUM_FOR_NO_SUFFIX);
if (none->icvs.default_device_var == INT_MIN)
/* This implies OMP_TARGET_OFFLOAD=mandatory. */
gomp_init_targets_once ();
fputs ("\nOPENMP DISPLAY ENVIRONMENT BEGIN\n", stderr);
fputs (" _OPENMP = '201511'\n", stderr);
fprintf (stderr, " [host] OMP_DYNAMIC = '%s'\n",
none->icvs.dyn_var ? "TRUE" : "FALSE");
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_DYNAMIC))
fprintf (stderr, " [all] OMP_DYNAMIC = '%s'\n",
all->icvs.dyn_var ? "TRUE" : "FALSE");
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_DYNAMIC))
fprintf (stderr, " [device] OMP_DYNAMIC = '%s'\n",
dev->icvs.dyn_var ? "TRUE" : "FALSE");
print_device_specific_icvs (GOMP_ICV_DYNAMIC);
/* The OMP_NESTED environment variable has been deprecated. */
fprintf (stderr, " [host] OMP_NESTED = '%s'\n",
none->icvs.max_active_levels_var > 1 ? "TRUE" : "FALSE");
fprintf (stderr, " [host] OMP_NUM_THREADS = '%lu",
none->icvs.nthreads_var);
for (i = 1; i < none->icvs.nthreads_var_list_len; i++)
fprintf (stderr, ",%lu", none->icvs.nthreads_var_list[i]);
fputs ("'\n", stderr);
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_NTHREADS))
{
fprintf (stderr, " [all] OMP_NUM_THREADS = '%lu",
all->icvs.nthreads_var);
for (i = 1; i < all->icvs.nthreads_var_list_len; i++)
fprintf (stderr, ",%lu", all->icvs.nthreads_var_list[i]);
fputs ("'\n", stderr);
}
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_NTHREADS))
{
fprintf (stderr, " [device] OMP_NUM_THREADS = '%lu",
dev->icvs.nthreads_var);
for (i = 1; i < dev->icvs.nthreads_var_list_len; i++)
fprintf (stderr, ",%lu", dev->icvs.nthreads_var_list[i]);
fputs ("'\n", stderr);
}
print_device_specific_icvs (GOMP_ICV_NTHREADS);
print_schedule (none->icvs.run_sched_var,
none->icvs.run_sched_chunk_size, "host");
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_SCHEDULE))
print_schedule (all->icvs.run_sched_var,
all->icvs.run_sched_chunk_size, "all");
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_SCHEDULE))
print_schedule (dev->icvs.run_sched_var,
dev->icvs.run_sched_chunk_size, "device");
print_device_specific_icvs (GOMP_ICV_SCHEDULE);
print_proc_bind (none->icvs.bind_var,
none->icvs.bind_var_list_len,
&none->icvs.bind_var_list, "host");
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_BIND))
print_proc_bind (all->icvs.bind_var,
all->icvs.bind_var_list_len,
&all->icvs.bind_var_list, "all");
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_BIND))
print_proc_bind (dev->icvs.bind_var,
dev->icvs.bind_var_list_len,
&dev->icvs.bind_var_list, "device");
print_device_specific_icvs (GOMP_ICV_BIND);
fputs (" [host] OMP_PLACES = '", stderr);
for (i = 0; i < gomp_places_list_len; i++)
{
fputs ("{", stderr);
gomp_affinity_print_place (gomp_places_list[i]);
fputs (i + 1 == gomp_places_list_len ? "}" : "},", stderr);
}
fputs ("'\n", stderr);
fprintf (stderr, " [host] OMP_STACKSIZE = '%lu'\n",
none->icvs.stacksize);
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_STACKSIZE))
fprintf (stderr, " [all] OMP_STACKSIZE = '%lu'\n",
all->icvs.stacksize);
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_STACKSIZE))
fprintf (stderr, " [device] OMP_STACKSIZE = '%lu'\n",
dev->icvs.stacksize);
print_device_specific_icvs (GOMP_ICV_STACKSIZE);
/* GOMP's default value is actually neither active nor passive. */
fprintf (stderr, " [host] OMP_WAIT_POLICY = '%s'\n",
none->icvs.wait_policy > 0 ? "ACTIVE" : "PASSIVE");
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_WAIT_POLICY))
fprintf (stderr, " [all] OMP_WAIT_POLICY = '%s'\n",
all->icvs.wait_policy > 0 ? "ACTIVE" : "PASSIVE");
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_WAIT_POLICY))
fprintf (stderr, " [device] OMP_WAIT_POLICY = '%s'\n",
dev->icvs.wait_policy > 0 ? "ACTIVE" : "PASSIVE");
print_device_specific_icvs (GOMP_ICV_WAIT_POLICY);
fprintf (stderr, " [host] OMP_THREAD_LIMIT = '%u'\n",
none->icvs.thread_limit_var);
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_THREAD_LIMIT))
fprintf (stderr, " [all] OMP_THREAD_LIMIT = '%d'\n",
all->icvs.thread_limit_var);
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_THREAD_LIMIT))
fprintf (stderr, " [device] OMP_THREAD_LIMIT = '%d'\n",
dev->icvs.thread_limit_var);
print_device_specific_icvs (GOMP_ICV_THREAD_LIMIT);
fprintf (stderr, " [host] OMP_MAX_ACTIVE_LEVELS = '%u'\n",
none->icvs.max_active_levels_var);
if (all != NULL && gomp_get_icv_flag (all->flags,
GOMP_ICV_MAX_ACTIVE_LEVELS))
fprintf (stderr, " [all] OMP_MAX_ACTIVE_LEVELS = '%u'\n",
all->icvs.max_active_levels_var);
if (dev != NULL && gomp_get_icv_flag (dev->flags,
GOMP_ICV_MAX_ACTIVE_LEVELS))
fprintf (stderr, " [device] OMP_MAX_ACTIVE_LEVELS = '%u'\n",
dev->icvs.max_active_levels_var);
print_device_specific_icvs (GOMP_ICV_MAX_ACTIVE_LEVELS);
fprintf (stderr, " [host] OMP_NUM_TEAMS = '%d'\n",
none->icvs.nteams_var);
if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_NTEAMS))
fprintf (stderr, " [all] OMP_NUM_TEAMS = '%d'\n",
all->icvs.nteams_var);
if (dev != NULL && gomp_get_icv_flag (dev->flags, GOMP_ICV_NTEAMS))
fprintf (stderr, " [device] OMP_NUM_TEAMS = '%d'\n",
dev->icvs.nteams_var);
print_device_specific_icvs (GOMP_ICV_NTEAMS);
fprintf (stderr, " [host] OMP_TEAMS_THREAD_LIMIT = '%u'\n",
none->icvs.teams_thread_limit_var);
if (all != NULL && gomp_get_icv_flag (all->flags,
GOMP_ICV_TEAMS_THREAD_LIMIT))
fprintf (stderr, " [all] OMP_TEAMS_THREAD_LIMIT = '%u'\n",
all->icvs.teams_thread_limit_var);
if (dev != NULL && gomp_get_icv_flag (dev->flags,
GOMP_ICV_TEAMS_THREAD_LIMIT))
fprintf (stderr, " [device] OMP_TEAMS_THREAD_LIMIT = '%u'\n",
dev->icvs.teams_thread_limit_var);
print_device_specific_icvs (GOMP_ICV_TEAMS_THREAD_LIMIT);
fprintf (stderr, " [all] OMP_CANCELLATION = '%s'\n",
gomp_cancel_var ? "TRUE" : "FALSE");
fprintf (stderr, " [all] OMP_DEFAULT_DEVICE = '%d'\n",
none->icvs.default_device_var);
fprintf (stderr, " [all] OMP_MAX_TASK_PRIORITY = '%d'\n",
gomp_max_task_priority_var);
fprintf (stderr, " [all] OMP_DISPLAY_AFFINITY = '%s'\n",
gomp_display_affinity_var ? "TRUE" : "FALSE");
fprintf (stderr, " [host] OMP_AFFINITY_FORMAT = '%s'\n",
gomp_affinity_format_var);
fprintf (stderr, " [host] OMP_ALLOCATOR = '");
switch (gomp_def_allocator)
{
#define C(v) case v: fputs (#v, stderr); break;
C (omp_default_mem_alloc)
C (omp_large_cap_mem_alloc)
C (omp_const_mem_alloc)
C (omp_high_bw_mem_alloc)
C (omp_low_lat_mem_alloc)
C (omp_cgroup_mem_alloc)
C (omp_pteam_mem_alloc)
C (omp_thread_mem_alloc)
#undef C
/* For an OMP_ALLOCATOR with traits, '' will be output. */
default:
if (gomp_def_allocator_envvar)
fputs (gomp_def_allocator_envvar, stderr);
break;
}
fputs ("'\n", stderr);
fputs (" [all] OMP_TARGET_OFFLOAD = '", stderr);
switch (gomp_target_offload_var)
{
case GOMP_TARGET_OFFLOAD_DEFAULT:
fputs ("DEFAULT", stderr);
break;
case GOMP_TARGET_OFFLOAD_MANDATORY:
fputs ("MANDATORY", stderr);
break;
case GOMP_TARGET_OFFLOAD_DISABLED:
fputs ("DISABLED", stderr);
break;
}
fputs ("'\n", stderr);
if (verbose)
{
fputs (" [host] GOMP_CPU_AFFINITY = ''\n", stderr);
fprintf (stderr, " [host] GOMP_STACKSIZE = '%lu'\n", stacksize);
#ifdef HAVE_INTTYPES_H
fprintf (stderr, " [host] GOMP_SPINCOUNT = '%"PRIu64"'\n",
(uint64_t) gomp_spin_count_var);
#else
fprintf (stderr, " [host] GOMP_SPINCOUNT = '%lu'\n",
(unsigned long) gomp_spin_count_var);
#endif
}
fputs ("OPENMP DISPLAY ENVIRONMENT END\n", stderr);
}
ialias (omp_display_env)
static void
handle_omp_display_env (void)
{
const char *env;
bool display = false;
bool verbose = false;
env = getenv ("OMP_DISPLAY_ENV");
if (env == NULL)
return;
while (isspace ((unsigned char) *env))
++env;
if (strncasecmp (env, "true", 4) == 0)
{
display = true;
env += 4;
}
else if (strncasecmp (env, "false", 5) == 0)
{
display = false;
env += 5;
}
else if (strncasecmp (env, "verbose", 7) == 0)
{
display = true;
verbose = true;
env += 7;
}
else
env = "X";
while (isspace ((unsigned char) *env))
++env;
if (*env != '\0')
gomp_error ("Invalid value for environment variable OMP_DISPLAY_ENV");
if (display)
ialias_call (omp_display_env) (verbose);
}
/* Helper function for initialize_env. Extracts the device number from
an environment variable name. ENV is the complete environment variable.
DEV_NUM_PTR points to the start of the device number in the environment
variable string. DEV_NUM_LEN is the returned length of the device num
string. */
static bool
get_device_num (char *env, char *dev_num_ptr, int *dev_num, int *dev_num_len)
{
char *end;
unsigned long val = strtoul (dev_num_ptr, &end, 10);
if (val > INT_MAX
|| *end != '='
|| (dev_num_ptr[0] == '0' && end != dev_num_ptr + 1)
|| (dev_num_ptr[0] < '0' || dev_num_ptr[0] > '9'))
{
gomp_error ("Invalid device number in %s", env);
return false;
}
*dev_num = val;
*dev_num_len = end - dev_num_ptr;
return true;
}
static void
get_icv_member_addr (struct gomp_initial_icvs *icvs, int icv_code,
void *icv_addr[3])
{
if (icv_code == 0 || icv_addr == NULL)
return;
icv_addr[0] = icv_addr[1] = icv_addr[2] = NULL;
switch (icv_code)
{
case GOMP_ICV_NTEAMS:
icv_addr[0] = &icvs->nteams_var;
/* icv_addr[1] = (void *) false; */
break;
case GOMP_ICV_DYNAMIC:
icv_addr[0] = &(*icvs).dyn_var;
break;
case GOMP_ICV_TEAMS_THREAD_LIMIT:
icv_addr[0] = &icvs->teams_thread_limit_var;
/* icv_addr[1] = (void *) false; */
break;
case GOMP_ICV_SCHEDULE:
icv_addr[0] = &icvs->run_sched_var;
icv_addr[1] = &icvs->run_sched_chunk_size;
break;
case GOMP_ICV_THREAD_LIMIT:
icv_addr[0] = &icvs->thread_limit_var;
/* icv_addr[1] = (void *) false; */
icv_addr[2] = (void *) UINT_MAX;
break;
case GOMP_ICV_NTHREADS:
icv_addr[0] = &icvs->nthreads_var;
icv_addr[1] = &icvs->nthreads_var_list;
icv_addr[2] = &icvs->nthreads_var_list_len;
break;
case GOMP_ICV_MAX_ACTIVE_LEVELS:
icv_addr[0] = &icvs->max_active_levels_var;
icv_addr[1] = (void *) true;
icv_addr[2] = (void *) gomp_supported_active_levels;
break;
case GOMP_ICV_BIND:
icv_addr[0] = &icvs->bind_var;
icv_addr[1] = &icvs->bind_var_list;
icv_addr[2] = &icvs->bind_var_list_len;
break;
case GOMP_ICV_WAIT_POLICY:
icv_addr[0] = &icvs->wait_policy;
break;
case GOMP_ICV_STACKSIZE:
icv_addr[0] = &icvs->stacksize;
break;
case GOMP_ICV_CANCELLATION:
icv_addr[0] = &gomp_cancel_var;
break;
case GOMP_ICV_DISPLAY_AFFINITY:
icv_addr[0] = &gomp_display_affinity_var;
break;
case GOMP_ICV_TARGET_OFFLOAD:
icv_addr[0] = &gomp_target_offload_var;
break;
case GOMP_ICV_MAX_TASK_PRIORITY:
icv_addr[0] = &gomp_max_task_priority_var;
break;
case GOMP_ICV_ALLOCATOR:
icv_addr[0] = &gomp_def_allocator;
break;
case GOMP_ICV_DEFAULT_DEVICE:
icv_addr[0] = &icvs->default_device_var;
icv_addr[1] = (void *) true;
break;
}
}
struct gomp_icv_list *
gomp_get_initial_icv_item (int dev_num)
{
struct gomp_icv_list *l = gomp_initial_icv_list;
while (l != NULL && l->device_num != dev_num)
l = l->next;
return l;
}
static void
initialize_icvs (struct gomp_initial_icvs *icvs)
{
icvs->nthreads_var_list = NULL;
icvs->bind_var_list = NULL;
icvs->nthreads_var = gomp_default_icv_values.nthreads_var;
icvs->nthreads_var_list_len = 0;
icvs->bind_var_list_len = 0;
icvs->stacksize = 0;
icvs->thread_limit_var = gomp_default_icv_values.thread_limit_var;
icvs->run_sched_var = gomp_default_icv_values.run_sched_var;
icvs->run_sched_chunk_size = gomp_default_icv_values.run_sched_chunk_size;
icvs->default_device_var = gomp_default_icv_values.default_device_var;
icvs->dyn_var = gomp_default_icv_values.dyn_var;
icvs->max_active_levels_var = gomp_default_icv_values.max_active_levels_var;
icvs->bind_var = gomp_default_icv_values.bind_var;
icvs->nteams_var = gomp_default_icv_values.nteams_var;
icvs->teams_thread_limit_var = gomp_default_icv_values.teams_thread_limit_var;
icvs->wait_policy = -1;
}
/* Helper function for initialize_env to add a device specific ICV value
to gomp_initial_icv_list. */
static uint32_t *
add_initial_icv_to_list (int dev_num, int icv_code, void *icv_addr[3])
{
struct gomp_icv_list *last = NULL, *l = gomp_initial_icv_list;
while (l != NULL && l->device_num != dev_num)
{
last = l;
l = l->next;
}
if (l == NULL)
{
l = ((struct gomp_icv_list *)
gomp_malloc_cleared (sizeof (struct gomp_icv_list)));
l->device_num = dev_num;
initialize_icvs (&l->icvs);
if (dev_num < 0)
{
l->next = gomp_initial_icv_list;
gomp_initial_icv_list = l;
}
else
{
l->next = NULL;
if (last == NULL)
gomp_initial_icv_list = l;
else
last->next = l;
}
}
get_icv_member_addr (&l->icvs, icv_code, icv_addr);
return &l->flags;
}
/* Return true if STR string starts with PREFIX. */
static inline bool
startswith (const char *str, const char *prefix)
{
return strncmp (str, prefix, strlen (prefix)) == 0;
}
static void __attribute__((destructor))
cleanup_env (void)
{
if (gomp_def_allocator_envvar != NULL)
{
free (gomp_def_allocator_envvar);
omp_destroy_allocator (gomp_def_allocator);
}
}
static void __attribute__((constructor))
initialize_env (void)
{
char **env;
int omp_var, dev_num = 0, dev_num_len = 0, i;
bool ignore = false;
char *env_val;
void *params[3];
uint32_t *flag_var_addr = NULL;
unsigned pos;
struct gomp_icv_list *all, *none;
/* Do a compile time check that mkomp_h.pl did good job. */
omp_check_defines ();
#ifndef HAVE_SYNC_BUILTINS
gomp_mutex_init (&gomp_managed_threads_lock);
#endif
gomp_init_num_threads ();
gomp_available_cpus = gomp_global_icv.nthreads_var;
/* Initial values for host environment variables should always exist even if
there is no explicitly set host environment variable. Moreover, they are
set to the initial global values. */
add_initial_icv_to_list (GOMP_DEVICE_NUM_FOR_NO_SUFFIX, 0, NULL);
none = gomp_get_initial_icv_item (GOMP_DEVICE_NUM_FOR_NO_SUFFIX);
initialize_icvs (&none->icvs);
if (environ)
for (env = environ; *env != 0; env++)
{
if (!startswith (*env, "OMP_"))
continue;
/* Name of the environment variable without suffix "OMP_". */
char *name = *env + sizeof ("OMP_") - 1;
for (omp_var = 0; omp_var < OMP_VAR_CNT; omp_var++)
{
if (startswith (name, envvars[omp_var].name))
{
pos = envvars[omp_var].name_len;
if (name[pos] == '=')
{
pos++;
flag_var_addr
= add_initial_icv_to_list (GOMP_DEVICE_NUM_FOR_NO_SUFFIX,
envvars[omp_var].flag_vars[0],
params);
}
else if (startswith (&name[pos], "_DEV=")
&& envvars[omp_var].flag & GOMP_ENV_SUFFIX_DEV)
{
pos += 5;
flag_var_addr
= add_initial_icv_to_list (GOMP_DEVICE_NUM_FOR_DEV,
envvars[omp_var].flag_vars[0],
params);
}
else if (startswith (&name[pos], "_ALL=")
&& envvars[omp_var].flag & GOMP_ENV_SUFFIX_ALL)
{
pos += 5;
flag_var_addr
= add_initial_icv_to_list (GOMP_DEVICE_NUM_FOR_ALL,
envvars[omp_var].flag_vars[0],
params);
}
else if (startswith (&name[pos], "_DEV_")
&& envvars[omp_var].flag & GOMP_ENV_SUFFIX_DEV_X)
{
pos += 5;
if (!get_device_num (*env, &name[pos], &dev_num,
&dev_num_len))
break;
pos += dev_num_len + 1;
flag_var_addr
= add_initial_icv_to_list (dev_num,
envvars[omp_var].flag_vars[0],
params);
}
else
{
gomp_error ("Invalid environment variable in %s", *env);
break;
}
env_val = &name[pos];
if (envvars[omp_var].parse_func (*env, env_val, params))
{
for (i = 0; i < 3; ++i)
if (envvars[omp_var].flag_vars[i])
gomp_set_icv_flag (flag_var_addr,
envvars[omp_var].flag_vars[i]);
else
break;
}
break;
}
}
}
all = gomp_get_initial_icv_item (GOMP_DEVICE_NUM_FOR_ALL);
for (omp_var = 0; omp_var < OMP_HOST_VAR_CNT; omp_var++)
{
if (none != NULL
&& gomp_get_icv_flag (none->flags, host_envvars[omp_var].flag_var))
get_icv_member_addr (&none->icvs,
host_envvars[omp_var].flag_var, params);
else if (all != NULL
&& gomp_get_icv_flag (all->flags,
host_envvars[omp_var].flag_var))
get_icv_member_addr (&all->icvs, host_envvars[omp_var].flag_var,
params);
else
continue;
switch (host_envvars[omp_var].type_code)
{
case PARSE_INT:
for (i = 0; i < 3; ++i)
if (host_envvars[omp_var].dest[i] != NULL && params[i] != NULL)
*(int *) (host_envvars[omp_var].dest[i]) = *(int *) params[i];
break;
case PARSE_BOOL:
for (i = 0; i < 3; ++i)
if (host_envvars[omp_var].dest[i] != NULL && params[i] != NULL)
*(bool *) (host_envvars[omp_var].dest[i]) = *(bool *) params[i];
break;
case PARSE_UINT:
for (i = 0; i < 3; ++i)
if (host_envvars[omp_var].dest[i] != NULL && params[i] != NULL)
*(unsigned int *) (host_envvars[omp_var].dest[i])
= *(unsigned int *) params[i];
break;
case PARSE_ULONG:
for (i = 0; i < 3; ++i)
if (host_envvars[omp_var].dest[i] != NULL && params[i] != NULL)
*(unsigned long *) (host_envvars[omp_var].dest[i])
= *(unsigned long *) params[i];
break;
case PARSE_UCHAR:
for (i = 0; i < 3; ++i)
if (host_envvars[omp_var].dest[i] != NULL && params[i] != NULL)
*(unsigned char *) (host_envvars[omp_var].dest[i])
= *(unsigned char *) params[i];
break;
case PARSE_SCHEDULE:
*(enum gomp_schedule_type *) (host_envvars[omp_var].dest[0])
= *(enum gomp_schedule_type *) params[0];
*(int *) (host_envvars[omp_var].dest[1]) = *(int *) params[1];
break;
case PARSE_BIND:
*(char *) (host_envvars[omp_var].dest[0]) = *(char *) params[0];
*(char **) (host_envvars[omp_var].dest[1]) = *(char **) params[1];
*(unsigned long *) (host_envvars[omp_var].dest[2])
= *(unsigned long *) params[2];
break;
}
}
if (((none != NULL && gomp_get_icv_flag (none->flags, GOMP_ICV_BIND))
|| (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_BIND)))
&& gomp_global_icv.bind_var == omp_proc_bind_false)
ignore = true;
if (!((none != NULL
&& gomp_get_icv_flag (none->flags, GOMP_ICV_MAX_ACTIVE_LEVELS))
|| (all != NULL
&& gomp_get_icv_flag (all->flags, GOMP_ICV_MAX_ACTIVE_LEVELS))))
{
bool nested = true;
const char *env = getenv ("OMP_NESTED");
/* OMP_NESTED is deprecated in OpenMP 5.0. */
if (parse_boolean ("OMP_NESTED", env, (void *[]) {&nested}))
gomp_global_icv.max_active_levels_var
= nested ? gomp_supported_active_levels : 1;
else if (gomp_nthreads_var_list_len > 1 || gomp_bind_var_list_len > 1)
gomp_global_icv.max_active_levels_var = gomp_supported_active_levels;
}
if (gomp_global_icv.default_device_var == INT_MIN
&& gomp_target_offload_var != GOMP_TARGET_OFFLOAD_MANDATORY)
none->icvs.default_device_var = gomp_global_icv.default_device_var = 0;
/* Process GOMP_* variables and dependencies between parsed ICVs. */
parse_int_secure ("GOMP_DEBUG", &gomp_debug_var, true);
/* Make sure OMP_PLACES and GOMP_CPU_AFFINITY env vars are always
parsed if present in the environment. If OMP_PROC_BIND was set
explicitly to false, don't populate places list though. If places
list was successfully set from OMP_PLACES, only parse but don't process
GOMP_CPU_AFFINITY. If OMP_PROC_BIND was not set in the environment,
default to OMP_PROC_BIND=true if OMP_PLACES or GOMP_CPU_AFFINITY
was successfully parsed into a places list, otherwise to
OMP_PROC_BIND=false. */
if (parse_places_var ("OMP_PLACES", ignore))
{
if (gomp_global_icv.bind_var == omp_proc_bind_false)
gomp_global_icv.bind_var = true;
ignore = true;
}
if (parse_affinity (ignore))
{
if (gomp_global_icv.bind_var == omp_proc_bind_false)
gomp_global_icv.bind_var = true;
ignore = true;
}
if (gomp_global_icv.bind_var != omp_proc_bind_false)
gomp_init_affinity ();
{
const char *env = getenv ("OMP_AFFINITY_FORMAT");
if (env != NULL)
gomp_set_affinity_format (env, strlen (env));
}
if (none != NULL && gomp_get_icv_flag (none->flags, GOMP_ICV_WAIT_POLICY))
wait_policy = none->icvs.wait_policy;
else if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_WAIT_POLICY))
wait_policy = all->icvs.wait_policy;
if (!parse_spincount ("GOMP_SPINCOUNT", &gomp_spin_count_var))
{
/* Using a rough estimation of 100000 spins per msec,
use 5 min blocking for OMP_WAIT_POLICY=active,
3 msec blocking when OMP_WAIT_POLICY is not specificed
and 0 when OMP_WAIT_POLICY=passive.
Depending on the CPU speed, this can be e.g. 5 times longer
or 5 times shorter. */
if (wait_policy > 0)
gomp_spin_count_var = 30000000000LL;
else if (wait_policy < 0)
{
gomp_spin_count_var = 300000LL;
do_adjust_default_spincount ();
}
}
/* gomp_throttled_spin_count_var is used when there are more libgomp
managed threads than available CPUs. Use very short spinning. */
if (wait_policy > 0)
gomp_throttled_spin_count_var = 1000LL;
else if (wait_policy < 0)
gomp_throttled_spin_count_var = 100LL;
if (gomp_throttled_spin_count_var > gomp_spin_count_var)
gomp_throttled_spin_count_var = gomp_spin_count_var;
/* Not strictly environment related, but ordering constructors is tricky. */
pthread_attr_init (&gomp_thread_attr);
if (!(none != NULL && gomp_get_icv_flag (none->flags, GOMP_ICV_STACKSIZE)))
{
const char *env = getenv ("GOMP_STACKSIZE");
if (env != NULL
&& parse_stacksize ("GOMP_STACKSIZE", env,
(void *[3]) {&none->icvs.stacksize}))
gomp_set_icv_flag (&none->flags, GOMP_ICV_STACKSIZE);
}
if (none != NULL && gomp_get_icv_flag (none->flags, GOMP_ICV_STACKSIZE))
stacksize = none->icvs.stacksize;
else if (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_STACKSIZE))
stacksize = all->icvs.stacksize;
if ((none != NULL && gomp_get_icv_flag (none->flags, GOMP_ICV_STACKSIZE))
|| (all != NULL && gomp_get_icv_flag (all->flags, GOMP_ICV_STACKSIZE))
|| GOMP_DEFAULT_STACKSIZE)
{
int err;
err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize);
#ifdef PTHREAD_STACK_MIN
if (err == EINVAL)
{
if (stacksize < PTHREAD_STACK_MIN)
gomp_error ("Stack size less than minimum of %luk",
PTHREAD_STACK_MIN / 1024ul
+ (PTHREAD_STACK_MIN % 1024 != 0));
else
gomp_error ("Stack size larger than system limit");
}
else
#endif
if (err != 0)
gomp_error ("Stack size change failed: %s", strerror (err));
}
handle_omp_display_env ();
/* OpenACC. */
if (!parse_int ("ACC_DEVICE_NUM", getenv ("ACC_DEVICE_NUM"),
(void *[]) {&goacc_device_num, (void *) true}))
goacc_device_num = 0;
parse_acc_device_type ();
parse_gomp_openacc_dim ();
goacc_runtime_initialize ();
goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
Reference in New Issue View Git Blame Copy Permalink