Supported Environment Variables

Intel® Fortran Compiler

Developer Guide and Reference

Download PDF

ID 767251

Date 3/31/2025

Version

Public

Supported Environment Variables

Compiler Compile-Time Environment Variables

The following table shows the compile-time environment variables that affect the compiler:

Compile-Time Environment Variable	Description
`IFXCFG`	Specifies an `ifx` configuration file that the compiler should use instead of the default configuration file. By default, the compiler uses the default configuration file (`ifx.cfg`) from the same directory where the compiler executable resides. NOTE: On Windows, this environment variable cannot be set from Visual Studio.
`__INTEL_PRE_FFLAGS` `__INTEL_POST_FFLAGS`	Specifies a set of compiler options to add to the compile line. This is an extension to the facility already provided in the compiler configuration file `ifx.cfg`. NOTE: By default, a configuration file named `ifx.cfg` is used. This file is in the same directory as the compiler executable. To use another configuration file in another location, you can use the `IFXCFG` environment variable to assign the directory and file name for the configuration file. You can insert command line options in the prefix position using `__INTEL_PRE_FFLAGS` , or in the suffix position using `__INTEL_POST_FFLAGS`. The command line is built as follows: Syntax: `ifx <PRE flags> <flags from configuration file> <flags from the compiler invocation> <POST flags>` NOTE: The driver issues a warning that the compiler is overriding an option because of an environment variable, but only when you include the option `-w3` (Linux) or `/W5` (Windows).
`PATH`	Specifies the directories the system searches for binary executable files. NOTE: On Windows, this also affects the search for Dynamic Link Libraries (DLLs).
`TMP` `TMPDIR` `TEMP`	Specifies the location for temporary files. If none of these are specified, or writeable, or found, the compiler stores temporary files in `/tmp` (Linux) or the current directory (Windows). The compiler searches for these variables in the following order: `TMP`, `TMPDIR`, and `TEMP`. NOTE: On Windows, these environment variables cannot be set from Visual Studio.
`LD_LIBRARY_PATH` (Linux)	Specifies the location for shared objects (`.so` files).
`INCLUDE (Windows)`	Specifies the directory path for the include files (files included by `INCLUDE` statements, `#include` files, `RC INCLUDE` files¹, and module files referenced by `USE` statements). ¹ Files from the Resource Compiler, used to create dialog boxes and other Windows-GUI interfaces.
`LIB` (Windows)	Specifies the directories for all libraries used by the compiler and linker.
GNU Environment Variables and Extensions
`CPATH` (Linux)	Specifies the path for include and module files.
`LIBRARY_PATH` (Linux)	Specifies the path for libraries to be used during the link phase.

NOTE:

INTEL_ROOT is an environment variable that is reserved for the Intel® Fortran Compiler. Its use is not supported. Use of this variable may result in unexpected compiler behavior.

Compiler Runtime Environment Variables

The Intel® Fortran Compiler runtime system recognizes a number of environment variables. These variables can be used to customize runtime diagnostic error reporting, allow program continuation under certain conditions, disable the display of certain dialog boxes under certain conditions, and allow just-in-time debugging.

Environment variables relating to file I/O are interpreted when the file is opened. Other variables are read when the program starts.

The order of precedence for runtime environment variables is:

OPEN keyword
Environment variable(s)
Command line option

For Fortran runtime environment variables that are boolean (either enabled or disabled), the following tables describe values you can use to enable or disable them. These rules do not apply to environment variables for OpenMP* (OMP_) and their extensions (KMP_).

Setting a Runtime Environment Variable to ON or OFF	Examples
An integer composed entirely of digits other than 0 enables the environment variable.	1 4938493848
A string starting with t or T, y or Y, enables the environment variable. Because you cannot include quotes, or spaces preceding the string, " T" and ' YES' do not work, because both spaces and quotation marks are considered letters.	T t TRUE TFALSE Y y yes yeti
Anything that does not enable the environment variable disables it.	0 -1 +1 <no value set>

Setting a Runtime Environment Variable to ON or OFF

Examples

An integer composed entirely of digits other than 0 enables the environment variable.

4938493848

A string starting with t or T, y or Y, enables the environment variable.

Because you cannot include quotes, or spaces preceding the string, " T" and ' YES' do not work, because both spaces and quotation marks are considered letters.

TRUE

TFALSE

yes

yeti

Anything that does not enable the environment variable disables it.

-1

The following table summarizes compiler environment variables that are recognized at runtime.

Environment Variable	Default Value	Description
`F_UFMTENDIAN`	n/a	This variable specifies the numbers of the units to be used for little-endian-to-big-endian conversion purposes. See Environment Variable F_UFMTENDIAN Method. The variable is retrieved once when the first unit is opened, and then checked for every open.
`CL_CONFIG_CPU_EXPENSIVE_MEM_OPT`	0	A bitmap indicating enabled expensive memory optimizations. These optimizations may lead to more just-in-time (JIT) compilation time, but give some performance benefit. NOTE: Currently, only the least significant bit is available. Available bits: 0: OpenCL™ address space alias analysis
`CL_CONFIG_CPU_FORCE_LOCAL_MEM_SIZE`	32KB	Forces `CL_DEVICE_LOCAL_MEM_SIZE` for CPU device to be the given value. The value needs to be set with size including units, examples: 8MB, 8192KB, 8388608B. NOTE: You must compile your host application with sufficient stack size. Our recommendation is to set the stack size equal to twice the local memory size to cover possible application and OpenCL™ Runtime overheads.
`CL_CONFIG_CPU_FORCE_PRIVATE_MEM_SIZE`	32KB	Forces `CL_DEVICE_PRIVATE_MEM_SIZE` for the CPU device to be the given value. The value must include the unit; for example: 8MB, 8192KB, 8388608B. NOTE: You must compile your host application with sufficient stack size.
`CL_CONFIG_CPU_STREAMING_ALWAYS`	`FALSE`	Controls whether non-temporal instructions are used.
`FOR_ACCEPT`	n/a	The `ACCEPT` statement does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the `FOR_ACCEPT` environment variable. If `FOR_ACCEPT` is not defined, the code `ACCEPT f,iolist` reads from standard input. If `FOR_ACCEPT` is defined (as a file name optionally containing a path), the specified file would be read.
`FOR_COARRAY_CONFIG_FILE`	n/a	This variable specifies the coarray configuration file and path to be used at execution time. The variable overrides the value specified by the `[Q]coarray-config-file=value` qualifier at runtime.
`FOR_COARRAY_DEBUG_STARTUP`	n/a	Boolean. When set to `TRUE`, this variable tells the Fortran runtime library to display the Message Passing Interface (MPI) launcher command that begins the underlying parallel support for coarrays.
`FOR_COARRAY_MPI_VERBOSE`	n/a	Boolean. When set to `TRUE`, this variable tells the Fortran runtime library to pass the `-verbose` qualifier to the MPI support underlying the coarray implementation so that MPI will issue status and activity messages.
`FOR_COARRAY_NUM_IMAGES`	n/a	This variable specifies the number of images created for coarrays. The value overrides the value specified by the `[Q]coarray-num-images=value` qualifier at runtime. If neither is specified, the number of logical processors is used.
`FOR_DEBUGGER_IS_PRESENT`	`FALSE`	Boolean. When set to `TRUE`, this variable tells the Fortran runtime library that your program is executing under a debugger, and generates debug exceptions whenever severe or continuable errors are detected. Under normal conditions, this variable can be extracted from the operating system for Windows. User-convenience feature: If you set this environment variable to a `TRUE` value (such as 1) on Windows and your program executes an `ERROR STOP` statement, the Windows system function `__debugbreak` will be called and will bring up the Windows debugger (if it is really present). You can use the debugger to look at the state of the application, and any step or continue command will continue the `ERROR STOP` process and terminate the application. On Linux, this variable must be set for debug exceptions. Setting this variable to `TRUE` when a program is not executing under a debugger causes unpredictable behavior.
`FOR_DEFAULT_PRINT_DEVICE` (Windows)	n/a	This variable lets you specify the print device other than the default print device `PRN` (`LPT1`) for files closed (`CLOSE` statement) with the `DISPOSE='PRINT'` specifier. To specify a different print device for the file associated with the `CLOSE` statement `DISPOSE='PRINT'` specifier, set `FOR_DEFAULT_PRINT_DEVICE` to any legal spooled print device before executing the program. It can also be used for the `PRINT` settings in the `OPEN: DISPOSE` specifier.
`FOR_DIAGNOSTIC_LOG_FILE`	n/a	If this variable is set to the name of a file, diagnostic output is written to the specified file. The Fortran runtime system attempts to open that file (append output) and write the error information (ASCII text) to the file. Because the setting of `FOR_DIAGNOSTIC_LOG_FILE` is independent of `FOR_DISABLE_DIAGNOSTIC_DISPLAY`, you can disable the screen display of information but still capture the error information in a file. Because the text string you assign for the file name is used literally, you must specify the full name. If the file open fails, no error is reported and the runtime system continues diagnostic processing. See also Locating Runtime Errors and Traceback.
`FOR_DISABLE_DIAGNOSTIC_DISPLAY`	n/a	Boolean. When set to `TRUE`, this variable disables the display of all error information. This variable is helpful if you just want to test the error status of your program and do not want the Fortran runtime system to display any information about an abnormal program termination. See also Traceback.
`FOR_DISABLE_KMP_MALLOC`	`FALSE`	Boolean. When set to `TRUE`, this variable forces Fortran allocate statements to resolve to `glibc malloc`.
`FOR_DISABLE_STACK_TRACE`	`FALSE`	Boolean. When set to `TRUE`, this variable disables the call stack trace information that typically follows the displayed severe error message text. The Fortran runtime error message is displayed regardless of whether `FOR_DISABLE_STACK_TRACE` is set to `TRUE`. If the program is executing under a debugger, the automatic output of the stack trace information by the Fortran library will be disabled to reduce noise. Use the debugger's stack trace facility to view the stack trace. See also Locating Runtime Errors and Traceback.
`FOR_DUMP_CORE_FILE`	`FALSE`	Boolean. When set to `TRUE`, if an Intel® Fortran runtime error occurs the program will attempt to exit in a way that causes the system to generate a core dump file. The system must be configured to generate core dumps for this flag to have an effect. The location of the core dump file is system-dependent. `decfort_dump_flag` is an alternate spelling for `FOR_DUMP_CORE_FILE`.
`FOR_FASTMEM_NORETRY`	`TRUE`	Boolean. When set to `TRUE`, this variable specifies that if an allocation from `FASTMEM` fails because either the `libmemkind` library is not linked into the executable or HBW memory is not available on the node then the runtime will report the failure to the user via `STAT=` or `ERRMSG=` or aborting the program with the appropriate error message. The variable is retrieved once at program initialization, and checked for each `FASTMEM` memory allocation.
`FOR_FASTMEM_RETRY`	`FALSE`	Boolean. When set to `TRUE`, this variable specifies that if an allocation from `FASTMEM` fails because either the `libmemkind` library is not linked into the executable or HBW memory is not available on the node then memory will be allocated from the default memory allocator for that platform. The variable is retrieved once at program initialization, and checked for each `FASTMEM` memory allocation.
`FOR_FASTMEM_RETRY_WARN`	`FALSE`	Boolean. When set to `TRUE`, this variable specifies that if an allocation from `FASTMEM` fails because either the `libmemkind` library is not linked into the executable or HBW memory is not available on the node then a warning message will be issued to `stdout` and memory will be allocated from the default memory allocator for that platform. The variable is retrieved once at program initialization, and checked for each `FASTMEM` memory allocation.
`FOR_FMT_TERMINATOR`		This variable specifies the numbers of the units to have a specific record terminator. See Record Types. The variable is retrieved once when the first unit is opened, and then checked for every open.
`FOR_FORCE_STACK_TRACE`	`FALSE`	Boolean. When set to `TRUE`, this variable forces a traceback to follow any runtime diagnostic message. If `FOR_DISABLE_STACK_TRACE` is also set, `FOR_FORCE_STACK_TRACE` takes precedence over `FOR_DISABLE_STACK_TRACE`.
`FOR_IGNORE_EXCEPTIONS`	`FALSE`	Boolean. When set to `TRUE`, this variable disables default runtime exception handling to allow, for example, just-in-time debugging. The runtime system exception handler returns `EXCEPTION_CONTINUE_SEARCH` to the operating system, which looks for other handlers to service the exception.
`FOR_NOERROR_DIALOGS`	`FALSE`	Boolean. When set to `TRUE`, this variable disables the display of dialog boxes when certain exceptions or errors occur. This is useful when running many test programs in batch mode to prevent a failure from stopping execution of the entire test stream.
`FOR_PRINT`	n/a	Neither the `PRINT` statement nor a `WRITE` statement with an asterisk () in place of a unit number includes an explicit logical unit number. Instead, both use an implicit internal logical unit number and the `FOR_PRINT` environment variable. If `FOR_PRINT` is not defined, the code `PRINT f,iolist` or `WRITE (,f) iolist` writes to standard output. If `FOR_PRINT` is defined (as a file name optionally containing a path), the specified file would be written to.
`FOR_READ`	n/a	A `READ` statement that uses an asterisk () in place of a unit number does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the `FOR_READ` environment variable. If `FOR_READ` is not defined, the code `READ (,f) iolist` or `READ f,iolist` reads from standard input. If `FOR_READ` is defined (as a file name optionally containing a path), the specified file would be read.
`FOR_TYPE`	n/a	The `TYPE` statement does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the `FOR_TYPE` environment variable. If `FOR_TYPE` is not defined, the code `TYPE f,iolist` writes to standard output. If `FOR_TYPE` is defined (as a file name optionally containing a path), the specified file would be written to.
`FORT_BLOCKSIZE`	n/a	Specifies the default `BLOCKSIZE` value to be used when `BLOCKSIZE=` is omitted on the `OPEN` statement. Valid values are 0 to 2147467264. Sizes are rounded up to the next 512-byte boundary. This variable applies to all Fortran I/O units except `stderr`, which is never buffered. The variable is retrieved once at program initialization, and checked for each unit open.
`FORT_BUFFERCOUNT`	n/a	Specifies the default `BUFFERCOUNT` value to be used when `BUFFERCOUNT=` is omitted on the `OPEN` statement. Valid values are 0 to 127. If set to 0, the default value of 1 is used. This variable applies to all Fortran I/O units except `stdout` (units * and 6) and `stderr`. The variable is retrieved once at program initialization, and checked for each unit open.
`FORT_BUFFERED`	`FALSE`	Boolean. When set to `TRUE`, this variable specifies that buffered I/O should be used at runtime for input and output on all Fortran I/O units, except `stdout` (units * and 6). Output to `stderr` is never buffered.
`FORT_BUFFERING_THRESHOLD=n`	n/a	Specifies dynamic buffering for unformatted sequential READ operations: I/O list items with a size `<=n` are buffered and are moved one at a time from the buffer to the I/O list item. I/O list items with a size `>n` are not buffered and are moved one at a time from the file to the I/O list item.
`FORT_CONVERT.ext` and `FORT_CONVERT_ext`	n/a	Specifies the data format for unformatted files with a particular file extension suffix (`.ext`), as described in Specify the Data Format.
`FORT_CONVERTn`	n/a	Specifies the data format for an unformatted file associated with a particular unit number (`n`), as described in Specify the Data Format.
`FORT_FMT_NO_WRAP_MARGIN`	`FALSE` (Wrap margin)	Boolean. When set to `TRUE`, disables column wrapping in Fortran list-directed output when the record being written is longer than 80 characters. NOTE: There is no environment variable to set a value for the right margin, this only disables wrapping. The `RECL=` open specifier can be used to set the right margin when the unit is opened.
`FORT_FMT_RECL`	n/a	Specifies the default record length (normally 132 bytes) for formatted files. The variable is retrieved once at program initialization, and checked for each unit open.
`FORT_TMPDIR` `TMP` `TMPDIR` `TEMP`	n/a	Specifies an alternate working directory where scratch files are created.
`FORT_UFMT_RECL`	n/a	Specifies the default record length (normally 2040 bytes) for unformatted files. The variable is retrieved once at program initialization, and checked for each unit open.
`FORTn`	n/a	Specifies the file name for a particular unit number `n`, when a file name is not specified in the `OPEN` statement or an implicit `OPEN` is used, and the compiler option `fpscomp` with option keyword `filesfromcmd` was not specified. Preconnected files attached to units 0, 5, and 6 are associated with system standard I/O files by default.
`GOMP_CPU_AFFINITY` (Linux)	Affinity is disabled	GNU extension recognized by the Intel OpenMP compatibility library. Specifies a list of OS processor IDs. You must set this environment variable before the first parallel region or before certain API calls including `omp_get_max_threads()`, `omp_get_num_procs()` and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface.
`GOMP_STACKSIZE` (Linux)	See the description for `OMP_STACKSIZE`.	GNU extension recognized by the Intel OpenMP compatibility library. Same as `OMP_STACKSIZE.KMP_STACKSIZE` overrides `GOMP_STACKSIZE,` which overrides `OMP_STACKSIZE.`
`KMP_AFFINITY`	`noverbose,warnings,noreset,respect,granularity=core,none` (Linux) `noverbose,warnings,noreset,norespect,granularity=group,compact,0,0` (Windows with multiple processor groups)	Enables runtime library to bind threads to physical processing units. You must set this environment variable before the first parallel region, or certain API calls including `omp_get_max_threads()`, `omp_get_num_procs()` and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface. NOTE: On Windows with multiple processor groups, the `norespect` affinity modifier is assumed when the process affinity mask equals a single processor group (which is the default on Windows). Otherwise, the `respect` affinity modifier is used.
`KMP_ALL_THREADS`	No enforced limit.	Limits the number of simultaneously-executing threads in an OpenMP program. If this limit is reached and another native operating system thread encounters OpenMP API calls or constructs, then the program may abort with an error message. If this limit is reached at the time an OpenMP parallel region begins, a one-time warning message may be generated indicating that the number of threads in the team was reduced, but the program will continue execution. This environment variable is only used for programs compiled with the `[q or Q]openmp` compiler option.
`KMP_BLOCKTIME`	When Intel® Hybrid Technology is detected, 0 milliseconds In all other cases, 200 milliseconds	Sets the time that a thread should busy-wait after completing execution of a parallel region before going to sleep. Use the optional character suffixes: `us` (microseconds) or `ms` (milliseconds) to specify the units. When no character suffix is specified, milliseconds are assumed. Specify `infinite` for an unlimited wait time. Related Environment Variable: `KMP_LIBRARY` environment variable.
`KMP_CPUINFO_FILE`	None	Specifies an alternate file name for a file containing the machine topology description. The file must be in the same format as /proc/cpuinfo.
`KMP_DETERMINISTIC_REDUCTION`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the use of a specific ordering of the reduction operations for implementing the reduction clause for an OpenMP parallel region. This has the effect that, for a given number of threads, in a given parallel region, for a given data set and reduction operation, a floating point reduction done for an OpenMP reduction clause has a consistent floating point result from run to run, since round-off errors are identical. NOTE: When compiling, you must set the following option to ensure correct behavior: Linux: `-fp-model precise` Windows: `-fp:precise`
`KMP_DYNAMIC_MODE`	When the Thread Composability Manager library is available, `tcm`. In all other cases, `thread_limit`.	Selects the method used to determine the number of threads to use for a parallel region when `OMP_DYNAMIC=TRUE`. Possible values: `tcm`: Requests threads from the Thread Composability Manager. `load_balance`: Tries to avoid using more threads than available execution units on the machine. `thread_limit`: Tries to avoid using more threads than total execution units on the machine.
`KMP_HIDDEN_HELPER_AFFINITY` (Linux)	`noverbose,warnings,granularity=core,none`	Enables runtime library to bind hidden helper threads to physical processing units. You must set this environment variable before the first hidden helper task, parallel region, or certain API calls including `omp_get_max_threads()`, `omp_get_num_procs()`, and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface. The syntax of this environment variable is equivalent to `KMP_AFFINITY` except that `reset`/`noreset` and `respect`/`norespect` modifiers are not available for this environment variable.
`KMP_HOT_TEAMS_MAX_LEVEL`	1	Sets the maximum nested level to which teams of threads will be hot. NOTE: A hot team is a team of threads optimized for faster reuse by subsequent parallel regions. In a hot team, threads are kept ready for execution of the next parallel region, in contrast to the cold team, which is freed after each parallel region, with its threads going into a common pool of threads. For values of 2 and above, nested parallelism should be enabled.
`KMP_HOT_TEAMS_MODE`	0	Specifies the runtime behavior when the number of threads in a hot team is reduced. Possible values: 0: Extra threads are freed and put into a common pool of threads. 1: Extra threads are kept in the team in reserve, for faster reuse in subsequent parallel regions.
`KMP_HW_SUBSET`	If omitted, the default value is to use all the available hardware resources.	Specifies the subset of available hardware resources for the hardware topology hierarchy. The subset is specified in terms of number of units per upper layer unit starting from top layer downwards. For example, it can specify the number of sockets (top layer units), cores per socket, and the threads per core, to use with an OpenMP application. It is a convenient alternative to writing complicated explicit affinity settings or a limiting process affinity mask. You can also specify an offset value to set which resources to use. When available, you can specify attributes to select different subsets of resources. An extended syntax is available when `KMP_TOPOLOGY_METHOD=hwloc`. Depending on what resources are detected, you may be able to specify additional resources, such as NUMA nodes and groups of hardware resources that share certain cache levels. Basic syntax: `[:][num_units]ID[@offset][:attribute] [,[num_units]ID[@offset][:attribute]...]` where An optional colon (:) can be specified at the beginning of the syntax to specify an explicit hardware subset. The default is an implicit hardware subset. `num_units` is either a positive integer, which requests an exact number of resources, or an asterisk (), which means using all available resources at that layer (for example, using all cores per socket). If `num_units` is not specified, the asterisk () semantics are assumed. `ID` is a supported ID: S - socket `num_units` specifies the requested number of sockets. D - die `num_units` specifies the requested number of dies per socket. C - core `num_units` specifies the requested number of cores per die - if any - otherwise, per socket. T - thread `num_units` specifies the requested number of HW threads per core. Supported unit IDs are not case-sensitive. `offset` is the number of units to skip (optional). `attribute` is an attribute differentiating resources at a particular layer (optional). This is only available for the core layer on machines with Intel® Hybrid Technology. The attributes available to users are: Core type: Either `intel_atom` or `intel_core` Core efficiency: Specified as `effnum` where `num` is a number from 0 to the number of core efficiencies detected in the machine topology minus one. For example: `eff0`. The greater the efficiency number, the more performant the core. There may be more core efficiencies than core types, which can be viewed by setting `KMP_AFFINITY=verbose`. NOTE: The hardware cache can be specified as a unit, for example L2 for L2 cache, or LL for last level cache. Extended syntax when KMP_TOPOLOGY_METHOD=hwloc: Additional IDs can be specified if detected. For example: N - numa `num_units` specifies the requested number of NUMA nodes per upper layer unit, for example: per socket. TI - tile `num_units` specifies the requested number of tiles to use per upper layer unit, for example, per NUMA node. When any `numa` or `tile` units are specified in `KMP_HW_SUBSET`, the `KMP_TOPOLOGY_METHOD` will be automatically set to `hwloc`, so there is no need to set it explicitly. For an explicit hardware subset, if one or more topology layers detected by the runtime are omitted from the subset, then those topology layers are ignored. Only explicitly specified topology layers are used in the subset. For an implicit hardware subset, it is implied that the socket, core, and thread topology types should be included in the subset. Other topology layers are not implicitly included and are ignored if they are not specified in the subset. Because the socket, core and thread topology types are always included in implicit hardware subsets, when they are omitted, it is assumed that all available resources of that type should be used. Implicit hardware subsets are the default. The runtime library prints a warning, and the setting of `KMP_HW_SUBSET` is ignored if: A resource is specified, but detection of that resource is not supported by the chosen topology detection method and/or A resource is specified twice. An exception to this condition is if attributes differentiate the resource. Attributes are used when unavailable, not detected in the machine topology, or conflict with each other. This variable does not work if the OpenMP affinity is set to `disabled`. Implicit Hardware Subset Examples: `2s,4c,2t`: Use the first 2 sockets (s0 and s1), the first 4 cores on each socket (c0 - c3), and the first 2 threads per core. `2s@2,4c@8,2t`: Skip the first 2 sockets (s0 and s1) and use the next 2 sockets (s2-s3), skip the first 8 cores (c0-c7) and use the next 4 cores on each socket (c8-c11), and use the first 2 threads per core. `5C@1,3T`: Use all available sockets, skip the first core and use the next 5 cores, and use the first 3 threads per core. `1T`: Use all cores on all sockets, 1 thread per core. `1s, 1d, 1n, 1c, 1t`: Use 1 socket, 1 die per socket, 1 NUMA node per die, 1 core per NUMA mode, 1 thread per core - use a single hardware thread as a result. `4c:intel_atom,5c:intel_core`: Use all available sockets and use the first 4 Intel Atom® processor cores and the first 5 Intel® Core™ processor cores per socket. `2c:eff0,3c:eff1`: Use all available sockets and use the first 2 cores with efficiency 0 and the first 3 cores with efficiency 1 per socket. Explicit Hardware Subset Examples: `:2s,6t` Use exactly the first two sockets and 6 threads per socket. `:1t@7` Skip the first 7 threads (t0-t6) and use exactly one thread (t7). `:5c,1t` Use exactly the first 5 cores (c0-c4) and the first thread on each core. To see the result of the setting, you can specify the `verbose` modifier in the `KMP_AFFINITY` environment variable. The OpenMP runtime library will output to `stderr` stream the information about the discovered hardware topology before and after the `KMP_HW_SUBSET` setting was applied. `KMP_HW_SUBSET=1N,1L2,1L1,1T` outputs various verbose information to `stderr`, including the following lines about discovered hardware topology before and after `KMP_HW_SUBSET` was applied: Info #191: `KMP_AFFINITY` 1 socket x 4 NUMA domains/socket x 8 tiles/NUMA domain x 2 cores/tile x 4 threads/core. (64 total cores) Info #191: `KMP_HW_SUBSET` 1 socket x 1 NUMA domain/socket x 1 tile/NUMA domain x 1 core/tile x 1 thread/core (1 total cores)
`KMP_INHERIT_FP_CONTROL`	`TRUE`	Enables (`TRUE`) or disables (`FALSE`) the copying of the floating-point control settings of the primary thread to the floating-point control settings of the OpenMP worker threads at the start of each parallel region.
`KMP_LIBRARY`	`throughput`	Selects the OpenMP runtime library execution mode. The values for this variable are `serial`, `turnaround`, or `throughput`.
`KMP_PLACE_THREADS`	n/a	Deprecated; use `KMP_HW_SUBSET` instead.
`KMP_SETTINGS`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the printing of OpenMP runtime library environment variables during program execution. Two lists of variables are printed: user-defined environment variables settings and effective values of variables used by OpenMP runtime library.
`KMP_STACKSIZE`	4m	Sets the number of bytes to allocate for each OpenMP thread to use as its private stack. Recommended size is 16m. Use the optional suffixes to specify byte units: `B` (bytes), `K` (Kilobytes), `M` (Megabytes), `G` (Gigabytes), or `T` (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be `K` (Kilobytes). `KMP_STACKSIZE` overrides `GOMP_STACKSIZE`, which overrides `OMP_STACKSIZE`.
`KMP_TOPOLOGY_METHOD`	`all`	Forces OpenMP to use a particular machine topology modeling method. Possible values are: `all`: Allows OpenMP choose which topology method is most appropriate based on the platform and possibly other environment variable settings. `cpuid_leaf31`: Decodes the APIC identifiers as specified by leaf 31 of the `cpuid` instruction. `cpuid_leaf11`: Decodes the APIC identifiers as specified by leaf 11 of the `cpuid` instruction. `cpuid_leaf4`: Decodes the APIC identifiers as specified in leaf 4 of the `cpuid` instruction. `cpuinfo`: If `KMP_CPUINFO_FILE` is not specified, forces OpenMP to parse /proc/cpuinfo to determine the topology (Linux only). If `KMP_CPUINFO_FILE` is specified as described above, OpenMP uses it. `group` (Windows only): Models the machine as a 2-level map, with level 0 specifying the different processors in a group, and level 1 specifying the different groups. NOTE: Support for `group` is now deprecated and will be removed in a future release. Use `all` instead. `flat`: Models the machine as a flat (linear) list of processors. `hwloc`: Models the machine as the Portable Hardware Locality* (`hwloc`) library does. This model is the most detailed and includes, but is not limited to: NUMA nodes, packages, cores, hardware threads, caches, and Windows processor groups.
`KMP_USER_LEVEL_MWAIT`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the use of user-level `mwait` as alternative to putting waiting threads to sleep, if available, either from ring3 or `WAITPKG`.
`KMP_VERSION`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the printing of OpenMP runtime library version information during program execution.
`KMP_WARNINGS`	`TRUE`	Enables (`TRUE`) or disables (`FALSE`) displaying warnings from the OpenMP runtime library during program execution.
`LIBOMPTARGET_DEBUG`	0	Controls whether debugging information will be displayed from the offload runtime. Possible values: `0`: Disabled. `1`: Displays basic debug information from the plugin actions such as device detection, kernel compilation, memory copy operations, kernel invocations, and other plugin-dependent actions. `2`: Displays which GPU runtime API functions are invoked with which arguments and parameters in addition to the information displayed with value `1`.
`LIBOMPTARGET_DEVICES`	`DEVICE`	Controls how subdevices or sub-subdevices are exposed to users if device supports subdevices. Possible values: `DEVICE` \| `device`: Only top-level devices are reported as OpenMP devices and `subdevice` clause is supported. `SUBDEVICE` \| `subdevice`: Only first-level subdevices are reported as OpenMP devices and the program aborts when the `subdevice` clause is used. `SUBSUBDEVICE` \| `subsubdevice`: Only second-level subdevices are reported as OpenMP devices and the program aborts when the `subdevice` clause is used.
`LIBOMPTARGET_DEVICETYPE`	`GPU`	Selects device type to which a target region is offloaded. Possible values: `GPU` \| `gpu`: GPU device is used. `CPU` \| `cpu`: CPU device is used. Offload plugin support for device type: Level Zero offload plugin only supports `GPU` type. OpenCL™ offload plugin supports both `GPU` and `CPU` types. X86_64 offload plugin ignores this variable.
`LIBOMPTARGET_DYNAMIC_MEMORY_SIZE`	1	Sets the size of preallocated memory in MB to service in-kernel malloc calls on the device. Possible values: Non-negative integer.
`LIBOMPTARGET_INFO`	0	Controls whether basic offloading information will be displayed from the offload runtime. Possible values: `0`: Disabled. `1`: Prints all data arguments upon entering an OpenMP device kernel. `2`: Indicates when a mapped address already exists in the device mapping table. `4`: Dump the contents of the device pointer map if target offloading fails. `8`: Indicates when an entry is changed in the device mapping table. `32`: Indicates when data is copied to and from the device.
`LIBOMPTARGET_LEVEL_ZERO_COMMAND_MODE`	`async`	Determines how each command in a target region is executed when immediate command lists are fully enabled by setting `LIBOMPTARGET_LEVEL_ZERO_USE_IMMEDIATE_COMMAND_LIST=all`. This variable has no effect on integrated devices. Possible values: `sync`: Host waits for completion of the current submitted command. `async`: Host does not wait for completion of the command and synchronization occurs later when it is required. `async_ordered`: Same as `async`, but command execution is ordered.
`LIBOMPTARGET_LEVEL_ZERO_COMPILATION_OPTIONS`	n/a	Passes extra build options when building native target program binaries. Possible values: Valid Level Zero module build options.
`LIBOMPTARGET_LEVEL_ZERO_DEFAULT_TARGET_MEM`	`DEVICE`	Selects memory type returned by the `omp_target_alloc` routine. Possible values: `DEVICE` \| `device`: Returned memory type is `device` type. Device owns the memory and data movement is explicit. `SHARED` \| `shared`: Returned memory type is `shared` type. Ownership of the memory is shared between host and device, and data movement is implicit. `HOST` \| `host`: Returned memory type is `host` type. Host owns the memory and data movement is implicit.
`LIBOMPTARGET_LEVEL_ZERO_MEMORY_POOL`	Equivalent to `device,1,4,256,host,1,4,256,shared,8,4,256`	Controls memory pool configuration. Possible values: `0`: Disables using memory pool. -or- `<PoolInfoList>=<PoolInfo>[,<PoolInfoList>]` `<PoolInfo>=<MemType>[,<AllocMax>[,<Capacity>[,<PoolSize>]]]` where: `<MemType>`=`all` \| `device` \| `host` \| `shared` `<AllocMax>` is a positive integer or empty `<Capacity>` is a positive integer or empty `<PoolSize>` is a positive integer or empty `<PoolInfoList>` controls how reusable memory pool is configured. Pool is a list of memory blocks that can serve at least `<Capacity>` allocations of up to `<AllocMax>` size from a single block, with total size not exceeding `<PoolSize>`. When `<PoolInfoList>` only contains a subset of {device, host, shared} configurations, the default configurations are used for the unspecified memory types, and memory pool for a specific memory type can be disabled by specifying 0 for `<AllocMax>` of the memory type. Examples: `all,2,8,1024`: Enables memory pool for all memory types which can allocate up to eight 2MB blocks from a single block allocated from Level Zero with 1GB total pool size allowed. `device,1,4,512`: Enables memory pool for `device` memory type which can allocate up to four 1MB blocks from a single block allocated from Level Zero with 512MB total pool size allowed. The default configuration controls allocation from other memory types.
`LIBOMPTARGET_LEVEL_ZERO_STAGING_BUFFER_SIZE`	16	Sets the staging buffer size in KB. Staging buffer is used in copy operations between host and device as a temporary storage for a two-step copy operation. The buffer is only used for discrete devices. Possible values: Non-negative integers where 0 disables use of staging buffer.
`LIBOMPTARGET_LEVEL_ZERO_USE_COPY_ENGINE`	`all`	Controls how to use copy engines for data transfer if the device supports them. Possible values: `0` \| `F` \| `f`: Disables use of copy engines. `main`: Enables only main copy engines if the device supports it. `link`: Enables only link copy engines if the device supports it. `all`: Enables all copy engines if the device supports it.
`LIBOMPTARGET_LEVEL_ZERO_USE_IMMEDIATE_COMMAND_LIST`	`all` for XeHPC devices; otherwise, `0`	Enables or disables using immediate command list for computation and/or memory copy operations. Possible values: `0` \| `F` \| `f`: Disable. `compute`: Enable only for computation. `copy`: Enable only for copy operation. `all`: Enable for computation and copy operation.
`LIBOMPTARGET_OPENCL_COMPILATION_OPTIONS`	n/a	Passes extra compilation options when compiling target programs from SPIRV target images. Possible values: Valid OpenCL™ compilation options.
`LIBOMPTARGET_OPENCL_LINKING_OPTIONS`	n/a	Passes extra linking options when linking target programs. Possible values: Valid OpenCL™ linking options.
`LIBOMPTARGET_PLUGIN`	`LEVEL_ZERO`	Specifies which offload plugin is used when offloading a target region. Possible values: `LEVEL_ZERO` \| `LEVEL0` \| `level_zero` \| `level0`: Uses Intel® oneAPI Level Zero (Level Zero) offload plugin. `OPENCL` \| `opencl`: Uses OpenCL™ offload plugin. `X86_64` \| `x86_64`: Uses X86_64 plugin.
`LIBOMPTARGET_PLUGIN_PROFILE`	Disabled	Enables basic plugin profiling and displays the result when program finishes. Syntax: `<Value>[,usec], where <Value>=1 \| T \| t` The unit of reported time is microsecond if `,usec` is appended; otherwise, millisecond.
`NLSPATH` (Linux)	n/a	Specifies the path for the Intel® Fortran runtime error message catalog.
`OCL_ICD_ENABLE_TRACE`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the trace mechanism in the OpenCL™ Installable Client Driver (ICD) loader. The possible values are: `OCL_ICD_ENABLE_TRACE=T` `OCL_ICD_ENABLE_TRACE=1` `OCL_ICD_ENABLE_TRACE=True`
`OMP_AFFINITY_FORMAT`	'`OMP: pid %P tid %i thread %n bound to OS proc set {%A}`'	Defines the format when displaying OpenMP thread affinity information. Possible values are any string with the following format field available: `%t` or `%{team_num}`: Value returned by `omp_get_team_num()` `%T` or `%{num_teams}`: Value returned by `omp_get_num_teams()` `%L` or `%{nesting_level}`: Value returned by `omp_get_level()` `%n` or `%{thread_num}`: Value returned by `omp_get_thread_num()` `%a` or `%{ancestor_tnum}`: Value returned by `omp_get_ancestor_thread_num(omp_get_level() – 1)` `%H` or `%{host}`: Name of host device `%P` or `%{process_id}`: Process ID `%i` or `%{native_thread_id}`: Native thread ID on the platform `%A` or `%{thread_affinity}`: List of processor ID on which a thread may execute
`OMP_ALLOCATOR`	`omp_default_mem_alloc`	Specifies the default allocator for allocation calls, directives, and clauses that do not specify an allocator. Syntax: `<PredefinedMemAllocator> \| <PredefinedMemSpace> \| <PredefinedMemSpace>:<Traits>` Currently supported values for `<PredefinedMemAllocator>` and `<PredefinedMemSpace>` : `omp_default_mem_alloc` and `omp_default_mem_space` Additional values are supported if `libmemkind` is available and there is system support for it: `omp_high_bw_mem_alloc` and `omp_high_bw_mem_space` `omp_large_cap_mem_alloc` and `omp_large_cap_mem_space` Refer to the OpenMP specification for more information.
`OMP_CANCELLATION`	`FALSE`	Activates cancellation of the innermost enclosing region of the type specified. If set to `TRUE`, the effects of the cancel construct and of cancellation points are enabled and cancellation is activated. If set to `FALSE`, cancellation is disabled, and the cancel construct and cancellation points are effectively ignored. NOTE: Internal barrier code will work differently depending on whether the cancellation is enabled. Barrier code should repeatedly check the global flag to figure out if the cancellation had been triggered. If a thread observes the cancellation, it should leave the barrier prematurely with the return value 1 (may wake up other threads). Otherwise, it should leave the barrier with the return value 0. Enables (`TRUE`) or disables (`FALSE`) cancellation of the innermost enclosing region of the type specified. Example: `OMP_CANCELLATION=TRUE`
`OMP_DEBUG`	`DISABLED`	Controls whether the OpenMP runtime collects information that an OMPD library may need to support a tool. Possible values: `ENABLED` or `DISABLED`. NOTE: Only the host OpenMP runtime is supported.
`OMP_DEFAULT_DEVICE`	n/a	Sets the device that will be used in a target region. The OpenMP routine `omp_set_default_device` or a device clause in a target pragma can override this variable. If no device with the specified device number exists, the code is executed on the host. If this environment variable is not set, device number 0 is used.
`OMP_DISPLAY_AFFINITY`	`FALSE`	Instructs the runtime to display formatted affinity information for all OpenMP threads in the parallel region upon entering the first parallel region and when any change occurs in the information accessible by the format specifiers listed in the `OMP_AFFINITY_FORMAT` entry. Possible values: `TRUE` or `FALSE`
`OMP_DISPLAY_ENV`	`FALSE`	Enables (`TRUE`) or disables (`FALSE`) the printing to `stderr` of the OpenMP version number and the values associated with the OpenMP environment variable. Possible values are `TRUE`, `FALSE`, or `VERBOSE`. Example: `OMP_DISPLAY_ENV=TRUE`
`OMP_DYNAMIC`	`TRUE`: When the environment variable `TCM_ENABLE=1` and the Thread Composability Manager library is available. `FALSE`: In all other cases.	Enables (`TRUE`) or disables (`FALSE`) the dynamic adjustment of the number of threads. Example: `OMP_DYNAMIC=TRUE`
`OMP_MAX_ACTIVE_LEVELS`	1	The maximum number of levels of parallel nesting for the program. Possible values: Non-negative integer.
`OMP_MAX_TASK_PRIORITY`	0	Controls the use of task priorities by setting the initial value. Possible values: Non-negative integer.
`OMP_NESTED`	n/a	Deprecated; use `OMP_MAX_ACTIVE_LEVELS` instead.
`OMP_NUM_TEAMS`	1	Sets the maximum number of teams created by a teams construct by setting `nteams-var ICV`. Possible values: Positive integer.
`OMP_NUM_THREADS`	The number of processors visible to the operating system on which the program is executed.	Sets the maximum number of threads to use for OpenMP parallel regions if no other value is specified in the application. The value can be a single integer or numeric abstract name, in which case it specifies the number of threads for all parallel regions. The value can also be a comma-separated list of positive integers and/or numeric abstract names, in which case each value specifies the number of threads for a parallel region at a nesting level. The first position in the list represents the outer-most parallel nesting level, the second position represents the next-inner parallel nesting level, and so on. At any level, the value can be left out of the list. If any level of nesting does not have a value, it should be comma separated. If the first value in a list is left out, it implies the normal default value for threads is used at the outer-most level. If the value is left out of any other level, the number of threads for that level is inherited from the previous level. See the NOTE in `OMP_PLACES` regarding numeric abstract names for further information. This environment variable applies to option `[q or Q]openmp` and option `[Q]parallel`. Syntax:`OMP_NUM_THREADS=value[,value]*`
`OMP_PLACES`	n/a	Specifies an explicit ordered list of places, either as an abstract name describing a set of places or as an explicit list of places described by nonnegative numbers. An exclusion operator “!” can also be used to exclude the number or place immediately following the operator. For explicit lists, each nonnegative number corresponds to a single unique, operating system defined, logical processor number. On Intel® Architecture Processors, the nonnegative numbers correspond to a single and unique hardware thread. A set of these nonnegative numbers can be thought of as an operating system affinity mask. Intervals can be specified using the `<lower-bound>` : `<length>` : `<stride>` notation to represent the following list of numbers: "<lower-bound>, <lower-bound> + <stride>, ..., <lower-bound> +(<length>-1)<stride>." When `<stride>` is omitted, a unit stride is assumed. Intervals can specify numbers within a place as well as sequences of places. # EXPLICIT LIST EXAMPLE setenv OMP_PLACES "{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}" setenv OMP_PLACES "{0:4},{4:4},{8:4},{12:4}" setenv OMP_PLACES "{0:4}:4:4" For explicit lists-based values, if all numerical values are invalid for the platform, the value of `OMP_PLACES` is ignored and set to a single place representing all hardware resources available to the initial thread. If only some of the numerical values are invalid, but some are valid, then the invalid values are ignored and the valid values are used. The abstract names listed below are understood by the runtime environment: `threads`: Each place corresponds to a single hardware thread on the target machine. `cores`: Each place corresponds to a single core (having one or more hardware threads) on the target machine. `ll_caches`: Each place corresponds to a set of cores that share the last level cache on the device. `numa_domains`: Each place corresponds to a set of cores for which their closest memory on the device is the same memory and at a similar distance from the cores. `sockets`: Each place corresponds to a single socket (consisting of one or more cores) on the target machine. Depending on the runtime environment and machine topology, certain topology layers may also be available from the following abstract names: `dice`: Each place corresponds to a single die (consisting of one or more cores) on the target machine. `modules`: Each place corresponds to a single module (consisting of one or more cores) on the target machine. `tiles`: Each place corresponds to a single tile (consisting of one or more cores) on the target machine. `l1_caches`: Each place corresponds to a single L1 cache (consisting of one or more cores) on the target machine. `l2_caches`: Each place corresponds to a single L2 cache (consisting of one or more cores) on the target machine. `l3_caches`:Each place corresponds to a single L3 cache (consisting of one or more cores) on the target machine. If Intel® Hybrid Technology is available in the machine topology, certain topology layers with attributes may also be available from the following abstract names: `cores:<attribute>`: Where `<attribute>` can be one of the following: Core type: Either `intel_atom` or `intel_core` Core efficiency: Specified as `effnum` where num* is a number from 0 to the number of core efficiencies detected in the machine topology minus one. Examples: OMP_PLACES=cores:intel_core OMP_PLACES=cores:eff1 For abstract name-based values, the resources on the machine are ordered so that consecutive resources (for example, consecutive cores) are close to each other. When requesting fewer places, `N`, than available, the runtime uses the first `N` places in the ordered resource list. For example, if requesting 4 cores when more are available, then the first 4 cores are used. When requesting more places than available, all the places are used. The abstract name may be appended by a positive number in parentheses to denote the length of the place list to be created, that is `abstract_name(num-places)` Additionally, an optional stride parameter can be specified to produce lists with a stride with `abstract_name(num-places:stride)`. # ABSTRACT NAMES EXAMPLE # Set to list of all available threads. setenv OMP_PLACES threads # Set to list of first four threads. setenv OMP_PLACES threads(4) # Set to list of four threads, beginning with the first thread and then skipping every other thread. setenv OMP_PLACES threads(4:2) NOTE: Numeric abstract names can be formed for some other OpenMP environment variable values by prepending `n_` to one of the abstract names mentioned above. For example, a valid numeric abstract name is `n_cores` or `n_sockets`. When specified in other OpenMP environment variables, the numeric abstract name is replaced by the number of the specified resource. For example, if there are 8 cores detected on a machine, then `n_cores` will be substituted with 8 as the value. This is only available for OpenMP environment variables, which explicitly mention support.
`OMP_PROC_BIND`	`FALSE`	Sets the thread affinity policy to be used for parallel regions at the corresponding nested level. Enables (`TRUE`) or disables (`FALSE`) the binding of threads to processor contexts. If enabled, this is the same as specifying `KMP_AFFINITY=scatter`. If disabled, this is the same as specifying `KMP_AFFINITY=none`. Acceptable values: `TRUE`, `FALSE`, or a comma separated list, each element of which is one of the following values: `PRIMARY`, `MASTER` (deprecated), `CLOSE`, `SPREAD`. If set to `FALSE`, the execution environment may move OpenMP threads between OpenMP places, thread affinity is disabled, and `proc_bind` clauses on parallel constructs are ignored. Otherwise, the execution environment should not move OpenMP threads between OpenMP places, thread affinity is enabled, and the initial thread is bound to the first place in the OpenMP place list. If set to `PRIMARY`, all threads are bound to the same place as the primary thread. If set to `CLOSE`, threads are bound to successive places, close to where the primary thread is bound. If set to `SPREAD`, the primary thread's partition is subdivided and threads are bound to single place successive sub-partitions. NOTE: `KMP_AFFINITY` takes precedence over `GOMP_CPU_AFFINITY` and `OMP_PROC_BIND`. `GOMP_CPU_AFFINITY` takes precedence over `OMP_PROC_BIND`.
`OMP_SCHEDULE`	`static`, no chunk size specified	Sets the runtime schedule type and an optional chunk size. Example syntax:`OMP_SCHEDULE="[modifier:]kind[,chunk_size]"` where `modifier` is one of `monotonic` or `nonmonotonic` `kind` is one of `static`, `dynamic`, `guided`, or `auto` `chunk_size` is a positive integer
`OMP_STACKSIZE`	4M	Sets the number of bytes to allocate for each OpenMP thread to use as the private stack for the thread. Recommended size is 16M. Use the optional suffixes to specify byte units: `B` (bytes), `K` (Kilobytes), `M` (Megabytes), `G` (Gigabytes), or `T` (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be `K` (Kilobytes). This variable does not affect the native operating system threads created by the user program, or the thread executing the sequential part of an OpenMP program or parallel programs created using option `[Q]parallel`. The `kmp_{set,get}_stacksize_s()` routines set/retrieve the value. The `kmp_set_stacksize_s()` routine must be called from sequential part, before first parallel region is created. Otherwise, calling `kmp_set_stacksize_s()` has no effect. Related environment variables: `KMP_STACKSIZE` (overrides `OMP_STACKSIZE`). Syntax: `OMP_STACKSIZE=value`
`OMP_TARGET_OFFLOAD`	`DEFAULT`	Controls the program behavior when offloading a target region. Possible values: `MANDATORY`: Program execution is terminated if a device construct or device memory routine is encountered and the device is not available or is not supported. `DISABLED`: Disables target offloading to devices and execution occurs on the host. `DEFAULT`: Target offloading is enabled if the device is available and supported.
`OMP_TEAMS_THREAD_LIMIT`	`<NumberOfProcessors> / <nteams-var ICV>`	Sets the maximum number of OpenMP threads to use in each team created by a teams construct. Possible values: Positive integer or numeric abstract name. See the NOTE in `OMP_PLACES` regarding numeric abstract names for further information.
`OMP_THREAD_LIMIT`	No enforced limit	Limits the number of simultaneously-executing threads in an OpenMP contention group. The value can be a positive integer or a numeric abstract name. See the NOTE in `OMP_PLACES` regarding numeric abstract names for further information. If this limit is reached and another native operating system thread encounters OpenMP API calls or constructs, the program can abort with an error message. If this limit is reached when an OpenMP parallel region begins, a one-time warning message might be generated indicating that the number of threads in the team was reduced, but the program will continue. This environment variable is only used for programs compiled with the following options: `[q or Q]openmp` and `[Q]parallel`. The omp_get_thread_limit() routine returns the value of the limit. Related environment variable: `KMP_ALL_THREADS` (overrides `OMP_THREAD_LIMIT`). Example syntax: `OMP_THREAD_LIMIT=value`
`OMP_TOOL`	`ENABLED`	Controls whether the OpenMP runtime will try to register a first party tool that uses OMPT interface. Possible values: `ENABLED` or `DISABLED`. NOTE: Only the host OpenMP runtime is supported.
`OMP_TOOL_LIBRARIES`	Empty	Sets a list of first-party tool locations that use the OMPT interface. The list enumerates names of dynamically-loadable libraries with OS-specific path separator. NOTE: Only the host OpenMP runtime is supported.
`OMP_TOOL_VERBOSE_INIT`	`DISABLED`	Controls whether the OpenMP runtime will verbosely log the registration of a tool that uses the OMPT interface. Possible values: `DISABLED`: Do not log the registration. `STDOUT`: Log the registration to `stdout`. `STDERR`: Log the registration to `stderr`. `File_Name`: Log the registration to the location specified by `File_Name`. NOTE: Only the host OpenMP runtime is supported.
`OMP_WAIT_POLICY`	Passive	Decides whether threads spin (active) or yield (passive) while they are waiting. `OMP_WAIT_POLICY=ACTIVE` is an alias for `KMP_LIBRARY=turnaround`, and `OMP_WAIT_POLICY=PASSIVE` is an alias for `KMP_LIBRARY=throughput`. Syntax:`OMP_WAIT_POLICY=value`
`ONEAPI_DEVICE_SELECTOR`	See ONEAPI_DEVICE_SELECTOR	This device selection environment variable can be used to limit the choice of devices available when the SYCL* application is run. Useful for limiting devices to a certain type (like GPUs or accelerators) or backends (like Level Zero or OpenCL™). This device selection mechanism is replacing `SYCL_DEVICE_FILTER`. The `ONEAPI_DEVICE_SELECTOR` syntax is shared with OpenMP and also allows sub-devices to be chosen.
`TBK_ENABLE_VERBOSE_STACK_TRACE`	`FALSE`	Boolean. When set to `TRUE`, traceback output displays more detailed call stack information in the event of an error. The default brief output is usually sufficient to determine where an error occurred. Brief output includes up to twenty stack frames, reported one line per stack frame. For each frame, the image name containing the PC, routine name, line number, and source file are given. The verbose output, if selected, will provide the exception context record (in addition to the information in brief output) if the error was a machine exception (machine register dump), and for each frame, the return address, frame pointer and stack pointer and possible parameters to the routine. This output can be quite long (limited to 16K bytes); we recommend that you use the environment variable `FOR_DIAGNOSTIC_LOG_FILE` if you want to capture the output accurately. Most situations should not require the use of verbose output. See also Locating Runtime Errors and Traceback.
`TBK_FULL_SRC_FILE_SPEC`	`FALSE`	Boolean. When set to `TRUE`, traceback output displays complete file name information including the path. By default, the traceback output displays only the file name and extension in the source file field. See also Locating Runtime Errors and Traceback.

NOTE:

Some environment variables are available for both Intel® microprocessors and non-Intel microprocessors, but may perform additional optimizations for Intel® microprocessors than for non-Intel microprocessors.

Parent topic: Compilation

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Developer Guide and Reference

Supported Environment Variables

Compiler Compile-Time Environment Variables

Compiler Runtime Environment Variables

See Also