| (C) 2010 by Argonne National Laboratory. |
| See COPYRIGHT in top-level directory. |
| |
| Automatically generated |
| by: ./maint/extractcvars |
| at: Mon Jan 6 15:48:01 2020 |
| DO NOT EDIT!!! |
| |
| This file lists the various environment variables available to change the |
| behavior of the MPICH library. These are intended to be used by advanced |
| users. |
| |
| |
| MPIR_CVAR_PROCTABLE_SIZE |
| Aliases: MPIR_PARAM_PROCTABLE_SIZE |
| MPICH_PROCTABLE_SIZE |
| MV2_PROCTABLE_SIZE |
| Description: Size of the "MPIR" debugger interface proctable (process |
| table). |
| Default: 64 |
| |
| MPIR_CVAR_PROCTABLE_PRINT |
| Aliases: MPIR_PARAM_PROCTABLE_PRINT |
| MPICH_PROCTABLE_PRINT |
| MV2_PROCTABLE_PRINT |
| Description: If true, dump the proctable entries at |
| MPIR_WaitForDebugger-time. |
| Default: 0 |
| |
| MPIR_CVAR_COMM_SPLIT_USE_QSORT |
| Aliases: MPIR_PARAM_COMM_SPLIT_USE_QSORT |
| MPICH_COMM_SPLIT_USE_QSORT |
| MV2_COMM_SPLIT_USE_QSORT |
| Description: Use qsort(3) in the implementation of MPI_Comm_split |
| instead of bubble sort. |
| Default: 1 |
| |
| MPIR_CVAR_CTXID_EAGER_SIZE |
| Aliases: MPIR_PARAM_CTXID_EAGER_SIZE |
| MPICH_CTXID_EAGER_SIZE |
| MV2_CTXID_EAGER_SIZE |
| Description: The MPIR_CVAR_CTXID_EAGER_SIZE environment variable allows |
| you to specify how many words in the context ID mask will be set |
| aside for the eager allocation protocol. If the application is |
| running out of context IDs, reducing this value may help. |
| Default: 2 |
| |
| MPIR_CVAR_PRINT_ERROR_STACK |
| Aliases: MPIR_PARAM_PRINT_ERROR_STACK |
| MPICH_PRINT_ERROR_STACK |
| MV2_PRINT_ERROR_STACK |
| Description: If true, print an error stack trace at error handling |
| time. |
| Default: 1 |
| |
| MPIR_CVAR_CHOP_ERROR_STACK |
| Aliases: MPIR_PARAM_CHOP_ERROR_STACK |
| MPICH_CHOP_ERROR_STACK |
| MV2_CHOP_ERROR_STACK |
| Description: If >0, truncate error stack output lines this many |
| characters wide. If 0, do not truncate, and if <0 use a sensible |
| default. |
| Default: 0 |
| |
| MPIR_CVAR_ENABLE_SMP_BARRIER |
| Aliases: MPIR_PARAM_ENABLE_SMP_BARRIER |
| MPICH_ENABLE_SMP_BARRIER |
| MV2_ENABLE_SMP_BARRIER |
| Description: Enable SMP aware barrier. |
| Default: 1 |
| |
| MPIR_CVAR_ALLGATHER_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLGATHER_SHORT_MSG_SIZE |
| MPICH_ALLGATHER_SHORT_MSG_SIZE |
| MV2_ALLGATHER_SHORT_MSG_SIZE |
| Description: For MPI_Allgather and MPI_Allgatherv, the short message |
| algorithm will be used if the send buffer size is < this value (in |
| bytes). (See also: MPIR_CVAR_ALLGATHER_LONG_MSG_SIZE) |
| Default: 81920 |
| |
| MPIR_CVAR_ALLGATHER_LONG_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLGATHER_LONG_MSG_SIZE |
| MPICH_ALLGATHER_LONG_MSG_SIZE |
| MV2_ALLGATHER_LONG_MSG_SIZE |
| Description: For MPI_Allgather and MPI_Allgatherv, the long message |
| algorithm will be used if the send buffer size is >= this value (in |
| bytes) (See also: MPIR_CVAR_ALLGATHER_SHORT_MSG_SIZE) |
| Default: 524288 |
| |
| MPIR_CVAR_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE |
| Aliases: MPIR_PARAM_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE |
| MPICH_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE |
| MV2_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE |
| Description: the long message algorithm will be used if the operation |
| is commutative and the send buffer size is >= this value (in bytes) |
| Default: 524288 |
| |
| MPIR_CVAR_GATHER_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_GATHER_COLLECTIVE_ALGORITHM |
| MPICH_GATHER_COLLECTIVE_ALGORITHM |
| MV2_GATHER_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for gather |
| operation. |
| Default: -1 |
| |
| MPIR_CVAR_ALLGATHER_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_ALLGATHER_COLLECTIVE_ALGORITHM |
| MPICH_ALLGATHER_COLLECTIVE_ALGORITHM |
| MV2_ALLGATHER_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for |
| allgather operation. |
| Default: -1 |
| |
| MPIR_CVAR_ALLREDUCE_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_ALLREDUCE_COLLECTIVE_ALGORITHM |
| MPICH_ALLREDUCE_COLLECTIVE_ALGORITHM |
| MV2_ALLREDUCE_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for |
| allreduce operation. |
| Default: -1 |
| |
| MPIR_CVAR_ALLTOALL_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_ALLTOALL_COLLECTIVE_ALGORITHM |
| MPICH_ALLTOALL_COLLECTIVE_ALGORITHM |
| MV2_ALLTOALL_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for alltoall |
| operation. |
| Default: -1 |
| |
| MPIR_CVAR_ALLTOALLV_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_ALLTOALLV_COLLECTIVE_ALGORITHM |
| MPICH_ALLTOALLV_COLLECTIVE_ALGORITHM |
| MV2_ALLTOALLV_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for |
| alltoallv operation. |
| Default: -1 |
| |
| MPIR_CVAR_BCAST_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_BCAST_COLLECTIVE_ALGORITHM |
| MPICH_BCAST_COLLECTIVE_ALGORITHM |
| MV2_BCAST_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for |
| broadcast operation. |
| Default: -1 |
| |
| MPIR_CVAR_REDUCE_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_REDUCE_COLLECTIVE_ALGORITHM |
| MPICH_REDUCE_COLLECTIVE_ALGORITHM |
| MV2_REDUCE_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for reduce |
| operation. |
| Default: -1 |
| |
| MPIR_CVAR_SCATTER_COLLECTIVE_ALGORITHM |
| Aliases: MPIR_PARAM_SCATTER_COLLECTIVE_ALGORITHM |
| MPICH_SCATTER_COLLECTIVE_ALGORITHM |
| MV2_SCATTER_COLLECTIVE_ALGORITHM |
| Description: This CVAR selects proper collective algorithm for scatter |
| operation. |
| Default: -1 |
| |
| MPIR_CVAR_REDUCE_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_REDUCE_SHORT_MSG_SIZE |
| MPICH_REDUCE_SHORT_MSG_SIZE |
| MV2_REDUCE_SHORT_MSG_SIZE |
| Description: the short message algorithm will be used if the send |
| buffer size is <= this value (in bytes) |
| Default: 2048 |
| |
| MPIR_CVAR_ENABLE_SMP_REDUCE |
| Aliases: MPIR_PARAM_ENABLE_SMP_REDUCE |
| MPICH_ENABLE_SMP_REDUCE |
| MV2_ENABLE_SMP_REDUCE |
| Description: Enable SMP aware reduce. |
| Default: 1 |
| |
| MPIR_CVAR_MAX_SMP_REDUCE_MSG_SIZE |
| Aliases: MPIR_PARAM_MAX_SMP_REDUCE_MSG_SIZE |
| MPICH_MAX_SMP_REDUCE_MSG_SIZE |
| MV2_MAX_SMP_REDUCE_MSG_SIZE |
| Description: Maximum message size for which SMP-aware reduce is used. |
| A value of '0' uses SMP-aware reduce for all message sizes. |
| Default: 0 |
| |
| MPIR_CVAR_GATHERV_INTER_SSEND_MIN_PROCS |
| Aliases: MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS |
| MPICH_GATHERV_INTER_SSEND_MIN_PROCS |
| MV2_GATHERV_INTER_SSEND_MIN_PROCS |
| Description: Use Ssend (synchronous send) for intercommunicator |
| MPI_Gatherv if the "group B" size is >= this value. Specifying |
| "-1" always avoids using Ssend. For backwards compatibility, |
| specifying "0" uses the default value. |
| Default: 32 |
| |
| MPIR_CVAR_BCAST_MIN_PROCS |
| Aliases: MPIR_PARAM_BCAST_MIN_PROCS |
| MPICH_BCAST_MIN_PROCS |
| MV2_BCAST_MIN_PROCS |
| Description: Let's define short messages as messages with size < |
| MPIR_CVAR_BCAST_SHORT_MSG_SIZE, and medium messages as messages |
| with size >= MPIR_CVAR_BCAST_SHORT_MSG_SIZE but < |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE, and long messages as messages with |
| size >= MPIR_CVAR_BCAST_LONG_MSG_SIZE. The broadcast algorithms |
| selection procedure is as follows. For short messages or when the |
| number of processes is < MPIR_CVAR_BCAST_MIN_PROCS, we do broadcast |
| using the binomial tree algorithm. Otherwise, for medium messages |
| and with a power-of-two number of processes, we do broadcast based |
| on a scatter followed by a recursive doubling allgather algorithm. |
| Otherwise, for long messages or with non power-of-two number of |
| processes, we do broadcast based on a scatter followed by a ring |
| allgather algorithm. (See also: MPIR_CVAR_BCAST_SHORT_MSG_SIZE, |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE) |
| Default: 8 |
| |
| MPIR_CVAR_BCAST_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_BCAST_SHORT_MSG_SIZE |
| MPICH_BCAST_SHORT_MSG_SIZE |
| MV2_BCAST_SHORT_MSG_SIZE |
| Description: Let's define short messages as messages with size < |
| MPIR_CVAR_BCAST_SHORT_MSG_SIZE, and medium messages as messages |
| with size >= MPIR_CVAR_BCAST_SHORT_MSG_SIZE but < |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE, and long messages as messages with |
| size >= MPIR_CVAR_BCAST_LONG_MSG_SIZE. The broadcast algorithms |
| selection procedure is as follows. For short messages or when the |
| number of processes is < MPIR_CVAR_BCAST_MIN_PROCS, we do broadcast |
| using the binomial tree algorithm. Otherwise, for medium messages |
| and with a power-of-two number of processes, we do broadcast based |
| on a scatter followed by a recursive doubling allgather algorithm. |
| Otherwise, for long messages or with non power-of-two number of |
| processes, we do broadcast based on a scatter followed by a ring |
| allgather algorithm. (See also: MPIR_CVAR_BCAST_MIN_PROCS, |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE) |
| Default: 12288 |
| |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE |
| Aliases: MPIR_PARAM_BCAST_LONG_MSG_SIZE |
| MPICH_BCAST_LONG_MSG_SIZE |
| MV2_BCAST_LONG_MSG_SIZE |
| Description: Let's define short messages as messages with size < |
| MPIR_CVAR_BCAST_SHORT_MSG_SIZE, and medium messages as messages |
| with size >= MPIR_CVAR_BCAST_SHORT_MSG_SIZE but < |
| MPIR_CVAR_BCAST_LONG_MSG_SIZE, and long messages as messages with |
| size >= MPIR_CVAR_BCAST_LONG_MSG_SIZE. The broadcast algorithms |
| selection procedure is as follows. For short messages or when the |
| number of processes is < MPIR_CVAR_BCAST_MIN_PROCS, we do broadcast |
| using the binomial tree algorithm. Otherwise, for medium messages |
| and with a power-of-two number of processes, we do broadcast based |
| on a scatter followed by a recursive doubling allgather algorithm. |
| Otherwise, for long messages or with non power-of-two number of |
| processes, we do broadcast based on a scatter followed by a ring |
| allgather algorithm. (See also: MPIR_CVAR_BCAST_MIN_PROCS, |
| MPIR_CVAR_BCAST_SHORT_MSG_SIZE) |
| Default: 524288 |
| |
| MPIR_CVAR_ENABLE_SMP_BCAST |
| Aliases: MPIR_PARAM_ENABLE_SMP_BCAST |
| MPICH_ENABLE_SMP_BCAST |
| MV2_ENABLE_SMP_BCAST |
| Description: Enable SMP aware broadcast (See also: |
| MPIR_CVAR_MAX_SMP_BCAST_MSG_SIZE) |
| Default: 1 |
| |
| MPIR_CVAR_MAX_SMP_BCAST_MSG_SIZE |
| Aliases: MPIR_PARAM_MAX_SMP_BCAST_MSG_SIZE |
| MPICH_MAX_SMP_BCAST_MSG_SIZE |
| MV2_MAX_SMP_BCAST_MSG_SIZE |
| Description: Maximum message size for which SMP-aware broadcast is |
| used. A value of '0' uses SMP-aware broadcast for all message |
| sizes. (See also: MPIR_CVAR_ENABLE_SMP_BCAST) |
| Default: 0 |
| |
| MPIR_CVAR_SCATTER_INTER_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_SCATTER_INTER_SHORT_MSG_SIZE |
| MPICH_SCATTER_INTER_SHORT_MSG_SIZE |
| MV2_SCATTER_INTER_SHORT_MSG_SIZE |
| Description: use the short message algorithm for intercommunicator |
| MPI_Scatter if the send buffer size is < this value (in bytes) |
| Default: 2048 |
| |
| MPIR_CVAR_ALLTOALL_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLTOALL_SHORT_MSG_SIZE |
| MPICH_ALLTOALL_SHORT_MSG_SIZE |
| MV2_ALLTOALL_SHORT_MSG_SIZE |
| Description: the short message algorithm will be used if the |
| per-destination message size (sendcount*size(sendtype)) is <= this |
| value (See also: MPIR_CVAR_ALLTOALL_MEDIUM_MSG_SIZE) |
| Default: 256 |
| |
| MPIR_CVAR_ALLTOALL_MEDIUM_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLTOALL_MEDIUM_MSG_SIZE |
| MPICH_ALLTOALL_MEDIUM_MSG_SIZE |
| MV2_ALLTOALL_MEDIUM_MSG_SIZE |
| Description: the medium message algorithm will be used if the |
| per-destination message size (sendcount*size(sendtype)) is <= this |
| value and larger than MPIR_CVAR_ALLTOALL_SHORT_MSG_SIZE (See also: |
| MPIR_CVAR_ALLTOALL_SHORT_MSG_SIZE) |
| Default: 32768 |
| |
| MPIR_CVAR_ALLTOALL_THROTTLE |
| Aliases: MPIR_PARAM_ALLTOALL_THROTTLE |
| MPICH_ALLTOALL_THROTTLE |
| MV2_ALLTOALL_THROTTLE |
| Description: max no. of irecvs/isends posted at a time in some alltoall |
| algorithms. Setting it to 0 causes all irecvs/isends to be posted |
| at once |
| Default: 32 |
| |
| MPIR_CVAR_ALLGATHERV_PIPELINE_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLGATHERV_PIPELINE_MSG_SIZE |
| MPICH_ALLGATHERV_PIPELINE_MSG_SIZE |
| MV2_ALLGATHERV_PIPELINE_MSG_SIZE |
| Description: The smallest message size that will be used for the |
| pipelined, large-message, ring algorithm in the MPI_Allgatherv |
| implementation. |
| Default: 32768 |
| |
| MPIR_CVAR_ALLREDUCE_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_ALLREDUCE_SHORT_MSG_SIZE |
| MPICH_ALLREDUCE_SHORT_MSG_SIZE |
| MV2_ALLREDUCE_SHORT_MSG_SIZE |
| Description: the short message algorithm will be used if the send |
| buffer size is <= this value (in bytes) |
| Default: 2048 |
| |
| MPIR_CVAR_ENABLE_SMP_COLLECTIVES |
| Aliases: MPIR_PARAM_ENABLE_SMP_COLLECTIVES |
| MPICH_ENABLE_SMP_COLLECTIVES |
| MV2_ENABLE_SMP_COLLECTIVES |
| Description: Enable SMP aware collective communication. |
| Default: 1 |
| |
| MPIR_CVAR_ENABLE_SMP_ALLREDUCE |
| Aliases: MPIR_PARAM_ENABLE_SMP_ALLREDUCE |
| MPICH_ENABLE_SMP_ALLREDUCE |
| MV2_ENABLE_SMP_ALLREDUCE |
| Description: Enable SMP aware allreduce. |
| Default: 1 |
| |
| MPIR_CVAR_MAX_SMP_ALLREDUCE_MSG_SIZE |
| Aliases: MPIR_PARAM_MAX_SMP_ALLREDUCE_MSG_SIZE |
| MPICH_MAX_SMP_ALLREDUCE_MSG_SIZE |
| MV2_MAX_SMP_ALLREDUCE_MSG_SIZE |
| Description: Maximum message size for which SMP-aware allreduce is |
| used. A value of '0' uses SMP-aware allreduce for all message |
| sizes. |
| Default: 0 |
| |
| MPIR_CVAR_GATHER_VSMALL_MSG_SIZE |
| Aliases: MPIR_PARAM_GATHER_VSMALL_MSG_SIZE |
| MPICH_GATHER_VSMALL_MSG_SIZE |
| MV2_GATHER_VSMALL_MSG_SIZE |
| Description: use a temporary buffer for intracommunicator MPI_Gather if |
| the send buffer size is < this value (in bytes) (See also: |
| MPIR_CVAR_GATHER_INTER_SHORT_MSG_SIZE) |
| Default: 1024 |
| |
| MPIR_CVAR_GATHER_INTER_SHORT_MSG_SIZE |
| Aliases: MPIR_PARAM_GATHER_INTER_SHORT_MSG_SIZE |
| MPICH_GATHER_INTER_SHORT_MSG_SIZE |
| MV2_GATHER_INTER_SHORT_MSG_SIZE |
| Description: use the short message algorithm for intercommunicator |
| MPI_Gather if the send buffer size is < this value (in bytes) (See |
| also: MPIR_CVAR_GATHER_VSMALL_MSG_SIZE) |
| Default: 2048 |
| |
| MPIR_CVAR_ASYNC_PROGRESS |
| Aliases: MPIR_PARAM_ASYNC_PROGRESS |
| MPICH_ASYNC_PROGRESS |
| MV2_ASYNC_PROGRESS |
| Description: If set to true, MPICH will initiate an additional thread |
| to make asynchronous progress on all communication operations |
| including point-to-point, collective, one-sided operations and I/O. |
| Setting this variable will automatically increase the |
| thread-safety level to MPI_THREAD_MULTIPLE. While this improves |
| the progress semantics, it might cause a small amount of |
| performance overhead for regular MPI operations. The user is |
| encouraged to leave one or more hardware threads vacant in order to |
| prevent contention between the application threads and the progress |
| thread(s). The impact of oversubscription is highly system |
| dependent but may be substantial in some cases, hence this |
| recommendation. |
| Default: 0 |
| |
| MPIR_CVAR_DEFAULT_THREAD_LEVEL |
| Aliases: MPIR_PARAM_DEFAULT_THREAD_LEVEL |
| MPICH_DEFAULT_THREAD_LEVEL |
| MV2_DEFAULT_THREAD_LEVEL |
| Description: Sets the default thread level to use when using MPI_INIT. |
| This variable is case-insensitive. |
| Default: "MPI_THREAD_SINGLE" |
| |
| MPIR_CVAR_SUPPRESS_ABORT_MESSAGE |
| Aliases: MPIR_PARAM_SUPPRESS_ABORT_MESSAGE |
| MPICH_SUPPRESS_ABORT_MESSAGE |
| MV2_SUPPRESS_ABORT_MESSAGE |
| Description: Disable printing of abort error message. |
| Default: 0 |
| |
| MPIR_CVAR_DEBUG_HOLD |
| Aliases: MPIR_PARAM_DEBUG_HOLD |
| MPICH_DEBUG_HOLD |
| MV2_DEBUG_HOLD |
| Description: If true, causes processes to wait in MPI_Init and |
| MPI_Initthread for a debugger to be attached. Once the debugger |
| has attached, the variable 'hold' should be set to 0 in order to |
| allow the process to continue (e.g., in gdb, "set hold=0"). |
| Default: 0 |
| |
| MPIR_CVAR_ERROR_CHECKING |
| Aliases: MPIR_PARAM_ERROR_CHECKING |
| MPICH_ERROR_CHECKING |
| MV2_ERROR_CHECKING |
| Description: If true, perform checks for errors, typically to verify |
| valid inputs to MPI routines. Only effective when MPICH is |
| configured with --enable-error-checking=runtime . |
| Default: 1 |
| |
| MPIR_CVAR_MEMDUMP |
| Aliases: MPIR_PARAM_MEMDUMP |
| MPICH_MEMDUMP |
| MV2_MEMDUMP |
| Description: If true, list any memory that was allocated by MPICH and |
| that remains allocated when MPI_Finalize completes. |
| Default: 1 |
| |
| MPIR_CVAR_NAMESERV_FILE_PUBDIR |
| Aliases: MPIR_PARAM_NAMESERV_FILE_PUBDIR |
| MPICH_NAMESERV_FILE_PUBDIR |
| MV2_NAMESERV_FILE_PUBDIR |
| MPIR_CVAR_NAMEPUB_DIR |
| MPIR_PARAM_NAMEPUB_DIR |
| MPICH_NAMEPUB_DIR |
| MV2_NAMEPUB_DIR |
| Description: Sets the directory to use for MPI service publishing in |
| the file nameserv implementation. Allows the user to override |
| where the publish and lookup information is placed for |
| connect/accept based applications. |
| Default: NULL |
| |
| MPIR_CVAR_ABORT_ON_LEAKED_HANDLES |
| Aliases: MPIR_PARAM_ABORT_ON_LEAKED_HANDLES |
| MPICH_ABORT_ON_LEAKED_HANDLES |
| MV2_ABORT_ON_LEAKED_HANDLES |
| Description: If true, MPI will call MPI_Abort at MPI_Finalize if any |
| MPI object handles have been leaked. For example, if MPI_Comm_dup |
| is called without calling a corresponding MPI_Comm_free. For |
| uninteresting reasons, enabling this option may prevent all known |
| object leaks from being reported. MPICH must have been configure |
| with "--enable-g=handlealloc" or better in order for this |
| functionality to work. |
| Default: 0 |
| |
| MPIR_CVAR_COLL_ALIAS_CHECK |
| Aliases: MPIR_PARAM_COLL_ALIAS_CHECK |
| MPICH_COLL_ALIAS_CHECK |
| MV2_COLL_ALIAS_CHECK |
| Description: Enable checking of aliasing in collective operations |
| Default: 1 |
| |
| MPIR_CVAR_FORCE_ARCH_TYPE |
| Aliases: MPIR_PARAM_FORCE_ARCH_TYPE |
| MPICH_FORCE_ARCH_TYPE |
| MV2_FORCE_ARCH_TYPE |
| Description: This parameter forces the architecture type. |
| Default: 0 |
| |
| MPIR_CVAR_FORCE_HCA_TYPE |
| Aliases: MPIR_PARAM_FORCE_HCA_TYPE |
| MPICH_FORCE_HCA_TYPE |
| MV2_FORCE_HCA_TYPE |
| Description: This parameter forces the HCA type. |
| Default: 0 |
| |
| MPIR_CVAR_NEMESIS_SHM_EAGER_MAX_SZ |
| Aliases: MPIR_PARAM_NEMESIS_SHM_EAGER_MAX_SZ |
| MPICH_NEMESIS_SHM_EAGER_MAX_SZ |
| MV2_NEMESIS_SHM_EAGER_MAX_SZ |
| Description: This cvar controls the message size at which Nemesis |
| switches from eager to rendezvous mode for shared memory. If this |
| cvar is set to -1, then Nemesis will choose an appropriate value. |
| Default: -1 |
| |
| MPIR_CVAR_NEMESIS_SHM_READY_EAGER_MAX_SZ |
| Aliases: MPIR_PARAM_NEMESIS_SHM_READY_EAGER_MAX_SZ |
| MPICH_NEMESIS_SHM_READY_EAGER_MAX_SZ |
| MV2_NEMESIS_SHM_READY_EAGER_MAX_SZ |
| Description: This cvar controls the message size at which Nemesis |
| switches from eager to rendezvous mode for ready-send messages. If |
| this cvar is set to -1, then ready messages will always be sent |
| eagerly. If this cvar is set to -2, then Nemesis will choose an |
| appropriate value. |
| Default: -2 |
| |
| MPIR_CVAR_NEMESIS_LMT_DMA_THRESHOLD |
| Aliases: MPIR_PARAM_NEMESIS_LMT_DMA_THRESHOLD |
| MPICH_NEMESIS_LMT_DMA_THRESHOLD |
| MV2_NEMESIS_LMT_DMA_THRESHOLD |
| Description: Messages larger than this size will use the "dma" (knem) |
| intranode LMT implementation, if it is enabled and available. |
| Default: 2097152 |
| |
| MPIR_CVAR_NEMESIS_ENABLE_CKPOINT |
| Aliases: MPIR_PARAM_NEMESIS_ENABLE_CKPOINT |
| MPICH_NEMESIS_ENABLE_CKPOINT |
| MV2_NEMESIS_ENABLE_CKPOINT |
| Description: If true, enables checkpointing support and returns an |
| error if checkpointing library cannot be initialized. |
| Default: 0 |
| |
| MPIR_CVAR_ENABLE_FT |
| Aliases: MPIR_PARAM_ENABLE_FT |
| MPICH_ENABLE_FT |
| MV2_ENABLE_FT |
| Description: Enable fault tolerance functions |
| Default: 0 |
| |
| MPIR_CVAR_NEMESIS_NETMOD |
| Aliases: MPIR_PARAM_NEMESIS_NETMOD |
| MPICH_NEMESIS_NETMOD |
| MV2_NEMESIS_NETMOD |
| Description: If non-empty, this cvar specifies which network module |
| should be used for communication. This variable is |
| case-insensitive. |
| Default: "" |
| |
| MPIR_CVAR_POLLS_BEFORE_YIELD |
| Aliases: MPIR_PARAM_POLLS_BEFORE_YIELD |
| MPICH_POLLS_BEFORE_YIELD |
| MV2_POLLS_BEFORE_YIELD |
| Description: When MPICH is in a busy waiting loop, it will periodically |
| call a function to yield the processor. This cvar sets the number |
| of loops before the yield function is called. A value of 0 |
| disables yielding. |
| Default: 1000 |
| |
| MPIR_CVAR_NEMESIS_MXM_BULK_CONNECT |
| Aliases: MPIR_PARAM_NEMESIS_MXM_BULK_CONNECT |
| MPICH_NEMESIS_MXM_BULK_CONNECT |
| MV2_NEMESIS_MXM_BULK_CONNECT |
| Description: If true, force mxm to connect all processes at |
| initialization time. |
| Default: 0 |
| |
| MPIR_CVAR_NEMESIS_MXM_BULK_DISCONNECT |
| Aliases: MPIR_PARAM_NEMESIS_MXM_BULK_DISCONNECT |
| MPICH_NEMESIS_MXM_BULK_DISCONNECT |
| MV2_NEMESIS_MXM_BULK_DISCONNECT |
| Description: If true, force mxm to disconnect all processes at |
| finalization time. |
| Default: 0 |
| |
| MPIR_CVAR_NEMESIS_MXM_HUGEPAGE |
| Aliases: MPIR_PARAM_NEMESIS_MXM_HUGEPAGE |
| MPICH_NEMESIS_MXM_HUGEPAGE |
| MV2_NEMESIS_MXM_HUGEPAGE |
| Description: If true, mxm tries detecting hugepage support. On HPC-X |
| 2.3 and earlier, this might cause problems on Ubuntu and other |
| platforms even if the system provides hugepage support. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_INTERFACE_HOSTNAME |
| Aliases: MPIR_PARAM_CH3_INTERFACE_HOSTNAME |
| MPICH_CH3_INTERFACE_HOSTNAME |
| MV2_CH3_INTERFACE_HOSTNAME |
| MPIR_CVAR_INTERFACE_HOSTNAME |
| MPIR_PARAM_INTERFACE_HOSTNAME |
| MPICH_INTERFACE_HOSTNAME |
| MV2_INTERFACE_HOSTNAME |
| Description: If non-NULL, this cvar specifies the IP address that other |
| processes should use when connecting to this process. This cvar is |
| mutually exclusive with the MPIR_CVAR_CH3_NETWORK_IFACE cvar and it |
| is an error to set them both. |
| Default: NULL |
| |
| MPIR_CVAR_CH3_PORT_RANGE |
| Aliases: MPIR_PARAM_CH3_PORT_RANGE |
| MPICH_CH3_PORT_RANGE |
| MV2_CH3_PORT_RANGE |
| MPIR_CVAR_PORTRANGE |
| MPIR_CVAR_PORT_RANGE |
| MPIR_PARAM_PORTRANGE |
| MPIR_PARAM_PORT_RANGE |
| MPICH_PORTRANGE |
| MPICH_PORT_RANGE |
| MV2_PORTRANGE |
| MV2_PORT_RANGE |
| Description: The MPIR_CVAR_CH3_PORT_RANGE environment variable allows |
| you to specify the range of TCP ports to be used by the process |
| manager and the MPICH library. The format of this variable is |
| <low>:<high>. To specify any available port, use 0:0. |
| Default: {0,0} |
| |
| MPIR_CVAR_NEMESIS_TCP_NETWORK_IFACE |
| Aliases: MPIR_PARAM_NEMESIS_TCP_NETWORK_IFACE |
| MPICH_NEMESIS_TCP_NETWORK_IFACE |
| MV2_NEMESIS_TCP_NETWORK_IFACE |
| MPIR_CVAR_NETWORK_IFACE |
| MPIR_PARAM_NETWORK_IFACE |
| MPICH_NETWORK_IFACE |
| MV2_NETWORK_IFACE |
| Description: If non-NULL, this cvar specifies which pseudo-ethernet |
| interface the tcp netmod should use (e.g., "eth1", "ib0"). Note, |
| this is a Linux-specific cvar. This cvar is mutually exclusive with |
| the MPIR_CVAR_CH3_INTERFACE_HOSTNAME cvar and it is an error to set |
| them both. |
| Default: NULL |
| |
| MPIR_CVAR_NEMESIS_TCP_HOST_LOOKUP_RETRIES |
| Aliases: MPIR_PARAM_NEMESIS_TCP_HOST_LOOKUP_RETRIES |
| MPICH_NEMESIS_TCP_HOST_LOOKUP_RETRIES |
| MV2_NEMESIS_TCP_HOST_LOOKUP_RETRIES |
| Description: This cvar controls the number of times to retry the |
| gethostbyname() function before giving up. |
| Default: 10 |
| |
| MPIR_CVAR_OFI_USE_PROVIDER |
| Aliases: MPIR_PARAM_OFI_USE_PROVIDER |
| MPICH_OFI_USE_PROVIDER |
| MV2_OFI_USE_PROVIDER |
| Description: If non-null, choose an OFI provider by name |
| Default: NULL |
| |
| MPIR_CVAR_OFI_DUMP_PROVIDERS |
| Aliases: MPIR_PARAM_OFI_DUMP_PROVIDERS |
| MPICH_OFI_DUMP_PROVIDERS |
| MV2_OFI_DUMP_PROVIDERS |
| Description: If true, dump provider information at init |
| Default: 0 |
| |
| MPIR_CVAR_USE_BLOCKING |
| Aliases: MPIR_PARAM_USE_BLOCKING |
| MPICH_USE_BLOCKING |
| MV2_USE_BLOCKING |
| Description: Setting this parameter enables mvapich2 to use blocking |
| mode progress. MPI applications do not take up any CPU when they |
| are waiting for incoming messages. |
| Default: 0 |
| |
| MPIR_CVAR_USE_SHARED_MEM |
| Aliases: MPIR_PARAM_USE_SHARED_MEM |
| MPICH_USE_SHARED_MEM |
| MV2_USE_SHARED_MEM |
| Description: Use shared memory for intra-node communication. |
| Default: 1 |
| |
| MPIR_CVAR_ON_DEMAND_THRESHOLD |
| Aliases: MPIR_PARAM_ON_DEMAND_THRESHOLD |
| MPICH_ON_DEMAND_THRESHOLD |
| MV2_ON_DEMAND_THRESHOLD |
| Description: This defines threshold for enabling on-demand connection |
| management scheme. When the size of the job is larger than the |
| threshold value, on-demand connection management will be used. |
| Default: 64 |
| |
| MPIR_CVAR_ENABLE_SHARP |
| Aliases: MPIR_PARAM_ENABLE_SHARP |
| MPICH_ENABLE_SHARP |
| MV2_ENABLE_SHARP |
| Description: This enables the hardware-based SHArP collectives. |
| Default: 0 |
| |
| MPIR_CVAR_SM_SCHEDULING |
| Aliases: MPIR_PARAM_SM_SCHEDULING |
| MPICH_SM_SCHEDULING |
| MV2_SM_SCHEDULING |
| Description: This specifies the policy that will be used to assign HCAs |
| to each of the processes. |
| Default: "FIXED_MAPPING" |
| |
| MPIR_CVAR_SMALL_MSG_RAIL_SHARING_POLICY |
| Aliases: MPIR_PARAM_SMALL_MSG_RAIL_SHARING_POLICY |
| MPICH_SMALL_MSG_RAIL_SHARING_POLICY |
| MV2_SMALL_MSG_RAIL_SHARING_POLICY |
| Description: This specifies the policy that will be used to assign HCAs |
| to each of the processes with small message sizes. |
| Default: "ROUND_ROBIN" |
| |
| MPIR_CVAR_MED_MSG_RAIL_SHARING_POLICY |
| Aliases: MPIR_PARAM_MED_MSG_RAIL_SHARING_POLICY |
| MPICH_MED_MSG_RAIL_SHARING_POLICY |
| MV2_MED_MSG_RAIL_SHARING_POLICY |
| Description: This specifies the policy that will be used to assign HCAs |
| to each of the processes with medium message sizes. |
| Default: "ROUND_ROBIN" |
| |
| MPIR_CVAR_RAIL_SHARING_POLICY |
| Aliases: MPIR_PARAM_RAIL_SHARING_POLICY |
| MPICH_RAIL_SHARING_POLICY |
| MV2_RAIL_SHARING_POLICY |
| Description: This specifies the policy that will be used to assign HCAs |
| to each of the processes. |
| Default: "FIXED_MAPPING" |
| |
| MPIR_CVAR_NUM_PORTS |
| Aliases: MPIR_PARAM_NUM_PORTS |
| MPICH_NUM_PORTS |
| MV2_NUM_PORTS |
| Description: This specifies the number of ports per InfiniBand adapter |
| to be used for communication per adapter on an end node. |
| Default: 1 |
| |
| MPIR_CVAR_NUM_QP_PER_PORT |
| Aliases: MPIR_PARAM_NUM_QP_PER_PORT |
| MPICH_NUM_QP_PER_PORT |
| MV2_NUM_QP_PER_PORT |
| Description: This parameter indicates number of queue pairs per port to |
| be used for communication on an end node. This is useful in the |
| presence of multiple send/recv engines available per port for data |
| transfer. |
| Default: 1 |
| |
| MPIR_CVAR_IBA_EAGER_THRESHOLD |
| Aliases: MPIR_PARAM_IBA_EAGER_THRESHOLD |
| MPICH_IBA_EAGER_THRESHOLD |
| MV2_IBA_EAGER_THRESHOLD |
| Description: This specifies the switch point between eager and |
| rendezvous protocol in MVAPICH2. For better performance, the value |
| of MPIR_CVAR_MV2_IBA_EAGER_THRESHOLD should be set the same as |
| MPIR_CVAR_MV2_VBUF_TOTAL_SIZE. |
| Default: -1 |
| |
| MPIR_CVAR_STRIPING_THRESHOLD |
| Aliases: MPIR_PARAM_STRIPING_THRESHOLD |
| MPICH_STRIPING_THRESHOLD |
| MV2_STRIPING_THRESHOLD |
| Description: This parameter specifies the message size above which we |
| begin to stripe the message across multiple rails (if present). |
| Default: 8192 |
| |
| MPIR_CVAR_RAIL_SHARING_MED_MSG_THRESHOLD |
| Aliases: MPIR_PARAM_RAIL_SHARING_MED_MSG_THRESHOLD |
| MPICH_RAIL_SHARING_MED_MSG_THRESHOLD |
| MV2_RAIL_SHARING_MED_MSG_THRESHOLD |
| Description: This specifies the threshold for the medium message size |
| beyond which medium rail sharing striping will take place. |
| Default: 2048 |
| |
| MPIR_CVAR_RAIL_SHARING_LARGE_MSG_THRESHOLD |
| Aliases: MPIR_PARAM_RAIL_SHARING_LARGE_MSG_THRESHOLD |
| MPICH_RAIL_SHARING_LARGE_MSG_THRESHOLD |
| MV2_RAIL_SHARING_LARGE_MSG_THRESHOLD |
| Description: This specifies the threshold for the large message size |
| beyond which large rail sharing striping will be effective. |
| Default: 16384 |
| |
| MPIR_CVAR_USE_MCAST |
| Aliases: MPIR_PARAM_USE_MCAST |
| MPICH_USE_MCAST |
| MV2_USE_MCAST |
| Description: Set this to 1, to enable hardware multicast support in |
| collective communication. |
| Default: 1 |
| |
| MPIR_CVAR_COALESCE_THRESHOLD |
| Aliases: MPIR_PARAM_COALESCE_THRESHOLD |
| MPICH_COALESCE_THRESHOLD |
| MV2_COALESCE_THRESHOLD |
| Description: This parameter determines the threshhold for message |
| coalescing. |
| Default: 6 |
| |
| MPIR_CVAR_USE_COALESCE |
| Aliases: MPIR_PARAM_USE_COALESCE |
| MPICH_USE_COALESCE |
| MV2_USE_COALESCE |
| Description: Coalesce multiple small messages into a single message to |
| increase small message throughput. |
| Default: 0 |
| |
| MPIR_CVAR_RNDV_PROTOCOL |
| Aliases: MPIR_PARAM_RNDV_PROTOCOL |
| MPICH_RNDV_PROTOCOL |
| MV2_RNDV_PROTOCOL |
| Description: The value of this variable can be set to choose different |
| rendezvous protocols. RPUT (default RDMA-Write) RGET (RDMA Read |
| based), R3 (send/recv based). |
| Default: "RPUT" |
| |
| MPIR_CVAR_SPIN_COUNT |
| Aliases: MPIR_PARAM_SPIN_COUNT |
| MPICH_SPIN_COUNT |
| MV2_SPIN_COUNT |
| Description: This is the number of the connection manager polls for new |
| control messages from UD channel for each interrupt. This may be |
| increased to reduce the interrupt overhead when many incoming |
| control messages from UD channel at the same time. |
| Default: 5000 |
| |
| MPIR_CVAR_DEFAULT_MTU |
| Aliases: MPIR_PARAM_DEFAULT_MTU |
| MPICH_DEFAULT_MTU |
| MV2_DEFAULT_MTU |
| Description: The internal MTU size. For Gen2, this parameter should be |
| a string instead of an integer. Valid values are: IBV_MTU_256, |
| IBV_MTU_512, IBV_MTU_1024, IBV_MTU_2048, IBV_MTU_4096. |
| Default: "IBV_MTU_1024" |
| |
| MPIR_CVAR_NUM_CQES_PER_POLL |
| Aliases: MPIR_PARAM_NUM_CQES_PER_POLL |
| MPICH_NUM_CQES_PER_POLL |
| MV2_NUM_CQES_PER_POLL |
| Description: Maximum number of InfiniBand messages retrieved from the |
| completion queue in one attempt. |
| Default: 96 |
| |
| MPIR_CVAR_USE_RDMA_CM |
| Aliases: MPIR_PARAM_USE_RDMA_CM |
| MPICH_USE_RDMA_CM |
| MV2_USE_RDMA_CM |
| Description: This parameter enables the use of RDMA CM for establishing |
| the connections. |
| Default: 0 |
| |
| MPIR_CVAR_USE_IWARP_MODE |
| Aliases: MPIR_PARAM_USE_IWARP_MODE |
| MPICH_USE_IWARP_MODE |
| MV2_USE_IWARP_MODE |
| Description: This parameter enables the library to run in iWARP mode. |
| Default: 0 |
| |
| MPIR_CVAR_SUPPORT_DPM |
| Aliases: MPIR_PARAM_SUPPORT_DPM |
| MPICH_SUPPORT_DPM |
| MV2_SUPPORT_DPM |
| Description: This option enables the dynamic process management |
| interface and on-demand connection management. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_RMA_SCALABLE_FENCE_PROCESS_NUM |
| Aliases: MPIR_PARAM_CH3_RMA_SCALABLE_FENCE_PROCESS_NUM |
| MPICH_CH3_RMA_SCALABLE_FENCE_PROCESS_NUM |
| MV2_CH3_RMA_SCALABLE_FENCE_PROCESS_NUM |
| Description: Specify the threshold of switching the algorithm used in |
| FENCE from the basic algorithm to the scalable algorithm. The value |
| can be nagative, zero or positive. When the number of processes is |
| larger than or equal to this value, FENCE will use a scalable |
| algorithm which do not use O(P) data structure; when the number of |
| processes is smaller than the value, FENCE will use a basic but |
| fast algorithm which requires an O(P) data structure. |
| Default: 1024 |
| |
| MPIR_CVAR_CH3_RMA_DELAY_ISSUING_FOR_PIGGYBACKING |
| Aliases: MPIR_PARAM_CH3_RMA_DELAY_ISSUING_FOR_PIGGYBACKING |
| MPICH_CH3_RMA_DELAY_ISSUING_FOR_PIGGYBACKING |
| MV2_CH3_RMA_DELAY_ISSUING_FOR_PIGGYBACKING |
| Description: Specify if delay issuing of RMA operations for |
| piggybacking LOCK/UNLOCK/FLUSH is enabled. It can be either 0 or 1. |
| When it is set to 1, the issuing of LOCK message is delayed until |
| origin process see the first RMA operation and piggyback LOCK with |
| that operation, and the origin process always keeps the current |
| last operation until the ending synchronization call in order to |
| piggyback UNLOCK/FLUSH with that operation. When it is set to 0, in |
| WIN_LOCK/UNLOCK case, the LOCK message is sent out as early as |
| possible, in WIN_LOCK_ALL/UNLOCK_ALL case, the origin process still |
| tries to piggyback LOCK message with the first operation; for |
| UNLOCK/FLUSH message, the origin process no longer keeps the |
| current last operation but only piggyback UNLOCK/FLUSH if there is |
| an operation avaliable in the ending synchronization call. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_ENABLE_HCOLL |
| Aliases: MPIR_PARAM_CH3_ENABLE_HCOLL |
| MPICH_CH3_ENABLE_HCOLL |
| MV2_CH3_ENABLE_HCOLL |
| Description: If true, enable HCOLL collectives. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_RMA_ACTIVE_REQ_THRESHOLD |
| Aliases: MPIR_PARAM_CH3_RMA_ACTIVE_REQ_THRESHOLD |
| MPICH_CH3_RMA_ACTIVE_REQ_THRESHOLD |
| MV2_CH3_RMA_ACTIVE_REQ_THRESHOLD |
| Description: Threshold of number of active requests to trigger blocking |
| waiting in operation routines. When the value is negative, we never |
| blockingly wait in operation routines. When the value is zero, we |
| always trigger blocking waiting in operation routines to wait until |
| no. of active requests becomes zero. When the value is positive, we |
| do blocking waiting in operation routines to wait until no. of |
| active requests being reduced to this value. |
| Default: 65536 |
| |
| MPIR_CVAR_CH3_RMA_POKE_PROGRESS_REQ_THRESHOLD |
| Aliases: MPIR_PARAM_CH3_RMA_POKE_PROGRESS_REQ_THRESHOLD |
| MPICH_CH3_RMA_POKE_PROGRESS_REQ_THRESHOLD |
| MV2_CH3_RMA_POKE_PROGRESS_REQ_THRESHOLD |
| Description: Threshold at which the RMA implementation attempts to |
| complete requests while completing RMA operations and while using |
| the lazy synchonization approach. Change this value if programs |
| fail because they run out of requests or other internal resources |
| Default: 128 |
| |
| MPIR_CVAR_CH3_RMA_OP_WIN_POOL_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_OP_WIN_POOL_SIZE |
| MPICH_CH3_RMA_OP_WIN_POOL_SIZE |
| MV2_CH3_RMA_OP_WIN_POOL_SIZE |
| Description: Size of the window-private RMA operations pool (in number |
| of operations) that stores information about RMA operations that |
| could not be issued immediately. Requires a positive value. |
| Default: 256 |
| |
| MPIR_CVAR_CH3_RMA_OP_GLOBAL_POOL_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_OP_GLOBAL_POOL_SIZE |
| MPICH_CH3_RMA_OP_GLOBAL_POOL_SIZE |
| MV2_CH3_RMA_OP_GLOBAL_POOL_SIZE |
| Description: Size of the Global RMA operations pool (in number of |
| operations) that stores information about RMA operations that could |
| not be issued immediatly. Requires a positive value. |
| Default: 16384 |
| |
| MPIR_CVAR_CH3_RMA_TARGET_WIN_POOL_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_TARGET_WIN_POOL_SIZE |
| MPICH_CH3_RMA_TARGET_WIN_POOL_SIZE |
| MV2_CH3_RMA_TARGET_WIN_POOL_SIZE |
| Description: Size of the window-private RMA target pool (in number of |
| targets) that stores information about RMA targets that could not |
| be issued immediately. Requires a positive value. |
| Default: 256 |
| |
| MPIR_CVAR_CH3_RMA_TARGET_GLOBAL_POOL_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_TARGET_GLOBAL_POOL_SIZE |
| MPICH_CH3_RMA_TARGET_GLOBAL_POOL_SIZE |
| MV2_CH3_RMA_TARGET_GLOBAL_POOL_SIZE |
| Description: Size of the Global RMA targets pool (in number of targets) |
| that stores information about RMA targets that could not be issued |
| immediatly. Requires a positive value. |
| Default: 16384 |
| |
| MPIR_CVAR_CH3_RMA_TARGET_LOCK_ENTRY_WIN_POOL_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_TARGET_LOCK_ENTRY_WIN_POOL_SIZE |
| MPICH_CH3_RMA_TARGET_LOCK_ENTRY_WIN_POOL_SIZE |
| MV2_CH3_RMA_TARGET_LOCK_ENTRY_WIN_POOL_SIZE |
| Description: Size of the window-private RMA lock entries pool (in |
| number of lock entries) that stores information about RMA lock |
| requests that could not be satisfied immediatly. Requires a |
| positive value. |
| Default: 256 |
| |
| MPIR_CVAR_CH3_RMA_OP_PIGGYBACK_LOCK_DATA_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_OP_PIGGYBACK_LOCK_DATA_SIZE |
| MPICH_CH3_RMA_OP_PIGGYBACK_LOCK_DATA_SIZE |
| MV2_CH3_RMA_OP_PIGGYBACK_LOCK_DATA_SIZE |
| Description: Specify the threshold of data size of a RMA operation |
| which can be piggybacked with a LOCK message. It is always a |
| positive value and should not be smaller than |
| MPIDI_RMA_IMMED_BYTES. If user sets it as a small value, for middle |
| and large data size, we will lose performance because of always |
| waiting for round-trip of LOCK synchronization; if user sets it as |
| a large value, we need to consume more memory on target side to |
| buffer this lock request when lock is not satisfied. |
| Default: 65536 |
| |
| MPIR_CVAR_CH3_NOLOCAL |
| Aliases: MPIR_PARAM_CH3_NOLOCAL |
| MPICH_CH3_NOLOCAL |
| MV2_CH3_NOLOCAL |
| MPIR_CVAR_CH3_NO_LOCAL |
| MPIR_PARAM_CH3_NO_LOCAL |
| MPICH_CH3_NO_LOCAL |
| MV2_CH3_NO_LOCAL |
| Description: If true, force all processes to operate as though all |
| processes are located on another node. For example, this disables |
| shared memory communication hierarchical collectives. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_ODD_EVEN_CLIQUES |
| Aliases: MPIR_PARAM_CH3_ODD_EVEN_CLIQUES |
| MPICH_CH3_ODD_EVEN_CLIQUES |
| MV2_CH3_ODD_EVEN_CLIQUES |
| MPIR_CVAR_CH3_EVEN_ODD_CLIQUES |
| MPIR_PARAM_CH3_EVEN_ODD_CLIQUES |
| MPICH_CH3_EVEN_ODD_CLIQUES |
| MV2_CH3_EVEN_ODD_CLIQUES |
| Description: If true, odd procs on a node are seen as local to each |
| other, and even procs on a node are seen as local to each other. |
| Used for debugging on a single machine. |
| Default: 0 |
| |
| MPIR_CVAR_CH3_EAGER_MAX_MSG_SIZE |
| Aliases: MPIR_PARAM_CH3_EAGER_MAX_MSG_SIZE |
| MPICH_CH3_EAGER_MAX_MSG_SIZE |
| MV2_CH3_EAGER_MAX_MSG_SIZE |
| Description: This cvar controls the message size at which CH3 switches |
| from eager to rendezvous mode. |
| Default: 131072 |
| |
| MPIR_CVAR_CH3_RMA_SLOTS_SIZE |
| Aliases: MPIR_PARAM_CH3_RMA_SLOTS_SIZE |
| MPICH_CH3_RMA_SLOTS_SIZE |
| MV2_CH3_RMA_SLOTS_SIZE |
| Description: Number of RMA slots during window creation. Each slot |
| contains a linked list of target elements. The distribution of |
| ranks among slots follows a round-robin pattern. Requires a |
| positive value. |
| Default: 262144 |
| |
| MPIR_CVAR_CH3_RMA_TARGET_LOCK_DATA_BYTES |
| Aliases: MPIR_PARAM_CH3_RMA_TARGET_LOCK_DATA_BYTES |
| MPICH_CH3_RMA_TARGET_LOCK_DATA_BYTES |
| MV2_CH3_RMA_TARGET_LOCK_DATA_BYTES |
| Description: Size (in bytes) of available lock data this window can |
| provided. If current buffered lock data is more than this value, |
| the process will drop the upcoming operation data. Requires a |
| positive calue. |
| Default: 655360 |
| |
| |