1 /* Copyright (c) 2009-2010, 2012-2015. The SimGrid Team.
2 * All rights reserved. */
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. */
7 /* sg_config: configuration infrastructure for the simulation world */
10 #include "xbt/config.h"
12 #include "xbt/mallocator.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"
22 #include "smpi/smpi_interface.h"
25 #include "src/mc/mc_record.h"
26 #include "simgrid/instr.h"
27 #include "src/mc/mc_replay.h"
29 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config, surf,
30 "About the configuration of SimGrid");
32 xbt_cfg_t _sg_cfg_set = NULL;
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!)
40 int _sg_cfg_init_status = 0;
42 /* instruct the upper layer (simix or simdag) to exit as soon as possible */
43 int _sg_cfg_exit_asap = 0;
45 #define sg_cfg_exit_early() do { _sg_cfg_exit_asap = 1; return; } while (0)
47 /* Parse the command line, looking for options */
48 static void sg_config_cmd_line(int *argc, char **argv)
54 for (j = i = 1; i < *argc; i++) {
55 if (!strncmp(argv[i], "--cfg=", strlen("--cfg="))) {
56 opt = strchr(argv[i], '=');
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);
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);
69 "Each of these configurations can be used by adding\n"
70 " --cfg=<option name>:<option value>\n"
71 "to the command line.\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"
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");
87 } else if (!strcmp(argv[i], "--help-models")) {
90 model_help("host", surf_host_model_description);
92 model_help("CPU", surf_cpu_model_description);
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++)
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");
102 } else if (!strcmp(argv[i], "--help-tracing")) {
117 /* callback of the plugin variable */
118 static void _sg_cfg_cb__plugin(const char *name, int pos)
123 xbt_assert(_sg_cfg_init_status < 2,
124 "Cannot load a plugin after the initialization");
126 val = xbt_cfg_get_string(_sg_cfg_set, name);
128 if (!strcmp(val, "help")) {
129 model_help("plugin", surf_plugin_description);
133 /* New Module missing */
134 int plugin_id = find_model_description(surf_plugin_description, val);
135 surf_plugin_description[plugin_id].model_init_preparse();
138 /* callback of the host/model variable */
139 static void _sg_cfg_cb__host_model(const char *name, int pos)
143 xbt_assert(_sg_cfg_init_status < 2,
144 "Cannot change the model after the initialization");
146 val = xbt_cfg_get_string(_sg_cfg_set, name);
148 if (!strcmp(val, "help")) {
149 model_help("host", surf_host_model_description);
153 /* Make sure that the model exists */
154 find_model_description(surf_host_model_description, val);
157 /* callback of the vm/model variable */
158 static void _sg_cfg_cb__vm_model(const char *name, int pos)
162 xbt_assert(_sg_cfg_init_status < 2,
163 "Cannot change the model after the initialization");
165 val = xbt_cfg_get_string(_sg_cfg_set, name);
167 if (!strcmp(val, "help")) {
168 model_help("vm", surf_vm_model_description);
172 /* Make sure that the model exists */
173 find_model_description(surf_vm_model_description, val);
176 /* callback of the cpu/model variable */
177 static void _sg_cfg_cb__cpu_model(const char *name, int pos)
181 xbt_assert(_sg_cfg_init_status < 2,
182 "Cannot change the model after the initialization");
184 val = xbt_cfg_get_string(_sg_cfg_set, name);
186 if (!strcmp(val, "help")) {
187 model_help("CPU", surf_cpu_model_description);
191 /* New Module missing */
192 find_model_description(surf_cpu_model_description, val);
195 /* callback of the cpu/model variable */
196 static void _sg_cfg_cb__optimization_mode(const char *name, int pos)
200 xbt_assert(_sg_cfg_init_status < 2,
201 "Cannot change the model after the initialization");
203 val = xbt_cfg_get_string(_sg_cfg_set, name);
205 if (!strcmp(val, "help")) {
206 model_help("optimization", surf_optimization_mode_description);
210 /* New Module missing */
211 find_model_description(surf_optimization_mode_description, val);
214 /* callback of the cpu/model variable */
215 static void _sg_cfg_cb__storage_mode(const char *name, int pos)
219 xbt_assert(_sg_cfg_init_status < 2,
220 "Cannot change the model after the initialization");
222 val = xbt_cfg_get_string(_sg_cfg_set, name);
224 if (!strcmp(val, "help")) {
225 model_help("storage", surf_storage_model_description);
229 /* New Module missing */
230 find_model_description(surf_storage_model_description, val);
233 /* callback of the network_model variable */
234 static void _sg_cfg_cb__network_model(const char *name, int pos)
238 xbt_assert(_sg_cfg_init_status < 2,
239 "Cannot change the model after the initialization");
241 val = xbt_cfg_get_string(_sg_cfg_set, name);
243 if (!strcmp(val, "help")) {
244 model_help("network", surf_network_model_description);
248 /* New Module missing */
249 find_model_description(surf_network_model_description, val);
252 /* callbacks of the network models values */
253 static void _sg_cfg_cb__tcp_gamma(const char *name, int pos)
255 sg_tcp_gamma = xbt_cfg_get_double(_sg_cfg_set, name);
258 static void _sg_cfg_cb__maxmin_precision(const char* name, int pos)
260 sg_maxmin_precision = xbt_cfg_get_double(_sg_cfg_set, name);
263 static void _sg_cfg_cb__surf_precision(const char* name, int pos)
265 sg_surf_precision = xbt_cfg_get_double(_sg_cfg_set, name);
268 static void _sg_cfg_cb__sender_gap(const char* name, int pos)
270 sg_sender_gap = xbt_cfg_get_double(_sg_cfg_set, name);
273 static void _sg_cfg_cb__latency_factor(const char *name, int pos)
275 sg_latency_factor = xbt_cfg_get_double(_sg_cfg_set, name);
278 static void _sg_cfg_cb__bandwidth_factor(const char *name, int pos)
280 sg_bandwidth_factor = xbt_cfg_get_double(_sg_cfg_set, name);
283 static void _sg_cfg_cb__weight_S(const char *name, int pos)
285 sg_weight_S_parameter = xbt_cfg_get_double(_sg_cfg_set, name);
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)
296 xbt_assert(_sg_cfg_init_status < 2,
297 "Cannot change the model after the initialization");
299 val = xbt_cfg_get_string(_sg_cfg_set, name);
301 if (!strcmp(val, "help")) {
302 coll_help(category, table);
306 /* New Module missing */
307 find_coll_description(table, val, category);
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);
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);
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);
318 static void _sg_cfg_cb__coll_allreduce(const char *name, int pos)
320 _sg_cfg_cb__coll("allreduce", mpi_coll_allreduce_description, name, pos);
322 static void _sg_cfg_cb__coll_alltoall(const char *name, int pos)
324 _sg_cfg_cb__coll("alltoall", mpi_coll_alltoall_description, name, pos);
326 static void _sg_cfg_cb__coll_alltoallv(const char *name, int pos)
328 _sg_cfg_cb__coll("alltoallv", mpi_coll_alltoallv_description, name, pos);
330 static void _sg_cfg_cb__coll_bcast(const char *name, int pos)
332 _sg_cfg_cb__coll("bcast", mpi_coll_bcast_description, name, pos);
334 static void _sg_cfg_cb__coll_reduce(const char *name, int pos)
336 _sg_cfg_cb__coll("reduce", mpi_coll_reduce_description, name, pos);
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);
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);
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);
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);
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);
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);
364 /* callback of the inclusion path */
365 static void _sg_cfg_cb__surf_path(const char *name, int pos)
367 char *path = xbt_strdup(xbt_cfg_get_string_at(_sg_cfg_set, name, pos));
368 xbt_dynar_push(surf_path, &path);
371 /* callback to decide if we want to use the model-checking */
372 #include "src/xbt_modinter.h"
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;
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);
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);
389 extern int _sg_do_verbose_exit;
391 static void _sg_cfg_cb_verbose_exit(const char *name, int pos)
393 _sg_do_verbose_exit = xbt_cfg_get_boolean(_sg_cfg_set, name);
396 extern int _sg_do_clean_atexit;
398 static void _sg_cfg_cb_clean_atexit(const char *name, int pos)
400 _sg_do_clean_atexit = xbt_cfg_get_boolean(_sg_cfg_set, name);
403 static void _sg_cfg_cb_context_factory(const char *name, int pos)
405 smx_context_factory_name = xbt_cfg_get_string(_sg_cfg_set, name);
408 static void _sg_cfg_cb_context_stack_size(const char *name, int pos)
410 smx_context_stack_size_was_set = 1;
411 smx_context_stack_size = xbt_cfg_get_int(_sg_cfg_set, name) * 1024;
414 static void _sg_cfg_cb_context_guard_size(const char *name, int pos)
416 smx_context_guard_size_was_set = 1;
417 smx_context_guard_size = xbt_cfg_get_int(_sg_cfg_set, name) * xbt_pagesize;
420 static void _sg_cfg_cb_contexts_nthreads(const char *name, int pos)
422 SIMIX_context_set_nthreads(xbt_cfg_get_int(_sg_cfg_set, name));
425 static void _sg_cfg_cb_contexts_parallel_threshold(const char *name, int pos)
427 SIMIX_context_set_parallel_threshold(xbt_cfg_get_int(_sg_cfg_set, name));
430 static void _sg_cfg_cb_contexts_parallel_mode(const char *name, int pos)
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);
436 else if (!strcmp(mode_name, "futex")) {
437 SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX);
439 else if (!strcmp(mode_name, "busy_wait")) {
440 SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT);
443 xbt_die("Command line setting of the parallel synchronization mode should "
444 "be one of \"posix\", \"futex\" or \"busy_wait\"");
448 static void _sg_cfg_cb__surf_network_coordinates(const char *name,
451 static int already_set = 0;
452 int val = xbt_cfg_get_boolean(_sg_cfg_set, name);
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);
461 xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
464 static void _sg_cfg_cb__surf_network_crosstraffic(const char *name,
467 sg_network_crosstraffic = xbt_cfg_get_boolean(_sg_cfg_set, name);
470 /* build description line with possible values */
471 static void describe_model(char *result,
472 const s_surf_model_description_t model_description[],
474 const char *description)
477 sprintf(result, "%s. Possible values: %s", description,
478 model_description[0].name ? model_description[0].name : "n/a");
480 for (i = 1; model_description[i].name; i++)
481 p += sprintf(p, ", %s", model_description[i].name);
483 ".\n (use 'help' as a value to see the long description of each %s)",
487 /* create the config set, register what should be and parse the command line*/
488 void sg_config_init(int *argc, char **argv)
490 char description[1024];
492 /* Create the configuration support */
493 if (_sg_cfg_init_status == 0) { /* Only create stuff if not already inited */
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, NULL);
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, NULL);
503 xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/model", "Cas01");
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, NULL);
507 xbt_cfg_setdefault_string(_sg_cfg_set, "cpu/optim", "Lazy");
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, NULL);
511 xbt_cfg_setdefault_string(_sg_cfg_set, "storage/model", "default");
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, NULL);
515 xbt_cfg_setdefault_string(_sg_cfg_set, "network/model", "LV08");
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, NULL);
519 xbt_cfg_setdefault_string(_sg_cfg_set, "network/optim", "Lazy");
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, NULL);
523 xbt_cfg_setdefault_string(_sg_cfg_set, "host/model", "default");
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, NULL);
527 xbt_cfg_setdefault_string(_sg_cfg_set, "vm/model", "default");
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, NULL);
532 xbt_cfg_setdefault_double(_sg_cfg_set, "network/TCP_gamma", 4194304.0);
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, NULL);
536 xbt_cfg_setdefault_double(_sg_cfg_set, "surf/precision", 0.00001);
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, NULL);
541 xbt_cfg_setdefault_double(_sg_cfg_set, "maxmin/precision", 0.00001);
543 /* The parameters of network models */
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, NULL);
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);
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, NULL);
553 xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
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, NULL);
558 xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor", 1.0);
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, NULL);
563 /* real default for "network/weight_S" is set in network_*.cpp */
564 xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", NAN);
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, NULL);
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, NULL);
574 xbt_cfg_setdefault_boolean(_sg_cfg_set, "cpu/maxmin_selective_update", "no");
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, NULL);
579 xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/maxmin_selective_update", "no");
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, NULL);
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, NULL);
590 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/record", "no");
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, NULL);
597 xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/checkpoint", 0);
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, NULL);
603 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/sparse_checkpoint", "no");
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, NULL);
609 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/soft-dirty", "no");
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, NULL);
614 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/ksm", "no");
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, NULL);
620 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/property", "");
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, NULL);
626 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/communications_determinism", "no");
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, NULL);
632 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/send_determinism", "no");
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, NULL);
638 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/reduction", "dpor");
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, NULL);
644 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/timeout", "no");
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 (exprimental)",
649 xbt_cfgelm_boolean, 1, 1, _mc_cfg_cb_hash, NULL);
650 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/hash", "no");
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, NULL);
657 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/snapshot_fds", "no");
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, NULL);
663 xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/max_depth", 1000);
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, NULL);
669 xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/visited", 0);
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, NULL);
675 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/dot_output", "");
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, NULL);
681 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/termination", "no");
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, NULL);
688 xbt_cfg_setdefault_boolean(_sg_cfg_set, "verbose-exit", "yes");
690 /* context factory */
691 const char *dflt_ctx_fact = "thread";
693 char *p = description +
695 "Context factory to use in SIMIX. Possible values: %s",
697 #ifdef HAVE_UCONTEXT_CONTEXTS
698 dflt_ctx_fact = "ucontext";
699 p += sprintf(p, ", %s", dflt_ctx_fact);
701 #ifdef HAVE_RAW_CONTEXTS
702 dflt_ctx_fact = "raw";
703 p += sprintf(p, ", %s", dflt_ctx_fact);
707 xbt_cfg_register(&_sg_cfg_set, "contexts/factory", description,
708 xbt_cfgelm_string, 1, 1, _sg_cfg_cb_context_factory, NULL);
709 xbt_cfg_setdefault_string(_sg_cfg_set, "contexts/factory", dflt_ctx_fact);
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, NULL);
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;
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, NULL);
723 #if defined(_XBT_WIN32) || (PTH_STACKGROWTH != -1)
724 xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/guard_size", 0);
726 xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/guard_size", 1);
728 /* No, it was not set yet (the above setdefault() changed this to 1). */
729 smx_context_guard_size_was_set = 0;
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, NULL);
735 xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/nthreads", 1);
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, NULL);
741 xbt_cfg_setdefault_int(_sg_cfg_set, "contexts/parallel_threshold", 2);
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, NULL);
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");
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, NULL);
756 xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/coordinates", "no");
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, NULL);
761 xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "no");
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, NULL);
767 xbt_cfg_setdefault_string(_sg_cfg_set, "ns3/TcpModel", "default");
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, 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");
781 xbt_cfg_register(&_sg_cfg_set, "smpi/lat_factor",
782 "Latency factors for smpi.",
783 xbt_cfgelm_string, 1, 1, NULL, 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");
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, NULL);
789 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/IB_penalty_factors", "0.965;0.925;1.35");
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, NULL);
795 xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/running_power", 20000.0);
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, NULL);
800 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/display_timing", "no");
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, NULL);
805 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/simulate_computation", "yes");
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, NULL);
810 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/use_shared_malloc", "yes");
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, NULL);
815 xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/cpu_threshold", 1e-6);
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, NULL);
820 xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/async_small_thresh", 0);
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, NULL);
825 xbt_cfg_setdefault_int(_sg_cfg_set, "smpi/send_is_detached_thresh", 65536);
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, NULL);
830 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/privatize_global_variables", "no");
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, NULL);
835 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/os", "1:0:0:0:0");
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, NULL);
840 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/ois", "1:0:0:0:0");
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, NULL);
845 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/or", "1:0:0:0:0");
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, NULL);
850 xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/iprobe", 1e-4);
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, NULL);
855 xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/test", 1e-4);
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, NULL);
860 xbt_cfg_setdefault_double(_sg_cfg_set, "smpi/wtime", 0.0);
862 xbt_cfg_register(&_sg_cfg_set, "smpi/coll_selector",
863 "Which collective selector to use",
864 xbt_cfgelm_string, 1, 1, NULL, NULL);
865 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/coll_selector", "default");
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
915 xbt_cfg_setdefault_boolean(_sg_cfg_set, "exception/cutpath", "no");
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, NULL);
920 xbt_cfg_setdefault_boolean(_sg_cfg_set, "clean_atexit", "yes");
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");
927 surf_path = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
928 xbt_cfg_setdefault_string(_sg_cfg_set, "path", initial_path);
931 xbt_cfg_check(_sg_cfg_set);
932 _sg_cfg_init_status = 1;
934 sg_config_cmd_line(argc, argv);
936 xbt_mallocator_initialization_is_done(SIMIX_context_is_parallel());
939 XBT_WARN("Call to sg_config_init() after initialization ignored");
943 void sg_config_finalize(void)
945 if (!_sg_cfg_init_status)
946 return; /* Not initialized yet. Nothing to do */
948 xbt_cfg_free(&_sg_cfg_set);
949 _sg_cfg_init_status = 0;
952 /* Pick the right models for CPU, net and host, and call their model_init_preparse */
953 void surf_config_models_setup()
955 const char *host_model_name;
956 const char *vm_model_name;
959 char *network_model_name = NULL;
960 char *cpu_model_name = NULL;
962 char *storage_model_name = NULL;
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");
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.
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);
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")) {
988 xbt_assert(cpu_model_name,
989 "Set a cpu model to use with the 'compound' host model");
991 xbt_assert(network_model_name,
992 "Set a network model to use with the 'compound' host model");
994 if(surf_cpu_model_init_preparse){
995 surf_cpu_model_init_preparse();
998 find_model_description(surf_cpu_model_description, cpu_model_name);
999 surf_cpu_model_description[cpu_id].model_init_preparse();
1003 find_model_description(surf_network_model_description,
1004 network_model_name);
1005 surf_network_model_description[network_id].model_init_preparse();
1008 XBT_DEBUG("Call host_model_init");
1009 surf_host_model_description[host_id].model_init_preparse();
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();
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();
1021 int sg_cfg_is_default_value(const char *name)
1023 return xbt_cfg_is_default_value(_sg_cfg_set, name);
1026 int sg_cfg_get_int(const char* name)
1028 return xbt_cfg_get_int(_sg_cfg_set, name);
1031 double sg_cfg_get_double(const char* name)
1033 return xbt_cfg_get_double(_sg_cfg_set, name);
1036 char* sg_cfg_get_string(const char* name)
1038 return xbt_cfg_get_string(_sg_cfg_set, name);
1041 int sg_cfg_get_boolean(const char* name)
1043 return xbt_cfg_get_boolean(_sg_cfg_set, name);
1046 xbt_dynar_t sg_cfg_get_dynar(const char* name)
1048 return xbt_cfg_get_dynar(_sg_cfg_set, name);