From: Arnaud Giersch <arnaud.giersch@univ-fcomte.fr>
Date: Thu, 19 Apr 2018 10:33:52 +0000 (+0200)
Subject: More snake_case in xbt/config (bind_flag, declare_flag).
X-Git-Tag: v3.20~380
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/52ce912c49d61c252e301393740350f4f0e41d8b?ds=sidebyside

More snake_case in xbt/config (bind_flag, declare_flag).
---

diff --git a/include/xbt/config.h b/include/xbt/config.h
index 06273915bb..a555624466 100644
--- a/include/xbt/config.h
+++ b/include/xbt/config.h
@@ -112,13 +112,13 @@ XBT_PUBLIC void xbt_cfg_dump(const char* name, const char* indent, xbt_cfg_t cfg
  *
  *  @{
  */
-XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declareFlag<>") XBT_PUBLIC
+XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declare_flag<double>") XBT_PUBLIC
     void xbt_cfg_register_double(const char* name, double default_val, xbt_cfg_cb_t cb_set, const char* desc);
-XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declareFlag<>") XBT_PUBLIC
+XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declare_flag<int>") XBT_PUBLIC
     void xbt_cfg_register_int(const char* name, int default_val, xbt_cfg_cb_t cb_set, const char* desc);
-XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declareFlag<>") XBT_PUBLIC
+XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declare_flag<std::string>") XBT_PUBLIC
     void xbt_cfg_register_string(const char* name, const char* default_val, xbt_cfg_cb_t cb_set, const char* desc);
-XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declareFlag<>") XBT_PUBLIC
+XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::declare_flag<bool>") XBT_PUBLIC
     void xbt_cfg_register_boolean(const char* name, const char* default_val, xbt_cfg_cb_t cb_set, const char* desc);
 XBT_ATTRIB_DEPRECATED_v323("Please use simgrid::config::alias") XBT_PUBLIC
     void xbt_cfg_register_alias(const char* newname, const char* oldname);
diff --git a/include/xbt/config.hpp b/include/xbt/config.hpp
index 852bdaded0..92ecb49a60 100644
--- a/include/xbt/config.hpp
+++ b/include/xbt/config.hpp
@@ -62,17 +62,17 @@ extern template XBT_PUBLIC std::string const& get_config<std::string>(const char
  *  @param callback    called with the option value
  */
 template <class T>
-XBT_PUBLIC void declareFlag(const char* name, const char* description, T value,
-                            std::function<void(const T&)> callback = std::function<void(const T&)>());
-
-extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value,
-                                            std::function<void(int const&)> callback);
-extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value,
-                                            std::function<void(double const&)> callback);
-extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value,
-                                            std::function<void(bool const&)> callback);
-extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value,
-                                            std::function<void(std::string const&)> callback);
+XBT_PUBLIC void declare_flag(const char* name, const char* description, T value,
+                             std::function<void(const T&)> callback = std::function<void(const T&)>());
+
+extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, int value,
+                                             std::function<void(int const&)> callback);
+extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, double value,
+                                             std::function<void(double const&)> callback);
+extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, bool value,
+                                             std::function<void(bool const&)> callback);
+extern template XBT_PUBLIC void declare_flag(const char* name, const char* description, std::string value,
+                                             std::function<void(std::string const&)> callback);
 
 // ***** alias *****
 
@@ -84,18 +84,15 @@ XBT_PUBLIC void alias(const char* realname, std::initializer_list<const char*> a
  *  @param name  Flag name
  *  @param description Option description
  */
-template<class T>
-void bindFlag(T& value, const char* name, const char* description)
+template <class T> void bind_flag(T& value, const char* name, const char* description)
 {
-  declareFlag<T>(name, description, value, [&value](T const& val) {
-    value = val;
-  });
+  declare_flag<T>(name, description, value, [&value](T const& val) { value = val; });
 }
 
 template <class T>
-void bindFlag(T& value, const char* name, std::initializer_list<const char*> aliases, const char* description)
+void bind_flag(T& value, const char* name, std::initializer_list<const char*> aliases, const char* description)
 {
-  bindFlag(value, name, description);
+  bind_flag(value, name, description);
   alias(name, std::move(aliases));
 }
 
@@ -103,7 +100,7 @@ void bindFlag(T& value, const char* name, std::initializer_list<const char*> ali
  *
  *  <pre><code>
  *  static int x;
- *  simgrid::config::bindFlag(a, "x", [](int x) {
+ *  simgrid::config::bind_flag(a, "x", [](int x) {
  *    if (x < x_min || x => x_max)
  *      throw std::range_error("must be in [x_min, x_max)")
  *  });
@@ -112,69 +109,65 @@ void bindFlag(T& value, const char* name, std::initializer_list<const char*> ali
 // F is a checker, F : T& -> ()
 template <class T, class F>
 typename std::enable_if<std::is_same<void, decltype(std::declval<F>()(std::declval<const T&>()))>::value, void>::type
-bindFlag(T& value, const char* name, const char* description, F callback)
+bind_flag(T& value, const char* name, const char* description, F callback)
 {
-  declareFlag(name, description, value, std::function<void(const T&)>([&value, callback](const T& val) {
-                callback(val);
-                value = std::move(val);
-              }));
+  declare_flag(name, description, value, std::function<void(const T&)>([&value, callback](const T& val) {
+                 callback(val);
+                 value = std::move(val);
+               }));
 }
 
 template <class T, class F>
 typename std::enable_if<std::is_same<void, decltype(std::declval<F>()(std::declval<const T&>()))>::value, void>::type
-bindFlag(T& value, const char* name, std::initializer_list<const char*> aliases, const char* description, F callback)
+bind_flag(T& value, const char* name, std::initializer_list<const char*> aliases, const char* description, F callback)
 {
-  bindFlag(value, name, description, std::move(callback));
+  bind_flag(value, name, description, std::move(callback));
   alias(name, std::move(aliases));
 }
 
 template <class T, class F>
 typename std::enable_if<std::is_same<void, decltype(std::declval<F>()(std::declval<const T&>()))>::value, void>::type
-bindFlag(T& value, const char* name, const char* description, std::map<T, std::string> valid_values, F callback)
+bind_flag(T& value, const char* name, const char* description, std::map<T, std::string> valid_values, F callback)
 {
-  declareFlag(name, description, value,
-              std::function<void(const T&)>([&value, name, valid_values, callback](const T& val) {
-                callback(val);
-                bool found = false;
-                for (auto kv : valid_values) {
-                  if (kv.first == val)
-                    found = true;
-                }
-                if (not found || std::string(val) == "help") {
-                  std::string mesg;
-                  if (std::string(val) == "help")
-                    mesg = std::string("\nPossible values for option ") + name + ":\n";
-                  else
-                    mesg = std::string("\nInvalid value '") + val + "' for option " + name + ". Possible values:\n";
-                  for (auto kv : valid_values)
-                    mesg += "  - '" + std::string(kv.first) + "': " + kv.second +
-                            (kv.first == value ? "  <=== DEFAULT" : "") + "\n";
-                  xbt_die("%s", mesg.c_str());
-                }
-                value = std::move(val);
-              }));
+  declare_flag(name, description, value,
+               std::function<void(const T&)>([&value, name, valid_values, callback](const T& val) {
+                 callback(val);
+                 bool found = false;
+                 for (auto kv : valid_values) {
+                   if (kv.first == val)
+                     found = true;
+                 }
+                 if (not found || std::string(val) == "help") {
+                   std::string mesg;
+                   if (std::string(val) == "help")
+                     mesg = std::string("\nPossible values for option ") + name + ":\n";
+                   else
+                     mesg = std::string("\nInvalid value '") + val + "' for option " + name + ". Possible values:\n";
+                   for (auto kv : valid_values)
+                     mesg += "  - '" + std::string(kv.first) + "': " + kv.second +
+                             (kv.first == value ? "  <=== DEFAULT" : "") + "\n";
+                   xbt_die("%s", mesg.c_str());
+                 }
+                 value = std::move(val);
+               }));
 }
 /** Bind a variable to configuration flag
  *
  *  <pre><code>
  *  static int x;
- *  simgrid::config::bindFlag(a, "x", [](int x) { return x > 0; });
+ *  simgrid::config::bind_flag(a, "x", [](int x) { return x > 0; });
  *  </code></pre>
  */
 // F is a predicate, F : T const& -> bool
-template<class T, class F>
-typename std::enable_if<std::is_same<
-  bool,
-  decltype( std::declval<F>()(std::declval<const T&>()) )
->::value, void>::type
-bindFlag(T& value, const char* name, const char* description,
-  F callback)
+template <class T, class F>
+typename std::enable_if<std::is_same<bool, decltype(std::declval<F>()(std::declval<const T&>()))>::value, void>::type
+bind_flag(T& value, const char* name, const char* description, F callback)
 {
-  declareFlag(name, description, value, std::function<void(const T&)>([&value, callback](const T& val) {
-                if (not callback(val))
-                  throw std::range_error("invalid value.");
-                value = std::move(val);
-              }));
+  declare_flag(name, description, value, std::function<void(const T&)>([&value, callback](const T& val) {
+                 if (not callback(val))
+                   throw std::range_error("invalid value.");
+                 value = std::move(val);
+               }));
 }
 
 /** A variable bound to a CLI option
@@ -198,13 +191,13 @@ public:
    */
   Flag(const char* name, const char* desc, T value) : value_(value)
   {
-    simgrid::config::bindFlag(value_, name, desc);
+    simgrid::config::bind_flag(value_, name, desc);
   }
 
   /** Constructor taking also an array of aliases for name */
   Flag(const char* name, std::initializer_list<const char*> aliases, const char* desc, T value) : value_(value)
   {
-    simgrid::config::bindFlag(value_, name, std::move(aliases), desc);
+    simgrid::config::bind_flag(value_, name, std::move(aliases), desc);
   }
 
   /* A constructor accepting a callback that will be passed the parameter.
@@ -213,14 +206,14 @@ public:
   template<class F>
   Flag(const char* name, const char* desc, T value, F callback) : value_(value)
   {
-    simgrid::config::bindFlag(value_, name, desc, std::move(callback));
+    simgrid::config::bind_flag(value_, name, desc, std::move(callback));
   }
 
   template <class F>
   Flag(const char* name, std::initializer_list<const char*> aliases, const char* desc, T value, F callback)
       : value_(value)
   {
-    simgrid::config::bindFlag(value_, name, std::move(aliases), desc, std::move(callback));
+    simgrid::config::bind_flag(value_, name, std::move(aliases), desc, std::move(callback));
   }
 
   /* A constructor accepting a map of valid values -> their description,
@@ -229,7 +222,7 @@ public:
   template <class F>
   Flag(const char* name, const char* desc, T value, std::map<T, std::string> valid_values, F callback) : value_(value)
   {
-    simgrid::config::bindFlag(value_, name, desc, std::move(valid_values), std::move(callback));
+    simgrid::config::bind_flag(value_, name, desc, std::move(valid_values), std::move(callback));
   }
 
   // No copy:
diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp
index f81f5d9b6a..e896000237 100644
--- a/src/instr/instr_config.cpp
+++ b/src/instr/instr_config.cpp
@@ -267,21 +267,21 @@ void TRACE_global_init()
 
   is_initialised = true;
   /* name of the tracefile */
-  simgrid::config::declareFlag<std::string>(OPT_TRACING_FILENAME, "Trace file created by the instrumented SimGrid.",
-                                            "simgrid.trace");
-  simgrid::config::declareFlag<std::string>(OPT_TRACING_FORMAT, "(smpi only) Switch the output format of Tracing",
-                                            "Paje");
-  simgrid::config::declareFlag<bool>(OPT_TRACING_FORMAT_TI_ONEFILE,
-                                     "(smpi only) For replay format only : output to one file only", false);
+  simgrid::config::declare_flag<std::string>(OPT_TRACING_FILENAME, "Trace file created by the instrumented SimGrid.",
+                                             "simgrid.trace");
+  simgrid::config::declare_flag<std::string>(OPT_TRACING_FORMAT, "(smpi only) Switch the output format of Tracing",
+                                             "Paje");
+  simgrid::config::declare_flag<bool>(OPT_TRACING_FORMAT_TI_ONEFILE,
+                                      "(smpi only) For replay format only : output to one file only", false);
   simgrid::config::alias(OPT_TRACING_FORMAT_TI_ONEFILE, {"tracing/smpi/format/ti_one_file"});
-  simgrid::config::declareFlag<std::string>(OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.",
-                                            "");
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<std::string>(OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.",
+                                             "");
+  simgrid::config::declare_flag<std::string>(
       OPT_TRACING_COMMENT_FILE, "The contents of the file are added to the top of the trace file as comment.", "");
   simgrid::config::alias(OPT_TRACING_COMMENT_FILE, {"tracing/comment_file"});
-  simgrid::config::declareFlag<int>(OPT_TRACING_PRECISION, "Numerical precision used when timestamping events "
-                                                           "(expressed in number of digits after decimal point)",
-                                    6);
+  simgrid::config::declare_flag<int>(OPT_TRACING_PRECISION, "Numerical precision used when timestamping events "
+                                                            "(expressed in number of digits after decimal point)",
+                                     6);
 }
 
 static void print_line (const char *option, const char *desc, const char *longdesc, int detailed)
diff --git a/src/msg/msg_global.cpp b/src/msg/msg_global.cpp
index 7e250dc00d..06c387f63b 100644
--- a/src/msg/msg_global.cpp
+++ b/src/msg/msg_global.cpp
@@ -33,8 +33,8 @@ void MSG_init_nocheck(int *argc, char **argv) {
     msg_global = new s_MSG_Global_t();
 
     msg_global->debug_multiple_use = false;
-    simgrid::config::bindFlag(msg_global->debug_multiple_use, "msg/debug-multiple-use",
-                              "Print backtraces of both processes when there is a conflict of multiple use of a task");
+    simgrid::config::bind_flag(msg_global->debug_multiple_use, "msg/debug-multiple-use",
+                               "Print backtraces of both processes when there is a conflict of multiple use of a task");
 
     SIMIX_global_init(argc, argv);
 
diff --git a/src/simgrid/sg_config.cpp b/src/simgrid/sg_config.cpp
index 42019689ae..dc9ef42c13 100644
--- a/src/simgrid/sg_config.cpp
+++ b/src/simgrid/sg_config.cpp
@@ -231,73 +231,73 @@ void sg_config_init(int *argc, char **argv)
 
   /* Plugins configuration */
   describe_model(description, descsize, surf_plugin_description, "plugin", "The plugins");
-  simgrid::config::declareFlag<std::string>("plugin", description, "", &_sg_cfg_cb__plugin);
+  simgrid::config::declare_flag<std::string>("plugin", description, "", &_sg_cfg_cb__plugin);
 
   describe_model(description, descsize, surf_cpu_model_description, "model", "The model to use for the CPU");
-  simgrid::config::declareFlag<std::string>("cpu/model", description, "Cas01", &_sg_cfg_cb__cpu_model);
+  simgrid::config::declare_flag<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");
-  simgrid::config::declareFlag<std::string>("storage/model", description, "default", &_sg_cfg_cb__storage_mode);
+  simgrid::config::declare_flag<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");
-  simgrid::config::declareFlag<std::string>("network/model", description, "LV08", &_sg_cfg_cb__network_model);
+  simgrid::config::declare_flag<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");
-  simgrid::config::declareFlag<std::string>("network/optim", description, "Lazy", &_sg_cfg_cb__optimization_mode);
+  simgrid::config::declare_flag<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");
-  simgrid::config::declareFlag<std::string>("host/model", description, "default", &_sg_cfg_cb__host_model);
+  simgrid::config::declare_flag<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)");
+  simgrid::config::bind_flag(sg_surf_precision, "surf/precision",
+                             "Numerical precision used when updating simulation times (in seconds)");
 
-  simgrid::config::bindFlag(sg_maxmin_precision, "maxmin/precision",
-                            "Numerical precision used when computing resource sharing (in flops/sec or bytes/sec)");
+  simgrid::config::bind_flag(sg_maxmin_precision, "maxmin/precision",
+                             "Numerical precision used when computing resource sharing (in flops/sec or bytes/sec)");
 
-  simgrid::config::bindFlag(sg_concurrency_limit, "maxmin/concurrency-limit", {"maxmin/concurrency_limit"},
-                            "Maximum number of concurrent variables in the maxmim system. Also limits the number of "
-                            "processes on each host, at higher level. (default: -1 means no such limitation)");
+  simgrid::config::bind_flag(sg_concurrency_limit, "maxmin/concurrency-limit", {"maxmin/concurrency_limit"},
+                             "Maximum number of concurrent variables in the maxmim system. Also limits the number of "
+                             "processes on each host, at higher level. (default: -1 means no such limitation)");
 
   /* The parameters of network models */
 
   sg_latency_factor = 13.01; // comes from the default LV08 network model
-  simgrid::config::bindFlag(sg_latency_factor, "network/latency-factor", {"network/latency_factor"},
-                            "Correction factor to apply to the provided latency (default value set by network model)");
+  simgrid::config::bind_flag(sg_latency_factor, "network/latency-factor", {"network/latency_factor"},
+                             "Correction factor to apply to the provided latency (default value set by network model)");
 
   sg_bandwidth_factor = 0.97; // comes from the default LV08 network model
-  simgrid::config::bindFlag(
+  simgrid::config::bind_flag(
       sg_bandwidth_factor, "network/bandwidth-factor", {"network/bandwidth_factor"},
       "Correction factor to apply to the provided bandwidth (default value set by network model)");
 
   sg_weight_S_parameter = 20537; // comes from the default LV08 network model
-  simgrid::config::bindFlag(
+  simgrid::config::bind_flag(
       sg_weight_S_parameter, "network/weight-S", {"network/weight_S"},
       "Correction factor to apply to the weight of competing streams (default value set by network model)");
 
   /* Inclusion path */
-  simgrid::config::declareFlag<std::string>("path", "Lookup path for inclusions in platform and deployment XML files",
-                                            "", [](std::string const& path) {
-                                              if (not path.empty())
-                                                surf_path.push_back(path);
-                                            });
-
-  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::declare_flag<std::string>("path", "Lookup path for inclusions in platform and deployment XML files",
+                                             "", [](std::string const& path) {
+                                               if (not path.empty())
+                                                 surf_path.push_back(path);
+                                             });
+
+  simgrid::config::declare_flag<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"});
-  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::declare_flag<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"});
 
   extern bool _sg_do_verbose_exit;
-  simgrid::config::bindFlag(_sg_do_verbose_exit, "verbose-exit", "Activate the \"do nothing\" mode in Ctrl-C");
+  simgrid::config::bind_flag(_sg_do_verbose_exit, "verbose-exit", "Activate the \"do nothing\" mode in Ctrl-C");
 
-  simgrid::config::declareFlag<int>("contexts/stack-size", "Stack size of contexts in KiB", 8 * 1024,
-                                    [](int value) { smx_context_stack_size = value * 1024; });
+  simgrid::config::declare_flag<int>("contexts/stack-size", "Stack size of contexts in KiB", 8 * 1024,
+                                     [](int value) { smx_context_stack_size = value * 1024; });
   simgrid::config::alias("contexts/stack-size", {"contexts/stack_size"});
 
   /* guard size for contexts stacks in memory pages */
@@ -306,16 +306,16 @@ void sg_config_init(int *argc, char **argv)
 #else
   int default_guard_size = 1;
 #endif
-  simgrid::config::declareFlag<int>("contexts/guard-size", "Guard size for contexts stacks in memory pages",
-                                    default_guard_size,
-                                    [](int value) { smx_context_guard_size = value * xbt_pagesize; });
+  simgrid::config::declare_flag<int>("contexts/guard-size", "Guard size for contexts stacks in memory pages",
+                                     default_guard_size,
+                                     [](int value) { smx_context_guard_size = value * xbt_pagesize; });
   simgrid::config::alias("contexts/guard-size", {"contexts/guard_size"});
-  simgrid::config::declareFlag<int>("contexts/nthreads", "Number of parallel threads used to execute user contexts", 1,
-                                    &SIMIX_context_set_nthreads);
+  simgrid::config::declare_flag<int>("contexts/nthreads", "Number of parallel threads used to execute user contexts", 1,
+                                     &SIMIX_context_set_nthreads);
 
-  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::declare_flag<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 */
@@ -324,69 +324,70 @@ void sg_config_init(int *argc, char **argv)
 #else //No futex on mac and posix is unimplememted yet
   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);
+  simgrid::config::declare_flag<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.
-  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::declare_flag<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"});
 
-  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::declare_flag<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"});
-  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::declare_flag<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
-  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::declare_flag<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"});
 
-  simgrid::config::declareFlag<bool>("smpi/keep-temps", "Whether we should keep the generated temporary files.", false);
+  simgrid::config::declare_flag<bool>("smpi/keep-temps", "Whether we should keep the generated temporary files.",
+                                      false);
 
-  simgrid::config::declareFlag<bool>("smpi/display-timing", "Whether we should display the timing after simulation.",
-                                     false);
+  simgrid::config::declare_flag<bool>("smpi/display-timing", "Whether we should display the timing after simulation.",
+                                      false);
   simgrid::config::alias("smpi/display-timing", {"smpi/display_timing"});
 
-  simgrid::config::declareFlag<bool>("smpi/simulate-computation",
-                                     "Whether the computational part of the simulated application should be simulated.",
-                                     true);
+  simgrid::config::declare_flag<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"});
 
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<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"});
-  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::declare_flag<double>("smpi/shared-malloc-blocksize",
+                                        "Size of the bogus file which will be created for global shared allocations",
+                                        1UL << 20);
+  simgrid::config::declare_flag<std::string>("smpi/shared-malloc-hugepage",
+                                             "Path to a mounted hugetlbfs, to use huge pages with shared malloc.", "");
 
-  simgrid::config::declareFlag<double>(
+  simgrid::config::declare_flag<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"});
 
-  simgrid::config::declareFlag<int>(
+  simgrid::config::declare_flag<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"});
 
-  simgrid::config::declareFlag<bool>("smpi/trace-call-location",
-                                     "Should filename and linenumber of MPI calls be traced?", false);
+  simgrid::config::declare_flag<bool>("smpi/trace-call-location",
+                                      "Should filename and linenumber of MPI calls be traced?", false);
 
-  simgrid::config::declareFlag<int>(
+  simgrid::config::declare_flag<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",
@@ -396,65 +397,65 @@ void sg_config_init(int *argc, char **argv)
   if (default_privatization == nullptr)
     default_privatization = "no";
 
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<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"});
 
-  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);
+  simgrid::config::declare_flag<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
-  simgrid::config::declareFlag<std::string>("smpi/papi-events",
-                                            "This switch enables tracking the specified counters with PAPI", "");
+  simgrid::config::declare_flag<std::string>("smpi/papi-events",
+                                             "This switch enables tracking the specified counters with PAPI", "");
 #endif
-  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>(
+  simgrid::config::declare_flag<std::string>("smpi/comp-adjustment-file",
+                                             "A file containing speedups or slowdowns for some parts of the code.", "");
+  simgrid::config::declare_flag<std::string>(
       "smpi/os", "Small messages timings (MPI_Send minimum time for small messages)", "0:0:0:0:0");
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<std::string>(
       "smpi/ois", "Small messages timings (MPI_Isend minimum time for small messages)", "0:0:0:0:0");
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<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::declare_flag<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::declare_flag<std::string>("smpi/coll-selector", "Which collective selector to use", "default");
   simgrid::config::alias("smpi/coll-selector", {"smpi/coll_selector"});
-  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::declare_flag<std::string>("smpi/gather", "Which collective to use for gather", "");
+  simgrid::config::declare_flag<std::string>("smpi/allgather", "Which collective to use for allgather", "");
+  simgrid::config::declare_flag<std::string>("smpi/barrier", "Which collective to use for barrier", "");
+  simgrid::config::declare_flag<std::string>("smpi/reduce_scatter", "Which collective to use for reduce_scatter", "");
   simgrid::config::alias("smpi/reduce_scatter", {"smpi/reduce-scatter"});
-  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", "");
+  simgrid::config::declare_flag<std::string>("smpi/scatter", "Which collective to use for scatter", "");
+  simgrid::config::declare_flag<std::string>("smpi/allgatherv", "Which collective to use for allgatherv", "");
+  simgrid::config::declare_flag<std::string>("smpi/allreduce", "Which collective to use for allreduce", "");
+  simgrid::config::declare_flag<std::string>("smpi/alltoall", "Which collective to use for alltoall", "");
+  simgrid::config::declare_flag<std::string>("smpi/alltoallv", "Which collective to use for alltoallv", "");
+  simgrid::config::declare_flag<std::string>("smpi/bcast", "Which collective to use for bcast", "");
+  simgrid::config::declare_flag<std::string>("smpi/reduce", "Which collective to use for reduce", "");
 #endif // HAVE_SMPI
 
   /* Storage */
 
   sg_storage_max_file_descriptors = 1024;
-  simgrid::config::bindFlag(sg_storage_max_file_descriptors, "storage/max_file_descriptors",
-                            "Maximum number of concurrently opened files per host. Default is 1024");
+  simgrid::config::bind_flag(sg_storage_max_file_descriptors, "storage/max_file_descriptors",
+                             "Maximum number of concurrently opened files per host. Default is 1024");
 
   /* Others */
 
-  simgrid::config::declareFlag<bool>(
+  simgrid::config::declare_flag<bool>(
       "exception/cutpath", "Whether to cut all path information from call traces, used e.g. in exceptions.", false);
 
   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.");
+  simgrid::config::bind_flag(_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", "./");
diff --git a/src/surf/plugins/host_dvfs.cpp b/src/surf/plugins/host_dvfs.cpp
index 3a24e60257..d141f54b3e 100644
--- a/src/surf/plugins/host_dvfs.cpp
+++ b/src/surf/plugins/host_dvfs.cpp
@@ -304,8 +304,8 @@ void sg_host_dvfs_plugin_init()
   sg_host_load_plugin_init();
 
   simgrid::s4u::Host::onCreation.connect(&on_host_added);
-  simgrid::config::declareFlag<double>(
+  simgrid::config::declare_flag<double>(
       property_sampling_rate, "How often should the dvfs plugin check whether the frequency needs to be changed?", 0.1);
-  simgrid::config::declareFlag<std::string>(
+  simgrid::config::declare_flag<std::string>(
       property_governor, "Which Governor should be used that adapts the CPU frequency?", "performance");
 }
diff --git a/src/xbt/config.cpp b/src/xbt/config.cpp
index a172a49155..8e7084e30a 100644
--- a/src/xbt/config.cpp
+++ b/src/xbt/config.cpp
@@ -386,24 +386,24 @@ void alias(const char* realname, std::initializer_list<const char*> aliases)
     simgrid_config->alias(realname, aliasname);
 }
 
-// ***** declareFlag *****
+// ***** declare_flag *****
 
 template <class T>
-XBT_PUBLIC void declareFlag(const char* name, const char* description, T value, std::function<void(const T&)> callback)
+XBT_PUBLIC void declare_flag(const char* name, const char* description, T value, std::function<void(const T&)> callback)
 {
   if (simgrid_config == nullptr)
     simgrid_config = xbt_cfg_new();
   simgrid_config->register_option<T>(name, description, std::move(value), std::move(callback));
 }
 
-template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value,
-                                     std::function<void(int const&)> callback);
-template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value,
-                                     std::function<void(double const&)> callback);
-template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value,
-                                     std::function<void(bool const&)> callback);
-template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value,
-                                     std::function<void(std::string const&)> callback);
+template XBT_PUBLIC void declare_flag(const char* name, const char* description, int value,
+                                      std::function<void(int const&)> callback);
+template XBT_PUBLIC void declare_flag(const char* name, const char* description, double value,
+                                      std::function<void(double const&)> callback);
+template XBT_PUBLIC void declare_flag(const char* name, const char* description, bool value,
+                                      std::function<void(bool const&)> callback);
+template XBT_PUBLIC void declare_flag(const char* name, const char* description, std::string value,
+                                      std::function<void(std::string const&)> callback);
 }
 }
 
@@ -684,9 +684,9 @@ static void make_set()
 {
   simgrid_config = nullptr;
   xbt_log_threshold_set(&_XBT_LOGV(xbt_cfg), xbt_log_priority_critical);
-  simgrid::config::declareFlag<int>("speed", "description", 0);
-  simgrid::config::declareFlag<std::string>("peername", "description", "");
-  simgrid::config::declareFlag<std::string>("user", "description", "");
+  simgrid::config::declare_flag<int>("speed", "description", 0);
+  simgrid::config::declare_flag<std::string>("peername", "description", "");
+  simgrid::config::declare_flag<std::string>("user", "description", "");
 }                               /* end_of_make_set */
 
 XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set")