}
/* callback of the plugin variable */
-static void _sg_cfg_cb__plugin(const char *name)
+static void _sg_cfg_cb__plugin(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot load a plugin after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val.empty())
+ if (value.empty())
return;
- if (val == "help") {
+ if (value == "help") {
model_help("plugin", surf_plugin_description);
sg_cfg_exit_early();
}
- int plugin_id = find_model_description(surf_plugin_description, val);
+ int plugin_id = find_model_description(surf_plugin_description, value);
surf_plugin_description[plugin_id].model_init_preparse();
}
/* callback of the host/model variable */
-static void _sg_cfg_cb__host_model(const char *name)
+static void _sg_cfg_cb__host_model(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val == "help") {
+ if (value == "help") {
model_help("host", surf_host_model_description);
sg_cfg_exit_early();
}
/* Make sure that the model exists */
- find_model_description(surf_host_model_description, val);
+ find_model_description(surf_host_model_description, value);
}
/* callback of the cpu/model variable */
-static void _sg_cfg_cb__cpu_model(const char *name)
+static void _sg_cfg_cb__cpu_model(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val == "help") {
+ if (value == "help") {
model_help("CPU", surf_cpu_model_description);
sg_cfg_exit_early();
}
/* New Module missing */
- find_model_description(surf_cpu_model_description, val);
+ find_model_description(surf_cpu_model_description, value);
}
/* callback of the cpu/model variable */
-static void _sg_cfg_cb__optimization_mode(const char *name)
+static void _sg_cfg_cb__optimization_mode(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val == "help") {
+ if (value == "help") {
model_help("optimization", surf_optimization_mode_description);
sg_cfg_exit_early();
}
/* New Module missing */
- find_model_description(surf_optimization_mode_description, val);
+ find_model_description(surf_optimization_mode_description, value);
}
/* callback of the cpu/model variable */
-static void _sg_cfg_cb__storage_mode(const char *name)
+static void _sg_cfg_cb__storage_mode(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val == "help") {
+ if (value == "help") {
model_help("storage", surf_storage_model_description);
sg_cfg_exit_early();
}
- find_model_description(surf_storage_model_description, val);
+ find_model_description(surf_storage_model_description, value);
}
/* callback of the network_model variable */
-static void _sg_cfg_cb__network_model(const char *name)
+static void _sg_cfg_cb__network_model(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- std::string val = xbt_cfg_get_string(name);
- if (val == "help") {
+ if (value == "help") {
model_help("network", surf_network_model_description);
sg_cfg_exit_early();
}
/* New Module missing */
- find_model_description(surf_network_model_description, val);
-}
-/* callback to decide if we want to use the model-checking */
-#include "src/xbt_modinter.h"
-
-static void _sg_cfg_cb_model_check_replay(const char *name) {
- MC_record_path = xbt_cfg_get_string(name);
+ find_model_description(surf_network_model_description, value);
}
#if SIMGRID_HAVE_MC
}
#endif
-extern int _sg_do_verbose_exit;
-static void _sg_cfg_cb_verbose_exit(const char *name)
-{
- _sg_do_verbose_exit = xbt_cfg_get_boolean(name);
-}
-
-extern int _sg_do_clean_atexit;
-static void _sg_cfg_cb_clean_atexit(const char *name)
-{
- _sg_do_clean_atexit = xbt_cfg_get_boolean(name);
-}
-
-static void _sg_cfg_cb_context_stack_size(const char *name)
-{
- smx_context_stack_size_was_set = 1;
- smx_context_stack_size = xbt_cfg_get_int(name) * 1024;
-}
-
-static void _sg_cfg_cb_context_guard_size(const char *name)
+static void _sg_cfg_cb_contexts_parallel_mode(const std::string& mode_name)
{
- smx_context_guard_size_was_set = 1;
- smx_context_guard_size = xbt_cfg_get_int(name) * xbt_pagesize;
-}
-
-static void _sg_cfg_cb_contexts_nthreads(const char *name)
-{
- SIMIX_context_set_nthreads(xbt_cfg_get_int(name));
-}
-
-static void _sg_cfg_cb_contexts_parallel_threshold(const char *name)
-{
- SIMIX_context_set_parallel_threshold(xbt_cfg_get_int(name));
-}
-
-static void _sg_cfg_cb_contexts_parallel_mode(const char *name)
-{
- std::string mode_name = xbt_cfg_get_string(name);
if (mode_name == "posix") {
SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX);
} else if (mode_name == "futex") {
/* Plugins configuration */
describe_model(description, descsize, surf_plugin_description, "plugin", "The plugins");
- xbt_cfg_register_string("plugin", "", &_sg_cfg_cb__plugin, description);
+ simgrid::config::declareFlag<std::string>("plugin", description, "", &_sg_cfg_cb__plugin);
describe_model(description, descsize, surf_cpu_model_description, "model", "The model to use for the CPU");
- xbt_cfg_register_string("cpu/model", "Cas01", &_sg_cfg_cb__cpu_model, description);
+ simgrid::config::declareFlag<std::string>("cpu/model", description, "Cas01", &_sg_cfg_cb__cpu_model);
describe_model(description, descsize, surf_storage_model_description, "model", "The model to use for the storage");
- xbt_cfg_register_string("storage/model", "default", &_sg_cfg_cb__storage_mode, description);
+ simgrid::config::declareFlag<std::string>("storage/model", description, "default", &_sg_cfg_cb__storage_mode);
describe_model(description, descsize, surf_network_model_description, "model", "The model to use for the network");
- xbt_cfg_register_string("network/model", "LV08", &_sg_cfg_cb__network_model, description);
+ simgrid::config::declareFlag<std::string>("network/model", description, "LV08", &_sg_cfg_cb__network_model);
describe_model(description, descsize, surf_optimization_mode_description, "optimization mode",
"The optimization modes to use for the network");
- xbt_cfg_register_string("network/optim", "Lazy", &_sg_cfg_cb__optimization_mode, description);
+ simgrid::config::declareFlag<std::string>("network/optim", description, "Lazy", &_sg_cfg_cb__optimization_mode);
describe_model(description, descsize, surf_host_model_description, "model", "The model to use for the host");
- xbt_cfg_register_string("host/model", "default", &_sg_cfg_cb__host_model, description);
+ simgrid::config::declareFlag<std::string>("host/model", description, "default", &_sg_cfg_cb__host_model);
simgrid::config::bindFlag(sg_surf_precision, "surf/precision",
"Numerical precision used when updating simulation times (in seconds)");
/* Inclusion path */
simgrid::config::declareFlag<std::string>("path", "Lookup path for inclusions in platform and deployment XML files",
"", [](std::string const& path) {
- if (path[0] != '\0') {
+ if (not path.empty())
surf_path.push_back(path);
- }
});
- xbt_cfg_register_boolean("cpu/maxmin-selective-update", "no", nullptr, "Update the constraint set propagating "
- "recursively to others constraints (off by "
- "default unless optim is set to lazy)");
+ simgrid::config::declareFlag<bool>("cpu/maxmin-selective-update", "Update the constraint set propagating recursively "
+ "to others constraints (off by default unless "
+ "optim is set to lazy)",
+ "no");
simgrid::config::alias("cpu/maxmin-selective-update", {"cpu/maxmin_selective_update"});
- xbt_cfg_register_boolean("network/maxmin-selective-update", "no", nullptr, "Update the constraint set propagating "
- "recursively to others constraints (off "
- "by default unless optim is set to lazy)");
+ simgrid::config::declareFlag<bool>("network/maxmin-selective-update", "Update the constraint set propagating "
+ "recursively to others constraints (off by "
+ "default unless optim is set to lazy)",
+ "no");
simgrid::config::alias("network/maxmin-selective-update", {"network/maxmin_selective_update"});
/* Replay (this part is enabled even if MC it disabled) */
- xbt_cfg_register_string("model-check/replay", nullptr, _sg_cfg_cb_model_check_replay,
- "Model-check path to replay (as reported by SimGrid when a violation is reported)");
+ simgrid::config::bindFlag(MC_record_path, "model-check/replay",
+ "Model-check path to replay (as reported by SimGrid when a violation is reported)");
#if SIMGRID_HAVE_MC
/* do model-checking-record */
"Whether to enable non progressive cycle detection");
#endif
- xbt_cfg_register_boolean("verbose-exit", "yes", _sg_cfg_cb_verbose_exit,
- "Activate the \"do nothing\" mode in Ctrl-C");
+ extern bool _sg_do_verbose_exit;
+ simgrid::config::bindFlag(_sg_do_verbose_exit, "verbose-exit", "Activate the \"do nothing\" mode in Ctrl-C");
- xbt_cfg_register_int("contexts/stack-size", 8 * 1024, _sg_cfg_cb_context_stack_size, "Stack size of contexts in KiB");
+ simgrid::config::declareFlag<int>("contexts/stack-size", "Stack size of contexts in KiB", 8 * 1024, [](int value) {
+ smx_context_stack_size_was_set = 1;
+ smx_context_stack_size = value * 1024;
+ });
/* (FIXME: this is unpleasant) Reset this static variable that was altered when setting the default value. */
smx_context_stack_size_was_set = 0;
simgrid::config::alias("contexts/stack-size", {"contexts/stack_size"});
/* guard size for contexts stacks in memory pages */
- xbt_cfg_register_int("contexts/guard-size",
#if defined(_WIN32) || (PTH_STACKGROWTH != -1)
- 0,
+ int default_guard_size = 0;
#else
- 1,
+ int default_guard_size = 1;
#endif
- _sg_cfg_cb_context_guard_size, "Guard size for contexts stacks in memory pages");
+ simgrid::config::declareFlag<int>("contexts/guard-size", "Guard size for contexts stacks in memory pages",
+ default_guard_size, [](int value) {
+ smx_context_guard_size_was_set = 1;
+ smx_context_guard_size = value * xbt_pagesize;
+ });
/* No, it was not set yet (the above setdefault() changed this to 1). */
smx_context_guard_size_was_set = 0;
simgrid::config::alias("contexts/guard-size", {"contexts/guard_size"});
- xbt_cfg_register_int("contexts/nthreads", 1, _sg_cfg_cb_contexts_nthreads,
- "Number of parallel threads used to execute user contexts");
+ simgrid::config::declareFlag<int>("contexts/nthreads", "Number of parallel threads used to execute user contexts", 1,
+ &SIMIX_context_set_nthreads);
- xbt_cfg_register_int("contexts/parallel-threshold", 2, _sg_cfg_cb_contexts_parallel_threshold,
- "Minimal number of user contexts to be run in parallel (raw contexts only)");
+ simgrid::config::declareFlag<int>("contexts/parallel-threshold",
+ "Minimal number of user contexts to be run in parallel (raw contexts only)", 2,
+ &SIMIX_context_set_parallel_threshold);
simgrid::config::alias("contexts/parallel-threshold", {"contexts/parallel_threshold"});
/* synchronization mode for parallel user contexts */
#if HAVE_FUTEX_H
- xbt_cfg_register_string(
- "contexts/synchro", "futex", _sg_cfg_cb_contexts_parallel_mode,
- "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)");
+ std::string default_synchro_mode = "futex";
#else //No futex on mac and posix is unimplememted yet
- xbt_cfg_register_string(
- "contexts/synchro", "busy_wait", _sg_cfg_cb_contexts_parallel_mode,
- "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)");
+ std::string default_synchro_mode = "busy_wait";
#endif
+ simgrid::config::declareFlag<std::string>("contexts/synchro", "Synchronization mode to use when running contexts in "
+ "parallel (either futex, posix or busy_wait)",
+ default_synchro_mode, &_sg_cfg_cb_contexts_parallel_mode);
// For smpi/bw-factor and smpi/lat-factor
// SMPI model can be used without enable_smpi, so keep this out of the ifdef.
- xbt_cfg_register_string("smpi/bw-factor", "65472:0.940694;15424:0.697866;9376:0.58729;5776:1.08739;3484:0.77493;1426:"
- "0.608902;732:0.341987;257:0.338112;0:0.812084",
- nullptr, "Bandwidth factors for smpi. Format: "
- "'threshold0:value0;threshold1:value1;...;thresholdN:valueN', meaning if(size "
- ">=thresholdN ) return valueN.");
+ simgrid::config::declareFlag<std::string>("smpi/bw-factor",
+ "Bandwidth factors for smpi. Format: "
+ "'threshold0:value0;threshold1:value1;...;thresholdN:valueN', "
+ "meaning if(size >=thresholdN ) return valueN.",
+ "65472:0.940694;15424:0.697866;9376:0.58729;5776:1.08739;3484:0.77493;"
+ "1426:0.608902;732:0.341987;257:0.338112;0:0.812084");
simgrid::config::alias("smpi/bw-factor", {"smpi/bw_factor"});
- xbt_cfg_register_string("smpi/lat-factor", "65472:11.6436;15424:3.48845;9376:2.59299;5776:2.18796;3484:1.88101;1426:"
- "1.61075;732:1.9503;257:1.95341;0:2.01467",
- nullptr, "Latency factors for smpi.");
+ simgrid::config::declareFlag<std::string>("smpi/lat-factor", "Latency factors for smpi.",
+ "65472:11.6436;15424:3.48845;9376:2.59299;5776:2.18796;3484:1.88101;"
+ "1426:1.61075;732:1.9503;257:1.95341;0:2.01467");
simgrid::config::alias("smpi/lat-factor", {"smpi/lat_factor"});
- xbt_cfg_register_string("smpi/IB-penalty-factors", "0.965;0.925;1.35", nullptr,
- "Correction factor to communications using Infiniband model with contention (default value "
- "based on Stampede cluster profiling)");
+ simgrid::config::declareFlag<std::string>("smpi/IB-penalty-factors",
+ "Correction factor to communications using Infiniband model with "
+ "contention (default value based on Stampede cluster profiling)",
+ "0.965;0.925;1.35");
simgrid::config::alias("smpi/IB-penalty-factors", {"smpi/IB_penalty_factors"});
#if HAVE_SMPI
- xbt_cfg_register_double("smpi/host-speed", 20000.0, nullptr,
- "Speed of the host running the simulation (in flop/s). Used to bench the operations.");
+ simgrid::config::declareFlag<double>("smpi/host-speed", "Speed of the host running the simulation (in flop/s). "
+ "Used to bench the operations.",
+ 20000.0);
simgrid::config::alias("smpi/host-speed", {"smpi/running_power", "smpi/running-power"});
- xbt_cfg_register_boolean("smpi/keep-temps", "no", nullptr, "Whether we should keep the generated temporary files.");
+ simgrid::config::declareFlag<bool>("smpi/keep-temps", "Whether we should keep the generated temporary files.", false);
- xbt_cfg_register_boolean("smpi/display-timing", "no", nullptr,
- "Whether we should display the timing after simulation.");
+ simgrid::config::declareFlag<bool>("smpi/display-timing", "Whether we should display the timing after simulation.",
+ false);
simgrid::config::alias("smpi/display-timing", {"smpi/display_timing"});
- xbt_cfg_register_boolean("smpi/simulate-computation", "yes", nullptr,
- "Whether the computational part of the simulated application should be simulated.");
+ simgrid::config::declareFlag<bool>("smpi/simulate-computation",
+ "Whether the computational part of the simulated application should be simulated.",
+ true);
simgrid::config::alias("smpi/simulate-computation", {"smpi/simulate_computation"});
- xbt_cfg_register_string("smpi/shared-malloc", "global", nullptr,
- "Whether SMPI_SHARED_MALLOC is enabled. Disable it for debugging purposes.");
+ simgrid::config::declareFlag<std::string>(
+ "smpi/shared-malloc", "Whether SMPI_SHARED_MALLOC is enabled. Disable it for debugging purposes.", "global");
simgrid::config::alias("smpi/shared-malloc", {"smpi/use_shared_malloc", "smpi/use-shared-malloc"});
- xbt_cfg_register_double("smpi/shared-malloc-blocksize", 1UL << 20, nullptr,
- "Size of the bogus file which will be created for global shared allocations");
- xbt_cfg_register_string("smpi/shared-malloc-hugepage", "", nullptr,
- "Path to a mounted hugetlbfs, to use huge pages with shared malloc.");
-
- xbt_cfg_register_double("smpi/cpu-threshold", 1e-6, nullptr,
- "Minimal computation time (in seconds) not discarded, or -1 for infinity.");
+ simgrid::config::declareFlag<double>("smpi/shared-malloc-blocksize",
+ "Size of the bogus file which will be created for global shared allocations",
+ 1UL << 20);
+ simgrid::config::declareFlag<std::string>("smpi/shared-malloc-hugepage",
+ "Path to a mounted hugetlbfs, to use huge pages with shared malloc.", "");
+
+ simgrid::config::declareFlag<double>(
+ "smpi/cpu-threshold", "Minimal computation time (in seconds) not discarded, or -1 for infinity.", 1e-6);
simgrid::config::alias("smpi/cpu-threshold", {"smpi/cpu_threshold"});
- xbt_cfg_register_int("smpi/async-small-thresh", 0, nullptr,
- "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver");
+ simgrid::config::declareFlag<int>(
+ "smpi/async-small-thresh",
+ "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver", 0);
simgrid::config::alias("smpi/async-small-thresh", {"smpi/async_small_thres", "smpi/async_small_thresh"});
- xbt_cfg_register_boolean("smpi/trace-call-location", "no", nullptr,
- "Should filename and linenumber of MPI calls be traced?");
+ simgrid::config::declareFlag<bool>("smpi/trace-call-location",
+ "Should filename and linenumber of MPI calls be traced?", false);
- xbt_cfg_register_int("smpi/send-is-detached-thresh", 65536, nullptr,
- "Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend");
+ simgrid::config::declareFlag<int>(
+ "smpi/send-is-detached-thresh",
+ "Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend", 65536);
simgrid::config::alias("smpi/send-is-detached-thresh",
{"smpi/send_is_detached_thres", "smpi/send_is_detached_thresh"});
if (default_privatization == nullptr)
default_privatization = "no";
- xbt_cfg_register_string("smpi/privatization", default_privatization, nullptr,
- "How we should privatize global variable at runtime (no, yes, mmap, dlopen).");
-
+ simgrid::config::declareFlag<std::string>(
+ "smpi/privatization", "How we should privatize global variable at runtime (no, yes, mmap, dlopen).",
+ default_privatization);
simgrid::config::alias("smpi/privatization", {"smpi/privatize_global_variables", "smpi/privatize-global-variables"});
- xbt_cfg_register_boolean("smpi/grow-injected-times", "yes", nullptr,
- "Whether we want to make the injected time in MPI_Iprobe and MPI_Test grow, to allow faster "
- "simulation. This can make simulation less precise, though.");
+ simgrid::config::declareFlag<bool>("smpi/grow-injected-times",
+ "Whether we want to make the injected time in MPI_Iprobe and MPI_Test grow, to "
+ "allow faster simulation. This can make simulation less precise, though.",
+ true);
#if HAVE_PAPI
- xbt_cfg_register_string("smpi/papi-events", nullptr, nullptr,
- "This switch enables tracking the specified counters with PAPI");
+ simgrid::config::declareFlag<std::string>("smpi/papi-events",
+ "This switch enables tracking the specified counters with PAPI", "");
#endif
- xbt_cfg_register_string("smpi/comp-adjustment-file", nullptr, nullptr,
- "A file containing speedups or slowdowns for some parts of the code.");
- xbt_cfg_register_string("smpi/os", "0:0:0:0:0", nullptr,
- "Small messages timings (MPI_Send minimum time for small messages)");
- xbt_cfg_register_string("smpi/ois", "0:0:0:0:0", nullptr,
- "Small messages timings (MPI_Isend minimum time for small messages)");
- xbt_cfg_register_string("smpi/or", "0:0:0:0:0", nullptr,
- "Small messages timings (MPI_Recv minimum time for small messages)");
-
- xbt_cfg_register_double("smpi/iprobe-cpu-usage", 1, nullptr, "Maximum usage of CPUs by MPI_Iprobe() calls. We've "
- "observed that MPI_Iprobes consume significantly less "
- "power than the maximum of a specific application. This "
- "value is then (Iprobe_Usage/Max_Application_Usage).");
-
- xbt_cfg_register_string("smpi/coll-selector", "default", nullptr, "Which collective selector to use");
+ simgrid::config::declareFlag<std::string>("smpi/comp-adjustment-file",
+ "A file containing speedups or slowdowns for some parts of the code.", "");
+ simgrid::config::declareFlag<std::string>(
+ "smpi/os", "Small messages timings (MPI_Send minimum time for small messages)", "0:0:0:0:0");
+ simgrid::config::declareFlag<std::string>(
+ "smpi/ois", "Small messages timings (MPI_Isend minimum time for small messages)", "0:0:0:0:0");
+ simgrid::config::declareFlag<std::string>(
+ "smpi/or", "Small messages timings (MPI_Recv minimum time for small messages)", "0:0:0:0:0");
+
+ simgrid::config::declareFlag<double>("smpi/iprobe-cpu-usage",
+ "Maximum usage of CPUs by MPI_Iprobe() calls. We've observed that MPI_Iprobes "
+ "consume significantly less power than the maximum of a specific application. "
+ "This value is then (Iprobe_Usage/Max_Application_Usage).",
+ 1.0);
+
+ simgrid::config::declareFlag<std::string>("smpi/coll-selector", "Which collective selector to use", "default");
simgrid::config::alias("smpi/coll-selector", {"smpi/coll_selector"});
- xbt_cfg_register_string("smpi/gather", nullptr, nullptr, "Which collective to use for gather");
- xbt_cfg_register_string("smpi/allgather", nullptr, nullptr, "Which collective to use for allgather");
- xbt_cfg_register_string("smpi/barrier", nullptr, nullptr, "Which collective to use for barrier");
- xbt_cfg_register_string("smpi/reduce_scatter", nullptr, nullptr, "Which collective to use for reduce_scatter");
+ simgrid::config::declareFlag<std::string>("smpi/gather", "Which collective to use for gather", "");
+ simgrid::config::declareFlag<std::string>("smpi/allgather", "Which collective to use for allgather", "");
+ simgrid::config::declareFlag<std::string>("smpi/barrier", "Which collective to use for barrier", "");
+ simgrid::config::declareFlag<std::string>("smpi/reduce_scatter", "Which collective to use for reduce_scatter", "");
simgrid::config::alias("smpi/reduce_scatter", {"smpi/reduce-scatter"});
- xbt_cfg_register_string("smpi/scatter", nullptr, nullptr, "Which collective to use for scatter");
- xbt_cfg_register_string("smpi/allgatherv", nullptr, nullptr, "Which collective to use for allgatherv");
- xbt_cfg_register_string("smpi/allreduce", nullptr, nullptr, "Which collective to use for allreduce");
- xbt_cfg_register_string("smpi/alltoall", nullptr, nullptr, "Which collective to use for alltoall");
- xbt_cfg_register_string("smpi/alltoallv", nullptr, nullptr, "Which collective to use for alltoallv");
- xbt_cfg_register_string("smpi/bcast", nullptr, nullptr, "Which collective to use for bcast");
- xbt_cfg_register_string("smpi/reduce", nullptr, nullptr, "Which collective to use for reduce");
+ simgrid::config::declareFlag<std::string>("smpi/scatter", "Which collective to use for scatter", "");
+ simgrid::config::declareFlag<std::string>("smpi/allgatherv", "Which collective to use for allgatherv", "");
+ simgrid::config::declareFlag<std::string>("smpi/allreduce", "Which collective to use for allreduce", "");
+ simgrid::config::declareFlag<std::string>("smpi/alltoall", "Which collective to use for alltoall", "");
+ simgrid::config::declareFlag<std::string>("smpi/alltoallv", "Which collective to use for alltoallv", "");
+ simgrid::config::declareFlag<std::string>("smpi/bcast", "Which collective to use for bcast", "");
+ simgrid::config::declareFlag<std::string>("smpi/reduce", "Which collective to use for reduce", "");
#endif // HAVE_SMPI
/* Storage */
/* Others */
- xbt_cfg_register_boolean("exception/cutpath", "no", nullptr,
- "Whether to cut all path information from call traces, used e.g. in exceptions.");
+ simgrid::config::declareFlag<bool>(
+ "exception/cutpath", "Whether to cut all path information from call traces, used e.g. in exceptions.", false);
- xbt_cfg_register_boolean("clean-atexit", "yes", _sg_cfg_cb_clean_atexit,
- "Whether to cleanup SimGrid at exit. Disable it if your code segfaults after its end.");
- simgrid::config::alias("clean-atexit", {"clean_atexit"});
+ extern bool _sg_do_clean_atexit;
+ simgrid::config::bindFlag(_sg_do_clean_atexit, "clean-atexit", {"clean_atexit"},
+ "Whether to cleanup SimGrid at exit. Disable it if your code segfaults after its end.");
if (surf_path.empty())
xbt_cfg_setdefault_string("path", "./");
