Intel® C++ Compiler 19.0 Developer Guide and Reference
You can customize your system environment by specifying paths where the compiler searches for certain files such as libraries, include files, configuration files, and certain settings.
The following table shows the compile-time environment variables that affect the compiler:
Compile-Time Environment Variable |
Description |
---|---|
CILK_NWORKERS (Windows*, Linux*) |
Specifies the number of worker threads to use in an Intel® Cilk™ Plus program. Intel® Cilk™ Plus is a deprecated feature.See the section Set Worker Count on Debugging an Intel® Cilk™ Plus Program. |
CL (Windows) _CL_ (Windows) |
Define the files and options you use most often with the CL variable. Note: You cannot set the CL environment variable to a string that contains an equal sign. You can use the pound sign instead. In the following example, the pound sign (#) is used as a substitute for an equal sign in the assigned string: SET CL=/Dtest#100 |
COV_DIR (Windows) |
Same as PROF_DIR. |
COV_DPI (Windows) |
Same as PROF_DPI. |
IA32ROOT (IA-32 architecture and Intel® 64 architecture) |
Points to the directories containing the include and library files for a non-standard installation structure. NoteIA-32 architecture is no longer supported on macOS*. |
ICCCFG |
Specifies the configuration file for customizing compilations when invoking the compiler using icc. |
ICPCCFG |
Specifies the configuration file for customizing compilations when invoking the compiler using icpc. |
ICLCFG (Windows) |
Specifies a configuration file, which the compiler should use instead of the default configuration file. |
INTEL_LICENSE_FILE |
Specifies the location for the Intel license file. NoteOn Windows*, this environment variable cannot be set from Visual Studio. |
__INTEL_PRE_CFLAGS __INTEL_POST_CFLAGS |
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 icl.cfg. NoteBy default, a configuration file named icl.cfg (Windows*), icc.cfg (Linux*, macOS*), or icpc.cfg (Linux*, macOS*) 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 ICLCFG (Windows*), ICCCFG (Linux*, macOS*), or ICPCCFG (Linux*, macOS*) 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_CFLAGS , or in the suffix position using __INTEL_POST_CFLAGS. The command line is built as follows: Syntax: (On Windows, use icl. On Linux or macOS* use icc)icl/icc <PRE flags> <flags from configuration file> <flags from the compiler invocation> <POST flags> NoteThe driver issues a warning that the compiler is overriding an option because of an environment variable, but only when you include the option /W5 (Windows*) or -w3 (Linux* and macOS*). |
INTEL_TARGET_ARCH_IA32 (Linux* and Windows*) |
Set this environment variable to target 32-bit compilations for all associated tools (this includes the compiler and Intel-specific linker tools). Without this environment variable, you will be required to use the explicit command line options, /Qm32 on Windows* and -m32 on Linux*, for each compiler invocation. NoteIA-32 architecture is no longer supported on macOS*. |
PATH |
Specifies the directories the system searches for binary executable files. NoteOn 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, macOS*) or the current directory (Windows). The compiler searches for these variables in the following order: TMP, TMPDIR, and TEMP. NoteOn Windows*, these environment variables cannot be set from Visual Studio. |
LD_LIBRARY_PATH (Linux*) |
Specifies the location for shared objects (.so files). |
DYLD_LIBRARY_PATH (macOS*) |
Specifies the path for dynamic libraries. |
INCLUDE (Windows*) |
Specifies the directories for the source header files (include files). |
LIB (Windows*) |
Specifies the directories for all libraries used by the compiler and linker. |
Intel® MIC Architecture Environment Variables | |
GNU Environment Variables and Extensions | |
CPATH (Linux* and macOS*) |
Specifies the path to include directory for C/C++ compilations. |
C_INCLUDE_PATH (Linux* and macOS*) |
Specifies path to include directory for C compilations. |
CPLUS_INCLUDE_PATH (Linux* and macOS*) |
Specifies path to include directory for C++ compilations. |
DEPENDENCIES_OUTPUT (Linux* and macOS*) |
Specifies how to output dependencies for make based on the non-system header files processed by the compiler. System header files are ignored in the dependency output. |
GCC_EXEC_PREFIX (Linux*) |
Specifies alternative names for the linker (ld) and assembler (as). |
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 macOS*) |
Specifies the path for libraries to be used during the link phase. |
SUNPRO_DEPENDENCIES (Linux*) |
This variable is the same as DEPENDENCIES_OUTPUT, except that system header files are not ignored. |
INTEL_ROOT is an environment variable that is reserved for the Intel compiler. It's use is not supported.
The following table summarizes compiler environment variables that are recognized at run time.
Run-Time Environment Variable |
Description |
---|---|
INTEL_CHKP_REPORT_MODE (Linux*) |
Changes the pointer checker reporting mode at runtime. See Finding and Reporting Out-of-Bounds Errors. |
GNU extensions (recognized by the Intel OpenMP* compatibility library) | |
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. |
OpenMP* Environment Variables (OMP_) and Extensions (KMP_) | |
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. NoteInternal 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. Default: FALSE Example: OMP_CANCELLATION=TRUE |
OMP_DISPLAY_ENV |
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. Default: FALSE Example: OMP_DISPLAY_ENV=TRUE |
OMP_DEFAULT_DEVICE |
Sets the device that will be used in a target region. The OpenMP routine omp_set_default_device or a device clause in a parallelpragma 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_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 macOS*), or Qparallel (Windows) or parallel (Linux and macOS*) . Default: The number of processors visible to the operating system on which the program is executed. 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>."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" The abstract names listed below should be understood by the execution and runtime environment:
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) NoteIf any numerical values cannot be mapped to a processor on the target platform the behavior is implementation-defined. The behavior is also implementation-defined when the OMP_PLACES environment variable is defined using an abstract name. |
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. NoteKMP_AFFINITY takes precedence over GOMP_CPU_AFFINITY and OMP_PROC_BIND. GOMP_CPU_AFFINITY takes precedence over OMP_PROC_BIND. |
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]" NoteSome 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. |
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 parallel (Linux and macOS*) . 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) NoteIA-32 architecture is no longer supported on macOS*.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 macOS*), or Qparallel (Windows) or parallel (Linux and macOS*) . 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,none Default (Intel® Xeon Phi™ product family): noverbose,warnings,respect,granularity=fine,scatter,0,0 Default (Windows* with multiple processor groups): noverbose,warnings,norespect,granularity=group,compact,0,0 NoteOn Windows* with multiple processor groups, the norespect affinity modifier is assumed when the process affinity mask equals a single processor group (which is default on Windows*). Otherwise, the respect affinity modifier is used. |
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 macOS*) 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,
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) NoteIA-32 architecture is no longer supported on macOS*. |
KMP_HOT_TEAMS_MAX_LEVEL |
Sets the maximum nested level to which teams of threads will be hot. NoteA 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. Default: 1 |
KMP_HOT_TEAMS_MODE |
Specifies the run-time behavior when the number of threads in a hot team is reduced. Possible values:
Default: 0 |
KMP_HW_SUBSET |
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 resources to use. 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. For example, tiles are sets of cores that share an L2 cache on some processors in the Intel® Xeon Phi™ family. Basic syntax: socketsS[@offset],coresC[@offset],threadsT S, C and T are not case-sensitive.
Extended syntax when KMP_TOPOLOGY_METHOD=hwloc: socketsS[@offset],numasN[@offset],tilesL2[@offset],coresC[@offset],threadsT S, N, L2, C and T are not case-sensitive. Some designators are aliases on some machines. Specifying duplicate or multiple alias designators for the same resource type is not allowed.
NoteIf you don't specify one or more types of resource, sockets, cores or threads, all available resources of that type are used. NoteIf a particular type of resource is specified, but detection of that resource is not supported by the chosen topology detection method, the setting of KMP_HW_SUBSET is ignored. NoteThis variable does not work if the OpenMP* affinity is set to disabled. Default: If omitted, the default value is to use all the available hardware resources. Examples:
|
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_PLACE_THREADS |
Deprecated; use KMP_HW_SUBSET instead. |
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 parallel (Linux and macOS*) . KMP_STACKSIZE overrides GOMP_STACKSIZE, which overrides OMP_STACKSIZE. Default (IA-32 architecture): 2m Default (Intel® 64 architecture): 4m Default (Intel® MIC architecture): 4M (on supported OSes) NoteIA-32 architecture is no longer supported on macOS*. |
KMP_TOPOLOGY_METHOD |
Forces OpenMP* to use a particular machine topology modeling method. Possible values are:
|
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. NoteBecause the MIC_LD_LIBRARY_PATH variable is not stripped and passed to the target, you cannot use MIC_ENV_PREFIX=MIC to change the LD_LIBRARY_PATH on the target. To change LD_LIBRARY_PATH on the target:
For example, setting these two environment variables on the host sets LD_LIBRARY_PATH on the target to /tmp/mylibs. 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_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:
Default: 12M Example: MIC_STACKSIZE=16M |
MIC_USE_2MB_BUFFERS |
Use 2M pages for (size > MIC_USE_2MB_BUFFERS). Pointer-based variables 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:
Example: MIC_USE_2MB_BUFFERS=64K |
OFFLOAD_DEVICES |
This variable is only available on Linux* systems. 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 pragmas are mapped to coprocessors specified in OFFLOAD_DEVICES. 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 coprocessor 1 or 2 as specified in OFFLOAD_DEVICES. Setting this variable to an empty value (export OFFLOAD_DEVICES= ) has no effect. Setting this varaible to value none (set OFFLOAD_DEVICES=none) impacts the execution of offloaded code within your program as follows:
You can specify optional and mandatory offloading using the optional and mandatory clauses in either of the following:
|
OFFLOAD_NODES |
Defines a subset of a cluster (group of servers or nodes) that is available for offloading from the host system. When offloading within a cluster, this environment variable must be set to specify the available offload-able nodes. The value of the environment variable is a comma-separated list of machine specifiers. A machine specifier is either a machine name or an IP address. The machine specifier may be optionally followed by a specification of the node type and fabric type in square brackets. The default node type is currently x200 and the default fabric type is OFI. More node and fabric types may be supported in the future. The offloadable machines in OFFLOAD_NODES are assigned device numbers 0, 1, 2 and so on, in the order specified. These device numbers are available for offloading through #pragma offload target(mic:<number>) . The OFFLOAD_DEVICES environment variable may be used to restrict offloading to a subset of the available cluster machines. Default: There is no default. The environment variable must be set if doing offload within a cluster. Example: export OFFLOAD_NODES="machine1,machine2,10.2.100.50" Example: export OFFLOAD_NODES="machine3[x200,OFI]" Example: In the following, machine2 and 10.2.100.50 will be used as processor 0 and 1 in target specified in the offload pragma. export OFFLOAD_NODES="machine1,machine2,10.2.100.50" export OFFLOAD_DEVICES=1,2 |
OFFLOAD_INIT |
Specifies a hint to the offload runtime indicating when to initialize targets. Possible values:
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:
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. NoteThe value specified in this environment variable must not contain < > : " / \ | ? * characters. The default naming scheme is used if an invalid prefix is 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:
|
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. |