The following environment variables allow you to modify the runtime behavior:

Variable	Description
ARCANE_PARALLEL_SERVICE (obsolete)	Name of the service used to manage parallelism. This variable must be set if you want a specific parallel execution model. Possible values are: Mpi or Sequential. The Mpi mode triggers the call to MPI_Init() and therefore the program must be launched by the platform's mpi launcher (e.g., mpiexec, mpirun, prun, ...). This variable should no longer be used because Arcane automatically detects MPI launching. If you want to override the parallelism service, you must specify it in the command line arguments (see Launching a Calculation)
ARCANE_CHECK	If defined, it adds verification tests for the validity of the operations performed. This is useful if the code crashes within an Arcane method. It is possible to rerun the code with this variable in hopes of detecting the cause of the error. The 'check' version of Arcane automatically includes these tests as well as other more costly tests like array overflows.
ARCANE_PAUSE_ON_ERROR	If defined, it pauses the code when an error is detected by Arcane, such as a fatal exception or an array overflow.
ARCANE_PROFILING	Name of the service to use for profiling information. Setting this option activates profiling. This allows you to see the time spent in each function at the end of execution. The two supported values are 'Papi' and 'Prof'. For 'Papi', the 'papi' library must be installed and the Linux kernel must be compatible. 'Prof' uses system signals.
ARCANE_PROFILING_PERIOD	Number of CPU cycles between two profiling samples. This variable is only used if profiling is active with 'Papi'. A correct value is 500000, which on a 3Ghz machine results in about 6000 events per second.
ARCANE_PROFILING_ONLYFLOPS	If true, it uses profiling solely to determine the number of floating-point operations performed. It should be noted that this is the number of instructions, not the number of operations. On certain machines like Itaniums, one instruction can perform two operations (multiplication + addition). This option is only available if profiling is active with the 'Papi' option.
ARCANE_LOOP_PROFILING_LEVEL	(version 3.8+). Integer indicating the loop profiling level. Setting it to a value greater than or equal to 1 activates loop traces based on macros provided by Arcane such as ENUMERATE_() (ENUMERATE_CELL(), ENUMERATE_NODE(), ...), and RUNCOMMAND (RUNCOMMAND_LOOP(), RUNCOMMAND_ENUMERATE()). At the end of the calculation, the time spent in each loop will be written in the listing and in files.
ARCANE_MESSAGE_PASSING_PROFILING	Allows activation of internal profiling for message passing operations. Possible values are: JSON: uses the tracing service in the same format. This contains information on the time spent in each MPI function. The information is grouped by iteration and by time loop entry point. OTF2, uses the tracing service in the same format. Once opened with a suitable tool (e.g., Vampir), the details of MPI communications can be analyzed. The information notably allows identifying the MPI functions implemented at each time loop entry point as well as those invoked by Arcane variable synchronization operations.
ARCANE_REDIRECT_SIGNALS	Activates (TRUE) or deactivates (FALSE) signal redirection by Arcane. This redirection is active by default in Arcane and allows displaying the call stack, especially in case of a crash. Nevertheless, this can interfere with other libraries, so it is possible to disable signal redirection.
ARCANE_PARALLEL_OUTPUT	Activates (TRUE) or deactivates (FALSE) the listing outputs of all subdomains in parallel. Each subdomain will write the listing information to the file 'output#x' where #x is the subdomain number.
ARCANE_TRACE_VARIABLE_CREATION	If defined, it retrieves the call stack for every variable reference creation. This information is then displayed at the end of execution to identify variables that have not been deallocated. Note that this can significantly slow down execution.
STDENV_VERIF, STDENV_VERIF_ENTRYPOINT, STDENV_VERIF_PATH, STDENV_VERIF_SKIP_GHOSTS	See section Bit-by-bit Comparison
ARCANE_CHECK_MEMORY, ARCANE_CHECK_MEMORY_BLOCK_SIZE	See section Memory Problem Detection. This only works with certain versions of Linux and glibc. This mechanism uses obsolete glibc features and is therefore not available with recent versions (>2021) of glibc. Notably, ubuntu 22.04 does not support this mechanism.
ARCANE_DATA_INIT_POLICY	Allows specifying the variable initialization policy. Using this variable is equivalent to calling the method Arcane::setGlobalDataInitialisationPolicy(). Possible values are: NONE: no initialization DEFAULT: default type value, i.e., 0 for integers and 0.0 for reals NAN: initializes reals with the NotANumber value, which allows, if floating-point exceptions are enabled, stopping the code if an explicitly uninitialized variable is used. LEGACY: mode prior to version 2.0 of Arcane. It should no longer be used (see Arcane::DIP_Legacy).
ARCANE_LISTENER_TIMEOUT	todo
ARCANE_GDB_STACK	todo
ARCANE_ENABLE_NON_IO_MASTER_CURVES	Environment variable allowing multiple processes to write curves. With the historical API (Arcane::ITimeHistoryMng), all processes write the curves, and with the writers available in Arcane, these processes write to the same file. A custom writer must therefore handle this. With the new APIs (Arcane::GlobalTimeHistoryAdder and Arcane::MeshTimeHistoryAdder), writing curves by multiple processes is handled correctly. This environment variable remains necessary to activate this feature (for now). See page How it works
ARCANE_ENABLE_ALL_REPLICATS_WRITE_CURVES	Environment variable useful when using replicas and allowing all processes to write curves.
ARCANE_REPLACE_SYMBOLS_IN_DATASET	Environment variable allowing the replacement of symbols in the dataset from command line arguments. See page Command Line and Dataset
ARCANE_USE_BACKWARDCPP	Environment variable allowing the display of the call stack via BackwardCpp. BackwardCpp requires Arcane to be compiled with at least the DW library. Default value: 0 Possible values: 0 or 1
ARCANE_CALLSTACK_VERBOSE	Environment variable allowing more or less information to be displayed when showing the call stack. Requires the ARCANE_USE_BACKWARDCPP environment variable. Default value: 2 Possible values: 0: Classic CallStack (function name only) 1: Classic CallStack with line number and file for classes/functions outside the Arcane namespace 2: Classic CallStack with line number and file for all classes/functions 3: Classic CallStack with line number, file for all classes/functions and snippet for classes/functions outside the Arcane namespace 4: Classic CallStack with line number, file and snippet for all classes/functions
ARCANE_CALLSTACK_HUMAN_READABLE	Environment variable allowing the call stack to be displayed with spaces between calls and the line number before the source file path, to improve readability. If the value is set to zero, the file path and line number are displayed in a format recognizable by a debugger or an IDE (path:line). Requires the ARCANE_USE_BACKWARDCPP environment variable. Default value: 1 Possible values: 0 or 1

Direct Execution Launch Using Traces