Supported Environment Variables

IFORTCFG

Specifies a configuration file that the compiler should use instead of the default configuration file.

By default, the compiler uses the default configuration file (ifort.cfg) from the same directory where the compiler executable resides.

INTEL_LICENSE_FILE

Specifies the location for the Intel license file.

__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 ifort.cfg.

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:ifort <PRE flags> <flags from configuration file> <flags from the compiler invocation> <POST flags>

PATH

Specifies the directories the system searches for binary executable files.

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, OS X) or the current directory (Windows).

On Windows* and OS X*, The compiler searches for these variables in the following order: TMP, TMPDIR, and TEMP.

On Linux*, The compiler searches for these variables in the following order: TMPDIR, TMP, and TEMP.

LD_LIBRARY_PATH (Linux*)

Specifies the location for shared objects (.so files).

DYLD_LIBRARY_PATH (OS X*)

Specifies the path for dynamic libraries.

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).

LIB

Specifies the directories for all libraries used by the compiler and linker.

MIC_LIBRARY_PATH

Specifies the location on the host for target-specific static libraries. LIBRARY_PATH specifies the location on the host for host-specific static libraries.

CPATH (Linux* and OS X*)

Specifies the path for include and module files.

GCCROOT (Linux*)

Specifies the location of the gcc* binaries.

Set this variable only when the compiler cannot locate the gcc binaries when using the -gcc-name option.

GXX_INCLUDE (Linux*)

Specifies the location of the gcc headers. Set this variable to specify the locations of the gcc installed files when the compiler does not find the needed values as specified by the use of -gcc-name=directory-name/gcc or -gxx-name=directory-name/g++.

GXX_ROOT (Linux*)

Specifies the location of the gcc binaries. Set this variable to specify the locations of the gcc installed files when the compiler does not find the needed values as specified by the use of -gcc-name=directory-name/gcc or -gxx-name=directory-name/g++.

LIBRARY_PATH (Linux* and OS X*)

Specifies the path for libraries to be used during the link phase.

An integer composed entirely of digits 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 doesn't enable the environment variable disables it.

0

-1

+1

<no value set>

decfort_dump_flag

Boolean.

This variable must be lowercase for Linux.

When set to TRUE, a core dump will be taken when any severe Intel® Fortran run-time error occurs.

Default: FALSE

F_UFMTENDIAN

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.

FOR_COARRAY_CONFIG_FILE (Windows* and Linux*)

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_NUM_IMAGES (Windows* and Linux*)

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.

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.

FORT_FMT_NO_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.

Default: FALSE (Wrap margin)

FOR_ACCEPT

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 CONIN$ (standard input). If FOR_ACCEPT is defined (as a file name optionally containing a path), the specified file would be read.

FOR_DEBUGGER_IS_PRESENT

Boolean.

When set to TRUE, this variable tells the Fortran run-time 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*.

On Linux* and OS X*, 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.

Default: FALSE

FOR_DEFAULT_PRINT_DEVICE (Windows*)

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 DOS print device before executing the program.

FOR_DIAGNOSTIC_LOG_FILE

If this variable is set to the name of a file, diagnostic output is written to the specified file.

The Fortran run-time 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 run-time system continues diagnostic processing.

See also Locating Run-Time Errors and Using Traceback Information Overview.

FOR_DISABLE_DIAGNOSTIC_DISPLAY

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 run-time system to display any information about an abnormal program termination.

See also Using Traceback Information Overview.

FOR_FORCE_STACK_TRACE

Boolean.

When set to TRUE, this variable forces a traceback to follow any run-time diagnostic message.

If FOR_DISABLE_STACK_TRACE is also set, FOR_FORCE_STACK_TRACE takes precedence over FOR_DISABLE_STACK_TRACE .

Default: FALSE

FOR_DISABLE_STACK_TRACE

Boolean.

When set to TRUE, this variable disables the call stack trace information that typically follows the displayed severe error message text.

The Fortran run-time 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.

Default: FALSE

See also Locating Run-Time Errors and Using Traceback Information Overview.

FOR_IGNORE_EXCEPTIONS

Boolean.

When set to TRUE, this variable disables default run-time exception handling to allow, for example, just-in-time debugging. The run-time system exception handler returns EXCEPTION_CONTINUE_SEARCH to the operating system, which looks for other handlers to service the exception.

Default: FALSE

FOR_NOERROR_DIALOGS

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.

Default: FALSE

FOR_PRINT

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 CONOUT$ (standard output). If FOR_PRINT is defined (as a file name optionally containing a path), the specified file would be written to.

FOR_READ

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 CONIN$ (standard input). If FOR_READ is defined (as a file name optionally containing a path), the specified file would be read.

FOR_TYPE

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 CONOUT$ (standard output). If FOR_TYPE is defined (as a file name optionally containing a path), the specified file would be written to.

FORT_BLOCKSIZE

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

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

Boolean.

When set to TRUE, this variable specifies that buffered I/O should be used at run time for input and output on all Fortran I/O units, except stdout (units * and 6). Output to stderr is never buffered.

Default: FALSE

FORT_BUFFERING_THRESHOLD=n

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_CONVERTn

Specifies the data format for an unformatted file associated with a particular unit number (n), as described in Methods of Specifying the Data Format.

FORT_CONVERT.ext and FORT_CONVERT_ext

Specifies the data format for unformatted files with a particular file extension suffix (.ext), as described in Methods of Specifying the Data Format.

FORT_FMT_RECL

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_UFMT_RECL

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

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.

NLSPATH (Linux* and OS X*)

Specifies the path for the Intel® Fortran run-time error message catalog.

TBK_ENABLE_VERBOSE_STACK_TRACE

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) and use of the environment variable FOR_DIAGNOSTIC_LOG_FILE is recommended if you want to capture the output accurately. Most situations should not require the use of verbose output.

Default: FALSE

See also Locating Run-Time Errors and Using Traceback Information Overview.

TBK_FULL_SRC_FILE_SPEC

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.

Default: FALSE

See also Locating Run-Time Errors and Using Traceback Information Overview.

FORT_TMPDIR

TMP

TMPDIR

TEMP

Specifies an alternate working directory where scratch files are created.

GOMP_CPU_AFFINITY (Linux*)

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.

Default: Affinity is disabled

GOMP_STACKSIZE (Linux*)

GNU extension recognized by the Intel® OpenMP compatibility library. Same as OMP_STACKSIZE. KMP_STACKSIZE overrides GOMP_STACKSIZE, which overrides OMP_STACKSIZE.

Default: See the description for OMP_STACKSIZE.

OMP_CANCELLATION

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.

Enables (true) or disables (false) cancellation of the innermost enclosing region of the type specified.

Default: FALSE

Example: OMP_CANCELLATION=true

OMP_DYNAMIC

Enables (true) or disables (false) the dynamic adjustment of the number of threads.

Default: FALSE

Example: OMP_DYNAMIC=true

OMP_MAX_ACTIVE_LEVELS

The maximum number of levels of parallel nesting for the program.

Default: 1

Syntax: OMP_MAX_ACTIVE_LEVELS=true

OMP_NESTED

Enables (true) or disables (false) nested parallelism.

Default: FALSE

Example: OMP_NESTED=true

OMP_NUM_THREADS

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, in which case it specifies the number of threads for all parallel regions. The value can also be a comma-separated list of integers, in which case each integer 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 integer can be left out of the list. If the first integer in a list is left out, it implies the normal default value for threads is used at the outer-most level. If the integer is left out of any other level, the number of threads for that level is inherited from the previous level.

This environment variable applies to the options Qopenmp (Windows) or qopenmp (Linux and OS X), or Qparallel (Windows) or qparallel (Linux and OS X) .

Default: The number of processors visible to the operating system

Syntax: OMP_NUM_THREADS=value[,value]*

OMP_PLACES

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, the meaning of the numbers and how the numbering is done for a list of nonnegative numbers are implementation defined. Generally, the numbers represent the smallest unit of execution exposed by the execution environment, typically a hardware thread.

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>."

# 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"

The abstract names listed below should be understood by the execution and 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.
• sockets: Each place corresponds to a single socket (consisting of one or more cores) on the target machine.

When requesting fewer places or more resources than available on the system, the determination of which resources of type abstract_name are to be included in the place list is implementation-defined. The precise definitions of the abstract names are implementation defined. An implementation may also add abstract names as appropriate for the target platform. 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).

# ABSTRACT NAMES EXAMPLE
  setenv OMP_PLACES threads
  setenv OMP_PLACES threads(4)

OMP_PROC_BIND (Windows, Linux)

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: master, close, spread.

Default: False

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 master, all threads are bound to the same place as the master thread. If set to close, threads are bound to successive places, close to where the master thread is bound. If set to spread, the master thread's partition is subdivided and threads are bound to single place successive sub-partitions.

OMP_SCHEDULE

Sets the run-time schedule type and an optional chunk size.

Default: STATIC, no chunk size specified

Example syntax: OMP_SCHEDULE="kind[,chunk_size]"

OMP_STACKSIZE

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 the option Qparallel (Windows) or qparallel (Linux and OS X) .

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.

Default (IA-32 architecture): 2M

Default (Intel® 64 architecture): 4M

Default (Intel® MIC architecture):4M (on supported OSes)

Related environment variables: KMP_STACKSIZE (overrides OMP_STACKSIZE).

Syntax: OMP_STACKSIZE=value

OMP_THREAD_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, 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: Qopenmp (Windows) or qopenmp (Linux and OS X), or Qparallel (Windows) or qparallel (Linux and OS X) .

The omp_get_thread_limit() routine returns the value of the limit.

Default: No enforced limit

Related environment variable: KMP_ALL_THREADS (overrides OMP_THREAD_LIMIT).

Example syntax: OMP_THREAD_LIMIT=value

OMP_WAIT_POLICY

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.

Default: Passive

Syntax: OMP_WAIT_POLICY=value

KMP_AFFINITY (Windows, Linux)

Enables run-time 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.

Default: noverbose,warnings,respect,granularity=core,duplicates,none

Default (Intel® MIC architecture): noverbose,warnings,respect,granularity=fine,duplicates,scatter,0,0

KMP_ALL_THREADS

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 Qopenmp(Windows) or qopenmp (Linux and OS X) option.

Default: No enforced limit.

KMP_BLOCKTIME

Sets the time, in milliseconds, that a thread should wait, after completing the execution of a parallel region, before sleeping.

Use the optional character suffixes: s (seconds), m (minutes), h (hours), or d (days) to specify the units.

Specify infinite for an unlimited wait time.

Default: 200 milliseconds

Related Environment Variable: KMP_LIBRARY environment variable.

KMP_CPUINFO_FILE

Specifies an alternate file name for a file containing the machine topology description. The file must be in the same format as /proc/cpuinfo.

Default: None

KMP_DETERMINISTIC_REDUCTION

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.

Default: false

KMP_DYNAMIC_MODE

Selects the method used to determine the number of threads to use for a parallel region when OMP_DYNAMIC=true. Possible values: (asat | load_balance | thread_limit), where,

• asat: estimates number of threads based on parallel start time;

  Note

  Support for asat (automatic self-allocating threads) is now deprecated and will be removed in a future release.

• 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.

Default (IA-32 architecture): load_balance (on all supported OSes)

Default (Intel® 64 architecture): load_balance (on all supported OSes)

Default (Intel® MIC architecture): thread_limit (on supported OSes)

KMP_HOT_TEAMS_MAX_LEVEL

Sets the maximum nested level to which teams of threads will be hot.

For values of 2 and above, nested parallelism should be enabled.

Default: 1

KMP_HOT_TEAMS_MODE

Specifies the run-time 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.

Default: 0

KMP_INHERIT_FP_CONTROL

Enables (true) or disables (false) the copying of the floating-point control settings of the master thread to the floating-point control settings of the OpenMP* worker threads at the start of each parallel region.

Default: true

KMP_LIBRARY

Selects the OpenMP* run-time library execution mode. The values for this variable are serial, turnaround, or throughput.

Default: throughput

KMP_MONITOR_STACKSIZE

Sets the number of bytes to allocate for the monitor thread, which is used for book-keeping during program execution.

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).

Default: max (32k, system minimum thread stack size)

KMP_PLACE_THREADS

Specifies the number of sockets, cores per socket, and the number of threads per core, to use with an OpenMP* application, as an alternative to writing explicit affinity settings or a process affinity mask. You can also specify an offset value to set which sockets and cores to use.

Syntax: socketsS[@offset],coresC[@offset],threadsT

S, C and T are not case-sensitive.

sockets

The number of sockets to use.

cores

The number of cores to use per socket.

threads

The number of threads to use per core.

offset

(Optional) The number of sockets or cores to skip.

Default: If omitted, the default value is the available number of sockets, cores, or threads.

Examples:

• 2s,4c,2t: Use the first 2 sockets (s0 and s1), the first 4 cores on each socket (c0 - c3), and 2 threads per core.

• 2s@2,4c@8,2t: Skip the first 2 sockets (s0 and s1) and use 2 sockets (s2-s3), skip the first 8 cores (c0-c7) and use 4 cores on each socket (c8-c11), and use 2 threads per core.

• 5C@1,3T: Use all available sockets, skip the first core and use 5 cores, and use 3 threads per core.

• 2T: Use all cores on all sockets, 2 threads per core.

• 4C@12: Use 4 cores with offset 12, all available threads per core.

KMP_SETTINGS

Enables (true) or disables (false) the printing of OpenMP* run-time 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* run-time library.

Default: false

KMP_STACKSIZE

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).

This variable does not affect the native operating system threads created by the user program nor the thread executing the sequential part of an OpenMP* program or parallel programs created using the option Qparallel (Windows) or qparallel (Linux and OS X) .

Default (IA-32 architecture): 2m

Default (Intel® 64 architecture): 4m

Default (Intel® MIC architecture):4M (on supported OSes)

KMP_VERSION

Enables (true) or disables (false) the printing of OpenMP* run-time library version information during program execution.

Default: false

KMP_WARNINGS

Enables (true) or disables (false) displaying warnings from the OpenMP* run-time library during program execution.

Default: true

Intel® Many Integrated Core (Intel® MIC) Environment Variables

MIC_ENV_PREFIX

Controls environment variables passed to the target.

By default, all environment variables set on the host are passed to the target. Setting MIC_ENV_PREFIX passes only environment variables that have a prefix of the value of this variable. For example, setting MIC_ENV_PREFIX=ABC passes only environment variables that have a prefix of ABC.

MIC_ENV_PREFIX=ABC
ABC_LD_LIBRARY_PATH=/tmp/mylibs

For information on passing environment variables to a particular coprocessor, and on passing multiple environment variables to one or all coprocessors, see Setting Environment Variables on the CPU to Modify the Coprocessor's Execution Environment.

MIC_LD_LIBRARY_PATH

Specifies the location on the host for target-specific shared objects that may be loaded to the target. The value is not passed to the target. See MIC_ENV_PREFIX for special handling of the value on the target.

LD_LIBRARY_PATH specifies the location on the host for host-specific shared objects.

MIC_PROXY_IO

Enables (1) or disables (0) the proxy of stderr and stdout, and specifies whether the process wants I/O proxy support between the host and target.

Default: 1

Example: MIC_PROXY_IO=0

MIC_SEP_MONITOR

Enables (1) or disables (0) SEP at offload regions.

Default: 0

Example: MIC_SEP_MONITOR=1

MIC_STACKSIZE

Specifies the stack size of the main thread for the offload. This value is typically much larger than the stack size for individual threads. It corresponds to what you would set with ulimit -s (BASH shell) or limit stacksize (C shell) if you were running natively on either the target or the host.

Set this variable to integerB|K|M|G|T, where:

• B = bytes

• K = kilobytes

• M = megabytes

• G = gigabytes

• T = terabytes

Default: 12M

Example: MIC_STACKSIZE=16M

MIC_USE_2MB_BUFFERS

Use 2M pages for (size > MIC_USE_2MB_BUFFERS). Variables with the ALLOCATABLE or POINTER attribute whose runtime length exceeds the value of this environment variable are allocated in large pages.

Set this variable to integerB|K|M|G|T, where:

• B = Bytes

• K = Kilobytes

• M = Megabytes

• G = Gigabytes

• T = Terabytes

Example: MIC_USE_2MB_BUFFERS=64K

OFFLOAD_DEVICES

Restricts the offload process to use only the coprocessors specified as the value of the variable.

Set this variable to a comma-separated list of target device numbers in the range 0 to (number_of_devices_in_the_system -1), where 0 is the first coprocessor in the system, and (number_of_devices_in_the_system -1) is the last coprocessor in the system.

Coprocessors available for offloading are numbered logically. The function OFFLOAD_NUMBER_OF_DEVICES returns the number of available coprocessors. Coprocessor indices that you use in the target specifier of the offload directives are in the range 0 to number_of_devices_in_the_system-1.

Default: The offload process uses all devices.

Example: OFFLOAD_DEVICES = 1,2

On a system with more than two coprocessors installed, this setting enables the application to use only coprocessors 1 and 2. Offloads to coprocessors 0 or 1 are performed on the second and third physical coprocessors. Offloads to target numbers higher than 1 wrap around, and all offloads remain within coprocessors 0 and 1. The function OFFLOAD_NUMBER_OF_DEVICES, executed on a coprocessor, returns 0 or 1 when the offload is running on the first or second coprocessor.

Setting this variable to an empty value on Linux (export OFFLOAD_DEVICES= ) or the value none on Windows (set OFFLOAD_DEVICES=none) impacts the execution of offloaded code within your program as follows:

• When you use optional offloading, the code executes on the host CPU.

• When you use mandatory offloading, the program terminates with an offload error, reporting that a device is not available, when it reaches a point in the execution where the coprocessor requires initialization for offloading.

You can specify optional and mandatory offloading using the optional and mandatory clauses in either of the following:

• The compiler option qoffload (Linux) or Qoffload (Windows)

• The OFFLOAD directive

OFFLOAD_INIT

Specifies a hint to the offload runtime indicating when to initialize targets.

Possible values:

• on_start: All available coprocessors are initialized before entering the main program.

• on_offload: The target is initialized immediately before the first offload to it. Initialization is done only on the target that handles the offload.

• on_offload_all: All available targets are initialized immediately before the first offload in an application.

Default: on_offload_all

Example: OFFLOAD_INIT=on_start

OFFLOAD_REPORT

Controls printing offload execution time, in seconds, and the amount of data transferred, in bytes. This environment variable is equivalent to using the __Offload_report API.

Possible values:

• 1: Prints the offload computation time, in seconds.

• 2: In addition to the information produced at value 1, adds the amount of data transferred between the CPU and the target, in bytes.

• 3: In addition to the information produced at value 2, gives additional details on offload activity, including device initialization, and individual variable transfers.

Default: None

Example: OFFLOAD_REPORT=1

See also _Offload_report.

Profile Guided Optimization (PGO_) Environment Variables

INTEL_PROF_DUMP_CUMULATIVE

When using interval profile dumping (initiated by INTEL_PROF_DUMP_INTERVAL or the function _PGOPTI_Set_Interval_Prof_Dump) during the execution of an instrumented user application, allows creation of a single .dyn file to contain profiling information instead of multiple .dyn files. If not set, executing an instrumented user application creates a new .dyn file for each interval.

Setting this environment variable is useful for applications that do not terminate or those that terminate abnormally (bypass the normal exit code).

INTEL_PROF_DUMP_INTERVAL

Initiates interval profile dumping in an instrumented user application. This environment variable may be used to initiate Interval Profile Dumping in an instrumented application.

See Interval Profile Dumping for more information

INTEL_PROF_DYN_PREFIX

Specifies the prefix to be used for the .dyn filename to distinguish it from the other .dyn files dumped by other PGO runs. Executing the instrumented application generates a .dyn filename as follows: <prefix>_<timestamp>_<pid>.dyn, where <prefix> is the identifier that you have specified.

PROF_DIR

Specifies the directory where profiling files (files with extensions .dyn, .dpi, .spi and so on) are stored. The default is to store the .dyn files in the source directory of the file containing the first executed instrumented routine in the binary compiled with [Q]prof-gen option.

This variable applies to all three phases of the profiling process:

• Instrumentation compilation and linking

• Instrumented execution

• Feedback compilation

PROF_DPI

Name for the .dpi file.

Default: pgopti.dpi

PROF_DUMP_INTERVAL

Deprecated; use INTEL_PROF_DUMP_INTERVAL instead.

PROF_NO_CLOBBER

Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges data from all dynamic information files and creates a new pgopti.dpi file if the .dyn files are newer than an existing pgopti.dpi file.

When this variable is set, the compiler does not overwrite the existing pgopti.dpi file. Instead, the compiler issues a warning. You must remove the pgopti.dpi file if you want to use additional dynamic information files.