Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cosmetics in cluster parsing
[simgrid.git] / 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 #include "simgrid_config.h" /* what was compiled in? */
22 #if HAVE_SMPI
23 #include "smpi/smpi_interface.h"
24 #endif
25 #include "mc/mc.h"
26 #include "src/mc/mc_record.h"
27 #include "simgrid/instr.h"
28 #include "src/mc/mc_replay.h"
29
30 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config, surf, "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 #if 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 #if 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 #if 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 #if 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 #if HAVE_UCONTEXT_CONTEXTS
698       dflt_ctx_fact = "ucontext";
699       p += sprintf(p, ", %s", dflt_ctx_fact);
700 #endif
701 #if 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(_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 #if 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", "yes");
762
763 #if 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 out of 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 #if 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   } else {
938     XBT_WARN("Call to sg_config_init() after initialization ignored");
939   }
940 }
941
942 void sg_config_finalize(void)
943 {
944   if (!_sg_cfg_init_status)
945     return;                     /* Not initialized yet. Nothing to do */
946
947   xbt_cfg_free(&_sg_cfg_set);
948   _sg_cfg_init_status = 0;
949 }
950
951 int sg_cfg_is_default_value(const char *name)
952 {
953   return xbt_cfg_is_default_value(_sg_cfg_set, name);
954 }
955
956 int sg_cfg_get_int(const char* name)
957 {
958   return xbt_cfg_get_int(_sg_cfg_set, name);
959 }
960
961 double sg_cfg_get_double(const char* name)
962 {
963   return xbt_cfg_get_double(_sg_cfg_set, name);
964 }
965
966 char* sg_cfg_get_string(const char* name)
967 {
968   return xbt_cfg_get_string(_sg_cfg_set, name);
969 }
970
971 int sg_cfg_get_boolean(const char* name)
972 {
973   return xbt_cfg_get_boolean(_sg_cfg_set, name);
974 }
975
976 xbt_dynar_t sg_cfg_get_dynar(const char* name)
977 {
978   return xbt_cfg_get_dynar(_sg_cfg_set, name);
979 }