static int ompi_register_mca_variables(void)
{
int ret;
/* Register MPI variables */
if (OMPI_SUCCESS != (ret = ompi_mpi_register_params())) {
return ret;
}
/* check to see if we want timing information */
ompi_enable_timing = false;
(void) mca_base_var_register("ompi", "ompi", NULL, "timing",
"Request that critical timing loops be measured",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_enable_timing);
ompi_enable_timing_ext = false;
(void) mca_base_var_register("ompi", "ompi", NULL, "timing_ext",
"Request that critical timing loops be measured",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_enable_timing_ext);
return OMPI_SUCCESS;
}
static int orte_iof_base_register(mca_base_register_flag_t flags)
{
/* check for maximum number of pending output messages */
orte_iof_base.output_limit = (size_t) INT_MAX;
(void) mca_base_var_register("orte", "iof", "base", "output_limit",
"Maximum backlog of output messages [default: unlimited]",
MCA_BASE_VAR_TYPE_SIZE_T, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_iof_base.output_limit);
/* check for files to be sent to stdin of procs */
orte_iof_base.input_files = NULL;
(void) mca_base_var_register("orte", "iof","base", "input_files",
"Comma-separated list of input files to be read and sent to stdin of procs (default: NULL)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_iof_base.input_files);
/* Redirect application stderr to stdout (at source) */
orte_iof_base.redirect_app_stderr_to_stdout = false;
(void) mca_base_var_register("orte", "iof","base", "redirect_app_stderr_to_stdout",
"Redirect application stderr to stdout at source (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_iof_base.redirect_app_stderr_to_stdout);
return ORTE_SUCCESS;
}
static int orte_sstore_base_register(mca_base_register_flag_t flags)
{
int mca_index;
/*
* Base Global Snapshot directory
*/
orte_sstore_base_global_snapshot_dir = (char *) opal_home_directory();
mca_index = mca_base_var_register("orte", "sstore", "base", "global_snapshot_dir",
"The base directory to use when storing global snapshots",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_sstore_base_global_snapshot_dir);
mca_base_var_register_synonym(mca_index, "orte", "snapc", "base", "global_snapshot_dir",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
/*
* User defined snapshot reference to use for this job
*/
orte_sstore_base_global_snapshot_ref = NULL;
mca_index = mca_base_var_register("orte", "sstore", "base", "global_snapshot_ref",
"The global snapshot reference to be used for this job. "
" [Default = ompi_global_snapshot_MPIRUNPID.ckpt]",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_sstore_base_global_snapshot_ref);
mca_base_var_register_synonym(mca_index, "orte", "snapc", "base", "global_snapshot_ref",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
return ORTE_SUCCESS;
}
static int mca_pml_base_register(mca_base_register_flag_t flags)
{
#if !MCA_ompi_pml_DIRECT_CALL && OPAL_ENABLE_FT_CR == 1
int var_id;
#endif
ompi_pml_base_bsend_allocator_name = "basic";
(void) mca_base_var_register("ompi", "pml", "base", "bsend_allocator", NULL,
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_pml_base_bsend_allocator_name);
#if !MCA_ompi_pml_DIRECT_CALL && OPAL_ENABLE_FT_CR == 1
ompi_pml_base_wrapper = NULL;
var_id = mca_base_var_register("ompi", "pml", "base", "wrapper",
"Use a Wrapper component around the selected PML component",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_pml_base_wrapper);
(void) mca_base_var_register_synonym(var_id, "ompi", "pml", NULL, "wrapper", 0);
#endif
return OMPI_SUCCESS;
}
static int orte_sensor_base_register(mca_base_register_flag_t flags)
{
int var_id;
orte_sensor_base_sample_rate = 0;
var_id = mca_base_var_register("orte", "sensor", "base", "sample_rate",
"Sample rate in seconds",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_sensor_base_sample_rate);
mca_base_var_register_synonym(var_id, "orte", "sensor", NULL, "sample_rate",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
/* see if we want samples logged */
orte_sensor_base.log_samples = false;
var_id = mca_base_var_register("orte", "sensor", "base", "log_samples",
"Log samples to database",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_sensor_base.log_samples);
mca_base_var_register_synonym(var_id, "orte", "sensor", NULL, "log_samples",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
return ORTE_SUCCESS;
}
int opal_dss_register_vars (void)
{
mca_base_var_enum_t *new_enum;
char *enviro_val;
int ret;
enviro_val = getenv("OPAL_dss_debug");
if (NULL != enviro_val) { /* debug requested */
opal_dss_verbose = 0;
}
opal_dss_group_id = mca_base_var_group_register ("opal", "dss", NULL, NULL);
/** set the default buffer type. If we are in debug mode, then we default
* to fully described buffers. Otherwise, we default to non-described for brevity
* and performance
*/
#if OPAL_ENABLE_DEBUG
default_buf_type = OPAL_DSS_BUFFER_FULLY_DESC;
#else
default_buf_type = OPAL_DSS_BUFFER_NON_DESC;
#endif
ret = mca_base_var_enum_create ("buffer types", buffer_type_values, &new_enum);
if (OPAL_SUCCESS != ret) {
fprintf (stderr, "Fail A\n");
return ret;
}
ret = mca_base_var_register ("opal", "dss", NULL, "buffer_type",
"Set the default mode for OpenRTE buffers (0=non-described, 1=described)",
MCA_BASE_VAR_TYPE_INT, new_enum, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_8, MCA_BASE_VAR_SCOPE_ALL_EQ,
&default_buf_type);
OBJ_RELEASE(new_enum);
if (0 > ret) {
return ret;
}
/* setup the initial size of the buffer. */
opal_dss_initial_size = OPAL_DSS_DEFAULT_INITIAL_SIZE;
ret = mca_base_var_register ("opal", "dss", NULL, "buffer_initial_size", NULL,
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_8, MCA_BASE_VAR_SCOPE_ALL_EQ,
&opal_dss_initial_size);
if (0 > ret) {
return ret;
}
/* the threshold as to where to stop doubling the size of the buffer
* allocated memory and start doing additive increases */
opal_dss_threshold_size = OPAL_DSS_DEFAULT_THRESHOLD_SIZE;
ret = mca_base_var_register ("opal", "dss", NULL, "buffer_threshold_size", NULL,
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_8, MCA_BASE_VAR_SCOPE_ALL_EQ,
&opal_dss_threshold_size);
return (0 > ret) ? ret : OPAL_SUCCESS;
}
static int opal_pmix_base_frame_register(mca_base_register_flag_t flags)
{
opal_pmix_base_async_modex = false;
(void) mca_base_var_register("opal", "pmix", "base", "async_modex", "Use asynchronous modex mode",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &opal_pmix_base_async_modex);
opal_pmix_collect_all_data = true;
(void) mca_base_var_register("opal", "pmix", "base", "collect_data", "Collect all data during modex",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &opal_pmix_collect_all_data);
return OPAL_SUCCESS;
}
int opal_datatype_register_params(void)
{
#if OPAL_ENABLE_DEBUG
int ret;
ret = mca_base_var_register ("opal", "mpi", NULL, "ddt_unpack_debug",
"Whether to output debugging information in the ddt unpack functions (nonzero = enabled)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_3,
MCA_BASE_VAR_SCOPE_LOCAL, &opal_unpack_debug);
if (0 > ret) {
return ret;
}
ret = mca_base_var_register ("opal", "mpi", NULL, "ddt_pack_debug",
"Whether to output debugging information in the ddt pack functions (nonzero = enabled)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_3,
MCA_BASE_VAR_SCOPE_LOCAL, &opal_pack_debug);
if (0 > ret) {
return ret;
}
ret = mca_base_var_register ("opal", "mpi", NULL, "ddt_position_debug",
"Non zero lead to output generated by the datatype position functions",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_3,
MCA_BASE_VAR_SCOPE_LOCAL, &opal_position_debug);
if (0 > ret) {
return ret;
}
ret = mca_base_var_register ("opal", "mpi", NULL, "ddt_copy_debug",
"Whether to output debugging information in the ddt copy functions (nonzero = enabled)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_3,
MCA_BASE_VAR_SCOPE_LOCAL, &opal_copy_debug);
if (0 > ret) {
return ret;
}
#if OPAL_CUDA_SUPPORT
/* Set different levels of verbosity in the cuda related code. */
ret = mca_base_var_register ("opal", "opal", NULL, "cuda_verbose",
"Set level of opal cuda verbosity",
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_8, MCA_BASE_VAR_SCOPE_LOCAL,
&opal_cuda_verbose);
if (0 > ret) {
return ret;
}
#endif /* OPAL_CUDA_SUPPORT */
#endif /* OPAL_ENABLE_DEBUG */
return OPAL_SUCCESS;
}
static void initFreeList(void)
{
mca_base_var_register("oshmem", "shmem", "java", "eager",
"Java buffers eager size",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY,
&oshmem_shmem_java_eager);
OBJ_CONSTRUCT(&shmem_java_buffers, opal_free_list_t);
int r = opal_free_list_init(&shmem_java_buffers,
sizeof(shmem_java_buffer_t),
opal_cache_line_size,
OBJ_CLASS(shmem_java_buffer_t),
0, /* payload size */
0, /* payload align */
2, /* initial elements to alloc */
-1, /* max elements */
2, /* num elements per alloc */
NULL, /* mpool */
0, /* mpool reg flags */
NULL, /* unused0 */
NULL, /* item_init */
NULL /* inem_init context */);
if(r != OPAL_SUCCESS)
{
fprintf(stderr, "Unable to initialize shmem_java_buffers.\n");
exit(1);
}
}
int oshmem_group_cache_list_init(void)
{
int mca_value;
int cache_size_default = 100;
OBJ_CONSTRUCT(&oshmem_group_cache_list, opal_list_t);
mca_value = cache_size_default;
(void) mca_base_var_register("oshmem",
"proc",
NULL,
"group_cache_size",
"The depth of the oshmem_group cache list used to speed up collective operations",
MCA_BASE_VAR_TYPE_INT,
NULL,
0,
MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_value);
if (mca_value < 0) {
opal_output(0,
"error: oshmem_group_cache_size mca parameter was set to %i while it has to be positive value. Default value %i will be used.",
mca_value,
cache_size_default);
mca_value = cache_size_default;
}
oshmem_group_cache_size = (unsigned int) mca_value;
return OSHMEM_SUCCESS;
}
extern void
ompi_debugger_setup_dlls(void)
{
int i;
char **dirs, **tmp1 = NULL, **tmp2 = NULL;
ompi_debugger_dll_path = opal_install_dirs.opallibdir;
(void) mca_base_var_register("ompi", "ompi", "debugger", "dll_path",
"List of directories where MPI_INIT should search for debugger plugins",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_debugger_dll_path);
/* Search the directory for MPI debugger DLLs */
if (NULL != ompi_debugger_dll_path) {
dirs = opal_argv_split(ompi_debugger_dll_path, ':');
for (i = 0; dirs[i] != NULL; ++i) {
check(dirs[i], OMPI_MPIHANDLES_DLL_PREFIX, tmp1);
check(dirs[i], OMPI_MSGQ_DLL_PREFIX, tmp2);
}
opal_argv_free(dirs);
}
/* Now that we have a full list of directories, assign the argv
arrays to the global variables (since the debugger may read the
global variables at any time, we want to ensure that they have
non-NULL values only when the entire array is ready). */
mpimsgq_dll_locations = tmp1;
mpidbg_dll_locations = tmp2;
}
void pmix_server_register_params(void)
{
/* register a verbosity */
orte_pmix_server_globals.verbosity = -1;
(void) mca_base_var_register ("orte", "pmix", NULL, "server_verbose",
"Debug verbosity for PMIx server",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_pmix_server_globals.verbosity);
if (0 <= orte_pmix_server_globals.verbosity) {
orte_pmix_server_globals.output = opal_output_open(NULL);
opal_output_set_verbosity(orte_pmix_server_globals.output,
orte_pmix_server_globals.verbosity);
}
/* specify the size of the hotel */
orte_pmix_server_globals.num_rooms = 256;
(void) mca_base_var_register ("orte", "pmix", NULL, "server_max_reqs",
"Maximum number of backlogged PMIx server direct modex requests",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_pmix_server_globals.num_rooms);
/* specify the timeout for the hotel */
orte_pmix_server_globals.timeout = 2;
(void) mca_base_var_register ("orte", "pmix", NULL, "server_max_wait",
"Maximum time (in seconds) the PMIx server should wait to service direct modex requests",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_pmix_server_globals.timeout);
/* register the URI of the UNIVERSAL data server */
orte_pmix_server_globals.server_uri = NULL;
(void) mca_base_var_register ("orte", "pmix", NULL, "server_uri",
"URI of a session-level keyval server for publish/lookup operations",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_pmix_server_globals.server_uri);
/* whether or not to wait for the universal server */
orte_pmix_server_globals.wait_for_server = false;
(void) mca_base_var_register ("orte", "pmix", NULL, "wait_for_server",
"Whether or not to wait for the session-level server to start",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_pmix_server_globals.wait_for_server);
}
static int opal_pmix_base_frame_register(mca_base_register_flag_t flags)
{
opal_pmix_base_async_modex = false;
(void) mca_base_var_register("opal", "pmix", "base", "async_modex", "Use asynchronous modex mode",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &opal_pmix_base_async_modex);
opal_pmix_collect_all_data = true;
(void) mca_base_var_register("opal", "pmix", "base", "collect_data", "Collect all data during modex",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &opal_pmix_collect_all_data);
opal_pmix_base.timeout = -1;
(void) mca_base_var_register("opal", "pmix", "base", "exchange_timeout",
"Time (in seconds) to wait for a data exchange to complete",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0, OPAL_INFO_LVL_3,
MCA_BASE_VAR_SCOPE_READONLY, &opal_pmix_base.timeout);
return OPAL_SUCCESS;
}
static int orte_ess_base_register(mca_base_register_flag_t flags)
{
mca_base_var_enum_t *new_enum;
int ret;
orte_ess_base_std_buffering = -1;
(void) mca_base_var_enum_create("ess_base_stream_buffering", stream_buffering_values, &new_enum);
(void) mca_base_var_register("orte", "ess", "base", "stream_buffering",
"Adjust buffering for stdout/stderr "
"[-1 system default] [0 unbuffered] [1 line buffered] [2 fully buffered] "
"(Default: -1)",
MCA_BASE_VAR_TYPE_INT, new_enum, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &orte_ess_base_std_buffering);
OBJ_RELEASE(new_enum);
orte_ess_base_jobid = NULL;
ret = mca_base_var_register("orte", "ess", "base", "jobid", "Process jobid",
MCA_BASE_VAR_TYPE_STRING, NULL, 0,
MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &orte_ess_base_jobid);
mca_base_var_register_synonym(ret, "orte", "orte", "ess", "jobid", 0);
orte_ess_base_vpid = NULL;
ret = mca_base_var_register("orte", "ess", "base", "vpid", "Process vpid",
MCA_BASE_VAR_TYPE_STRING, NULL, 0,
MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &orte_ess_base_vpid);
mca_base_var_register_synonym(ret, "orte", "orte", "ess", "vpid", 0);
orte_ess_base_num_procs = -1;
ret = mca_base_var_register("orte", "ess", "base", "num_procs",
"Used to discover the number of procs in the job",
MCA_BASE_VAR_TYPE_INT, NULL, 0,
MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY, &orte_ess_base_num_procs);
mca_base_var_register_synonym(ret, "orte", "orte", "ess", "num_procs", 0);
return ORTE_SUCCESS;
}
static int mca_mpool_base_register (mca_base_register_flag_t flags)
{
mca_mpool_base_default_hints = NULL;
(void) mca_base_var_register ("opal", "mpool", "base", "default_hints",
"Hints to use when selecting the default memory pool",
MCA_BASE_VAR_TYPE_STRING, NULL, 0,
MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL,
&mca_mpool_base_default_hints);
mca_mpool_base_default_priority = 50;
(void) mca_base_var_register ("opal", "mpool", "base", "default_priority",
"Priority of the default mpool module",
MCA_BASE_VAR_TYPE_INT, NULL, 0,
MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL,
&mca_mpool_base_default_priority);
return OPAL_SUCCESS;
}
static int orte_oob_base_register(mca_base_register_flag_t flags)
{
(void)mca_base_var_register("orte", "oob", "base", "enable_module_progress_threads",
"Whether to independently progress OOB messages for each interface",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_oob_base.use_module_threads);
return ORTE_SUCCESS;
}
static int orte_odls_base_register(mca_base_register_flag_t flags)
{
orte_odls_globals.timeout_before_sigkill = 1;
(void) mca_base_var_register("orte", "odls", "base", "sigkill_timeout",
"Time to wait for a process to die after issuing a kill signal to it",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_odls_globals.timeout_before_sigkill);
return ORTE_SUCCESS;
}
static int orte_state_base_register(mca_base_register_flag_t flags)
{
orte_state_base_run_fdcheck = false;
mca_base_var_register("orte", "state", "base", "check_fds",
"Daemons should check fds for leaks after each job completes",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_state_base_run_fdcheck);
return ORTE_SUCCESS;
}
int ompi_netpatterns_register_mca_params(void)
{
ompi_netpatterns_base_verbose = 0;
mca_base_var_register("ompi", "common", "netpatterns", "base_verbose",
"Verbosity level of the NETPATTERNS framework",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_netpatterns_base_verbose);
return OMPI_SUCCESS;
}
static void register_internal(void)
{
ompi_common_verbs_warn_nonexistent_if = true;
warn_nonexistent_if_index =
mca_base_var_register("ompi", "ompi_common", "verbs", "warn_nonexistent_if",
"Warn if non-existent devices and/or ports are specified in device include/exclude MCA parameters "
"(0 = do not warn; any other value = warn)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL,
&ompi_common_verbs_warn_nonexistent_if);
registered = true;
}
OPAL_DECLSPEC void opal_common_ucx_mca_register(void)
{
opal_common_ucx.registered++;
if (opal_common_ucx.registered > 1) {
/* process once */
return;
}
mca_base_var_register("opal", "opal_common", "ucx", "verbose",
"Verbose level of the UCX components",
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL,
&opal_common_ucx.verbose);
mca_base_var_register("opal", "opal_common", "ucx", "progress_iterations",
"Set number of calls of internal UCX progress calls per opal_progress call",
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL,
&opal_common_ucx.progress_iterations);
opal_common_ucx.output = opal_output_open(NULL);
opal_output_set_verbosity(opal_common_ucx.output, opal_common_ucx.verbose);
}
static int mca_bml_base_register(mca_base_register_flag_t flags)
{
#if OPAL_ENABLE_DEBUG_RELIABILITY
do {
int var_id;
mca_bml_base_error_rate_floor = 0;
var_id = mca_base_var_register("ompi", "bml", "base", "error_rate_floor", NULL,
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_bml_base_error_rate_floor);
(void) mca_base_var_register_synonym(var_id, "ompi", "bml", NULL, "error_rate_floor",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
mca_bml_base_error_rate_ceiling = 0;
var_id = mca_base_var_register("ompi", "bml", "base", "error_rate_ceiling", NULL,
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_bml_base_error_rate_ceiling);
(void) mca_base_var_register_synonym(var_id, "ompi", "bml", NULL, "error_rate_ceiling",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
mca_bml_base_srand = true;
var_id = mca_base_var_register("ompi", "bml", "base", "srand", NULL,
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_bml_base_srand);
(void) mca_base_var_register_synonym(var_id, "ompi", "bml", NULL, "srand",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
} while (0);
#endif
return OMPI_SUCCESS;
}
int oshmem_shmem_preconnect_all(void)
{
int mca_value = 0;
int rc = OSHMEM_SUCCESS;
(void) mca_base_var_register("oshmem",
"runtime",
NULL,
"preconnect_all",
"Whether to force SHMEM processes to fully "
"wire-up the connections between SHMEM "
"processes during "
"initialization (vs. making connections lazily -- "
"upon the first SHMEM traffic between each "
"process peer pair)",
MCA_BASE_VAR_TYPE_INT,
NULL,
0,
MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_value);
/* force qp creation and rkey exchange for memheap. Does not force exchange of static vars */
if (mca_value) {
long val;
int nproc = 0;
int i;
val = 0xdeadbeaf;
if (!preconnect_value) {
rc =
MCA_MEMHEAP_CALL(private_alloc(sizeof(long), (void **)&preconnect_value));
}
if (!preconnect_value || (rc != OSHMEM_SUCCESS)) {
SHMEM_API_ERROR("shmem_preconnect_all failed");
return OSHMEM_ERR_OUT_OF_RESOURCE;
}
nproc = _num_pes();
for (i = 0; i < nproc; i++) {
shmem_long_p(preconnect_value, val, i);
}
shmem_fence();
shmem_barrier_all();
SHMEM_API_VERBOSE(5, "Preconnected all PEs");
}
return OSHMEM_SUCCESS;
}
static int mca_bcol_base_register(mca_base_register_flag_t flags)
{
/* figure out which bcol and sbgp components will actually be used */
/* get list of sub-grouping functions to use */
ompi_bcol_bcols_string = "basesmuma,basesmuma,iboffload,ptpcoll,ugni";
(void) mca_base_var_register("ompi", "bcol", "base", "string",
"Default set of basic collective components to use",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_bcol_bcols_string);
return OMPI_SUCCESS;
}
int opal_cr_refresh_environ(int prev_pid) {
char *file_name;
#if OPAL_ENABLE_CRDEBUG == 1
char *tmp;
#endif
struct stat file_status;
if( 0 >= prev_pid ) {
prev_pid = getpid();
}
/*
* Make sure the file exists. If it doesn't then this means 2 things:
* 1) We have already executed this function, and
* 2) The file has been deleted on the previous round.
*/
asprintf(&file_name, "%s/%s-%d", opal_tmp_directory(), OPAL_CR_BASE_ENV_NAME, prev_pid);
if (NULL == file_name) {
return OPAL_ERR_OUT_OF_RESOURCE;
}
if(0 != stat(file_name, &file_status) ){
free(file_name);
return OPAL_SUCCESS;
}
#if OPAL_ENABLE_CRDEBUG == 1
mca_base_var_env_name ("opal_cr_enable_crdebug", &tmp);
opal_unsetenv(tmp, &environ);
free (tmp);
#endif
extract_env_vars(prev_pid, file_name);
#if OPAL_ENABLE_CRDEBUG == 1
MPIR_debug_with_checkpoint = 0;
(void) mca_base_var_register ("opal", "opal", "cr", "enable_crdebug",
"Enable checkpoint/restart debugging",
MCA_BASE_VAR_TYPE_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_8, MCA_BASE_VAR_SCOPE_ALL_EQ,
&MPIR_debug_with_checkpoint);
opal_output_verbose(10, opal_cr_output,
"opal_cr: init: C/R Debugging Enabled [%s] (refresh)\n",
(MPIR_debug_with_checkpoint ? "True": "False"));
#endif
free(file_name);
return OPAL_SUCCESS;
}
/**
* Register some sshmem-wide MCA params
*/
static int
mca_sshmem_base_register (mca_base_register_flag_t flags)
{
int index;
index = mca_base_var_register("oshmem",
"sshmem",
"base",
"start_address",
"Specify base address for shared memory region",
MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG,
NULL,
0,
MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_sshmem_base_start_address);
(void) mca_base_var_register_synonym(index, "oshmem", "memheap", "base",
"start_address",
MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
mca_sshmem_base_backing_file_dir = "/dev/shm";
index = mca_base_var_register("oshmem",
"sshmem",
"base",
"backing_file_dir",
"Specifies where backing files will be created when "
"mmap is used and shmem_mmap_anonymous set to 0.",
MCA_BASE_VAR_TYPE_STRING,
NULL,
0,
MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_sshmem_base_backing_file_dir);
return OSHMEM_SUCCESS;
}
JNIEXPORT jobjectArray JNICALL Java_mpi_MPI_Init_1jni(
JNIEnv *env, jclass clazz, jobjectArray argv)
{
jsize i;
jclass string;
jobject value;
int len = (*env)->GetArrayLength(env, argv);
char **sargs = (char**)calloc(len+1, sizeof(char*));
for(i = 0; i < len; i++)
{
jstring jc = (jstring)(*env)->GetObjectArrayElement(env, argv, i);
const char *s = (*env)->GetStringUTFChars(env, jc, NULL);
sargs[i] = strdup(s);
(*env)->ReleaseStringUTFChars(env, jc, s);
(*env)->DeleteLocalRef(env, jc);
}
int rc = MPI_Init(&len, &sargs);
ompi_java_exceptionCheck(env, rc);
mca_base_var_register("ompi", "mpi", "java", "eager",
"Java buffers eager size",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_mpi_java_eager);
string = (*env)->FindClass(env, "java/lang/String");
value = (*env)->NewObjectArray(env, len, string, NULL);
for(i = 0; i < len; i++)
{
jstring jc = (*env)->NewStringUTF(env, sargs[i]);
(*env)->SetObjectArrayElement(env, value, i, jc);
(*env)->DeleteLocalRef(env, jc);
free (sargs[i]);
}
free (sargs);
findClasses(env);
initFreeList();
return value;
}
/*
* Class: mpi_MPI
* Method: loadGlobalLibraries
*
* Java implementations typically default to loading dynamic
* libraries strictly to a local namespace. This breaks the
* Open MPI model where components reference back up to the
* base libraries (e.g., libmpi) as it requires that the
* symbols in those base libraries be globally available.
*
* One option, of course, is to build with --disable-dlopen.
* However, this would preclude the ability to pickup 3rd-party
* binary plug-ins at time of execution. This is a valuable
* capability that would be a negative factor towards use of
* the Java bindings.
*
* The other option is to explicitly dlopen libmpi ourselves
* and instruct dlopen to add all those symbols to the global
* namespace. This must be done prior to calling any MPI
* function (e.g., MPI_Init) or else Java will have already
* loaded the library to the local namespace. So create a
* special JNI entry point that just loads the required libmpi
* to the global namespace and call it first (see MPI.java),
* thus making all symbols available to subsequent dlopen calls
* when opening OMPI components.
*/
jint JNI_OnLoad(JavaVM *vm, void *reserved)
{
libmpi = dlopen("libmpi." OPAL_DYN_LIB_SUFFIX, RTLD_NOW | RTLD_GLOBAL);
if(libmpi == NULL)
{
fprintf(stderr, "Java bindings failed to load liboshmem.\n");
exit(1);
}
mca_base_var_register("ompi", "mpi", "java", "eager",
"Java buffers eager size",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_mpi_java_eager);
return JNI_VERSION_1_6;
}
static int orte_rml_base_register(mca_base_register_flag_t flags)
{
int var_id;
/*
* Which RML Wrapper component to use, if any
* - NULL or "" = No wrapper
* - ow. select that specific wrapper component
*/
orte_rml_base_wrapper = NULL;
var_id = mca_base_var_register("orte", "rml", "base", "wrapper",
"Use a Wrapper component around the selected RML component",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&orte_rml_base_wrapper);
(void) mca_base_var_register_synonym(var_id, "orte", "rml",NULL,"wrapper", 0);
return ORTE_SUCCESS;
}
int orte_register_params(void)
{
int id;
opal_output_stream_t lds;
/* only go thru this once - mpirun calls it twice, which causes
* any error messages to show up twice
*/
if (passed_thru) {
return ORTE_SUCCESS;
}
passed_thru = true;
/* get a clean output channel too - need to do this here because
* we use it below, and orterun and some other tools call this
* function prior to calling orte_init
*/
OBJ_CONSTRUCT(&lds, opal_output_stream_t);
lds.lds_want_stdout = true;
orte_clean_output = opal_output_open(&lds);
OBJ_DESTRUCT(&lds);
orte_help_want_aggregate = true;
(void) mca_base_var_register ("orte", "orte", "base", "help_aggregate",
"If orte_base_help_aggregate is true, duplicate help messages will be aggregated rather than displayed individually. This can be helpful for parallel jobs that experience multiple identical failures; rather than print out the same help/failure message N times, display it once with a count of how many processes sent the same message.",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_help_want_aggregate);
/* LOOK FOR A TMP DIRECTORY BASE */
/* Several options are provided to cover a range of possibilities:
*
* (a) all processes need to use a specified location as the base
* for tmp directories
* (b) daemons on remote nodes need to use a specified location, but
* one different from that used by mpirun
* (c) mpirun needs to use a specified location, but one different
* from that used on remote nodes
*/
orte_tmpdir_base = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "tmpdir_base",
"Base of the session directory tree to be used by all processes",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_tmpdir_base);
orte_local_tmpdir_base = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "local_tmpdir_base",
"Base of the session directory tree to be used by orterun/mpirun",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_local_tmpdir_base);
orte_remote_tmpdir_base = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "remote_tmpdir_base",
"Base of the session directory tree on remote nodes, if required to be different from head node",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_remote_tmpdir_base);
/* if a global tmpdir was specified, then we do not allow specification
* of the local or remote values to avoid confusion
*/
if (NULL != orte_tmpdir_base &&
(NULL != orte_local_tmpdir_base || NULL != orte_remote_tmpdir_base)) {
opal_output(orte_clean_output,
"------------------------------------------------------------------\n"
"The MCA param orte_tmpdir_base was specified, which sets the base\n"
"of the temporary directory tree for all procs. However, values for\n"
"the local and/or remote tmpdir base were also given. This can lead\n"
"to confusion and is therefore not allowed. Please specify either a\n"
"global tmpdir base OR a local/remote tmpdir base value\n"
"------------------------------------------------------------------");
exit(1);
}
if (NULL != orte_tmpdir_base) {
if (NULL != orte_process_info.tmpdir_base) {
free(orte_process_info.tmpdir_base);
}
orte_process_info.tmpdir_base = strdup (orte_tmpdir_base);
} else if (ORTE_PROC_IS_HNP && NULL != orte_local_tmpdir_base) {
/* orterun will pickup the value for its own use */
if (NULL != orte_process_info.tmpdir_base) {
free(orte_process_info.tmpdir_base);
}
orte_process_info.tmpdir_base = strdup (orte_local_tmpdir_base);
} else if (ORTE_PROC_IS_DAEMON && NULL != orte_remote_tmpdir_base) {
/* orterun will pickup the value and forward it along, but must not
* use it in its own work. So only a daemon needs to get it, and the
* daemon will pass it down to its application procs. Note that orterun
* will pass -its- value to any procs local to it
*/
if (NULL != orte_process_info.tmpdir_base) {
free(orte_process_info.tmpdir_base);
}
orte_process_info.tmpdir_base = strdup (orte_remote_tmpdir_base);
}
orte_top_session_dir = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "top_session_dir",
"Top of the session directory tree for applications",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_top_session_dir);
if (NULL != orte_top_session_dir) {
if (NULL != orte_process_info.top_session_dir) {
free(orte_process_info.top_session_dir);
}
orte_process_info.top_session_dir = strdup(orte_top_session_dir);
}
orte_jobfam_session_dir = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "jobfam_session_dir",
"The jobfamily session directory for applications",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL_EQ,
&orte_jobfam_session_dir);
if (NULL != orte_jobfam_session_dir) {
if (NULL != orte_process_info.jobfam_session_dir) {
free(orte_process_info.jobfam_session_dir);
}
orte_process_info.jobfam_session_dir = strdup(orte_jobfam_session_dir);
}
orte_prohibited_session_dirs = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "no_session_dirs",
"Prohibited locations for session directories (multiple locations separated by ',', default=NULL)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_prohibited_session_dirs);
orte_create_session_dirs = true;
(void) mca_base_var_register ("orte", "orte", NULL, "create_session_dirs",
"Create session directories",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_create_session_dirs);
orte_execute_quiet = false;
(void) mca_base_var_register ("orte", "orte", NULL, "execute_quiet",
"Do not output error and help messages",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_execute_quiet);
orte_report_silent_errors = false;
(void) mca_base_var_register ("orte", "orte", NULL, "report_silent_errors",
"Report all errors, including silent ones",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_report_silent_errors);
orte_debug_flag = false;
(void) mca_base_var_register ("orte", "orte", NULL, "debug",
"Top-level ORTE debug switch (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_debug_flag);
orte_debug_verbosity = -1;
(void) mca_base_var_register ("orte", "orte", NULL, "debug_verbose",
"Verbosity level for ORTE debug messages (default: 1)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_debug_verbosity);
orte_debug_daemons_file_flag = false;
(void) mca_base_var_register ("orte", "orte", NULL, "debug_daemons_file",
"Whether want stdout/stderr of daemons to go to a file or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_debug_daemons_file_flag);
/* If --debug-daemons-file was specified, that also implies
--debug-daemons */
if (orte_debug_daemons_file_flag) {
orte_debug_daemons_flag = true;
/* value can't change */
(void) mca_base_var_register ("orte", "orte", NULL, "debug_daemons",
"Whether to debug the ORTE daemons or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_CONSTANT,
&orte_debug_daemons_flag);
} else {
orte_debug_daemons_flag = false;
(void) mca_base_var_register ("orte", "orte", NULL, "debug_daemons",
"Whether to debug the ORTE daemons or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_debug_daemons_flag);
}
orte_progress_thread_debug_level = -1;
(void) mca_base_var_register ("orte", "orte", NULL, "progress_thread_debug",
"Debug level for ORTE progress threads",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_progress_thread_debug_level);
if (0 <= orte_progress_thread_debug_level) {
orte_progress_thread_debug = opal_output_open(NULL);
opal_output_set_verbosity(orte_progress_thread_debug,
orte_progress_thread_debug_level);
}
/* do we want session output left open? */
orte_leave_session_attached = false;
(void) mca_base_var_register ("orte", "orte", NULL, "leave_session_attached",
"Whether applications and/or daemons should leave their sessions "
"attached so that any output can be received - this allows X forwarding "
"without all the attendant debugging output",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_leave_session_attached);
/* if any debug level is set, ensure we output debug level dumps */
if (orte_debug_flag || orte_debug_daemons_flag || orte_leave_session_attached) {
orte_devel_level_output = true;
}
/* See comment in orte/tools/orterun/orterun.c about this MCA
param (this param is internal) */
orte_in_parallel_debugger = false;
(void) mca_base_var_register ("orte", "orte", NULL, "in_parallel_debugger",
"Whether the application is being debugged "
"in a parallel debugger (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_in_parallel_debugger);
orte_debugger_dump_proctable = false;
(void) mca_base_var_register ("orte", "orte", NULL, "output_debugger_proctable",
"Whether or not to output the debugger proctable after launch (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orte_debugger_dump_proctable);
orte_debugger_test_daemon = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "debugger_test_daemon",
"Name of the executable to be used to simulate a debugger colaunch (relative or absolute path)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_debugger_test_daemon);
orte_debugger_test_attach = false;
(void) mca_base_var_register ("orte", "orte", NULL, "debugger_test_attach",
"Test debugger colaunch after debugger attachment",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_debugger_test_daemon);
orte_debugger_check_rate = 0;
(void) mca_base_var_register ("orte", "orte", NULL, "debugger_check_rate",
"Set rate (in secs) for auto-detect of debugger attachment (0 => do not check)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_debugger_check_rate);
orte_do_not_launch = false;
(void) mca_base_var_register ("orte", "orte", NULL, "do_not_launch",
"Perform all necessary operations to prepare to launch the application, but do not actually launch it",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_do_not_launch);
orted_spin_flag = false;
(void) mca_base_var_register ("orte", "orte", NULL, "daemon_spin",
"Have any orteds spin until we can connect a debugger to them",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orted_spin_flag);
orted_debug_failure = ORTE_VPID_INVALID;
(void) mca_base_var_register ("orte", "orte", NULL, "daemon_fail",
"Have the specified orted fail after init for debugging purposes",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orted_debug_failure);
orted_debug_failure_delay = 0;
(void) mca_base_var_register ("orte", "orte", NULL, "daemon_fail_delay",
"Have the specified orted fail after specified number of seconds (default: 0 => no delay)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orted_debug_failure_delay);
orte_startup_timeout = 0;
(void) mca_base_var_register ("orte", "orte", NULL, "startup_timeout",
"Seconds to wait for startup or job launch before declaring failed_to_start (default: 0 => do not check)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_startup_timeout);
/* User-level debugger info string */
orte_base_user_debugger = "totalview @mpirun@ -a @mpirun_args@ : ddt -n @np@ -start @executable@ @executable_argv@ @single_app@ : fxp @mpirun@ -a @mpirun_args@";
(void) mca_base_var_register ("orte", "orte", NULL, "base_user_debugger",
"Sequence of user-level debuggers to search for in orterun",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_base_user_debugger);
#if 0
mca_base_param_reg_int_name("orte", "abort_timeout",
"Max time to wait [in secs] before aborting an ORTE operation (default: 1sec)",
false, false, 1, &value);
orte_max_timeout = 1000000.0 * value; /* convert to usec */
mca_base_param_reg_int_name("orte", "timeout_step",
"Time to wait [in usecs/proc] before aborting an ORTE operation (default: 1000 usec/proc)",
false, false, 1000, &orte_timeout_usec_per_proc);
#endif
/* default hostfile */
orte_default_hostfile = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "default_hostfile",
"Name of the default hostfile (relative or absolute path, \"none\" to ignore environmental or default MCA param setting)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_default_hostfile);
if (NULL == orte_default_hostfile) {
/* nothing was given, so define the default */
asprintf(&orte_default_hostfile, "%s/openmpi-default-hostfile", opal_install_dirs.sysconfdir);
/* flag that nothing was given */
orte_default_hostfile_given = false;
} else if (0 == strcmp(orte_default_hostfile, "none")) {
free (orte_default_hostfile);
orte_default_hostfile = NULL;
/* flag that it was given */
orte_default_hostfile_given = true;
} else {
/* flag that it was given */
orte_default_hostfile_given = true;
}
/* default dash-host */
orte_default_dash_host = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "default_dash_host",
"Default -host setting (specify \"none\" to ignore environmental or default MCA param setting)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_default_dash_host);
if (NULL != orte_default_dash_host &&
0 == strcmp(orte_default_dash_host, "none")) {
free(orte_default_dash_host);
orte_default_dash_host = NULL;
}
/* regex of nodes in system */
orte_node_regex = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "node_regex",
"Regular expression defining nodes in the system",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_node_regex);
/* whether or not to keep FQDN hostnames */
orte_keep_fqdn_hostnames = false;
(void) mca_base_var_register ("orte", "orte", NULL, "keep_fqdn_hostnames",
"Whether or not to keep FQDN hostnames [default: no]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_keep_fqdn_hostnames);
/* whether or not to retain aliases of hostnames */
orte_retain_aliases = false;
(void) mca_base_var_register ("orte", "orte", NULL, "retain_aliases",
"Whether or not to keep aliases for host names [default: no]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_retain_aliases);
/* which alias to use in MPIR_proctab */
orte_use_hostname_alias = 1;
(void) mca_base_var_register ("orte", "orte", NULL, "hostname_alias_index",
"If hostname aliases are being retained, which one to use for the debugger proc table [default: 1st alias]",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_use_hostname_alias);
orte_xml_output = false;
(void) mca_base_var_register ("orte", "orte", NULL, "xml_output",
"Display all output in XML format (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_xml_output);
/* whether to tag output */
/* if we requested xml output, be sure to tag the output as well */
orte_tag_output = orte_xml_output;
(void) mca_base_var_register ("orte", "orte", NULL, "tag_output",
"Tag all output with [job,rank] (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_tag_output);
if (orte_xml_output) {
orte_tag_output = true;
}
orte_xml_file = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "xml_file",
"Provide all output in XML format to the specified file",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_xml_file);
if (NULL != orte_xml_file) {
if (ORTE_PROC_IS_HNP && NULL == orte_xml_fp) {
/* only the HNP opens this file! Make sure it only happens once */
orte_xml_fp = fopen(orte_xml_file, "w");
if (NULL == orte_xml_fp) {
opal_output(0, "Could not open specified xml output file: %s", orte_xml_file);
return ORTE_ERROR;
}
}
/* ensure we set the flags to tag output */
orte_xml_output = true;
orte_tag_output = true;
} else {
/* default to stdout */
orte_xml_fp = stdout;
}
/* whether to timestamp output */
orte_timestamp_output = false;
(void) mca_base_var_register ("orte", "orte", NULL, "timestamp_output",
"Timestamp all application process output (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_timestamp_output);
/* redirect output into files */
orte_output_filename = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "output_filename",
"Redirect output from application processes into filename.rank [default: NULL]",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_output_filename);
orte_show_resolved_nodenames = false;
(void) mca_base_var_register ("orte", "orte", NULL, "show_resolved_nodenames",
"Display any node names that are resolved to a different name (default: false)",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_show_resolved_nodenames);
#if 0
/* XXX -- option doesn't appear to do anything */
mca_base_param_reg_int_name("orte", "hetero_apps",
"Indicates that multiple app_contexts are being provided that are a mix of 32/64 bit binaries (default: false)",
false, false, (int) false, &value);
orte_hetero_apps = OPAL_INT_TO_BOOL(value);
#endif
orte_hetero_nodes = false;
(void) mca_base_var_register ("orte", "orte", NULL, "hetero_nodes",
"Nodes in cluster may differ in topology, so send the topology back from each node [Default = false]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_hetero_nodes);
/* allow specification of the launch agent */
orte_launch_agent = "orted";
(void) mca_base_var_register ("orte", "orte", NULL, "launch_agent",
"Command used to start processes on remote nodes (default: orted)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_launch_agent);
orte_fork_agent_string = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "fork_agent",
"Command used to fork processes on remote nodes (default: NULL)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_fork_agent_string);
if (NULL != orte_fork_agent_string) {
orte_fork_agent = opal_argv_split(orte_fork_agent_string, ' ');
}
/* whether or not to require RM allocation */
orte_allocation_required = false;
(void) mca_base_var_register ("orte", "orte", NULL, "allocation_required",
"Whether or not an allocation by a resource manager is required [default: no]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_allocation_required);
/* whether or not to map stddiag to stderr */
orte_map_stddiag_to_stderr = false;
(void) mca_base_var_register ("orte", "orte", NULL, "map_stddiag_to_stderr",
"Map output from opal_output to stderr of the local process [default: no]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_map_stddiag_to_stderr);
/* generate new terminal windows to display output from specified ranks */
orte_xterm = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "xterm",
"Create a new xterm window and display output from the specified ranks there [default: none]",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_xterm);
if (NULL != orte_xterm) {
/* if an xterm request is given, we have to leave any ssh
* sessions attached so the xterm window manager can get
* back to the controlling terminal
*/
orte_leave_session_attached = true;
/* also want to redirect stddiag output from opal_output
* to stderr from the process so those messages show
* up in the xterm window instead of being forwarded to mpirun
*/
orte_map_stddiag_to_stderr = true;
}
/* whether or not to report launch progress */
orte_report_launch_progress = false;
(void) mca_base_var_register ("orte", "orte", NULL, "report_launch_progress",
"Output a brief periodic report on launch progress [default: no]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_report_launch_progress);
/* cluster hardware info detected by orte only */
orte_local_cpu_type = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "cpu_type",
"cpu type detected in node",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_local_cpu_type);
orte_local_cpu_model = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "cpu_model",
"cpu model detected in node",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_local_cpu_model);
/* tool communication controls */
orte_report_events_uri = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "report_events",
"URI to which events are to be reported (default: NULL)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_report_events_uri);
if (NULL != orte_report_events_uri) {
orte_report_events = true;
}
/* barrier control */
orte_do_not_barrier = false;
(void) mca_base_var_register ("orte", "orte", NULL, "do_not_barrier",
"Do not barrier in orte_init",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_INTERNAL,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_do_not_barrier);
orte_enable_recovery = false;
(void) mca_base_var_register ("orte", "orte", NULL, "enable_recovery",
"Enable recovery from process failure [Default = disabled]",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_enable_recovery);
orte_max_restarts = 0;
(void) mca_base_var_register ("orte", "orte", NULL, "max_restarts",
"Max number of times to restart a failed process",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_max_restarts);
if (!orte_enable_recovery && orte_max_restarts != 0) {
if (ORTE_PROC_IS_HNP) {
opal_output(orte_clean_output,
"------------------------------------------------------------------\n"
"The MCA param orte_enable_recovery was not set to true, but\n"
"a value was provided for the number of restarts:\n\n"
"Max restarts: %d\n"
"We are enabling process recovery and continuing execution. To avoid\n"
"this warning in the future, please set the orte_enable_recovery\n"
"param to non-zero.\n"
"------------------------------------------------------------------",
orte_max_restarts);
}
orte_enable_recovery = true;
}
orte_abort_non_zero_exit = true;
(void) mca_base_var_register ("orte", "orte", NULL, "abort_on_non_zero_status",
"Abort the job if any process returns a non-zero exit status - no restart in such cases",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_abort_non_zero_exit);
orte_allowed_exit_without_sync = false;
(void) mca_base_var_register ("orte", "orte", NULL, "allowed_exit_without_sync",
"Process exiting without calling finalize will not trigger job termination",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_allowed_exit_without_sync);
orte_staged_execution = false;
(void) mca_base_var_register ("orte", "orte", NULL, "staged_execution",
"Staged execution is being used",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_staged_execution);
orte_report_child_jobs_separately = false;
(void) mca_base_var_register ("orte", "orte", NULL, "report_child_jobs_separately",
"Return the exit status of the primary job only",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_report_child_jobs_separately);
#if 0
/* XXX -- unused parameter */
mca_base_param_reg_int_name("orte", "child_time_to_exit",
"Max time a spawned child job is allowed to run after the primary job has terminated (seconds)",
false, false,
INT_MAX, &value);
orte_child_time_to_exit.tv_sec = value;
orte_child_time_to_exit.tv_usec = 0;
#endif
orte_stat_history_size = 1;
(void) mca_base_var_register ("orte", "orte", NULL, "stat_history_size",
"Number of stat samples to keep",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_stat_history_size);
orte_max_vm_size = -1;
(void) mca_base_var_register ("orte", "orte", NULL, "max_vm_size",
"Maximum size of virtual machine - used to subdivide allocation",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_max_vm_size);
if (opal_hwloc_use_hwthreads_as_cpus) {
orte_set_slots = "hwthreads";
} else {
orte_set_slots = "cores";
}
(void) mca_base_var_register ("orte", "orte", NULL, "set_default_slots",
"Set the number of slots on nodes that lack such info to the"
" number of specified objects [a number, \"cores\" (default),"
" \"numas\", \"sockets\", \"hwthreads\" (default if hwthreads_as_cpus is set),"
" or \"none\" to skip this option]",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_set_slots);
/* should we display the allocation after determining it? */
orte_display_allocation = false;
id = mca_base_var_register ("orte", "orte", NULL, "display_alloc",
"Whether to display the allocation after it is determined",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_display_allocation);
/* register a synonym for old name -- should we remove this now? */
mca_base_var_register_synonym (id, "orte", "ras", "base", "display_alloc", MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
/* should we display a detailed (developer-quality) version of the allocation after determining it? */
orte_devel_level_output = false;
id = mca_base_var_register ("orte", "orte", NULL, "display_devel_alloc",
"Whether to display a developer-detail allocation after it is determined",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_devel_level_output);
/* register a synonym for old name -- should we remove this now? */
mca_base_var_register_synonym (id, "orte", "ras", "base", "display_devel_alloc", MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
if (orte_devel_level_output) {
orte_display_allocation = true;
}
/* should we treat any -host directives as "soft" - i.e., desired
* but not required
*/
orte_soft_locations = false;
(void) mca_base_var_register ("orte", "orte", NULL, "soft_locations",
"Treat -host directives as desired, but not required",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_soft_locations);
/* allow specification of the cores to be used by daemons */
orte_daemon_cores = NULL;
(void) mca_base_var_register ("orte", "orte", NULL, "daemon_cores",
"Restrict the ORTE daemons (including mpirun) to operate on the specified cores (comma-separated list of ranges)",
MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
OPAL_INFO_LVL_5, MCA_BASE_VAR_SCOPE_READONLY,
&orte_daemon_cores);
/* cutoff for full modex */
orte_direct_modex_cutoff = UINT32_MAX;
id = mca_base_var_register ("orte", "orte", NULL, "direct_modex_cutoff",
"If the number of processes in the application exceeds the provided value,"
"modex will be done upon demand [default: UINT32_MAX]",
MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&orte_direct_modex_cutoff);
/* register a synonym for old name */
mca_base_var_register_synonym (id, "ompi", "ompi", "hostname", "cutoff", MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
return ORTE_SUCCESS;
}
