src/simgrid/sg_config.c

   1 /* Copyright (c) 2009-2010, 2012-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 /* sg_config: configuration infrastructure for the simulation world       */
   8
   9 #include "xbt/misc.h"
  10 #include "xbt/config.h"
  11 #include "xbt/log.h"
  12 #include "xbt/mallocator.h"
  13 #include "xbt/str.h"
  14 #include "xbt/lib.h"
  15 #include "xbt/sysdep.h"
  16 #include "surf/surf.h"
  17 #include "surf/maxmin.h"
  18 #include "instr/instr_interface.h"
  19 #include "simgrid/simix.h"
  20 #include "simgrid/sg_config.h"
  21 #ifdef HAVE_SMPI
  22 #include "smpi/smpi_interface.h"
  23 #endif
  24 #include "mc/mc.h"
  25 #include "src/mc/mc_record.h"
  26 #include "simgrid/instr.h"
  27 #include "src/mc/mc_replay.h"
  28
  29 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config, surf,
  30                                 "About the configuration of SimGrid");
  31
  32 xbt_cfg_t _sg_cfg_set = NULL;
  33
  34 /* 0: beginning of time (config cannot be changed yet);
  35  * 1: initialized: cfg_set created (config can now be changed);
  36  * 2: configured: command line parsed and config part of platform file was
  37  *    integrated also, platform construction ongoing or done.
  38  *    (Config cannot be changed anymore!)
  39  */
  40 int _sg_cfg_init_status = 0;
  41
  42 /* instruct the upper layer (simix or simdag) to exit as soon as possible
  43  */
  44 int _sg_cfg_exit_asap = 0;
  45
  46 #define sg_cfg_exit_early() do { _sg_cfg_exit_asap = 1; return; } while (0)
  47
  48 /* Parse the command line, looking for options */
  49 static void sg_config_cmd_line(int *argc, char **argv)
  50 {
  51   int shall_exit = 0;
  52   int i, j;
  53   char *opt;
  54
  55   for (j = i = 1; i < *argc; i++) {
  56     if (!strncmp(argv[i], "--cfg=", strlen("--cfg="))) {
  57       opt = strchr(argv[i], '=');
  58       opt++;
  59
  60       xbt_cfg_set_parse(_sg_cfg_set, opt);
  61       XBT_DEBUG("Did apply '%s' as config setting", opt);
  62     } else if (!strcmp(argv[i], "--version")) {
  63       printf("%s\n", SIMGRID_VERSION_STRING);
  64       shall_exit = 1;
  65     } else if (!strcmp(argv[i], "--cfg-help") || !strcmp(argv[i], "--help")) {
  66       printf
  67           ("Description of the configuration accepted by this simulator:\n");
  68       xbt_cfg_help(_sg_cfg_set);
  69       printf(
  70 "\n"
  71 "Each of these configurations can be used by adding\n"
  72 "    --cfg=<option name>:<option value>\n"
  73 "to the command line.\n"
  74 "\n"
  75 "You can also use --help-models to see the details of all models known by this simulator.\n"
  76 "\n"
  77 "You can also use --help-tracing to see the details of all tracing options known by this simulator.\n"
  78 "\n"
  79 "You can also use --help-logs and --help-log-categories to see the details of logging output.\n"
  80 "\n"
  81 "You can also use --version to get SimGrid version information.\n"
  82 "\n"
  83         );
  84       shall_exit = 1;
  85     } else if (!strcmp(argv[i], "--help-models")) {
  86       int k;
  87
  88       model_help("host", surf_host_model_description);
  89       printf("\n");
  90       model_help("CPU", surf_cpu_model_description);
  91       printf("\n");
  92       model_help("network", surf_network_model_description);
  93       printf("\nLong description of all optimization levels accepted by the models of this simulator:\n");
  94       for (k = 0; surf_optimization_mode_description[k].name; k++)
  95         printf("  %s: %s\n",
  96                surf_optimization_mode_description[k].name,
  97                surf_optimization_mode_description[k].description);
  98       printf("Both network and CPU models have 'Lazy' as default optimization level\n\n");
  99       shall_exit = 1;
 100     } else if (!strcmp(argv[i], "--help-tracing")) {
 101       TRACE_help (1);
 102       shall_exit = 1;
 103     } else {
 104       argv[j++] = argv[i];
 105     }
 106   }
 107   if (j < *argc) {
 108     argv[j] = NULL;
 109     *argc = j;
 110   }
 111   if (shall_exit)
 112     sg_cfg_exit_early();
 113 }
 114
 115 /* callback of the plugin variable */
 116 static void _sg_cfg_cb__plugin(const char *name, int pos)
 117 {
 118   char *val;
 119
 120   XBT_VERB("PLUGIN");
 121   xbt_assert(_sg_cfg_init_status < 2,
 122               "Cannot load a plugin after the initialization");
 123
 124   val = xbt_cfg_get_string(_sg_cfg_set, name);
 125
 126   if (!strcmp(val, "help")) {
 127     model_help("plugin", surf_plugin_description);
 128     sg_cfg_exit_early();
 129   }
 130
 131   /* New Module missing */
 132   int plugin_id = find_model_description(surf_plugin_description, val);
 133   surf_plugin_description[plugin_id].model_init_preparse();
 134 }
 135
 136 /* callback of the host/model variable */
 137 static void _sg_cfg_cb__host_model(const char *name, int pos)
 138 {
 139   char *val;
 140
 141   xbt_assert(_sg_cfg_init_status < 2,
 142               "Cannot change the model after the initialization");
 143
 144   val = xbt_cfg_get_string(_sg_cfg_set, name);
 145
 146   if (!strcmp(val, "help")) {
 147     model_help("host", surf_host_model_description);
 148     sg_cfg_exit_early();
 149   }
 150
 151   /* Make sure that the model exists */
 152   find_model_description(surf_host_model_description, val);
 153 }
 154
 155 /* callback of the vm/model variable */
 156 static void _sg_cfg_cb__vm_model(const char *name, int pos)
 157 {
 158   char *val;
 159
 160   xbt_assert(_sg_cfg_init_status < 2,
 161               "Cannot change the model after the initialization");
 162
 163   val = xbt_cfg_get_string(_sg_cfg_set, name);
 164
 165   if (!strcmp(val, "help")) {
 166     model_help("vm", surf_vm_model_description);
 167     sg_cfg_exit_early();
 168   }
 169
 170   /* Make sure that the model exists */
 171   find_model_description(surf_vm_model_description, val);
 172 }
 173
 174 /* callback of the cpu/model variable */
 175 static void _sg_cfg_cb__cpu_model(const char *name, int pos)
 176 {
 177   char *val;
 178
 179   xbt_assert(_sg_cfg_init_status < 2,
 180               "Cannot change the model after the initialization");
 181
 182   val = xbt_cfg_get_string(_sg_cfg_set, name);
 183
 184   if (!strcmp(val, "help")) {
 185     model_help("CPU", surf_cpu_model_description);
 186     sg_cfg_exit_early();
 187   }
 188
 189   /* New Module missing */
 190   find_model_description(surf_cpu_model_description, val);
 191 }
 192
 193 /* callback of the cpu/model variable */
 194 static void _sg_cfg_cb__optimization_mode(const char *name, int pos)
 195 {
 196   char *val;
 197
 198   xbt_assert(_sg_cfg_init_status < 2,
 199               "Cannot change the model after the initialization");
 200
 201   val = xbt_cfg_get_string(_sg_cfg_set, name);
 202
 203   if (!strcmp(val, "help")) {
 204     model_help("optimization", surf_optimization_mode_description);
 205     sg_cfg_exit_early();
 206   }
 207
 208   /* New Module missing */
 209   find_model_description(surf_optimization_mode_description, val);
 210 }
 211
 212 /* callback of the cpu/model variable */
 213 static void _sg_cfg_cb__storage_mode(const char *name, int pos)
 214 {
 215   char *val;
 216
 217   xbt_assert(_sg_cfg_init_status < 2,
 218               "Cannot change the model after the initialization");
 219
 220   val = xbt_cfg_get_string(_sg_cfg_set, name);
 221
 222   if (!strcmp(val, "help")) {
 223     model_help("storage", surf_storage_model_description);
 224     sg_cfg_exit_early();
 225   }
 226
 227   /* New Module missing */
 228   find_model_description(surf_storage_model_description, val);
 229 }
 230
 231 /* callback of the network_model variable */
 232 static void _sg_cfg_cb__network_model(const char *name, int pos)
 233 {
 234   char *val;
 235
 236   xbt_assert(_sg_cfg_init_status < 2,
 237               "Cannot change the model after the initialization");
 238
 239   val = xbt_cfg_get_string(_sg_cfg_set, name);
 240
 241   if (!strcmp(val, "help")) {
 242     model_help("network", surf_network_model_description);
 243     sg_cfg_exit_early();
 244   }
 245
 246   /* New Module missing */
 247   find_model_description(surf_network_model_description, val);
 248 }
 249
 250 /* callbacks of the network models values */
 251 static void _sg_cfg_cb__tcp_gamma(const char *name, int pos)
 252 {
 253   sg_tcp_gamma = xbt_cfg_get_double(_sg_cfg_set, name);
 254 }
 255
 256 static void _sg_cfg_cb__maxmin_precision(const char* name, int pos)
 257 {
 258   sg_maxmin_precision = xbt_cfg_get_double(_sg_cfg_set, name);
 259 }
 260
 261 static void _sg_cfg_cb__surf_precision(const char* name, int pos)
 262 {
 263   sg_surf_precision = xbt_cfg_get_double(_sg_cfg_set, name);
 264 }
 265
 266 static void _sg_cfg_cb__sender_gap(const char* name, int pos)
 267 {
 268   sg_sender_gap = xbt_cfg_get_double(_sg_cfg_set, name);
 269 }
 270
 271 static void _sg_cfg_cb__latency_factor(const char *name, int pos)
 272 {
 273   sg_latency_factor = xbt_cfg_get_double(_sg_cfg_set, name);
 274 }
 275
 276 static void _sg_cfg_cb__bandwidth_factor(const char *name, int pos)
 277 {
 278   sg_bandwidth_factor = xbt_cfg_get_double(_sg_cfg_set, name);
 279 }
 280
 281 static void _sg_cfg_cb__weight_S(const char *name, int pos)
 282 {
 283   sg_weight_S_parameter = xbt_cfg_get_double(_sg_cfg_set, name);
 284 }
 285
 286 #ifdef HAVE_SMPI
 287 /* callback of the mpi collectives */
 288 static void _sg_cfg_cb__coll(const char *category,
 289                              s_mpi_coll_description_t * table,
 290                              const char *name, int pos)
 291 {
 292   char *val;
 293
 294   xbt_assert(_sg_cfg_init_status < 2,
 295               "Cannot change the model after the initialization");
 296
 297   val = xbt_cfg_get_string(_sg_cfg_set, name);
 298
 299   if (!strcmp(val, "help")) {
 300     coll_help(category, table);
 301     sg_cfg_exit_early();
 302   }
 303
 304   /* New Module missing */
 305   find_coll_description(table, val, category);
 306 }
 307 static void _sg_cfg_cb__coll_gather(const char *name, int pos){
 308   _sg_cfg_cb__coll("gather", mpi_coll_gather_description, name, pos);
 309 }
 310 static void _sg_cfg_cb__coll_allgather(const char *name, int pos){
 311   _sg_cfg_cb__coll("allgather", mpi_coll_allgather_description, name, pos);
 312 }
 313 static void _sg_cfg_cb__coll_allgatherv(const char *name, int pos){
 314   _sg_cfg_cb__coll("allgatherv", mpi_coll_allgatherv_description, name, pos);
 315 }
 316 static void _sg_cfg_cb__coll_allreduce(const char *name, int pos)
 317 {
 318   _sg_cfg_cb__coll("allreduce", mpi_coll_allreduce_description, name, pos);
 319 }
 320 static void _sg_cfg_cb__coll_alltoall(const char *name, int pos)
 321 {
 322   _sg_cfg_cb__coll("alltoall", mpi_coll_alltoall_description, name, pos);
 323 }
 324 static void _sg_cfg_cb__coll_alltoallv(const char *name, int pos)
 325 {
 326   _sg_cfg_cb__coll("alltoallv", mpi_coll_alltoallv_description, name, pos);
 327 }
 328 static void _sg_cfg_cb__coll_bcast(const char *name, int pos)
 329 {
 330   _sg_cfg_cb__coll("bcast", mpi_coll_bcast_description, name, pos);
 331 }
 332 static void _sg_cfg_cb__coll_reduce(const char *name, int pos)
 333 {
 334   _sg_cfg_cb__coll("reduce", mpi_coll_reduce_description, name, pos);
 335 }
 336 static void _sg_cfg_cb__coll_reduce_scatter(const char *name, int pos){
 337   _sg_cfg_cb__coll("reduce_scatter", mpi_coll_reduce_scatter_description, name, pos);
 338 }
 339 static void _sg_cfg_cb__coll_scatter(const char *name, int pos){
 340   _sg_cfg_cb__coll("scatter", mpi_coll_scatter_description, name, pos);
 341 }
 342 static void _sg_cfg_cb__coll_barrier(const char *name, int pos){
 343   _sg_cfg_cb__coll("barrier", mpi_coll_barrier_description, name, pos);
 344 }
 345
 346 static void _sg_cfg_cb__wtime_sleep(const char *name, int pos){
 347   smpi_wtime_sleep = xbt_cfg_get_double(_sg_cfg_set, name);
 348 }
 349
 350 static void _sg_cfg_cb__iprobe_sleep(const char *name, int pos){
 351   smpi_iprobe_sleep = xbt_cfg_get_double(_sg_cfg_set, name);
 352 }
 353
 354 static void _sg_cfg_cb__test_sleep(const char *name, int pos){
 355   smpi_test_sleep = xbt_cfg_get_double(_sg_cfg_set, name);
 356 }
 357
 358
 359
 360 #endif
 361
 362 /* callback of the inclusion path */
 363 static void _sg_cfg_cb__surf_path(const char *name, int pos)
 364 {
 365   char *path = xbt_cfg_get_string_at(_sg_cfg_set, name, pos);
 366   xbt_dynar_push(surf_path, &path);
 367 }
 368
 369 /* callback to decide if we want to use the model-checking */
 370 #include "src/xbt_modinter.h"
 371
 372 #ifdef HAVE_MC
 373 extern int _sg_do_model_check;   /* this variable lives in xbt_main until I find a right location for it */
 374 extern int _sg_do_model_check_record;
 375 #endif
 376
 377 static void _sg_cfg_cb_model_check_replay(const char *name, int pos) {
 378   MC_record_path = xbt_cfg_get_string(_sg_cfg_set, name);
 379 }
 380
 381 #ifdef HAVE_MC
 382 static void _sg_cfg_cb_model_check_record(const char *name, int pos) {
 383   _sg_do_model_check_record = xbt_cfg_get_boolean(_sg_cfg_set, name);
 384 }
 385 #endif
 386
 387 extern int _sg_do_verbose_exit;
 388
 389 static void _sg_cfg_cb_verbose_exit(const char *name, int pos)
 390 {
 391   _sg_do_verbose_exit = xbt_cfg_get_boolean(_sg_cfg_set, name);
 392 }
 393
 394 extern int _sg_do_clean_atexit;
 395
 396 static void _sg_cfg_cb_clean_atexit(const char *name, int pos)
 397 {
 398   _sg_do_clean_atexit = xbt_cfg_get_boolean(_sg_cfg_set, name);
 399 }
 400
 401 static void _sg_cfg_cb_context_factory(const char *name, int pos)
 402 {
 403   smx_context_factory_name = xbt_cfg_get_string(_sg_cfg_set, name);
 404 }
 405
 406 static void _sg_cfg_cb_context_stack_size(const char *name, int pos)
 407 {
 408   smx_context_stack_size_was_set = 1;
 409   smx_context_stack_size = xbt_cfg_get_int(_sg_cfg_set, name) * 1024;
 410 }
 411
 412 static void _sg_cfg_cb_context_guard_size(const char *name, int pos)
 413 {
 414   smx_context_guard_size_was_set = 1;
 415   smx_context_guard_size = xbt_cfg_get_int(_sg_cfg_set, name) * xbt_pagesize;
 416 }
 417
 418 static void _sg_cfg_cb_contexts_nthreads(const char *name, int pos)
 419 {
 420   SIMIX_context_set_nthreads(xbt_cfg_get_int(_sg_cfg_set, name));
 421 }
 422
 423 static void _sg_cfg_cb_contexts_parallel_threshold(const char *name, int pos)
 424 {
 425   SIMIX_context_set_parallel_threshold(xbt_cfg_get_int(_sg_cfg_set, name));
 426 }
 427
 428 static void _sg_cfg_cb_contexts_parallel_mode(const char *name, int pos)
 429 {
 430   const char* mode_name = xbt_cfg_get_string(_sg_cfg_set, name);
 431   if (!strcmp(mode_name, "posix")) {
 432     SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX);
 433   }
 434   else if (!strcmp(mode_name, "futex")) {
 435     SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX);
 436   }
 437   else if (!strcmp(mode_name, "busy_wait")) {
 438     SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT);
 439   }
 440   else {
 441     xbt_die("Command line setting of the parallel synchronization mode should "
 442             "be one of \"posix\", \"futex\" or \"busy_wait\"");
 443   }
 444 }
 445
 446 static void _sg_cfg_cb__surf_network_coordinates(const char *name,
 447                                                  int pos)
 448 {
 449   static int already_set = 0;
 450   int val = xbt_cfg_get_boolean(_sg_cfg_set, name);
 451   if (val) {
 452     if (!already_set) {
 453       COORD_HOST_LEVEL = sg_host_extension_create(xbt_dynar_free_voidp);
 454       COORD_ASR_LEVEL  = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp);
 455     }
 456     already_set = 1;
 457   } else
 458     if (already_set)
 459       xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
 460 }
 461
 462 static void _sg_cfg_cb__surf_network_crosstraffic(const char *name,
 463                                                   int pos)
 464 {
 465   sg_network_crosstraffic = xbt_cfg_get_boolean(_sg_cfg_set, name);
 466 }
 467
 468 /* build description line with possible values */
 469 static void describe_model(char *result,
 470                            const s_surf_model_description_t model_description[],
 471                            const char *name,
 472                            const char *description)
 473 {
 474   char *p = result +
 475     sprintf(result, "%s. Possible values: %s", description,
 476             model_description[0].name ? model_description[0].name : "n/a");
 477   int i;
 478   for (i = 1; model_description[i].name; i++)
 479     p += sprintf(p, ", %s", model_description[i].name);
 480   sprintf(p,
 481       ".\n       (use 'help' as a value to see the long description of each %s)",
 482           name);
 483 }
 484
 485 /* create the config set, register what should be and parse the command line*/
 486 void sg_config_init(int *argc, char **argv)
 487 {
 488   char description[1024];
 489
 490   /* Create the configuration support */
 491   if (_sg_cfg_init_status == 0) { /* Only create stuff if not already inited */
 492
 493     /* Plugins configuration */
 494     describe_model(description, surf_plugin_description,
 495                    "plugin", "The plugins");
 496     xbt_cfg_register(&_sg_cfg_set, "plugin", description,
 497                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__plugin, NULL);
 498
 499     describe_model(description, surf_cpu_model_description,
 500                    "model", "The model to use for the CPU");
 501     xbt_cfg_register(&_sg_cfg_set, "cpu/model", description,
 502                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__cpu_model, NULL);
 503     xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/model", "Cas01");
 504
 505     describe_model(description, surf_optimization_mode_description,
 506                    "optimization mode",
 507                    "The optimization modes to use for the CPU");
 508     xbt_cfg_register(&_sg_cfg_set, "cpu/optim", description,
 509                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
 510     xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/optim", "Lazy");
 511
 512     describe_model(description, surf_storage_model_description,
 513                    "model", "The model to use for the storage");
 514     xbt_cfg_register(&_sg_cfg_set, "storage/model", description,
 515                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__storage_mode, NULL);
 516     xbt_cfg_setdefault_string(_sg_cfg_set, "storage/model", "default");
 517
 518     describe_model(description, surf_network_model_description,
 519                    "model", "The model to use for the network");
 520     xbt_cfg_register(&_sg_cfg_set, "network/model", description,
 521                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__network_model, NULL);
 522     xbt_cfg_setdefault_string(_sg_cfg_set, "network/model", "LV08");
 523
 524     describe_model(description, surf_optimization_mode_description,
 525                    "optimization mode",
 526                    "The optimization modes to use for the network");
 527     xbt_cfg_register(&_sg_cfg_set, "network/optim", description,
 528                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
 529     xbt_cfg_setdefault_string(_sg_cfg_set, "network/optim", "Lazy");
 530
 531     describe_model(description, surf_host_model_description,
 532                    "model", "The model to use for the host");
 533     xbt_cfg_register(&_sg_cfg_set, "host/model", description,
 534                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__host_model, NULL);
 535     xbt_cfg_setdefault_string(_sg_cfg_set, "host/model", "default");
 536
 537     describe_model(description, surf_vm_model_description,
 538                    "model", "The model to use for the vm");
 539     xbt_cfg_register(&_sg_cfg_set, "vm/model", description,
 540                      xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__vm_model, NULL);
 541     xbt_cfg_setdefault_string(_sg_cfg_set, "vm/model", "default");
 542
 543     xbt_cfg_register(&_sg_cfg_set, "network/TCP_gamma",
 544                      "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)",
 545                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__tcp_gamma, NULL);
 546     xbt_cfg_setdefault_double(_sg_cfg_set, "network/TCP_gamma", 4194304.0);
 547
 548     xbt_cfg_register(&_sg_cfg_set, "surf/precision",
 549                      "Numerical precision used when updating simulation times (hence this value is expressed in seconds)",
 550                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__surf_precision, NULL);
 551     xbt_cfg_setdefault_double(_sg_cfg_set, "surf/precision", 0.00001);
 552
 553     xbt_cfg_register(&_sg_cfg_set, "maxmin/precision",
 554                      "Numerical precision used when computing resource sharing (hence this value is expressed in ops/sec or bytes/sec)",
 555                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__maxmin_precision, NULL);
 556     xbt_cfg_setdefault_double(_sg_cfg_set, "maxmin/precision", 0.00001);
 557
 558     /* The parameters of network models */
 559
 560     xbt_cfg_register(&_sg_cfg_set, "network/sender_gap",
 561                      "Minimum gap between two overlapping sends",
 562                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__sender_gap, NULL);
 563     /* real default for "network/sender_gap" is set in network_smpi.cpp */
 564     xbt_cfg_setdefault_double(_sg_cfg_set, "network/sender_gap", NAN);
 565
 566     xbt_cfg_register(&_sg_cfg_set, "network/latency_factor",
 567                      "Correction factor to apply to the provided latency (default value set by network model)",
 568                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__latency_factor, NULL);
 569     xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
 570
 571     xbt_cfg_register(&_sg_cfg_set, "network/bandwidth_factor",
 572                      "Correction factor to apply to the provided bandwidth (default value set by network model)",
 573                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__bandwidth_factor, NULL);
 574     xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor", 1.0);
 575
 576     xbt_cfg_register(&_sg_cfg_set, "network/weight_S",
 577                      "Correction factor to apply to the weight of competing streams (default value set by network model)",
 578                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__weight_S, NULL);
 579     /* real default for "network/weight_S" is set in network_*.cpp */
 580     xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", NAN);
 581
 582     /* Inclusion path */
 583     xbt_cfg_register(&_sg_cfg_set, "path",
 584                      "Lookup path for inclusions in platform and deployment XML files",
 585                      xbt_cfgelm_string, 1, 0, _sg_cfg_cb__surf_path, NULL);
 586
 587     xbt_cfg_register(&_sg_cfg_set, "cpu/maxmin_selective_update",
 588                      "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
 589                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 590     xbt_cfg_setdefault_boolean(_sg_cfg_set, "cpu/maxmin_selective_update", "no");
 591
 592     xbt_cfg_register(&_sg_cfg_set, "network/maxmin_selective_update",
 593                      "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
 594                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 595     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/maxmin_selective_update", "no");
 596
 597     /* Replay (this part is enabled even if MC it disabled) */
 598     xbt_cfg_register(&_sg_cfg_set, "model-check/replay",
 599       "Uenable replay mode with the given path",
 600       xbt_cfgelm_string, 0, 1, _sg_cfg_cb_model_check_replay, NULL);
 601
 602 #ifdef HAVE_MC
 603     /* do model-checking-record */
 604     xbt_cfg_register(&_sg_cfg_set, "model-check/record",
 605                      "Record the model-checking paths",
 606                      xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_model_check_record, NULL);
 607     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/record", "no");
 608
 609     /* do stateful model-checking */
 610     xbt_cfg_register(&_sg_cfg_set, "model-check/checkpoint",
 611                      "Specify the amount of steps between checkpoints during stateful model-checking (default: 0 => stateless verification). "
 612                      "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.",
 613                      xbt_cfgelm_int, 1, 1, _mc_cfg_cb_checkpoint, NULL);
 614     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/checkpoint", 0);
 615
 616     /* do stateful model-checking */
 617     xbt_cfg_register(&_sg_cfg_set, "model-check/sparse_checkpoint",
 618                      "Use sparse per-page snapshots.",
 619                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_sparse_checkpoint, NULL);
 620     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/sparse_checkpoint", "no");
 621
 622     /* do stateful model-checking */
 623     xbt_cfg_register(&_sg_cfg_set, "model-check/soft-dirty",
 624                      "Use sparse per-page snapshots.",
 625                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_soft_dirty, NULL);
 626     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/soft-dirty", "no");
 627
 628     xbt_cfg_register(&_sg_cfg_set, "model-check/ksm",
 629                      "Kernel same-page merging",
 630                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_ksm, NULL);
 631     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/ksm", "no");
 632
 633     /* do liveness model-checking */
 634     xbt_cfg_register(&_sg_cfg_set, "model-check/property",
 635                      "Specify the name of the file containing the property. It must be the result of the ltl2ba program.",
 636                      xbt_cfgelm_string, 1, 1, _mc_cfg_cb_property, NULL);
 637     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/property", "");
 638
 639     /* do communications determinism model-checking */
 640     xbt_cfg_register(&_sg_cfg_set, "model-check/communications_determinism",
 641                      "Enable/disable the detection of determinism in the communications schemes",
 642                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_comms_determinism, NULL);
 643     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/communications_determinism", "no");
 644
 645     /* do send determinism model-checking */
 646     xbt_cfg_register(&_sg_cfg_set, "model-check/send_determinism",
 647                      "Enable/disable the detection of send-determinism in the communications schemes",
 648                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_send_determinism, NULL);
 649     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/send_determinism", "no");
 650
 651     /* Specify the kind of model-checking reduction */
 652     xbt_cfg_register(&_sg_cfg_set, "model-check/reduction",
 653                      "Specify the kind of exploration reduction (either none or DPOR)",
 654                      xbt_cfgelm_string, 1, 1, _mc_cfg_cb_reduce, NULL);
 655     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/reduction", "dpor");
 656
 657     /* Enable/disable timeout for wait requests with model-checking */
 658     xbt_cfg_register(&_sg_cfg_set, "model-check/timeout",
 659                      "Enable/Disable timeout for wait requests",
 660                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_timeout, NULL);
 661     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/timeout", "no");
 662
 663     /* Enable/disable global hash computation with model-checking */
 664     xbt_cfg_register(&_sg_cfg_set, "model-check/hash",
 665                      "Enable/Disable state hash for state comparison (exprimental)",
 666                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_hash, NULL);
 667     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/hash", "no");
 668
 669     /* Set max depth exploration */
 670     /* Currently, this option cannot be used. */
 671     xbt_cfg_register(&_sg_cfg_set, "model-check/snapshot_fds",
 672                      "Whether file descriptors must be snapshoted",
 673                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_snapshot_fds, NULL);
 674     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/snapshot_fds", "no");
 675
 676     /* Set max depth exploration */
 677     xbt_cfg_register(&_sg_cfg_set, "model-check/max_depth",
 678                      "Specify the max depth of exploration (default : 1000)",
 679                      xbt_cfgelm_int, 1, 1, _mc_cfg_cb_max_depth, NULL);
 680     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/max_depth", 1000);
 681
 682     /* Set number of visited state stored for state comparison reduction*/
 683     xbt_cfg_register(&_sg_cfg_set, "model-check/visited",
 684                      "Specify the number of visited state stored for state comparison reduction. If value=5, the last 5 visited states are stored",
 685                      xbt_cfgelm_int, 1, 1, _mc_cfg_cb_visited, NULL);
 686     xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/visited", 0);
 687
 688     /* Set file name for dot output of graph state */
 689     xbt_cfg_register(&_sg_cfg_set, "model-check/dot_output",
 690                      "Specify the name of dot file corresponding to graph state",
 691                      xbt_cfgelm_string, 1, 1, _mc_cfg_cb_dot_output, NULL);
 692     xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/dot_output", "");
 693
 694      /* Enable/disable non progressive cycles detection with model-checking */
 695     xbt_cfg_register(&_sg_cfg_set, "model-check/termination",
 696                      "Enable/Disable non progressive cycle detection",
 697                      xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_termination, NULL);
 698     xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/termination", "no");
 699 #endif
 700
 701     /* do verbose-exit */
 702     xbt_cfg_register(&_sg_cfg_set, "verbose-exit",
 703                      "Activate the \"do nothing\" mode in Ctrl-C",
 704                      xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_verbose_exit, NULL);
 705     xbt_cfg_setdefault_boolean(_sg_cfg_set, "verbose-exit", "yes");
 706
 707     /* context factory */
 708     const char *dflt_ctx_fact = "thread";
 709     {
 710       char *p = description +
 711         sprintf(description,
 712                 "Context factory to use in SIMIX. Possible values: %s",
 713                 dflt_ctx_fact);
 714 #ifdef HAVE_UCONTEXT_CONTEXTS
 715       dflt_ctx_fact = "ucontext";
 716       p += sprintf(p, ", %s", dflt_ctx_fact);
 717 #endif
 718 #ifdef HAVE_RAW_CONTEXTS
 719       dflt_ctx_fact = "raw";
 720       p += sprintf(p, ", %s", dflt_ctx_fact);
 721 #endif
 722       sprintf(p, ".");
 723     }
 724     xbt_cfg_register(&_sg_cfg_set, "contexts/factory", description,
 725                      xbt_cfgelm_string, 1, 1, _sg_cfg_cb_context_factory, NULL);
 726     xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/factory", dflt_ctx_fact);
 727
 728     /* stack size of contexts in KiB */
 729     xbt_cfg_register(&_sg_cfg_set, "contexts/stack_size",
 730                      "Stack size of contexts in KiB",
 731                      xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_stack_size, NULL);
 732     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/stack_size", 8*1024);
 733     /* No, it was not set yet (the above setdefault() changed this to 1). */
 734     smx_context_stack_size_was_set = 0;
 735
 736     /* guard size for contexts stacks in memory pages */
 737     xbt_cfg_register(&_sg_cfg_set, "contexts/guard_size",
 738                      "Guard size for contexts stacks in memory pages",
 739                      xbt_cfgelm_int, 1, 1, _sg_cfg_cb_context_guard_size, NULL);
 740 #if defined(_XBT_WIN32) || (PTH_STACKGROWTH != -1)
 741     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/guard_size", 0);
 742 #else
 743     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/guard_size", 1);
 744 #endif
 745     /* No, it was not set yet (the above setdefault() changed this to 1). */
 746     smx_context_guard_size_was_set = 0;
 747
 748     /* number of parallel threads for user processes */
 749     xbt_cfg_register(&_sg_cfg_set, "contexts/nthreads",
 750                      "Number of parallel threads used to execute user contexts",
 751                      xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_nthreads, NULL);
 752     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/nthreads", 1);
 753
 754     /* minimal number of user contexts to be run in parallel */
 755     xbt_cfg_register(&_sg_cfg_set, "contexts/parallel_threshold",
 756                      "Minimal number of user contexts to be run in parallel (raw contexts only)",
 757                      xbt_cfgelm_int, 1, 1, _sg_cfg_cb_contexts_parallel_threshold, NULL);
 758     xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/parallel_threshold", 2);
 759
 760     /* synchronization mode for parallel user contexts */
 761     xbt_cfg_register(&_sg_cfg_set, "contexts/synchro",
 762                      "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)",
 763                      xbt_cfgelm_string, 1, 1, _sg_cfg_cb_contexts_parallel_mode, NULL);
 764 #ifdef HAVE_FUTEX_H
 765     xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/synchro", "futex");
 766 #else //No futex on mac and posix is unimplememted yet
 767     xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/synchro", "busy_wait");
 768 #endif
 769
 770     xbt_cfg_register(&_sg_cfg_set, "network/coordinates",
 771                      "\"yes\" or \"no\", specifying whether we use a coordinate-based routing (as Vivaldi)",
 772                      xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_coordinates, NULL);
 773     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/coordinates", "no");
 774
 775     xbt_cfg_register(&_sg_cfg_set, "network/crosstraffic",
 776                      "Activate the interferences between uploads and downloads for fluid max-min models (LV08, CM02)",
 777                      xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb__surf_network_crosstraffic, NULL);
 778     xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "no");
 779
 780 #ifdef HAVE_NS3
 781     xbt_cfg_register(&_sg_cfg_set, "ns3/TcpModel",
 782                      "The ns3 tcp model can be : NewReno or Reno or Tahoe",
 783                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 784     xbt_cfg_setdefault_string(_sg_cfg_set, "ns3/TcpModel", "default");
 785 #endif
 786
 787     //For smpi/bw_factor and smpi/lat_factor
 788     //Default value have to be "threshold0:value0;threshold1:value1;...;thresholdN:valueN"
 789     //test is if( size >= thresholdN ) return valueN;
 790     //Values can be modified with command line --cfg=smpi/bw_factor:"threshold0:value0;threshold1:value1;...;thresholdN:valueN"
 791     //  or with tag config put line <prop id="smpi/bw_factor" value="threshold0:value0;threshold1:value1;...;thresholdN:valueN"></prop>
 792     // SMPI model can be used without enable_smpi, so keep this the ifdef.
 793     xbt_cfg_register(&_sg_cfg_set, "smpi/bw_factor",
 794                      "Bandwidth factors for smpi.",
 795                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 796     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");
 797
 798     xbt_cfg_register(&_sg_cfg_set, "smpi/lat_factor",
 799                      "Latency factors for smpi.",
 800                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 801     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");
 802
 803     xbt_cfg_register(&_sg_cfg_set, "smpi/IB_penalty_factors",
 804                      "Correction factor to communications using Infiniband model with contention (default value based on Stampede cluster profiling)",
 805                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 806     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/IB_penalty_factors", "0.965;0.925;1.35");
 807
 808 #ifdef HAVE_SMPI
 809     xbt_cfg_register(&_sg_cfg_set, "smpi/running_power",
 810                      "Power of the host running the simulation (in flop/s). Used to bench the operations.",
 811                      xbt_cfgelm_double, 1, 1, NULL, NULL);
 812     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/running_power", 20000.0);
 813
 814     xbt_cfg_register(&_sg_cfg_set, "smpi/display_timing",
 815                      "Boolean indicating whether we should display the timing after simulation.",
 816                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 817     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/display_timing", "no");
 818
 819     xbt_cfg_register(&_sg_cfg_set, "smpi/simulate_computation",
 820                      "Boolean indicating whether the computational part of the simulated application should be simulated.",
 821                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 822     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/simulate_computation", "yes");
 823
 824     xbt_cfg_register(&_sg_cfg_set, "smpi/use_shared_malloc",
 825                      "Boolean indicating whether we should use shared memory when using SMPI_SHARED_MALLOC. Allows user to disable it for debug purposes.",
 826                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 827     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/use_shared_malloc", "yes");
 828
 829     xbt_cfg_register(&_sg_cfg_set, "smpi/cpu_threshold",
 830                      "Minimal computation time (in seconds) not discarded, or -1 for infinity.",
 831                      xbt_cfgelm_double, 1, 1, NULL, NULL);
 832     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/cpu_threshold", 1e-6);
 833
 834     xbt_cfg_register(&_sg_cfg_set, "smpi/async_small_thresh",
 835                      "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver",
 836                      xbt_cfgelm_int, 1, 1, NULL, NULL);
 837     xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/async_small_thresh", 0);
 838
 839     xbt_cfg_register(&_sg_cfg_set, "smpi/send_is_detached_thresh",
 840                      "Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend",
 841                      xbt_cfgelm_int, 1, 1, NULL, NULL);
 842     xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/send_is_detached_thresh", 65536);
 843
 844     xbt_cfg_register(&_sg_cfg_set, "smpi/privatize_global_variables",
 845                      "Boolean indicating whether we should privatize global variable at runtime.",
 846                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 847     xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/privatize_global_variables", "no");
 848
 849     xbt_cfg_register(&_sg_cfg_set, "smpi/os",
 850                      "Small messages timings (MPI_Send minimum time for small messages)",
 851                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 852     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/os", "1:0:0:0:0");
 853
 854     xbt_cfg_register(&_sg_cfg_set, "smpi/ois",
 855                      "Small messages timings (MPI_Isend minimum time for small messages)",
 856                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 857     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/ois", "1:0:0:0:0");
 858
 859     xbt_cfg_register(&_sg_cfg_set, "smpi/or",
 860                      "Small messages timings (MPI_Recv minimum time for small messages)",
 861                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 862     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/or", "1:0:0:0:0");
 863
 864     xbt_cfg_register(&_sg_cfg_set, "smpi/iprobe",
 865                      "Minimum time to inject inside a call to MPI_Iprobe",
 866                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__iprobe_sleep, NULL);
 867     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/iprobe", 1e-4);
 868
 869     xbt_cfg_register(&_sg_cfg_set, "smpi/test",
 870                      "Minimum time to inject inside a call to MPI_Test",
 871                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__test_sleep, NULL);
 872     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/test", 1e-4);
 873
 874     xbt_cfg_register(&_sg_cfg_set, "smpi/wtime",
 875                      "Minimum time to inject inside a call to MPI_Wtime",
 876                      xbt_cfgelm_double, 1, 1, _sg_cfg_cb__wtime_sleep, NULL);
 877     xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/wtime", 0.0);
 878
 879     xbt_cfg_register(&_sg_cfg_set, "smpi/coll_selector",
 880                      "Which collective selector to use",
 881                      xbt_cfgelm_string, 1, 1, NULL, NULL);
 882     xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/coll_selector", "default");
 883
 884     xbt_cfg_register(&_sg_cfg_set, "smpi/gather",
 885                      "Which collective to use for gather",
 886                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_gather, NULL);
 887
 888     xbt_cfg_register(&_sg_cfg_set, "smpi/allgather",
 889                      "Which collective to use for allgather",
 890                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgather, NULL);
 891
 892     xbt_cfg_register(&_sg_cfg_set, "smpi/barrier",
 893                      "Which collective to use for barrier",
 894                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_barrier, NULL);
 895
 896     xbt_cfg_register(&_sg_cfg_set, "smpi/reduce_scatter",
 897                      "Which collective to use for reduce_scatter",
 898                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce_scatter, NULL);
 899
 900     xbt_cfg_register(&_sg_cfg_set, "smpi/scatter",
 901                      "Which collective to use for scatter",
 902                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_scatter, NULL);
 903
 904     xbt_cfg_register(&_sg_cfg_set, "smpi/allgatherv",
 905                      "Which collective to use for allgatherv",
 906                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allgatherv, NULL);
 907
 908     xbt_cfg_register(&_sg_cfg_set, "smpi/allreduce",
 909                      "Which collective to use for allreduce",
 910                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_allreduce, NULL);
 911
 912     xbt_cfg_register(&_sg_cfg_set, "smpi/alltoall",
 913                      "Which collective to use for alltoall",
 914                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoall, NULL);
 915
 916     xbt_cfg_register(&_sg_cfg_set, "smpi/alltoallv",
 917                      "Which collective to use for alltoallv",
 918                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_alltoallv, NULL);
 919
 920     xbt_cfg_register(&_sg_cfg_set, "smpi/bcast",
 921                      "Which collective to use for bcast",
 922                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_bcast, NULL);
 923
 924     xbt_cfg_register(&_sg_cfg_set, "smpi/reduce",
 925                      "Which collective to use for reduce",
 926                      xbt_cfgelm_string, 0, 1, &_sg_cfg_cb__coll_reduce, NULL);
 927 #endif // HAVE_SMPI
 928
 929     xbt_cfg_register(&_sg_cfg_set, "exception/cutpath",
 930                      "\"yes\" or \"no\". \"yes\" will cut all path information from call traces, used e.g. in exceptions.",
 931                      xbt_cfgelm_boolean, 1, 1, NULL, NULL);
 932     xbt_cfg_setdefault_boolean(_sg_cfg_set, "exception/cutpath", "no");
 933
 934     xbt_cfg_register(&_sg_cfg_set, "clean_atexit",
 935                      "\"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.",
 936                      xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_clean_atexit, NULL);
 937     xbt_cfg_setdefault_boolean(_sg_cfg_set, "clean_atexit", "yes");
 938
 939     if (!surf_path) {
 940       /* retrieves the current directory of the current process */
 941       const char *initial_path = __surf_get_initial_path();
 942       xbt_assert((initial_path),
 943                   "__surf_get_initial_path() failed! Can't resolve current Windows directory");
 944
 945       surf_path = xbt_dynar_new(sizeof(char *), NULL);
 946       xbt_cfg_setdefault_string(_sg_cfg_set, "path", initial_path);
 947     }
 948
 949     xbt_cfg_check(_sg_cfg_set);
 950     _sg_cfg_init_status = 1;
 951
 952     sg_config_cmd_line(argc, argv);
 953
 954     xbt_mallocator_initialization_is_done(SIMIX_context_is_parallel());
 955
 956   } else {
 957     XBT_WARN("Call to sg_config_init() after initialization ignored");
 958   }
 959 }
 960
 961 void sg_config_finalize(void)
 962 {
 963   if (!_sg_cfg_init_status)
 964     return;                     /* Not initialized yet. Nothing to do */
 965
 966   xbt_cfg_free(&_sg_cfg_set);
 967   _sg_cfg_init_status = 0;
 968 }
 969
 970 /* Pick the right models for CPU, net and host, and call their model_init_preparse */
 971 void surf_config_models_setup()
 972 {
 973   const char *host_model_name;
 974   const char *vm_model_name;
 975   int host_id = -1;
 976   int vm_id = -1;
 977   char *network_model_name = NULL;
 978   char *cpu_model_name = NULL;
 979   int storage_id = -1;
 980   char *storage_model_name = NULL;
 981
 982   host_model_name = xbt_cfg_get_string(_sg_cfg_set, "host/model");
 983   vm_model_name = xbt_cfg_get_string(_sg_cfg_set, "vm/model");
 984   network_model_name = xbt_cfg_get_string(_sg_cfg_set, "network/model");
 985   cpu_model_name = xbt_cfg_get_string(_sg_cfg_set, "cpu/model");
 986   storage_model_name = xbt_cfg_get_string(_sg_cfg_set, "storage/model");
 987
 988   /* Check whether we use a net/cpu model differing from the default ones, in which case
 989    * we should switch to the "compound" host model to correctly dispatch stuff to
 990    * the right net/cpu models.
 991    */
 992
 993   if ((!xbt_cfg_is_default_value(_sg_cfg_set, "network/model") ||
 994        !xbt_cfg_is_default_value(_sg_cfg_set, "cpu/model")) &&
 995       xbt_cfg_is_default_value(_sg_cfg_set, "host/model")) {
 996     host_model_name = "compound";
 997     xbt_cfg_set_string(_sg_cfg_set, "host/model", host_model_name);
 998   }
 999
1000   XBT_DEBUG("host model: %s", host_model_name);
1001   host_id = find_model_description(surf_host_model_description, host_model_name);
1002   if (!strcmp(host_model_name, "compound")) {
1003     int network_id = -1;
1004     int cpu_id = -1;
1005
1006     xbt_assert(cpu_model_name,
1007                 "Set a cpu model to use with the 'compound' host model");
1008
1009     xbt_assert(network_model_name,
1010                 "Set a network model to use with the 'compound' host model");
1011
1012     if(surf_cpu_model_init_preparse){
1013       surf_cpu_model_init_preparse();
1014     } else {
1015       cpu_id =
1016           find_model_description(surf_cpu_model_description, cpu_model_name);
1017       surf_cpu_model_description[cpu_id].model_init_preparse();
1018     }
1019
1020     network_id =
1021         find_model_description(surf_network_model_description,
1022                                network_model_name);
1023     surf_network_model_description[network_id].model_init_preparse();
1024   }
1025
1026   XBT_DEBUG("Call host_model_init");
1027   surf_host_model_description[host_id].model_init_preparse();
1028
1029   XBT_DEBUG("Call vm_model_init");
1030   vm_id = find_model_description(surf_vm_model_description, vm_model_name);
1031   surf_vm_model_description[vm_id].model_init_preparse();
1032
1033   XBT_DEBUG("Call storage_model_init");
1034   storage_id = find_model_description(surf_storage_model_description, storage_model_name);
1035   surf_storage_model_description[storage_id].model_init_preparse();
1036
1037 }
1038
1039 int sg_cfg_is_default_value(const char *name)
1040 {
1041   return xbt_cfg_is_default_value(_sg_cfg_set, name);
1042 }
1043
1044 int sg_cfg_get_int(const char* name)
1045 {
1046   return xbt_cfg_get_int(_sg_cfg_set, name);
1047 }
1048
1049 double sg_cfg_get_double(const char* name)
1050 {
1051   return xbt_cfg_get_double(_sg_cfg_set, name);
1052 }
1053
1054 char* sg_cfg_get_string(const char* name)
1055 {
1056   return xbt_cfg_get_string(_sg_cfg_set, name);
1057 }
1058
1059 int sg_cfg_get_boolean(const char* name)
1060 {
1061   return xbt_cfg_get_boolean(_sg_cfg_set, name);
1062 }
1063
1064 xbt_dynar_t sg_cfg_get_dynar(const char* name)
1065 {
1066   return xbt_cfg_get_dynar(_sg_cfg_set, name);
1067 }