From: Martin Quinson <martin.quinson@loria.fr>
Date: Wed, 17 Feb 2016 18:00:28 +0000 (+0100)
Subject: Merge branch 'master' of scm.gforge.inria.fr:/gitroot/simgrid/simgrid
X-Git-Tag: v3_13~797^2~1
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/946b604fdce1a3ca5bfd2f512aa69d78b3259a13?hp=25829dc9295bf70044f3bb3c46e6c253ed378fe1

Merge branch 'master' of scm.gforge.inria.fr:/gitroot/simgrid/simgrid
---

diff --git a/ChangeLog b/ChangeLog
index 265cdce589..622a81b8be 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -77,6 +77,7 @@ SimGrid (3.13) UNRELEASED; urgency=low
  * Kill the setset data container: MC don't use it anymore.
  * Kill the queue data container: it made more sense with GRAS.
  * Kill the xbt_peer_t data type: it's useless without GRAS.
+ * Kill rm_cb feature of config sets: it was never useful.
  * New functions:
    - xbt_dynar_sort_strings(), when the content is char*
    - xbt_str_parse_int / xbt_str_parse_double, wrapping strtol/strtod
diff --git a/include/xbt/config.h b/include/xbt/config.h
index 46884ae8e2..effe000e59 100644
--- a/include/xbt/config.h
+++ b/include/xbt/config.h
@@ -181,12 +181,8 @@ XBT_PUBLIC(void) xbt_cfg_dump(const char *name, const char *indent,
  *
  *  @{
  */
-XBT_PUBLIC(void) xbt_cfg_register(xbt_cfg_t * cfg,
-                                  const char *name,
-                                  const char *description,
-                                  e_xbt_cfgelm_type_t type,
-                                  int min, int max,
-                                  xbt_cfg_cb_t cb_set, xbt_cfg_cb_t cb_rm);
+XBT_PUBLIC(void) xbt_cfg_register(xbt_cfg_t * cfg, const char *name, const char *description,
+    e_xbt_cfgelm_type_t type, int min, int max, xbt_cfg_cb_t cb_set);
 XBT_PUBLIC(void) xbt_cfg_register_alias(xbt_cfg_t * cfg, const char *newname, const char *oldname);
 XBT_PUBLIC(void) xbt_cfg_unregister(xbt_cfg_t cfg, const char *name);
 XBT_PUBLIC(void) xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry);
diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp
index 73bfa4de94..059ab243d4 100644
--- a/src/instr/instr_config.cpp
+++ b/src/instr/instr_config.cpp
@@ -367,166 +367,166 @@ void TRACE_global_init(int *argc, char **argv)
   /* name of the tracefile */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FILENAME,
                    "Trace file created by the instrumented SimGrid.",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FILENAME, "simgrid.trace");
 
   /* tracing */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING,
                    "Enable Tracing.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING, "no");
 
   /* register platform in the trace */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_PLATFORM,
                    "Register the platform in the trace as a hierarchy.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_PLATFORM, "no");
 
   /* register platform in the trace */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_TOPOLOGY,
                    "Register the platform topology in the trace as a graph.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_TOPOLOGY, "yes");
 
   /* smpi */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI,
                    "Tracing of the SMPI interface.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI, "no");
 
   /* smpi grouped */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_GROUP,
                    "Group MPI processes by host.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_GROUP, "no");
 
   /* smpi computing */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING,
                    "Generate states for timing out of SMPI parts of the application",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING, "no");
 
 /* smpi sleeping */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_SLEEPING,
                    "Generate states for timing out of SMPI parts of the application",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_SLEEPING, "no");
 
 
   /* smpi internals */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS,
                    "View internal messages sent by Collective communications in SMPI",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS, "no");
 
   /* tracing categorized resource utilization traces */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_CATEGORIZED,
                    "Tracing categorized resource utilization of hosts and links.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_CATEGORIZED, "no");
 
   /* tracing uncategorized resource utilization */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_UNCATEGORIZED,
                    "Tracing uncategorized resource utilization of hosts and links.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED, "no");
 
   /* msg process */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_PROCESS,
                    "Tracing of MSG process behavior.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_PROCESS, "no");
 
   /* msg process */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_VM,
                    "Tracing of MSG process behavior.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_VM, "no");
 
   /* disable tracing link */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_LINK,
                    "Do not trace link bandwidth and latency.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_LINK, "no");
 
   /* disable tracing link */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_POWER,
                    "Do not trace host power.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_POWER, "no");
 
 
   /* tracing buffer */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BUFFER,
                    "Buffer trace events to put them in temporal order.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BUFFER, "yes");
 
   /* tracing one link only */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_ONELINK_ONLY,
                    "Use only routes with one link to trace platform.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY, "no");
 
   /* disable destroy */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY,
                    "Disable platform containers destruction.",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY, "no");
 
   /* basic -- Avoid extended events (impoverished trace file) */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BASIC,
                    "Avoid extended events (impoverished trace file).",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BASIC, "no");
 
   /* display_sizes -- Extended events with message size information */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES,
                    "(smpi only for now) Extended events with message size information",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES, "no");
 
   /* format -- Switch the ouput format of Tracing */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT,
                    "(smpi only for now) Switch the output format of Tracing",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FORMAT, "Paje");
 
 
   /* format -- Switch the ouput format of Tracing */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE,
                    "(smpi only for now) For replay format only : output to one file only",
-                   xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                   xbt_cfgelm_boolean, 1, 1, NULL);
   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE, "no");
 
   /* comment */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT,
                    "Comment to be added on the top of the trace file.",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT, "");
 
   /* comment_file */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT_FILE,
                    "The contents of the file are added to the top of the trace file as comment.",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE, "");
 
   /* trace timestamp precision */
   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_PRECISION,
                    "Numerical precision used when timestamping events (hence this value is expressed in number of digits after decimal point)",
-                   xbt_cfgelm_int, 1, 1, NULL, NULL);
+                   xbt_cfgelm_int, 1, 1, NULL);
   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_PRECISION, 6);
 
   /* Viva graph configuration for uncategorized tracing */
   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_UNCAT_CONF,
                    "Viva Graph configuration file for uncategorized resource utilization traces.",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF, "");
 
   /* Viva graph configuration for uncategorized tracing */
   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_CAT_CONF,
                    "Viva Graph configuration file for categorized resource utilization traces.",
-                   xbt_cfgelm_string, 1, 1, NULL, NULL);
+                   xbt_cfgelm_string, 1, 1, NULL);
   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_CAT_CONF, "");
 
   /* instrumentation can be considered configured now */
diff --git a/src/msg/msg_global.cpp b/src/msg/msg_global.cpp
index bab2b103bc..d2f631ba0b 100644
--- a/src/msg/msg_global.cpp
+++ b/src/msg/msg_global.cpp
@@ -53,7 +53,7 @@ void MSG_init_nocheck(int *argc, char **argv) {
 
     xbt_cfg_register(&_sg_cfg_set, "msg/debug_multiple_use",
                      "Print backtraces of both processes when there is a conflict of multiple use of a task",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_msg_debug_multiple_use, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_msg_debug_multiple_use);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "msg/debug_multiple_use", "no");
 
     SIMIX_global_init(argc, argv);
diff --git a/src/simgrid/sg_config.c b/src/simgrid/sg_config.c
index bd3cad56e1..4a9c9d7917 100644
--- a/src/simgrid/sg_config.c
+++ b/src/simgrid/sg_config.c
@@ -39,8 +39,7 @@ xbt_cfg_t _sg_cfg_set = NULL;
  */
 int _sg_cfg_init_status = 0;
 
-/* instruct the upper layer (simix or simdag) to exit as soon as possible
- */
+/* instruct the upper layer (simix or simdag) to exit as soon as possible */
 int _sg_cfg_exit_asap = 0;
 
 #define sg_cfg_exit_early() do { _sg_cfg_exit_asap = 1; return; } while (0)
@@ -63,25 +62,28 @@ static void sg_config_cmd_line(int *argc, char **argv)
       printf("%s\n", SIMGRID_VERSION_STRING);
       shall_exit = 1;
     } else if (!strcmp(argv[i], "--cfg-help") || !strcmp(argv[i], "--help")) {
-      printf
-          ("Description of the configuration accepted by this simulator:\n");
+      printf("Description of the configuration accepted by this simulator:\n");
       xbt_cfg_help(_sg_cfg_set);
       printf(
-"\n"
-"Each of these configurations can be used by adding\n"
-"    --cfg=<option name>:<option value>\n"
-"to the command line.\n"
-"\n"
-"You can also use --help-models to see the details of all models known by this simulator.\n"
-"\n"
-"You can also use --help-tracing to see the details of all tracing options known by this simulator.\n"
-"\n"
-"You can also use --help-logs and --help-log-categories to see the details of logging output.\n"
-"\n"
-"You can also use --version to get SimGrid version information.\n"
-"\n"
+          "\n"
+          "Each of these configurations can be used by adding\n"
+          "    --cfg=<option name>:<option value>\n"
+          "to the command line.\n"
+          "\n"
+          "For more information, please refer to:\n"
+          "   --help-aliases for the list of all option aliases.\n"
+          "   --help-logs and --help-log-categories for the details of logging output.\n"
+          "   --help-models for a list of all models known by this simulator.\n"
+          "   --help-tracing for the details of all tracing options known by this simulator.\n"
+          "   --version to get SimGrid version information.\n"
+          "\n"
         );
       shall_exit = 1;
+    } else if (!strcmp(argv[i], "--help-aliases")) {
+      printf("Here is a list of all deprecated option names, with their replacement.\n");
+      xbt_cfg_aliases(_sg_cfg_set);
+      printf("Please consider using the recent names\n");
+      shall_exit = 1;
     } else if (!strcmp(argv[i], "--help-models")) {
       int k;
 
@@ -494,214 +496,195 @@ void sg_config_init(int *argc, char **argv)
     describe_model(description, surf_plugin_description,
                    "plugin", "The plugins");
     xbt_cfg_register(&_sg_cfg_set, "plugin", description,
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__plugin, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__plugin);
 
-    describe_model(description, surf_cpu_model_description,
-                   "model", "The model to use for the CPU");
-    xbt_cfg_register(&_sg_cfg_set, "cpu/model", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__cpu_model, NULL);
+    describe_model(description, surf_cpu_model_description, "model", "The model to use for the CPU");
+    xbt_cfg_register(&_sg_cfg_set, "cpu/model", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__cpu_model);
     xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/model", "Cas01");
 
-    describe_model(description, surf_optimization_mode_description,
-                   "optimization mode",
-                   "The optimization modes to use for the CPU");
-    xbt_cfg_register(&_sg_cfg_set, "cpu/optim", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
+    describe_model(description, surf_optimization_mode_description, "optimization mode", "The optimization modes to use for the CPU");
+    xbt_cfg_register(&_sg_cfg_set, "cpu/optim", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode);
     xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/optim", "Lazy");
 
-    describe_model(description, surf_storage_model_description,
-                   "model", "The model to use for the storage");
-    xbt_cfg_register(&_sg_cfg_set, "storage/model", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__storage_mode, NULL);
+    describe_model(description, surf_storage_model_description, "model", "The model to use for the storage");
+    xbt_cfg_register(&_sg_cfg_set, "storage/model", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__storage_mode);
     xbt_cfg_setdefault_string(_sg_cfg_set, "storage/model", "default");
 
-    describe_model(description, surf_network_model_description,
-                   "model", "The model to use for the network");
-    xbt_cfg_register(&_sg_cfg_set, "network/model", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__network_model, NULL);
+    describe_model(description, surf_network_model_description, "model", "The model to use for the network");
+    xbt_cfg_register(&_sg_cfg_set, "network/model", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__network_model);
     xbt_cfg_setdefault_string(_sg_cfg_set, "network/model", "LV08");
 
-    describe_model(description, surf_optimization_mode_description,
-                   "optimization mode",
-                   "The optimization modes to use for the network");
-    xbt_cfg_register(&_sg_cfg_set, "network/optim", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
+    describe_model(description, surf_optimization_mode_description, "optimization mode", "The optimization modes to use for the network");
+    xbt_cfg_register(&_sg_cfg_set, "network/optim", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode);
     xbt_cfg_setdefault_string(_sg_cfg_set, "network/optim", "Lazy");
 
-    describe_model(description, surf_host_model_description,
-                   "model", "The model to use for the host");
-    xbt_cfg_register(&_sg_cfg_set, "host/model", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__host_model, NULL);
+    describe_model(description, surf_host_model_description, "model", "The model to use for the host");
+    xbt_cfg_register(&_sg_cfg_set, "host/model", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__host_model);
     xbt_cfg_setdefault_string(_sg_cfg_set, "host/model", "default");
 
-    describe_model(description, surf_vm_model_description,
-                   "model", "The model to use for the vm");
-    xbt_cfg_register(&_sg_cfg_set, "vm/model", description,
-                     xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__vm_model, NULL);
+    describe_model(description, surf_vm_model_description, "model", "The model to use for the vm");
+    xbt_cfg_register(&_sg_cfg_set, "vm/model", description, xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__vm_model);
     xbt_cfg_setdefault_string(_sg_cfg_set, "vm/model", "default");
 
     xbt_cfg_register(&_sg_cfg_set, "network/TCP_gamma",
                      "Size of the biggest TCP window (cat /proc/sys/net/ipv4/tcp_[rw]mem for recv/send window; Use the last given value, which is the max window size)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__tcp_gamma, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__tcp_gamma);
     xbt_cfg_setdefault_double(_sg_cfg_set, "network/TCP_gamma", 4194304.0);
 
-    xbt_cfg_register(&_sg_cfg_set, "surf/precision",
-                     "Numerical precision used when updating simulation times (hence this value is expressed in seconds)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__surf_precision, NULL);
+    xbt_cfg_register(&_sg_cfg_set, "surf/precision", "Numerical precision used when updating simulation times (in seconds)",
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__surf_precision);
     xbt_cfg_setdefault_double(_sg_cfg_set, "surf/precision", 0.00001);
 
     xbt_cfg_register(&_sg_cfg_set, "maxmin/precision",
-                     "Numerical precision used when computing resource sharing (hence this value is expressed in ops/sec or bytes/sec)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__maxmin_precision, NULL);
+                     "Numerical precision used when computing resource sharing (in ops/sec or bytes/sec)",
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__maxmin_precision);
     xbt_cfg_setdefault_double(_sg_cfg_set, "maxmin/precision", 0.00001);
 
     /* The parameters of network models */
 
-    xbt_cfg_register(&_sg_cfg_set, "network/sender_gap",
-                     "Minimum gap between two overlapping sends",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__sender_gap, NULL);
+    xbt_cfg_register(&_sg_cfg_set, "network/sender_gap", "Minimum gap between two overlapping sends",
+        xbt_cfgelm_double, 1, 1, _sg_cfg_cb__sender_gap);
     /* real default for "network/sender_gap" is set in network_smpi.cpp */
     xbt_cfg_setdefault_double(_sg_cfg_set, "network/sender_gap", NAN);
 
     xbt_cfg_register(&_sg_cfg_set, "network/latency_factor",
                      "Correction factor to apply to the provided latency (default value set by network model)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__latency_factor, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__latency_factor);
     xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
 
     xbt_cfg_register(&_sg_cfg_set, "network/bandwidth_factor",
                      "Correction factor to apply to the provided bandwidth (default value set by network model)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__bandwidth_factor, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__bandwidth_factor);
     xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor", 1.0);
 
     xbt_cfg_register(&_sg_cfg_set, "network/weight_S",
                      "Correction factor to apply to the weight of competing streams (default value set by network model)",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__weight_S, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__weight_S);
     /* real default for "network/weight_S" is set in network_*.cpp */
     xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", NAN);
 
     /* Inclusion path */
     xbt_cfg_register(&_sg_cfg_set, "path",
                      "Lookup path for inclusions in platform and deployment XML files",
-                     xbt_cfgelm_string, 1, 0, _sg_cfg_cb__surf_path, NULL);
+                     xbt_cfgelm_string, 1, 0, _sg_cfg_cb__surf_path);
 
     xbt_cfg_register(&_sg_cfg_set, "cpu/maxmin_selective_update",
                      "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "cpu/maxmin_selective_update", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "network/maxmin_selective_update",
                      "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/maxmin_selective_update", "no");
 
     /* Replay (this part is enabled even if MC it disabled) */
     xbt_cfg_register(&_sg_cfg_set, "model-check/replay",
-      "Uenable replay mode with the given path",
-      xbt_cfgelm_string, 0, 1, _sg_cfg_cb_model_check_replay, NULL);
+      "Enable replay mode with the given path", xbt_cfgelm_string, 0, 1, _sg_cfg_cb_model_check_replay);
 
 #ifdef HAVE_MC
     /* do model-checking-record */
     xbt_cfg_register(&_sg_cfg_set, "model-check/record",
                      "Record the model-checking paths",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_model_check_record, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_model_check_record);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/record", "no");
 
     /* do stateful model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/checkpoint",
                      "Specify the amount of steps between checkpoints during stateful model-checking (default: 0 => stateless verification). "
                      "If value=1, one checkpoint is saved for each step => faster verification, but huge memory consumption; higher values are good compromises between speed and memory consumption.",
-                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_checkpoint, NULL);
+                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_checkpoint);
     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/checkpoint", 0);
 
     /* do stateful model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/sparse_checkpoint",
                      "Use sparse per-page snapshots.",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_sparse_checkpoint, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_sparse_checkpoint);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/sparse_checkpoint", "no");
 
     /* do stateful model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/soft-dirty",
                      "Use sparse per-page snapshots.",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_soft_dirty, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_soft_dirty);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/soft-dirty", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "model-check/ksm",
                      "Kernel same-page merging",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_ksm, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_ksm);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/ksm", "no");
 
     /* do liveness model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/property",
                      "Specify the name of the file containing the property. It must be the result of the ltl2ba program.",
-                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_property, NULL);
+                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_property);
     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/property", "");
 
     /* do communications determinism model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/communications_determinism",
                      "Enable/disable the detection of determinism in the communications schemes",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_comms_determinism, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_comms_determinism);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/communications_determinism", "no");
 
     /* do send determinism model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/send_determinism",
                      "Enable/disable the detection of send-determinism in the communications schemes",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_send_determinism, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_send_determinism);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/send_determinism", "no");
 
     /* Specify the kind of model-checking reduction */
     xbt_cfg_register(&_sg_cfg_set, "model-check/reduction",
                      "Specify the kind of exploration reduction (either none or DPOR)",
-                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_reduce, NULL);
+                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_reduce);
     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/reduction", "dpor");
 
     /* Enable/disable timeout for wait requests with model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/timeout",
                      "Enable/Disable timeout for wait requests",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_timeout, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_timeout);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/timeout", "no");
 
     /* Enable/disable global hash computation with model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/hash",
-                     "Enable/Disable state hash for state comparison (exprimental)",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_hash, NULL);
+                     "Enable/Disable state hash for state comparison (experimental)",
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_hash);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/hash", "no");
 
     /* Set max depth exploration */
     /* Currently, this option cannot be used. */
     xbt_cfg_register(&_sg_cfg_set, "model-check/snapshot_fds",
                      "Whether file descriptors must be snapshoted",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_snapshot_fds, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_snapshot_fds);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/snapshot_fds", "no");
 
     /* Set max depth exploration */
     xbt_cfg_register(&_sg_cfg_set, "model-check/max_depth",
                      "Specify the max depth of exploration (default : 1000)",
-                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_max_depth, NULL);
+                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_max_depth);
     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/max_depth", 1000);
 
     /* Set number of visited state stored for state comparison reduction*/
     xbt_cfg_register(&_sg_cfg_set, "model-check/visited",
                      "Specify the number of visited state stored for state comparison reduction. If value=5, the last 5 visited states are stored",
-                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_visited, NULL);
+                     xbt_cfgelm_int, 1, 1, _mc_cfg_cb_visited);
     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/visited", 0);
 
     /* Set file name for dot output of graph state */
     xbt_cfg_register(&_sg_cfg_set, "model-check/dot_output",
                      "Specify the name of dot file corresponding to graph state",
-                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_dot_output, NULL);
+                     xbt_cfgelm_string, 1, 1, _mc_cfg_cb_dot_output);
     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/dot_output", "");
 
      /* Enable/disable non progressive cycles detection with model-checking */
     xbt_cfg_register(&_sg_cfg_set, "model-check/termination",
                      "Enable/Disable non progressive cycle detection",
-                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_termination, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_termination);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/termination", "no");
 #endif
 
     /* do verbose-exit */
     xbt_cfg_register(&_sg_cfg_set, "verbose-exit",
                      "Activate the \"do nothing\" mode in Ctrl-C",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_verbose_exit, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_verbose_exit);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "verbose-exit", "yes");
 
     /* context factory */
@@ -722,13 +705,13 @@ void sg_config_init(int *argc, char **argv)
       sprintf(p, ".");
     }
     xbt_cfg_register(&_sg_cfg_set, "contexts/factory", description,
-                     xbt_cfgelm_string, 1, 1, _sg_cfg_cb_context_factory, NULL);
+                     xbt_cfgelm_string, 1, 1, _sg_cfg_cb_context_factory);
     xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/factory", dflt_ctx_fact);
 
     /* stack size of contexts in KiB */
     xbt_cfg_register(&_sg_cfg_set, "contexts/stack_size",
                      "Stack size of contexts in KiB",
-                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_stack_size, NULL);
+                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_stack_size);
     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/stack_size", 8*1024);
     /* No, it was not set yet (the above setdefault() changed this to 1). */
     smx_context_stack_size_was_set = 0;
@@ -736,7 +719,7 @@ void sg_config_init(int *argc, char **argv)
     /* guard size for contexts stacks in memory pages */
     xbt_cfg_register(&_sg_cfg_set, "contexts/guard_size",
                      "Guard size for contexts stacks in memory pages",
-                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_guard_size, NULL);
+                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_guard_size);
 #if defined(_XBT_WIN32) || (PTH_STACKGROWTH != -1)
     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/guard_size", 0);
 #else
@@ -748,19 +731,19 @@ void sg_config_init(int *argc, char **argv)
     /* number of parallel threads for user processes */
     xbt_cfg_register(&_sg_cfg_set, "contexts/nthreads",
                      "Number of parallel threads used to execute user contexts",
-                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_nthreads, NULL);
+                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_nthreads);
     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/nthreads", 1);
 
     /* minimal number of user contexts to be run in parallel */
     xbt_cfg_register(&_sg_cfg_set, "contexts/parallel_threshold",
                      "Minimal number of user contexts to be run in parallel (raw contexts only)",
-                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_parallel_threshold, NULL);
+                     xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_parallel_threshold);
     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/parallel_threshold", 2);
 
     /* synchronization mode for parallel user contexts */
     xbt_cfg_register(&_sg_cfg_set, "contexts/synchro",
                      "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)",
-                     xbt_cfgelm_string, 1, 1, _sg_cfg_cb_contexts_parallel_mode, NULL);
+                     xbt_cfgelm_string, 1, 1, _sg_cfg_cb_contexts_parallel_mode);
 #ifdef HAVE_FUTEX_H
     xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/synchro", "futex");
 #else //No futex on mac and posix is unimplememted yet
@@ -769,18 +752,18 @@ void sg_config_init(int *argc, char **argv)
 
     xbt_cfg_register(&_sg_cfg_set, "network/coordinates",
                      "\"yes\" or \"no\", specifying whether we use a coordinate-based routing (as Vivaldi)",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_coordinates, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_coordinates);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/coordinates", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "network/crosstraffic",
                      "Activate the interferences between uploads and downloads for fluid max-min models (LV08, CM02)",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_crosstraffic, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_crosstraffic);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "no");
 
 #ifdef HAVE_NS3
     xbt_cfg_register(&_sg_cfg_set, "ns3/TcpModel",
                      "The ns3 tcp model can be : NewReno or Reno or Tahoe",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "ns3/TcpModel", "default");
 #endif
 
@@ -792,155 +775,154 @@ void sg_config_init(int *argc, char **argv)
     // SMPI model can be used without enable_smpi, so keep this the ifdef.
     xbt_cfg_register(&_sg_cfg_set, "smpi/bw_factor",
                      "Bandwidth factors for smpi.",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "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");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/lat_factor",
                      "Latency factors for smpi.",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "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");
     
     xbt_cfg_register(&_sg_cfg_set, "smpi/IB_penalty_factors",
                      "Correction factor to communications using Infiniband model with contention (default value based on Stampede cluster profiling)",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/IB_penalty_factors", "0.965;0.925;1.35");
     
 #ifdef HAVE_SMPI
     xbt_cfg_register(&_sg_cfg_set, "smpi/running_power",
                      "Power of the host running the simulation (in flop/s). Used to bench the operations.",
-                     xbt_cfgelm_double, 1, 1, NULL, NULL);
+                     xbt_cfgelm_double, 1, 1, NULL);
     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/running_power", 20000.0);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/display_timing",
                      "Boolean indicating whether we should display the timing after simulation.",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/display_timing", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/simulate_computation",
                      "Boolean indicating whether the computational part of the simulated application should be simulated.",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/simulate_computation", "yes");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/use_shared_malloc",
                      "Boolean indicating whether we should use shared memory when using SMPI_SHARED_MALLOC. Allows user to disable it for debug purposes.",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/use_shared_malloc", "yes");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/cpu_threshold",
                      "Minimal computation time (in seconds) not discarded, or -1 for infinity.",
-                     xbt_cfgelm_double, 1, 1, NULL, NULL);
+                     xbt_cfgelm_double, 1, 1, NULL);
     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/cpu_threshold", 1e-6);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/async_small_thresh",
                      "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver",
-                     xbt_cfgelm_int, 1, 1, NULL, NULL);
+                     xbt_cfgelm_int, 1, 1, NULL);
     xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/async_small_thresh", 0);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/send_is_detached_thresh",
                      "Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend",
-                     xbt_cfgelm_int, 1, 1, NULL, NULL);
+                     xbt_cfgelm_int, 1, 1, NULL);
     xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/send_is_detached_thresh", 65536);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/privatize_global_variables",
                      "Boolean indicating whether we should privatize global variable at runtime.",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/privatize_global_variables", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/os",
                      "Small messages timings (MPI_Send minimum time for small messages)",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/os", "1:0:0:0:0");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/ois",
                      "Small messages timings (MPI_Isend minimum time for small messages)",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/ois", "1:0:0:0:0");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/or",
                      "Small messages timings (MPI_Recv minimum time for small messages)",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/or", "1:0:0:0:0");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/iprobe",
                      "Minimum time to inject inside a call to MPI_Iprobe",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__iprobe_sleep, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__iprobe_sleep);
     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/iprobe", 1e-4);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/test",
                      "Minimum time to inject inside a call to MPI_Test",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__test_sleep, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__test_sleep);
     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/test", 1e-4);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/wtime",
                      "Minimum time to inject inside a call to MPI_Wtime",
-                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__wtime_sleep, NULL);
+                     xbt_cfgelm_double, 1, 1, _sg_cfg_cb__wtime_sleep);
     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/wtime", 0.0);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/coll_selector",
                      "Which collective selector to use",
-                     xbt_cfgelm_string, 1, 1, NULL, NULL);
+                     xbt_cfgelm_string, 1, 1, NULL);
     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/coll_selector", "default");
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/gather",
                      "Which collective to use for gather",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_gather, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_gather);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/allgather",
                      "Which collective to use for allgather",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgather, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgather);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/barrier",
                      "Which collective to use for barrier",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_barrier, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_barrier);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/reduce_scatter",
                      "Which collective to use for reduce_scatter",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce_scatter, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce_scatter);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/scatter",
                      "Which collective to use for scatter",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_scatter, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_scatter);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/allgatherv",
                      "Which collective to use for allgatherv",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgatherv, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgatherv);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/allreduce",
                      "Which collective to use for allreduce",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allreduce, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allreduce);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/alltoall",
                      "Which collective to use for alltoall",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoall, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoall);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/alltoallv",
                      "Which collective to use for alltoallv",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoallv, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoallv);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/bcast",
                      "Which collective to use for bcast",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_bcast, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_bcast);
 
     xbt_cfg_register(&_sg_cfg_set, "smpi/reduce",
                      "Which collective to use for reduce",
-                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce, NULL);
+                     xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce);
 #endif // HAVE_SMPI
 
     xbt_cfg_register(&_sg_cfg_set, "exception/cutpath",
                      "\"yes\" or \"no\". \"yes\" will cut all path information from call traces, used e.g. in exceptions.",
-                     xbt_cfgelm_boolean, 1, 1, NULL, NULL);
+                     xbt_cfgelm_boolean, 1, 1, NULL);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "exception/cutpath", "no");
 
     xbt_cfg_register(&_sg_cfg_set, "clean_atexit",
                      "\"yes\" or \"no\". \"yes\" enables all the cleanups of SimGrid (XBT,SIMIX,MSG) to be registered with atexit. \"no\" may be useful if your code segfaults when calling the exit function.",
-                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_clean_atexit, NULL);
+                     xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_clean_atexit);
     xbt_cfg_setdefault_boolean(_sg_cfg_set, "clean_atexit", "yes");
 
     if (!surf_path) {
       /* retrieves the current directory of the current process */
       const char *initial_path = __surf_get_initial_path();
-      xbt_assert((initial_path),
-                  "__surf_get_initial_path() failed! Can't resolve current Windows directory");
+      xbt_assert((initial_path), "__surf_get_initial_path() failed! Can't resolve current Windows directory");
 
       surf_path = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
       xbt_cfg_setdefault_string(_sg_cfg_set, "path", initial_path);
diff --git a/src/xbt/config.c b/src/xbt/config.c
index b7650f53aa..a1f7e73ff2 100644
--- a/src/xbt/config.c
+++ b/src/xbt/config.c
@@ -37,10 +37,8 @@ typedef struct {
 
   /* Callbacks */
   xbt_cfg_cb_t cb_set;
-  xbt_cfg_cb_t cb_rm;
 
-  /* actual content
-     (cannot be an union because type peer used to use both str and i, but it could be converted now) */
+  /* actual content (could be an union or something) */
   xbt_dynar_t content;
 } s_xbt_cfgelm_t, *xbt_cfgelm_t;
 
@@ -95,8 +93,7 @@ void xbt_cfg_cpy(xbt_cfg_t tocopy, xbt_cfg_t * whereto)
 
   xbt_dict_foreach((xbt_dict_t) tocopy, cursor, name, variable) {
     xbt_cfg_register(whereto, name, variable->desc, variable->type,
-                     variable->min, variable->max, variable->cb_set,
-                     variable->cb_rm);
+                     variable->min, variable->max, variable->cb_set);
   }
 }
 
@@ -110,7 +107,7 @@ void xbt_cfg_free(xbt_cfg_t * cfg)
 /** @brief Dump a config set for debuging purpose
  *
  * @param name The name to give to this config set
- * @param indent what to write at the begining of each line (right number of spaces)
+ * @param indent what to write at the beginning of each line (right number of spaces)
  * @param cfg the config set
  */
 void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg)
@@ -133,10 +130,8 @@ void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg)
 
     size = xbt_dynar_length(variable->content);
     printf
-        ("%d_to_%d_%s. Actual size=%d. prerm=%p,postset=%p, List of values:\n",
-         variable->min, variable->max,
-         xbt_cfgelm_type_name[variable->type], size, variable->cb_rm,
-         variable->cb_set);
+        ("%d_to_%d_%s. Actual size=%d. postset=%p, List of values:\n",
+         variable->min, variable->max, xbt_cfgelm_type_name[variable->type], size, variable->cb_set);
 
     switch (variable->type) {
 
@@ -214,13 +209,12 @@ void xbt_cfgelm_free(void *data)
  *  @param min the minimum number of values for this config element
  *  @param max the maximum number of values for this config element
  *  @param cb_set callback function called when a value is set
- *  @param cb_rm callback function called when a value is removed
  */
 
 void xbt_cfg_register(xbt_cfg_t * cfg,
                  const char *name, const char *desc,
                  e_xbt_cfgelm_type_t type, int min,
-                 int max, xbt_cfg_cb_t cb_set, xbt_cfg_cb_t cb_rm)
+                 int max, xbt_cfg_cb_t cb_set)
 {
   xbt_cfgelm_t res;
 
@@ -241,7 +235,6 @@ void xbt_cfg_register(xbt_cfg_t * cfg,
   res->min = min;
   res->max = max;
   res->cb_set = cb_set;
-  res->cb_rm = cb_rm;
   res->isdefault = 1;
 
   switch (type) {
@@ -275,7 +268,10 @@ void xbt_cfg_register_alias(xbt_cfg_t * cfg, const char *newname, const char *ol
     *cfg = xbt_cfg_new();
 
   xbt_cfgelm_t res = xbt_dict_get_or_null((xbt_dict_t) * cfg, oldname);
-  xbt_assert(NULL == res, "Refusing to register the config element '%s' twice.", oldname);
+  xbt_assert(NULL == res, "Refusing to register the option '%s' twice.", oldname);
+
+  res = xbt_dict_get_or_null((xbt_dict_t) * cfg, newname);
+  xbt_assert(res, "Cannot define an alias to the non-existing option '%s'.", newname);
 
   res = xbt_new0(s_xbt_cfgelm_t, 1);
   XBT_DEBUG("Register cfg alias %s -> %s in set %p)",oldname,newname, *cfg);
@@ -356,7 +352,7 @@ void xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry)
               "Invalid type in config element descriptor: %s%s", entry,
               "; Should be one of 'string', 'int' or 'double'.");
 
-  xbt_cfg_register(cfg, entrycpy, NULL, type, min, max, NULL, NULL);
+  xbt_cfg_register(cfg, entrycpy, NULL, type, min, max, NULL);
 
   free(entrycpy);               /* strdup'ed by dict mechanism, but cannot be const */
 }
@@ -499,14 +495,15 @@ static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm
   xbt_cfgelm_t res = xbt_dict_get_or_null((xbt_dict_t) cfg, name);
 
   // The user used the old name. Switch to the new one after a short warning
-  if (res && res->type == xbt_cfgelm_alias) {
+  while (res && res->type == xbt_cfgelm_alias) {
     const char* newname = (const char *)res->content;
-    XBT_VERB("Option %s has been renamed to %s. Consider switching.", name, newname);
+    XBT_INFO("Option %s has been renamed to %s. Consider switching.", name, newname);
     res = xbt_cfgelm_get(cfg, newname, type);
   }
 
   if (!res) {
     xbt_cfg_help(cfg);
+    fflush(stdout);
     THROWF(not_found_error, 0, "No registered variable '%s' in this config set.", name);
   }
 
@@ -690,6 +687,9 @@ void xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options) {
     }
     *(val++) = '\0';
 
+    if (strncmp(name, "contexts/", strlen("contexts/")) && strncmp(name, "path", strlen("path")))
+      XBT_INFO("Configuration change: Set '%s' to '%s'", name, val);
+
     TRY {
       xbt_cfg_set_as_string(cfg,name,val);
     } CATCH_ANONYMOUS {
@@ -717,13 +717,10 @@ void *xbt_cfg_set_as_string(xbt_cfg_t cfg, const char *key, const char *value) {
   int i;
   double d;
 
-  if (strncmp(key, "contexts/", strlen("contexts/")) && strncmp(key, "path", strlen("path")))
-    XBT_INFO("Configuration change: Set '%s' to '%s'", key, value);
-
   TRY {
     while (variable == NULL) {
       variable = xbt_dict_get((xbt_dict_t) cfg, key);
-      if (variable->type == xbt_cfgelm_alias) {
+      while (variable->type == xbt_cfgelm_alias) {
         const char *newname = (const char*)variable->content;
         XBT_INFO("Note: configuration '%s' is deprecated. Please use '%s' instead.", key, newname);
         key = newname;
@@ -861,15 +858,11 @@ void xbt_cfg_setdefault_boolean(xbt_cfg_t cfg, const char *name, const char *val
  */
 void xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val)
 {
-  xbt_cfgelm_t variable;
 
   XBT_VERB("Configuration setting: %s=%d", name, val);
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int);
 
   if (variable->max == 1) {
-    if (variable->cb_rm && !xbt_dynar_is_empty(variable->content))
-      variable->cb_rm(name, 0);
-
     xbt_dynar_set(variable->content, 0, &val);
   } else {
     if (variable->max
@@ -896,15 +889,11 @@ void xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val)
 
 void xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val)
 {
-  xbt_cfgelm_t variable;
 
   XBT_VERB("Configuration setting: %s=%f", name, val);
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double);
 
   if (variable->max == 1) {
-    if (variable->cb_rm && !xbt_dynar_is_empty(variable->content))
-      variable->cb_rm(name, 0);
-
     xbt_dynar_set(variable->content, 0, &val);
   } else {
     if (variable->max
@@ -931,23 +920,18 @@ void xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val)
 
 void xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val)
 {
-  xbt_cfgelm_t variable;
   char *newval = xbt_strdup(val);
 
   XBT_VERB("Configuration setting: %s=%s", name, val);
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string);
+
   XBT_DEBUG("Variable: %d to %d %s (=%d) @%p",
-         variable->min, variable->max,
-            xbt_cfgelm_type_name[variable->type], (int)variable->type, variable);
+         variable->min, variable->max, xbt_cfgelm_type_name[variable->type], (int)variable->type, variable);
 
   if (variable->max == 1) {
     if (!xbt_dynar_is_empty(variable->content)) {
-      if (variable->cb_rm)
-        variable->cb_rm(name, 0);
-      else if (variable->type == xbt_cfgelm_string) {
-        char *sval = xbt_dynar_get_as(variable->content, 0, char *);
-        free(sval);
-      }
+      char *sval = xbt_dynar_get_as(variable->content, 0, char *);
+      free(sval);
     }
 
     xbt_dynar_set(variable->content, 0, &newval);
@@ -974,11 +958,10 @@ void xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val)
  */
 void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val)
 {
-  xbt_cfgelm_t variable;
   int i, bval;
 
   XBT_VERB("Configuration setting: %s=%s", name, val);
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean);
 
   for (i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) {
   if (strcmp(val, xbt_cfgelm_boolean_values[i].true_val) == 0){
@@ -995,9 +978,6 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val)
   }
 
   if (variable->max == 1) {
-    if (variable->cb_rm && !xbt_dynar_is_empty(variable->content))
-      variable->cb_rm(name, 0);
-
     xbt_dynar_set(variable->content, 0, &bval);
   } else {
     if (variable->max
@@ -1026,11 +1006,10 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val)
 void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val)
 {
 
-  xbt_cfgelm_t variable;
   unsigned int cpt;
   int seen;
 
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int);
 
   if (xbt_dynar_length(variable->content) == variable->min)
     THROWF(mismatch_error, 0,
@@ -1039,8 +1018,6 @@ void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val)
 
   xbt_dynar_foreach(variable->content, cpt, seen) {
     if (seen == val) {
-      if (variable->cb_rm)
-        variable->cb_rm(name, cpt);
       xbt_dynar_cursor_rm(variable->content, &cpt);
       return;
     }
@@ -1060,11 +1037,10 @@ void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val)
 
 void xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val)
 {
-  xbt_cfgelm_t variable;
   unsigned int cpt;
   double seen;
 
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double);
 
   if (xbt_dynar_length(variable->content) == variable->min)
     THROWF(mismatch_error, 0,
@@ -1074,8 +1050,6 @@ void xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val)
   xbt_dynar_foreach(variable->content, cpt, seen) {
     if (seen == val) {
       xbt_dynar_cursor_rm(variable->content, &cpt);
-      if (variable->cb_rm)
-        variable->cb_rm(name, cpt);
       return;
     }
   }
@@ -1093,11 +1067,9 @@ void xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val)
  */
 void xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val)
 {
-  xbt_cfgelm_t variable;
   unsigned int cpt;
   char *seen;
-
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string);
 
   if (xbt_dynar_length(variable->content) == variable->min)
     THROWF(mismatch_error, 0,
@@ -1106,8 +1078,6 @@ void xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val)
 
   xbt_dynar_foreach(variable->content, cpt, seen) {
     if (!strcpy(seen, val)) {
-      if (variable->cb_rm)
-        variable->cb_rm(name, cpt);
       xbt_dynar_cursor_rm(variable->content, &cpt);
       return;
     }
@@ -1127,11 +1097,9 @@ void xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val)
 void xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val)
 {
 
-  xbt_cfgelm_t variable;
   unsigned int cpt;
   int seen;
-
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean);
 
   if (xbt_dynar_length(variable->content) == variable->min)
     THROWF(mismatch_error, 0,
@@ -1140,8 +1108,6 @@ void xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val)
 
   xbt_dynar_foreach(variable->content, cpt, seen) {
     if (seen == val) {
-      if (variable->cb_rm)
-        variable->cb_rm(name, cpt);
       xbt_dynar_cursor_rm(variable->content, &cpt);
       return;
     }
@@ -1157,17 +1123,13 @@ void xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val)
 void xbt_cfg_rm_at(xbt_cfg_t cfg, const char *name, int pos)
 {
 
-  xbt_cfgelm_t variable;
-
-  variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_any);
+  xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_any);
 
   if (xbt_dynar_length(variable->content) == variable->min)
     THROWF(mismatch_error, 0,
            "Cannot remove %dth value from the config element %s since it's already at its minimal size (=%d)",
            pos, name, variable->min);
 
-  if (variable->cb_rm)
-    variable->cb_rm(name, pos);
   xbt_dynar_remove_at(variable->content, pos, NULL);
 }
 
@@ -1190,21 +1152,11 @@ void xbt_cfg_empty(xbt_cfg_t cfg, const char *name)
       RETHROW;
 
     xbt_ex_free(e);
-    THROWF(not_found_error, 0,
-           "Can't empty  '%s' since this config element does not exist",
-           name);
+    THROWF(not_found_error, 0, "Can't empty  '%s' since this option does not exist", name);
   }
 
-  if (variable) {
-    if (variable->cb_rm) {
-      unsigned int cpt;
-      void *ignored;
-      xbt_dynar_foreach(variable->content, cpt, ignored) {
-        variable->cb_rm(name, cpt);
-      }
-    }
+  if (variable)
     xbt_dynar_reset(variable->content);
-  }
 }
 /*
  * Say if the value is the default value
@@ -1225,8 +1177,6 @@ int xbt_cfg_is_default_value(xbt_cfg_t cfg, const char *name)
  * Returns the first value from the config set under the given name.
  * If there is more than one value, it will issue a warning. Consider using
  * xbt_cfg_get_dynar() instead.
- *
- * \warning the returned value is the actual content of the config set
  */
 int xbt_cfg_get_int(xbt_cfg_t cfg, const char *name)
 {
@@ -1249,8 +1199,6 @@ int xbt_cfg_get_int(xbt_cfg_t cfg, const char *name)
  * Returns the first value from the config set under the given name.
  * If there is more than one value, it will issue a warning. Consider using
  * xbt_cfg_get_dynar() instead.
- *
- * \warning the returned value is the actual content of the config set
  */
 
 double xbt_cfg_get_double(xbt_cfg_t cfg, const char *name)
@@ -1301,8 +1249,6 @@ char *xbt_cfg_get_string(xbt_cfg_t cfg, const char *name)
  * Returns the first value from the config set under the given name.
  * If there is more than one value, it will issue a warning. Consider using
  * xbt_cfg_get_dynar() instead.
- *
- * \warning the returned value is the actual content of the config set
  */
 int xbt_cfg_get_boolean(xbt_cfg_t cfg, const char *name)
 {