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