src/surf/surf_config.c

   1 /* Copyright (c) 2009, 2010. 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 /* surf_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/str.h"
  13 #include "surf/surf_private.h"
  14 #include "surf/surf_routing.h"  /* COORD_HOST_LEVEL and COORD_ASR_LEVEL */
  15 #include "simgrid/simix.h"
  16 #include "mc/mc.h" /* configuration callbacks of model-checking */
  17
  18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config, surf,
  19                                 "About the configuration of surf (and the rest of the simulation)");
  20
  21 xbt_cfg_t _surf_cfg_set = NULL;
  22
  23 /* Parse the command line, looking for options */
  24 static void surf_config_cmd_line(int *argc, char **argv)
  25 {
  26   int shall_exit = 0;
  27   int i, j;
  28   char *opt;
  29
  30   for (j = i = 1; i < *argc; i++) {
  31     if (!strncmp(argv[i], "--cfg=", strlen("--cfg="))) {
  32       opt = strchr(argv[i], '=');
  33       opt++;
  34
  35       xbt_cfg_set_parse(_surf_cfg_set, opt);
  36       XBT_DEBUG("Did apply '%s' as config setting", opt);
  37     } else if (!strcmp(argv[i], "--cfg-help") || !strcmp(argv[i], "--help")) {
  38       printf
  39           ("Description of the configuration accepted by this simulator:\n");
  40       xbt_cfg_help(_surf_cfg_set);
  41       printf(
  42 "\n"
  43 "Each of these configurations can be used by adding\n"
  44 "    --cfg=<option name>:<option value>\n"
  45 "to the command line.\n"
  46 "You can also use --help-models to see the details of all models known by this simulator.\n"
  47 #ifdef HAVE_TRACING
  48 "\n"
  49 "You can also use --help-tracing to see the details of all tracing options known by this simulator.\n"
  50 #endif
  51 "\n"
  52 "You can also use --help-logs and --help-log-categories to see the details of logging output.\n"
  53 "\n"
  54         );
  55       shall_exit = 1;
  56     } else if (!strcmp(argv[i], "--help-models")) {
  57       int k;
  58
  59       model_help("workstation", surf_workstation_model_description);
  60       printf("\n");
  61       model_help("CPU", surf_cpu_model_description);
  62       printf("\n");
  63       model_help("network", surf_network_model_description);
  64       printf("\nLong description of all optimization levels accepted by the models of this simulator:\n");
  65       for (k = 0; surf_optimization_mode_description[k].name; k++)
  66         printf("  %s: %s\n",
  67                surf_optimization_mode_description[k].name,
  68                surf_optimization_mode_description[k].description);
  69       printf("Both network and CPU models have 'Lazy' as default optimization level\n\n");
  70       shall_exit = 1;
  71 #ifdef HAVE_TRACING
  72     } else if (!strcmp(argv[i], "--help-tracing")) {
  73       TRACE_help (1);
  74       shall_exit = 1;
  75 #endif
  76     } else {
  77       argv[j++] = argv[i];
  78     }
  79   }
  80   if (j < *argc) {
  81     argv[j] = NULL;
  82     *argc = j;
  83   }
  84   if (shall_exit)
  85     exit(0);
  86 }
  87
  88
  89 int _surf_init_status = 0;      /* 0: beginning of time (config cannot be changed yet);
  90                                    1: initialized: cfg_set created (config can now be changed);
  91                                    2: configured: command line parsed and config part of platform file was integrated also, platform construction ongoing or done.
  92                                       (Config cannot be changed anymore!) */
  93
  94 /* callback of the workstation/model variable */
  95 static void _surf_cfg_cb__workstation_model(const char *name, int pos)
  96 {
  97   char *val;
  98
  99   xbt_assert(_surf_init_status == 1,
 100               "Cannot change the model after the initialization");
 101
 102   val = xbt_cfg_get_string(_surf_cfg_set, name);
 103
 104   if (!strcmp(val, "help")) {
 105     model_help("workstation", surf_workstation_model_description);
 106     exit(0);
 107   }
 108
 109   /* Make sure that the model exists */
 110   find_model_description(surf_workstation_model_description, val);
 111 }
 112
 113 /* callback of the cpu/model variable */
 114 static void _surf_cfg_cb__cpu_model(const char *name, int pos)
 115 {
 116   char *val;
 117
 118   xbt_assert(_surf_init_status == 1,
 119               "Cannot change the model after the initialization");
 120
 121   val = xbt_cfg_get_string(_surf_cfg_set, name);
 122
 123   if (!strcmp(val, "help")) {
 124     model_help("CPU", surf_cpu_model_description);
 125     exit(0);
 126   }
 127
 128   /* New Module missing */
 129   find_model_description(surf_cpu_model_description, val);
 130 }
 131
 132 /* callback of the cpu/model variable */
 133 static void _surf_cfg_cb__optimization_mode(const char *name, int pos)
 134 {
 135   char *val;
 136
 137   xbt_assert(_surf_init_status == 1,
 138               "Cannot change the model after the initialization");
 139
 140   val = xbt_cfg_get_string(_surf_cfg_set, name);
 141
 142   if (!strcmp(val, "help")) {
 143     model_help("optimization", surf_optimization_mode_description);
 144     exit(0);
 145   }
 146
 147   /* New Module missing */
 148   find_model_description(surf_optimization_mode_description, val);
 149 }
 150
 151 /* callback of the cpu/model variable */
 152 static void _surf_cfg_cb__storage_mode(const char *name, int pos)
 153 {
 154   char *val;
 155
 156   xbt_assert(_surf_init_status == 1,
 157               "Cannot change the model after the initialization");
 158
 159   val = xbt_cfg_get_string(_surf_cfg_set, name);
 160
 161   if (!strcmp(val, "help")) {
 162     model_help("storage", surf_storage_model_description);
 163     exit(0);
 164   }
 165
 166   /* New Module missing */
 167   find_model_description(surf_storage_model_description, val);
 168 }
 169
 170 /* callback of the workstation_model variable */
 171 static void _surf_cfg_cb__network_model(const char *name, int pos)
 172 {
 173   char *val;
 174
 175   xbt_assert(_surf_init_status == 1,
 176               "Cannot change the model after the initialization");
 177
 178   val = xbt_cfg_get_string(_surf_cfg_set, name);
 179
 180   if (!strcmp(val, "help")) {
 181     model_help("network", surf_network_model_description);
 182     exit(0);
 183   }
 184
 185   /* New Module missing */
 186   find_model_description(surf_network_model_description, val);
 187 }
 188
 189
 190 /* callbacks of the network models values */
 191 static void _surf_cfg_cb__tcp_gamma(const char *name, int pos)
 192 {
 193   sg_tcp_gamma = xbt_cfg_get_double(_surf_cfg_set, name);
 194 }
 195
 196 static void _surf_cfg_cb__maxmin_precision(const char* name, int pos)
 197 {
 198   sg_maxmin_precision = xbt_cfg_get_double(_surf_cfg_set, name);
 199 }
 200
 201 static void _surf_cfg_cb__sender_gap(const char* name, int pos)
 202 {
 203   sg_sender_gap = xbt_cfg_get_double(_surf_cfg_set, name);
 204 }
 205
 206 static void _surf_cfg_cb__latency_factor(const char *name, int pos)
 207 {
 208   sg_latency_factor = xbt_cfg_get_double(_surf_cfg_set, name);
 209 }
 210
 211 static void _surf_cfg_cb__bandwidth_factor(const char *name, int pos)
 212 {
 213   sg_bandwidth_factor = xbt_cfg_get_double(_surf_cfg_set, name);
 214 }
 215
 216 static void _surf_cfg_cb__weight_S(const char *name, int pos)
 217 {
 218   sg_weight_S_parameter = xbt_cfg_get_double(_surf_cfg_set, name);
 219 }
 220
 221 /* callback of the inclusion path */
 222 static void _surf_cfg_cb__surf_path(const char *name, int pos)
 223 {
 224   char *path = xbt_cfg_get_string_at(_surf_cfg_set, name, pos);
 225   xbt_dynar_push(surf_path, &path);
 226 }
 227
 228 /* callback to decide if we want to use the model-checking */
 229 #include "xbt_modinter.h"
 230 extern int _surf_do_model_check;   /* this variable lives in xbt_main until I find a right location for it */
 231
 232 static void _surf_cfg_cb_model_check(const char *name, int pos)
 233 {
 234   _surf_do_model_check = xbt_cfg_get_int(_surf_cfg_set, name);
 235
 236 #ifndef HAVE_MC
 237   if (_surf_do_model_check) {
 238     xbt_die("You tried to activate the model-checking from the command line, but it was not compiled in. Change your settings in cmake, recompile and try again");
 239   }
 240 #endif
 241 }
 242
 243 extern int _surf_do_verbose_exit;
 244
 245 static void _surf_cfg_cb_verbose_exit(const char *name, int pos)
 246 {
 247   _surf_do_verbose_exit = xbt_cfg_get_int(_surf_cfg_set, name);
 248 }
 249
 250
 251 static void _surf_cfg_cb_context_factory(const char *name, int pos) {
 252   smx_context_factory_name = xbt_cfg_get_string(_surf_cfg_set, name);
 253 }
 254
 255 static void _surf_cfg_cb_context_stack_size(const char *name, int pos)
 256 {
 257   smx_context_stack_size = xbt_cfg_get_int(_surf_cfg_set, name) * 1024;
 258 }
 259
 260 static void _surf_cfg_cb_contexts_nthreads(const char *name, int pos)
 261 {
 262   SIMIX_context_set_nthreads(xbt_cfg_get_int(_surf_cfg_set, name));
 263 }
 264
 265 static void _surf_cfg_cb_contexts_parallel_threshold(const char *name, int pos)
 266 {
 267   SIMIX_context_set_parallel_threshold(xbt_cfg_get_int(_surf_cfg_set, name));
 268 }
 269
 270 static void _surf_cfg_cb_contexts_parallel_mode(const char *name, int pos)
 271 {
 272   const char* mode_name = xbt_cfg_get_string(_surf_cfg_set, name);
 273   if (!strcmp(mode_name, "posix")) {
 274     SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX);
 275   }
 276   else if (!strcmp(mode_name, "futex")) {
 277     SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX);
 278   }
 279   else if (!strcmp(mode_name, "busy_wait")) {
 280     SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT);
 281   }
 282   else {
 283     xbt_die("Command line setting of the parallel synchronization mode should "
 284         "be one of \"posix\", \"futex\" or \"busy_wait\"");
 285   }
 286 }
 287
 288 static void _surf_cfg_cb_surf_nthreads(const char *name, int pos)
 289 {
 290   surf_set_nthreads(xbt_cfg_get_int(_surf_cfg_set, name));
 291 }
 292
 293 static void _surf_cfg_cb__surf_network_coordinates(const char *name,
 294                                                    int pos)
 295 {
 296   char *val = xbt_cfg_get_string(_surf_cfg_set, name);
 297   if (!strcmp(val, "yes")) {
 298     if (!COORD_HOST_LEVEL) {
 299       COORD_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_dynar_free_voidp);
 300       COORD_ASR_LEVEL  = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp);
 301     }
 302   } else if (!strcmp(val, "no")) {
 303     if (COORD_HOST_LEVEL)
 304       xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
 305   } else {
 306     xbt_die("Command line setting of whether to use coordinates must be either \"yes\" or \"no\"");
 307   }
 308 }
 309
 310 static void _surf_cfg_cb__surf_network_crosstraffic(const char *name,
 311                                                   int pos)
 312 {
 313   sg_network_crosstraffic = xbt_cfg_get_int(_surf_cfg_set, name);
 314 }
 315
 316 #ifdef HAVE_GTNETS
 317 static void _surf_cfg_cb__gtnets_jitter(const char *name, int pos)
 318 {
 319   sg_gtnets_jitter = xbt_cfg_get_double(_surf_cfg_set, name);
 320 }
 321
 322 static void _surf_cfg_cb__gtnets_jitter_seed(const char *name, int pos)
 323 {
 324   sg_gtnets_jitter_seed = xbt_cfg_get_int(_surf_cfg_set, name);
 325 }
 326 #endif
 327
 328 /* create the config set, register what should be and parse the command line*/
 329 void surf_config_init(int *argc, char **argv)
 330 {
 331   char *description = xbt_malloc(1024), *p = description;
 332   char *default_value;
 333   double double_default_value;
 334   int default_value_int;
 335   int i;
 336
 337   /* Create the configuration support */
 338   if (_surf_init_status == 0) { /* Only create stuff if not already inited */
 339     sprintf(description,
 340             "The model to use for the CPU. Possible values: ");
 341     p = description;
 342     while (*(++p) != '\0');
 343     for (i = 0; surf_cpu_model_description[i].name; i++)
 344       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 345                    surf_cpu_model_description[i].name);
 346     sprintf(p,
 347             ".\n       (use 'help' as a value to see the long description of each model)");
 348     default_value = xbt_strdup("Cas01");
 349     xbt_cfg_register(&_surf_cfg_set, "cpu/model", description, xbt_cfgelm_string,
 350                      &default_value, 1, 1, &_surf_cfg_cb__cpu_model, NULL);
 351
 352     sprintf(description,
 353             "The optimization modes to use for the CPU. Possible values: ");
 354     p = description;
 355     while (*(++p) != '\0');
 356     for (i = 0; surf_optimization_mode_description[i].name; i++)
 357       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 358                    surf_optimization_mode_description[i].name);
 359     sprintf(p,
 360             ".\n       (use 'help' as a value to see the long description of each optimization mode)");
 361     default_value = xbt_strdup("Lazy");
 362     xbt_cfg_register(&_surf_cfg_set, "cpu/optim", description, xbt_cfgelm_string,
 363                      &default_value, 1, 1, &_surf_cfg_cb__optimization_mode, NULL);
 364
 365     sprintf(description,
 366             "The model to use for the storage. Possible values: ");
 367     p = description;
 368     while (*(++p) != '\0');
 369     for (i = 0; surf_storage_model_description[i].name; i++)
 370       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 371                    surf_storage_model_description[i].name);
 372     sprintf(p,
 373             ".\n       (use 'help' as a value to see the long description of each model)");
 374     default_value = xbt_strdup("default");
 375     xbt_cfg_register(&_surf_cfg_set, "storage/model", description, xbt_cfgelm_string,
 376                      &default_value, 1, 1, &_surf_cfg_cb__storage_mode,
 377                      NULL);
 378
 379     /* ********************************************************************* */
 380     /* TUTORIAL: New model                                                   */
 381     sprintf(description,
 382             "The model to use for the New model. Possible values: ");
 383     p = description;
 384     while (*(++p) != '\0');
 385     for (i = 0; surf_new_model_description[i].name; i++)
 386       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 387                    surf_new_model_description[i].name);
 388     sprintf(p,
 389             ".\n       (use 'help' as a value to see the long description of each model)");
 390     default_value = xbt_strdup("default");
 391     xbt_cfg_register(&_surf_cfg_set, "new_model/model", description, xbt_cfgelm_string,
 392                      &default_value, 1, 1, &_surf_cfg_cb__storage_mode,
 393                      NULL);
 394     /* ********************************************************************* */
 395
 396     sprintf(description,
 397             "The model to use for the network. Possible values: ");
 398     p = description;
 399     while (*(++p) != '\0');
 400     for (i = 0; surf_network_model_description[i].name; i++)
 401       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 402                    surf_network_model_description[i].name);
 403     sprintf(p,
 404             ".\n       (use 'help' as a value to see the long description of each model)");
 405     default_value = xbt_strdup("LV08");
 406     xbt_cfg_register(&_surf_cfg_set, "network/model", description, xbt_cfgelm_string,
 407                      &default_value, 1, 1, &_surf_cfg_cb__network_model,
 408                      NULL);
 409
 410     sprintf(description,
 411             "The optimization modes to use for the network. Possible values: ");
 412     p = description;
 413     while (*(++p) != '\0');
 414     for (i = 0; surf_optimization_mode_description[i].name; i++)
 415       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 416                    surf_optimization_mode_description[i].name);
 417     sprintf(p,
 418             ".\n       (use 'help' as a value to see the long description of each optimization mode)");
 419     default_value = xbt_strdup("Lazy");
 420     xbt_cfg_register(&_surf_cfg_set, "network/optim", description, xbt_cfgelm_string,
 421                      &default_value, 1, 1, &_surf_cfg_cb__optimization_mode, NULL);
 422
 423     sprintf(description,
 424             "The model to use for the workstation. Possible values: ");
 425     p = description;
 426     while (*(++p) != '\0');
 427     for (i = 0; surf_workstation_model_description[i].name; i++)
 428       p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
 429                    surf_workstation_model_description[i].name);
 430     sprintf(p,
 431             ".\n       (use 'help' as a value to see the long description of each model)");
 432     default_value = xbt_strdup("default");
 433     xbt_cfg_register(&_surf_cfg_set, "workstation/model", description, xbt_cfgelm_string,
 434                      &default_value, 1, 1,
 435                      &_surf_cfg_cb__workstation_model, NULL);
 436
 437     xbt_free(description);
 438
 439     xbt_cfg_register(&_surf_cfg_set, "network/TCP_gamma",
 440                      "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)",
 441                      xbt_cfgelm_double, NULL, 1, 1,
 442                      _surf_cfg_cb__tcp_gamma, NULL);
 443     xbt_cfg_setdefault_double(_surf_cfg_set, "network/TCP_gamma", 20000.0);
 444
 445     xbt_cfg_register(&_surf_cfg_set, "maxmin/precision",
 446                      "Numerical precision used when updating simulation models (epsilon in double comparisons)",
 447                      xbt_cfgelm_double, NULL, 1, 1, _surf_cfg_cb__maxmin_precision, NULL);
 448     xbt_cfg_setdefault_double(_surf_cfg_set, "maxmin/precision", 0.00001); // FIXME use setdefault everywhere here!
 449
 450     /* The parameters of network models */
 451
 452     double_default_value = 0.0;
 453     xbt_cfg_register(&_surf_cfg_set, "network/sender_gap",
 454                      "Minimum gap between two overlapping sends",
 455                      xbt_cfgelm_double, &double_default_value, 1, 1,
 456                      _surf_cfg_cb__sender_gap, NULL);
 457
 458     double_default_value = 1.0;
 459     xbt_cfg_register(&_surf_cfg_set, "network/latency_factor",
 460                      "Correction factor to apply to the provided latency (default value set by network model)",
 461                      xbt_cfgelm_double, &double_default_value, 1, 1,
 462                      _surf_cfg_cb__latency_factor, NULL);
 463     double_default_value = 1.0;
 464     xbt_cfg_register(&_surf_cfg_set, "network/bandwidth_factor",
 465                      "Correction factor to apply to the provided bandwidth (default value set by network model)",
 466                      xbt_cfgelm_double, &double_default_value, 1, 1,
 467                      _surf_cfg_cb__bandwidth_factor, NULL);
 468     double_default_value = 0.0;
 469     xbt_cfg_register(&_surf_cfg_set, "network/weight_S",
 470                      "Correction factor to apply to the weight of competing streams(default value set by network model)",
 471                      xbt_cfgelm_double, &double_default_value, 1, 1,
 472                      _surf_cfg_cb__weight_S, NULL);
 473
 474     /* Inclusion path */
 475     xbt_cfg_register(&_surf_cfg_set, "path",
 476                      "Lookup path for inclusions in platform and deployment XML files",
 477                      xbt_cfgelm_string, NULL, 0, 0,
 478                      _surf_cfg_cb__surf_path, NULL);
 479
 480     default_value_int = 0;
 481     xbt_cfg_register(&_surf_cfg_set, "cpu/maxmin_selective_update",
 482                      "Update the constraint set propagating recursively to others constraints (1 by default when optim is set to lazy)",
 483                      xbt_cfgelm_int, &default_value_int, 0, 1,
 484                      NULL, NULL);
 485     default_value_int = 0;
 486     xbt_cfg_register(&_surf_cfg_set, "network/maxmin_selective_update",
 487                      "Update the constraint set propagating recursively to others constraints (1 by default when optim is set to lazy)",
 488                      xbt_cfgelm_int, &default_value_int, 0, 1,
 489                      NULL, NULL);
 490
 491 #ifdef HAVE_MC
 492     /* do model-checking */
 493     default_value_int = 0;
 494     xbt_cfg_register(&_surf_cfg_set, "model-check",
 495                      "Verify the system through model-checking instead of simulating it (EXPERIMENTAL)",
 496                      xbt_cfgelm_int, &default_value_int, 0, 1,
 497                      _surf_cfg_cb_model_check, NULL);
 498
 499     /* do stateful model-checking */
 500     default_value_int = 0;
 501     xbt_cfg_register(&_surf_cfg_set, "model-check/checkpoint",
 502                      "Specify the amount of steps between checkpoints during stateful model-checking (default: 0 => stateless verification). "
 503                      "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.",
 504                      xbt_cfgelm_int, &default_value_int, 0, 1,
 505                      _mc_cfg_cb_checkpoint, NULL);
 506
 507     /* do liveness model-checking */
 508     default_value = xbt_strdup("");
 509     xbt_cfg_register(&_surf_cfg_set, "model-check/property",
 510                      "Specify the name of the file containing the property. It must be the result of the ltl2ba program.",
 511                      xbt_cfgelm_string, &default_value, 0, 1,
 512                      _mc_cfg_cb_property, NULL);
 513
 514     /* Specify the kind of model-checking reduction */
 515     default_value = xbt_strdup("unset");
 516     xbt_cfg_register(&_surf_cfg_set, "model-check/reduction",
 517                      "Specify the kind of exploration reduction (either none or DPOR)",
 518                      xbt_cfgelm_string, &default_value, 0, 1,
 519                      _mc_cfg_cb_reduce, NULL);
 520
 521     /* Enable/disable timeout for wait requests with model-checking */
 522     default_value_int = 1;
 523     xbt_cfg_register(&_surf_cfg_set, "model-check/timeout",
 524                      "Enable/Disable timeout for wait requests",
 525                      xbt_cfgelm_int, &default_value, 0, 1,
 526                      _mc_cfg_cb_timeout, NULL);
 527
 528     /* Set max depth exploration */
 529     default_value_int = 1000;
 530     xbt_cfg_register(&_surf_cfg_set, "model-check/max_depth",
 531                      "Specify the max depth of exploration (default : 1000)",
 532                      xbt_cfgelm_int, &default_value, 0, 1,
 533                      _mc_cfg_cb_max_depth, NULL);
 534
 535     /* Set number of visited state stored in stateful mode */
 536     default_value_int = 10;
 537     xbt_cfg_register(&_surf_cfg_set, "model-check/stateful",
 538                      "Specify the number of visited state stored in stateful mode. The default value is 10 which means that we only keep in memory the last 10 visited states",
 539                      xbt_cfgelm_int, &default_value, 0, 1,
 540                      _mc_cfg_cb_stateful, NULL);
 541 #endif
 542
 543     /* do verbose-exit */
 544     default_value_int = 1;
 545     xbt_cfg_register(&_surf_cfg_set, "verbose-exit",
 546                      "Activate the \"do nothing\" mode in Ctrl-C",
 547                      xbt_cfgelm_int, &default_value_int, 0, 1,
 548                      _surf_cfg_cb_verbose_exit, NULL);
 549
 550
 551     /* context factory */
 552     default_value = xbt_strdup("ucontext");
 553     xbt_cfg_register(&_surf_cfg_set, "contexts/factory",
 554                      "Context factory to use in SIMIX (ucontext, thread or raw)",
 555                      xbt_cfgelm_string, &default_value, 1, 1, _surf_cfg_cb_context_factory, NULL);
 556
 557     /* stack size of contexts in Ko */
 558     default_value_int = 128;
 559     xbt_cfg_register(&_surf_cfg_set, "contexts/stack_size",
 560                      "Stack size of contexts in Kib (ucontext or raw only)",
 561                      xbt_cfgelm_int, &default_value_int, 1, 1,
 562                      _surf_cfg_cb_context_stack_size, NULL);
 563
 564     /* number of parallel threads for user processes */
 565     default_value_int = 1;
 566     xbt_cfg_register(&_surf_cfg_set, "contexts/nthreads",
 567                      "Number of parallel threads used to execute user contexts",
 568                      xbt_cfgelm_int, &default_value_int, 1, 1,
 569                      _surf_cfg_cb_contexts_nthreads, NULL);
 570
 571     /* minimal number of user contexts to be run in parallel */
 572     default_value_int = 2;
 573     xbt_cfg_register(&_surf_cfg_set, "contexts/parallel_threshold",
 574         "Minimal number of user contexts to be run in parallel (raw contexts only)",
 575         xbt_cfgelm_int, &default_value_int, 1, 1,
 576         _surf_cfg_cb_contexts_parallel_threshold, NULL);
 577
 578     /* synchronization mode for parallel user contexts */
 579 #ifdef HAVE_FUTEX_H
 580     default_value = xbt_strdup("futex");
 581 #else //No futex on mac and posix is unimplememted yet
 582     default_value = xbt_strdup("busy_wait");
 583 #endif
 584     xbt_cfg_register(&_surf_cfg_set, "contexts/synchro",
 585         "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)",
 586         xbt_cfgelm_string, &default_value, 1, 1,
 587         _surf_cfg_cb_contexts_parallel_mode, NULL);
 588
 589     /* number of parallel threads for Surf */
 590     default_value_int = surf_get_nthreads();
 591     xbt_cfg_register(&_surf_cfg_set, "surf/nthreads",
 592                      "Number of parallel threads used to update Surf models",
 593                      xbt_cfgelm_int, &default_value_int, 1, 1,
 594                      _surf_cfg_cb_surf_nthreads, NULL);
 595
 596     default_value = xbt_strdup("no");
 597     xbt_cfg_register(&_surf_cfg_set, "network/coordinates",
 598                      "\"yes\" or \"no\", specifying whether we use a coordinate-based routing (as Vivaldi)",
 599                      xbt_cfgelm_string, &default_value, 1, 1,
 600                      _surf_cfg_cb__surf_network_coordinates, NULL);
 601     xbt_cfg_setdefault_string(_surf_cfg_set, "network/coordinates", default_value);
 602
 603     default_value_int = 0;
 604     xbt_cfg_register(&_surf_cfg_set, "network/crosstraffic",
 605                      "Activate the interferences between uploads and downloads for fluid max-min models (LV08, CM02)",
 606                      xbt_cfgelm_int, &default_value_int, 0, 1,
 607                      _surf_cfg_cb__surf_network_crosstraffic, NULL);
 608     xbt_cfg_setdefault_int(_surf_cfg_set, "network/crosstraffic", default_value_int);
 609
 610 #ifdef HAVE_GTNETS
 611     xbt_cfg_register(&_surf_cfg_set, "gtnets/jitter",
 612                      "Double value to oscillate the link latency, uniformly in random interval [-latency*gtnets_jitter,latency*gtnets_jitter)",
 613                      xbt_cfgelm_double, NULL, 1, 1,
 614                      _surf_cfg_cb__gtnets_jitter, NULL);
 615     xbt_cfg_setdefault_double(_surf_cfg_set, "gtnets/jitter", 0.0);
 616
 617     default_value_int = 10;
 618     xbt_cfg_register(&_surf_cfg_set, "gtnets/jitter_seed",
 619                      "Use a positive seed to reproduce jitted results, value must be in [1,1e8], default is 10",
 620                      xbt_cfgelm_int, &default_value_int, 0, 1,
 621                      _surf_cfg_cb__gtnets_jitter_seed, NULL);
 622 #endif
 623 #ifdef HAVE_NS3
 624     xbt_cfg_register(&_surf_cfg_set, "ns3/TcpModel",
 625                      "The ns3 tcp model can be : NewReno or Reno or Tahoe",
 626                      xbt_cfgelm_string, NULL, 1, 1,
 627                      NULL, NULL);
 628     xbt_cfg_setdefault_string(_surf_cfg_set, "ns3/TcpModel", "default");
 629 #endif
 630
 631 //SMPI
 632     double default_reference_speed = 20000.0;
 633     xbt_cfg_register(&_surf_cfg_set, "smpi/running_power",
 634                      "Power of the host running the simulation (in flop/s). Used to bench the operations.",
 635                      xbt_cfgelm_double, &default_reference_speed, 1, 1, NULL,
 636                      NULL);
 637
 638     int default_display_timing = 0;
 639     xbt_cfg_register(&_surf_cfg_set, "smpi/display_timing",
 640                      "Boolean indicating whether we should display the timing after simulation.",
 641                      xbt_cfgelm_int, &default_display_timing, 1, 1, NULL,
 642                      NULL);
 643
 644     double default_threshold = 1e-6;
 645     xbt_cfg_register(&_surf_cfg_set, "smpi/cpu_threshold",
 646                      "Minimal computation time (in seconds) not discarded.",
 647                      xbt_cfgelm_double, &default_threshold, 1, 1, NULL,
 648                      NULL);
 649
 650     int default_small_messages_threshold = 0;
 651     xbt_cfg_register(&_surf_cfg_set, "smpi/async_small_thres",
 652                      "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver",
 653                      xbt_cfgelm_int, &default_small_messages_threshold, 1, 1, NULL,
 654                      NULL);
 655
 656     //For smpi/bw_factor and smpi/lat_factor
 657     //Default value have to be "threshold0:value0;threshold1:value1;...;thresholdN:valueN"
 658     //test is if( size >= thresholdN ) return valueN;
 659     //Values can be modified with command line --cfg=smpi/bw_factor:"threshold0:value0;threshold1:value1;...;thresholdN:valueN"
 660     //  or with tag config put line <prop id="smpi/bw_factor" value="threshold0:value0;threshold1:value1;...;thresholdN:valueN"></prop>
 661     xbt_cfg_register(&_surf_cfg_set, "smpi/bw_factor",
 662                      "Bandwidth factors for smpi.",
 663                      xbt_cfgelm_string, NULL, 1, 1, NULL,
 664                      NULL);
 665     xbt_cfg_setdefault_string(_surf_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");
 666
 667     xbt_cfg_register(&_surf_cfg_set, "smpi/lat_factor",
 668                      "Latency factors for smpi.",
 669                      xbt_cfgelm_string, NULL, 1, 1, NULL,
 670                      NULL);
 671     xbt_cfg_setdefault_string(_surf_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");
 672 //END SMPI
 673
 674
 675     if (!surf_path) {
 676       /* retrieves the current directory of the        current process */
 677       const char *initial_path = __surf_get_initial_path();
 678       xbt_assert((initial_path),
 679                   "__surf_get_initial_path() failed! Can't resolves current Windows directory");
 680
 681       surf_path = xbt_dynar_new(sizeof(char *), NULL);
 682       xbt_cfg_setdefault_string(_surf_cfg_set, "path", initial_path);
 683     }
 684
 685     _surf_init_status = 1;
 686
 687     surf_config_cmd_line(argc, argv);
 688
 689   } else {
 690     XBT_WARN("Call to surf_config_init() after initialization ignored");
 691   }
 692 }
 693
 694 void surf_config_finalize(void)
 695 {
 696   if (!_surf_init_status)
 697     return;                     /* Not initialized yet. Nothing to do */
 698
 699   xbt_cfg_free(&_surf_cfg_set);
 700   _surf_init_status = 0;
 701 }
 702
 703 /* Pick the right models for CPU, net and workstation, and call their model_init_preparse */
 704 void surf_config_models_setup()
 705 {
 706   char *workstation_model_name;
 707   int workstation_id = -1;
 708   char *network_model_name = NULL;
 709   char *cpu_model_name = NULL;
 710   int storage_id = -1;
 711   char *storage_model_name = NULL;
 712
 713   workstation_model_name =
 714       xbt_cfg_get_string(_surf_cfg_set, "workstation/model");
 715   network_model_name = xbt_cfg_get_string(_surf_cfg_set, "network/model");
 716   cpu_model_name = xbt_cfg_get_string(_surf_cfg_set, "cpu/model");
 717   storage_model_name = xbt_cfg_get_string(_surf_cfg_set, "storage/model");
 718
 719   /* Check whether we use a net/cpu model differing from the default ones, in which case
 720    * we should switch to the "compound" workstation model to correctly dispatch stuff to
 721    * the right net/cpu models.
 722    */
 723
 724   if((!xbt_cfg_is_default_value(_surf_cfg_set, "network/model") ||
 725     !xbt_cfg_is_default_value(_surf_cfg_set, "cpu/model")) &&
 726     xbt_cfg_is_default_value(_surf_cfg_set, "workstation/model"))
 727   {
 728       const char *val = "compound";
 729       XBT_INFO
 730           ("Switching workstation model to compound since you changed the network and/or cpu model(s)");
 731       xbt_cfg_set_string(_surf_cfg_set, "workstation/model", val);
 732       workstation_model_name = (char *) "compound";
 733   }
 734
 735   XBT_DEBUG("Workstation model: %s", workstation_model_name);
 736   workstation_id =
 737       find_model_description(surf_workstation_model_description,
 738                              workstation_model_name);
 739   if (!strcmp(workstation_model_name, "compound")) {
 740     int network_id = -1;
 741     int cpu_id = -1;
 742
 743     xbt_assert(cpu_model_name,
 744                 "Set a cpu model to use with the 'compound' workstation model");
 745
 746     xbt_assert(network_model_name,
 747                 "Set a network model to use with the 'compound' workstation model");
 748
 749     network_id =
 750         find_model_description(surf_network_model_description,
 751                                network_model_name);
 752     cpu_id =
 753         find_model_description(surf_cpu_model_description, cpu_model_name);
 754
 755     surf_cpu_model_description[cpu_id].model_init_preparse();
 756     surf_network_model_description[network_id].model_init_preparse();
 757   }
 758
 759   XBT_DEBUG("Call workstation_model_init");
 760   surf_workstation_model_description[workstation_id].model_init_preparse();
 761
 762   XBT_DEBUG("Call storage_model_init");
 763   storage_id = find_model_description(surf_storage_model_description, storage_model_name);
 764   surf_storage_model_description[storage_id].model_init_preparse();
 765
 766   /* ********************************************************************* */
 767   /* TUTORIAL: New model                                                   */
 768   int new_model_id = -1;
 769   char *new_model_name = NULL;
 770   new_model_name = xbt_cfg_get_string(_surf_cfg_set, "new_model/model");
 771   XBT_DEBUG("Call new model_init");
 772   new_model_id = find_model_description(surf_new_model_description, new_model_name);
 773   surf_new_model_description[new_model_id].model_init_preparse();
 774   /* ********************************************************************* */
 775 }