1 /* Copyright (c) 2009, 2010. 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"
21 #include "smpi/smpi_interface.h"
23 #include "instr/instr.h"
25 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config, surf,
26 "About the configuration of simgrid");
28 xbt_cfg_t _sg_cfg_set = NULL;
30 int _sg_init_status = 0; /* 0: beginning of time (config cannot be changed yet);
31 1: initialized: cfg_set created (config can now be changed);
32 2: configured: command line parsed and config part of platform file was integrated also, platform construction ongoing or done.
33 (Config cannot be changed anymore!) */
35 /* Parse the command line, looking for options */
36 static void sg_config_cmd_line(int *argc, char **argv)
42 for (j = i = 1; i < *argc; i++) {
43 if (!strncmp(argv[i], "--cfg=", strlen("--cfg="))) {
44 opt = strchr(argv[i], '=');
47 xbt_cfg_set_parse(_sg_cfg_set, opt);
48 XBT_DEBUG("Did apply '%s' as config setting", opt);
49 } else if (!strcmp(argv[i], "--cfg-help") || !strcmp(argv[i], "--help")) {
51 ("Description of the configuration accepted by this simulator:\n");
52 xbt_cfg_help(_sg_cfg_set);
55 "Each of these configurations can be used by adding\n"
56 " --cfg=<option name>:<option value>\n"
57 "to the command line.\n"
58 "You can also use --help-models to see the details of all models known by this simulator.\n"
61 "You can also use --help-tracing to see the details of all tracing options known by this simulator.\n"
64 "You can also use --help-logs and --help-log-categories to see the details of logging output.\n"
68 } else if (!strcmp(argv[i], "--help-models")) {
71 model_help("workstation", surf_workstation_model_description);
73 model_help("CPU", surf_cpu_model_description);
75 model_help("network", surf_network_model_description);
76 printf("\nLong description of all optimization levels accepted by the models of this simulator:\n");
77 for (k = 0; surf_optimization_mode_description[k].name; k++)
79 surf_optimization_mode_description[k].name,
80 surf_optimization_mode_description[k].description);
81 printf("Both network and CPU models have 'Lazy' as default optimization level\n\n");
84 } else if (!strcmp(argv[i], "--help-tracing")) {
97 _sg_init_status=1; // get everything cleanly cleaned on exit
102 /* callback of the workstation/model variable */
103 static void _sg_cfg_cb__workstation_model(const char *name, int pos)
107 xbt_assert(_sg_init_status == 1,
108 "Cannot change the model after the initialization");
110 val = xbt_cfg_get_string(_sg_cfg_set, name);
112 if (!strcmp(val, "help")) {
113 model_help("workstation", surf_workstation_model_description);
117 /* Make sure that the model exists */
118 find_model_description(surf_workstation_model_description, val);
121 /* callback of the cpu/model variable */
122 static void _sg_cfg_cb__cpu_model(const char *name, int pos)
126 xbt_assert(_sg_init_status == 1,
127 "Cannot change the model after the initialization");
129 val = xbt_cfg_get_string(_sg_cfg_set, name);
131 if (!strcmp(val, "help")) {
132 model_help("CPU", surf_cpu_model_description);
136 /* New Module missing */
137 find_model_description(surf_cpu_model_description, val);
140 /* callback of the cpu/model variable */
141 static void _sg_cfg_cb__optimization_mode(const char *name, int pos)
145 xbt_assert(_sg_init_status == 1,
146 "Cannot change the model after the initialization");
148 val = xbt_cfg_get_string(_sg_cfg_set, name);
150 if (!strcmp(val, "help")) {
151 model_help("optimization", surf_optimization_mode_description);
155 /* New Module missing */
156 find_model_description(surf_optimization_mode_description, val);
159 /* callback of the cpu/model variable */
160 static void _sg_cfg_cb__storage_mode(const char *name, int pos)
164 xbt_assert(_sg_init_status == 1,
165 "Cannot change the model after the initialization");
167 val = xbt_cfg_get_string(_sg_cfg_set, name);
169 if (!strcmp(val, "help")) {
170 model_help("storage", surf_storage_model_description);
174 /* New Module missing */
175 find_model_description(surf_storage_model_description, val);
178 /* callback of the workstation_model variable */
179 static void _sg_cfg_cb__network_model(const char *name, int pos)
183 xbt_assert(_sg_init_status == 1,
184 "Cannot change the model after the initialization");
186 val = xbt_cfg_get_string(_sg_cfg_set, name);
188 if (!strcmp(val, "help")) {
189 model_help("network", surf_network_model_description);
193 /* New Module missing */
194 find_model_description(surf_network_model_description, val);
198 /* callbacks of the network models values */
199 static void _sg_cfg_cb__tcp_gamma(const char *name, int pos)
201 sg_tcp_gamma = xbt_cfg_get_double(_sg_cfg_set, name);
204 static void _sg_cfg_cb__maxmin_precision(const char* name, int pos)
206 sg_maxmin_precision = xbt_cfg_get_double(_sg_cfg_set, name);
209 static void _sg_cfg_cb__sender_gap(const char* name, int pos)
211 sg_sender_gap = xbt_cfg_get_double(_sg_cfg_set, name);
214 static void _sg_cfg_cb__latency_factor(const char *name, int pos)
216 sg_latency_factor = xbt_cfg_get_double(_sg_cfg_set, name);
219 static void _sg_cfg_cb__bandwidth_factor(const char *name, int pos)
221 sg_bandwidth_factor = xbt_cfg_get_double(_sg_cfg_set, name);
224 static void _sg_cfg_cb__weight_S(const char *name, int pos)
226 sg_weight_S_parameter = xbt_cfg_get_double(_sg_cfg_set, name);
230 /* callback of the mpi collectives */
231 static void _sg_cfg_cb__coll(const char *category,
232 s_mpi_coll_description_t * table,
233 const char *name, int pos)
237 xbt_assert(_sg_init_status == 1,
238 "Cannot change the model after the initialization");
240 val = xbt_cfg_get_string(_sg_cfg_set, name);
242 if (!strcmp(val, "help")) {
243 coll_help(category, table);
247 /* New Module missing */
248 find_coll_description(table, val);
250 static void _sg_cfg_cb__coll_gather(const char *name, int pos){
251 _sg_cfg_cb__coll("gather", mpi_coll_gather_description, name, pos);
253 static void _sg_cfg_cb__coll_allgather(const char *name, int pos){
254 _sg_cfg_cb__coll("allgather", mpi_coll_allgather_description, name, pos);
256 static void _sg_cfg_cb__coll_allgatherv(const char *name, int pos){
257 _sg_cfg_cb__coll("allgatherv", mpi_coll_allgatherv_description, name, pos);
259 static void _sg_cfg_cb__coll_allreduce(const char *name, int pos)
261 _sg_cfg_cb__coll("allreduce", mpi_coll_allreduce_description, name, pos);
263 static void _sg_cfg_cb__coll_alltoall(const char *name, int pos)
265 _sg_cfg_cb__coll("alltoall", mpi_coll_alltoall_description, name, pos);
267 static void _sg_cfg_cb__coll_alltoallv(const char *name, int pos)
269 _sg_cfg_cb__coll("alltoallv", mpi_coll_alltoallv_description, name, pos);
271 static void _sg_cfg_cb__coll_bcast(const char *name, int pos)
273 _sg_cfg_cb__coll("bcast", mpi_coll_bcast_description, name, pos);
275 static void _sg_cfg_cb__coll_reduce(const char *name, int pos)
277 _sg_cfg_cb__coll("reduce", mpi_coll_reduce_description, name, pos);
279 static void _sg_cfg_cb__coll_reduce_scatter(const char *name, int pos){
280 _sg_cfg_cb__coll("reduce_scatter", mpi_coll_reduce_scatter_description, name, pos);
282 static void _sg_cfg_cb__coll_scatter(const char *name, int pos){
283 _sg_cfg_cb__coll("scatter", mpi_coll_scatter_description, name, pos);
285 static void _sg_cfg_cb__coll_barrier(const char *name, int pos){
286 _sg_cfg_cb__coll("barrier", mpi_coll_barrier_description, name, pos);
290 /* callback of the inclusion path */
291 static void _sg_cfg_cb__surf_path(const char *name, int pos)
293 char *path = xbt_cfg_get_string_at(_sg_cfg_set, name, pos);
294 xbt_dynar_push(surf_path, &path);
297 /* callback to decide if we want to use the model-checking */
298 #include "xbt_modinter.h"
300 extern int _sg_do_model_check; /* this variable lives in xbt_main until I find a right location for it */
303 static void _sg_cfg_cb_model_check(const char *name, int pos)
306 _sg_do_model_check = xbt_cfg_get_boolean(_sg_cfg_set, name);
308 if (xbt_cfg_get_boolean(_sg_cfg_set, name)) {
309 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");
314 extern int _sg_do_verbose_exit;
316 static void _sg_cfg_cb_verbose_exit(const char *name, int pos)
318 _sg_do_verbose_exit = xbt_cfg_get_boolean(_sg_cfg_set, name);
321 extern int _sg_do_clean_atexit;
323 static void _sg_cfg_cb_clean_atexit(const char *name, int pos)
325 _sg_do_clean_atexit = xbt_cfg_get_boolean(_sg_cfg_set, name);
329 static void _sg_cfg_cb_context_factory(const char *name, int pos) {
330 smx_context_factory_name = xbt_cfg_get_string(_sg_cfg_set, name);
333 static void _sg_cfg_cb_context_stack_size(const char *name, int pos)
335 smx_context_stack_size_was_set = 1;
336 smx_context_stack_size = xbt_cfg_get_int(_sg_cfg_set, name) * 1024;
339 static void _sg_cfg_cb_contexts_nthreads(const char *name, int pos)
341 SIMIX_context_set_nthreads(xbt_cfg_get_int(_sg_cfg_set, name));
344 static void _sg_cfg_cb_contexts_parallel_threshold(const char *name, int pos)
346 SIMIX_context_set_parallel_threshold(xbt_cfg_get_int(_sg_cfg_set, name));
349 static void _sg_cfg_cb_contexts_parallel_mode(const char *name, int pos)
351 const char* mode_name = xbt_cfg_get_string(_sg_cfg_set, name);
352 if (!strcmp(mode_name, "posix")) {
353 SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX);
355 else if (!strcmp(mode_name, "futex")) {
356 SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX);
358 else if (!strcmp(mode_name, "busy_wait")) {
359 SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT);
362 xbt_die("Command line setting of the parallel synchronization mode should "
363 "be one of \"posix\", \"futex\" or \"busy_wait\"");
367 static void _sg_cfg_cb__surf_network_coordinates(const char *name,
370 int val = xbt_cfg_get_boolean(_sg_cfg_set, name);
372 if (!COORD_HOST_LEVEL) {
373 COORD_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_dynar_free_voidp);
374 COORD_ASR_LEVEL = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp);
377 if (COORD_HOST_LEVEL)
378 xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
381 static void _sg_cfg_cb__surf_network_crosstraffic(const char *name,
384 sg_network_crosstraffic = xbt_cfg_get_boolean(_sg_cfg_set, name);
388 static void _sg_cfg_cb__gtnets_jitter(const char *name, int pos)
390 sg_gtnets_jitter = xbt_cfg_get_double(_sg_cfg_set, name);
393 static void _sg_cfg_cb__gtnets_jitter_seed(const char *name, int pos)
395 sg_gtnets_jitter_seed = xbt_cfg_get_int(_sg_cfg_set, name);
399 /* create the config set, register what should be and parse the command line*/
400 void sg_config_init(int *argc, char **argv)
402 char *description = xbt_malloc(1024), *p = description;
404 double double_default_value;
405 int default_value_int;
408 /* Create the configuration support */
409 if (_sg_init_status == 0) { /* Only create stuff if not already inited */
411 "The model to use for the CPU. Possible values: ");
413 while (*(++p) != '\0');
414 for (i = 0; surf_cpu_model_description[i].name; i++)
415 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
416 surf_cpu_model_description[i].name);
418 ".\n (use 'help' as a value to see the long description of each model)");
419 default_value = xbt_strdup("Cas01");
420 xbt_cfg_register(&_sg_cfg_set, "cpu/model", description, xbt_cfgelm_string,
421 &default_value, 1, 1, &_sg_cfg_cb__cpu_model, NULL);
424 "The optimization modes to use for the CPU. Possible values: ");
426 while (*(++p) != '\0');
427 for (i = 0; surf_optimization_mode_description[i].name; i++)
428 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
429 surf_optimization_mode_description[i].name);
431 ".\n (use 'help' as a value to see the long description of each optimization mode)");
432 default_value = xbt_strdup("Lazy");
433 xbt_cfg_register(&_sg_cfg_set, "cpu/optim", description, xbt_cfgelm_string,
434 &default_value, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
437 "The model to use for the storage. Possible values: ");
439 while (*(++p) != '\0');
440 for (i = 0; surf_storage_model_description[i].name; i++)
441 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
442 surf_storage_model_description[i].name);
444 ".\n (use 'help' as a value to see the long description of each model)");
445 default_value = xbt_strdup("default");
446 xbt_cfg_register(&_sg_cfg_set, "storage/model", description, xbt_cfgelm_string,
447 &default_value, 1, 1, &_sg_cfg_cb__storage_mode,
450 /* ********************************************************************* */
451 /* TUTORIAL: New model */
453 "The model to use for the New model. Possible values: ");
455 while (*(++p) != '\0');
456 for (i = 0; surf_new_model_description[i].name; i++)
457 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
458 surf_new_model_description[i].name);
460 ".\n (use 'help' as a value to see the long description of each model)");
461 default_value = xbt_strdup("default");
462 xbt_cfg_register(&_sg_cfg_set, "new_model/model", description, xbt_cfgelm_string,
463 &default_value, 1, 1, &_sg_cfg_cb__storage_mode,
465 /* ********************************************************************* */
468 "The model to use for the network. Possible values: ");
470 while (*(++p) != '\0');
471 for (i = 0; surf_network_model_description[i].name; i++)
472 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
473 surf_network_model_description[i].name);
475 ".\n (use 'help' as a value to see the long description of each model)");
476 default_value = xbt_strdup("LV08");
477 xbt_cfg_register(&_sg_cfg_set, "network/model", description, xbt_cfgelm_string,
478 &default_value, 1, 1, &_sg_cfg_cb__network_model,
482 "The optimization modes to use for the network. Possible values: ");
484 while (*(++p) != '\0');
485 for (i = 0; surf_optimization_mode_description[i].name; i++)
486 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
487 surf_optimization_mode_description[i].name);
489 ".\n (use 'help' as a value to see the long description of each optimization mode)");
490 default_value = xbt_strdup("Lazy");
491 xbt_cfg_register(&_sg_cfg_set, "network/optim", description, xbt_cfgelm_string,
492 &default_value, 1, 1, &_sg_cfg_cb__optimization_mode, NULL);
495 "The model to use for the workstation. Possible values: ");
497 while (*(++p) != '\0');
498 for (i = 0; surf_workstation_model_description[i].name; i++)
499 p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
500 surf_workstation_model_description[i].name);
502 ".\n (use 'help' as a value to see the long description of each model)");
503 default_value = xbt_strdup("default");
504 xbt_cfg_register(&_sg_cfg_set, "workstation/model", description, xbt_cfgelm_string,
505 &default_value, 1, 1,
506 &_sg_cfg_cb__workstation_model, NULL);
508 xbt_free(description);
510 xbt_cfg_register(&_sg_cfg_set, "network/TCP_gamma",
511 "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)",
512 xbt_cfgelm_double, NULL, 1, 1,
513 _sg_cfg_cb__tcp_gamma, NULL);
514 xbt_cfg_setdefault_double(_sg_cfg_set, "network/TCP_gamma", 4194304.0);
516 xbt_cfg_register(&_sg_cfg_set, "maxmin/precision",
517 "Numerical precision used when updating simulation models (epsilon in double comparisons)",
518 xbt_cfgelm_double, NULL, 1, 1, _sg_cfg_cb__maxmin_precision, NULL);
519 xbt_cfg_setdefault_double(_sg_cfg_set, "maxmin/precision", 0.00001);
521 /* The parameters of network models */
523 xbt_cfg_register(&_sg_cfg_set, "network/sender_gap",
524 "Minimum gap between two overlapping sends",
525 xbt_cfgelm_double, NULL, 1, 1, /* default is set in network.c */
526 _sg_cfg_cb__sender_gap, NULL);
528 double_default_value = 1.0; // FIXME use setdefault everywhere here!
529 xbt_cfg_register(&_sg_cfg_set, "network/latency_factor",
530 "Correction factor to apply to the provided latency (default value set by network model)",
531 xbt_cfgelm_double, &double_default_value, 1, 1,
532 _sg_cfg_cb__latency_factor, NULL);
533 double_default_value = 1.0;
534 xbt_cfg_register(&_sg_cfg_set, "network/bandwidth_factor",
535 "Correction factor to apply to the provided bandwidth (default value set by network model)",
536 xbt_cfgelm_double, &double_default_value, 1, 1,
537 _sg_cfg_cb__bandwidth_factor, NULL);
539 xbt_cfg_register(&_sg_cfg_set, "network/weight_S",
540 "Correction factor to apply to the weight of competing streams (default value set by network model)",
541 xbt_cfgelm_double, NULL, 1, 1, /* default is set in network.c */
542 _sg_cfg_cb__weight_S, NULL);
545 xbt_cfg_register(&_sg_cfg_set, "path",
546 "Lookup path for inclusions in platform and deployment XML files",
547 xbt_cfgelm_string, NULL, 0, 0,
548 _sg_cfg_cb__surf_path, NULL);
550 default_value = xbt_strdup("off");
551 xbt_cfg_register(&_sg_cfg_set, "cpu/maxmin_selective_update",
552 "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
553 xbt_cfgelm_boolean, &default_value, 0, 1,
555 default_value = xbt_strdup("off");
556 xbt_cfg_register(&_sg_cfg_set, "network/maxmin_selective_update",
557 "Update the constraint set propagating recursively to others constraints (off by default when optim is set to lazy)",
558 xbt_cfgelm_boolean, &default_value, 0, 1,
562 /* do model-checking */
563 default_value = xbt_strdup("off");
564 xbt_cfg_register(&_sg_cfg_set, "model-check",
565 "Verify the system through model-checking instead of simulating it (EXPERIMENTAL)",
566 xbt_cfgelm_boolean, NULL, 0, 1,
567 _sg_cfg_cb_model_check, NULL);
568 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check", default_value);
570 /* do stateful model-checking */
571 default_value = xbt_strdup("off");
572 xbt_cfg_register(&_sg_cfg_set, "model-check/checkpoint",
573 "Specify the amount of steps between checkpoints during stateful model-checking (default: off => stateless verification). "
574 "If value=on, one checkpoint is saved for each step => faster verification, but huge memory consumption; higher values are good compromises between speed and memory consumption.",
575 xbt_cfgelm_boolean, NULL, 0, 1,
576 _mc_cfg_cb_checkpoint, NULL);
577 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/checkpoint", default_value);
579 /* do liveness model-checking */
580 xbt_cfg_register(&_sg_cfg_set, "model-check/property",
581 "Specify the name of the file containing the property. It must be the result of the ltl2ba program.",
582 xbt_cfgelm_string, NULL, 0, 1,
583 _mc_cfg_cb_property, NULL);
584 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/property", "");
586 /* Specify the kind of model-checking reduction */
587 xbt_cfg_register(&_sg_cfg_set, "model-check/reduction",
588 "Specify the kind of exploration reduction (either none or DPOR)",
589 xbt_cfgelm_string, NULL, 0, 1,
590 _mc_cfg_cb_reduce, NULL);
591 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/reduction", "dpor");
593 /* Enable/disable timeout for wait requests with model-checking */
594 default_value = xbt_strdup("off");
595 xbt_cfg_register(&_sg_cfg_set, "model-check/timeout",
596 "Enable/Disable timeout for wait requests",
597 xbt_cfgelm_boolean, NULL, 0, 1,
598 _mc_cfg_cb_timeout, NULL);
599 xbt_cfg_setdefault_boolean(_sg_cfg_set, "model-check/timeout", default_value);
601 /* Set max depth exploration */
602 xbt_cfg_register(&_sg_cfg_set, "model-check/max_depth",
603 "Specify the max depth of exploration (default : 1000)",
604 xbt_cfgelm_int, NULL, 0, 1,
605 _mc_cfg_cb_max_depth, NULL);
606 xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/max_depth", 1000);
608 /* Set number of visited state stored for state comparison reduction*/
609 xbt_cfg_register(&_sg_cfg_set, "model-check/visited",
610 "Specify the number of visited state stored for state comparison reduction. If value=5, the last 5 visited states are stored",
611 xbt_cfgelm_int, NULL, 0, 1,
612 _mc_cfg_cb_visited, NULL);
613 xbt_cfg_setdefault_int(_sg_cfg_set, "model-check/visited", 0);
615 /* Set file name for dot output of graph state */
616 xbt_cfg_register(&_sg_cfg_set, "model-check/dot_output",
617 "Specify the name of dot file corresponding to graph state",
618 xbt_cfgelm_string, NULL, 0, 1,
619 _mc_cfg_cb_dot_output, NULL);
620 xbt_cfg_setdefault_string(_sg_cfg_set, "model-check/dot_output", "");
623 /* do verbose-exit */
624 default_value = xbt_strdup("on");
625 xbt_cfg_register(&_sg_cfg_set, "verbose-exit",
626 "Activate the \"do nothing\" mode in Ctrl-C",
627 xbt_cfgelm_boolean, &default_value, 0, 1,
628 _sg_cfg_cb_verbose_exit, NULL);
631 /* context factory */
632 default_value = xbt_strdup("ucontext");
633 xbt_cfg_register(&_sg_cfg_set, "contexts/factory",
634 "Context factory to use in SIMIX (ucontext, thread or raw)",
635 xbt_cfgelm_string, &default_value, 1, 1, _sg_cfg_cb_context_factory, NULL);
637 /* stack size of contexts in Ko */
638 default_value_int = 128;
639 xbt_cfg_register(&_sg_cfg_set, "contexts/stack_size",
640 "Stack size of contexts in Kib (ucontext or raw only)",
641 xbt_cfgelm_int, &default_value_int, 1, 1,
642 _sg_cfg_cb_context_stack_size, NULL);
644 /* number of parallel threads for user processes */
645 default_value_int = 1;
646 xbt_cfg_register(&_sg_cfg_set, "contexts/nthreads",
647 "Number of parallel threads used to execute user contexts",
648 xbt_cfgelm_int, &default_value_int, 1, 1,
649 _sg_cfg_cb_contexts_nthreads, NULL);
651 /* minimal number of user contexts to be run in parallel */
652 default_value_int = 2;
653 xbt_cfg_register(&_sg_cfg_set, "contexts/parallel_threshold",
654 "Minimal number of user contexts to be run in parallel (raw contexts only)",
655 xbt_cfgelm_int, &default_value_int, 1, 1,
656 _sg_cfg_cb_contexts_parallel_threshold, NULL);
658 /* synchronization mode for parallel user contexts */
660 default_value = xbt_strdup("futex");
661 #else //No futex on mac and posix is unimplememted yet
662 default_value = xbt_strdup("busy_wait");
664 xbt_cfg_register(&_sg_cfg_set, "contexts/synchro",
665 "Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait)",
666 xbt_cfgelm_string, &default_value, 1, 1,
667 _sg_cfg_cb_contexts_parallel_mode, NULL);
669 default_value = xbt_strdup("no");
670 xbt_cfg_register(&_sg_cfg_set, "network/coordinates",
671 "\"yes\" or \"no\", specifying whether we use a coordinate-based routing (as Vivaldi)",
672 xbt_cfgelm_boolean, &default_value, 1, 1,
673 _sg_cfg_cb__surf_network_coordinates, NULL);
674 xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/coordinates", default_value);
676 default_value = xbt_strdup("no");
677 xbt_cfg_register(&_sg_cfg_set, "network/crosstraffic",
678 "Activate the interferences between uploads and downloads for fluid max-min models (LV08, CM02)",
679 xbt_cfgelm_boolean, &default_value, 0, 1,
680 _sg_cfg_cb__surf_network_crosstraffic, NULL);
681 xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", default_value);
684 xbt_cfg_register(&_sg_cfg_set, "gtnets/jitter",
685 "Double value to oscillate the link latency, uniformly in random interval [-latency*gtnets_jitter,latency*gtnets_jitter)",
686 xbt_cfgelm_double, NULL, 1, 1,
687 _sg_cfg_cb__gtnets_jitter, NULL);
688 xbt_cfg_setdefault_double(_sg_cfg_set, "gtnets/jitter", 0.0);
690 default_value_int = 10;
691 xbt_cfg_register(&_sg_cfg_set, "gtnets/jitter_seed",
692 "Use a positive seed to reproduce jitted results, value must be in [1,1e8], default is 10",
693 xbt_cfgelm_int, &default_value_int, 0, 1,
694 _sg_cfg_cb__gtnets_jitter_seed, NULL);
697 xbt_cfg_register(&_sg_cfg_set, "ns3/TcpModel",
698 "The ns3 tcp model can be : NewReno or Reno or Tahoe",
699 xbt_cfgelm_string, NULL, 1, 1,
701 xbt_cfg_setdefault_string(_sg_cfg_set, "ns3/TcpModel", "default");
705 double default_reference_speed = 20000.0;
706 xbt_cfg_register(&_sg_cfg_set, "smpi/running_power",
707 "Power of the host running the simulation (in flop/s). Used to bench the operations.",
708 xbt_cfgelm_double, &default_reference_speed, 1, 1, NULL,
711 default_value = xbt_strdup("no");
712 xbt_cfg_register(&_sg_cfg_set, "smpi/display_timing",
713 "Boolean indicating whether we should display the timing after simulation.",
714 xbt_cfgelm_boolean, &default_value, 1, 1, NULL,
716 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/display_timing", default_value);
718 default_value = xbt_strdup("yes");
719 xbt_cfg_register(&_sg_cfg_set, "smpi/use_shared_malloc",
720 "Boolean indicating whether we should use shared memory when using SMPI_SHARED_MALLOC. Allows user to disable it for debug purposes.",
721 xbt_cfgelm_boolean, &default_value, 1, 1, NULL,
723 xbt_cfg_setdefault_boolean(_sg_cfg_set, "smpi/use_shared_malloc", default_value);
725 double default_threshold = 1e-6;
726 xbt_cfg_register(&_sg_cfg_set, "smpi/cpu_threshold",
727 "Minimal computation time (in seconds) not discarded.",
728 xbt_cfgelm_double, &default_threshold, 1, 1, NULL,
731 int default_small_messages_threshold = 0;
732 xbt_cfg_register(&_sg_cfg_set, "smpi/async_small_thres",
733 "Maximal size of messages that are to be sent asynchronously, without waiting for the receiver",
734 xbt_cfgelm_int, &default_small_messages_threshold, 1, 1, NULL,
737 int default_send_is_detached_threshold = 65536;
738 xbt_cfg_register(&_sg_cfg_set, "smpi/send_is_detached_thres",
739 "Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend",
740 xbt_cfgelm_int, &default_send_is_detached_threshold, 1, 1, NULL,
743 //For smpi/bw_factor and smpi/lat_factor
744 //Default value have to be "threshold0:value0;threshold1:value1;...;thresholdN:valueN"
745 //test is if( size >= thresholdN ) return valueN;
746 //Values can be modified with command line --cfg=smpi/bw_factor:"threshold0:value0;threshold1:value1;...;thresholdN:valueN"
747 // or with tag config put line <prop id="smpi/bw_factor" value="threshold0:value0;threshold1:value1;...;thresholdN:valueN"></prop>
748 xbt_cfg_register(&_sg_cfg_set, "smpi/bw_factor",
749 "Bandwidth factors for smpi.",
750 xbt_cfgelm_string, NULL, 1, 1, NULL,
752 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");
754 xbt_cfg_register(&_sg_cfg_set, "smpi/lat_factor",
755 "Latency factors for smpi.",
756 xbt_cfgelm_string, NULL, 1, 1, NULL,
758 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");
760 xbt_cfg_register(&_sg_cfg_set, "smpi/os",
761 "Small messages timings (MPI_Send minimum time for small messages)",
762 xbt_cfgelm_string, NULL, 1, 1, NULL,
764 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/os", "1:0:0:0:0");
766 xbt_cfg_register(&_sg_cfg_set, "smpi/ois",
767 "Small messages timings (MPI_Isend minimum time for small messages)",
768 xbt_cfgelm_string, NULL, 1, 1, NULL,
770 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/ois", "1:0:0:0:0");
772 xbt_cfg_register(&_sg_cfg_set, "smpi/or",
773 "Small messages timings (MPI_Recv minimum time for small messages)",
774 xbt_cfgelm_string, NULL, 1, 1, NULL,
776 xbt_cfg_setdefault_string(_sg_cfg_set, "smpi/or", "1:0:0:0:0");
777 double default_iprobe_time = 1e-4;
778 xbt_cfg_register(&_sg_cfg_set, "smpi/iprobe",
779 "Minimum time to inject inside a call to MPI_Iprobe",
780 xbt_cfgelm_double, &default_iprobe_time, 1, 1, NULL,
782 default_value = xbt_strdup("default");
783 xbt_cfg_register(&_sg_cfg_set, "smpi/coll_selector",
784 "Which collective selector to use",
785 xbt_cfgelm_string, &default_value, 1, 1, NULL,
788 xbt_cfg_register(&_sg_cfg_set, "smpi/gather",
789 "Which collective to use for gather",
790 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_gather,
793 xbt_cfg_register(&_sg_cfg_set, "smpi/allgather",
794 "Which collective to use for allgather",
795 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_allgather,
798 xbt_cfg_register(&_sg_cfg_set, "smpi/barrier",
799 "Which collective to use for barrier",
800 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_barrier,
803 xbt_cfg_register(&_sg_cfg_set, "smpi/reduce_scatter",
804 "Which collective to use for reduce_scatter",
805 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_reduce_scatter,
808 xbt_cfg_register(&_sg_cfg_set, "smpi/scatter",
809 "Which collective to use for scatter",
810 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_scatter,
813 xbt_cfg_register(&_sg_cfg_set, "smpi/allgatherv",
814 "Which collective to use for allgatherv",
815 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_allgatherv,
818 xbt_cfg_register(&_sg_cfg_set, "smpi/allreduce",
819 "Which collective to use for allreduce",
820 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_allreduce,
823 xbt_cfg_register(&_sg_cfg_set, "smpi/alltoall",
824 "Which collective to use for alltoall",
825 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_alltoall,
828 xbt_cfg_register(&_sg_cfg_set, "smpi/alltoallv",
829 "Which collective to use for alltoallv",
830 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_alltoallv,
833 xbt_cfg_register(&_sg_cfg_set, "smpi/bcast",
834 "Which collective to use for bcast",
835 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_bcast,
838 xbt_cfg_register(&_sg_cfg_set, "smpi/reduce",
839 "Which collective to use for reduce",
840 xbt_cfgelm_string, NULL, 1, 1, &_sg_cfg_cb__coll_reduce,
844 default_value = xbt_strdup("yes");
845 xbt_cfg_register(&_sg_cfg_set, "clean_atexit",
846 "\"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.",
847 xbt_cfgelm_boolean, &default_value, 1, 1,
848 _sg_cfg_cb_clean_atexit, NULL);
849 xbt_cfg_setdefault_boolean(_sg_cfg_set, "clean_atexit", default_value);
852 /* retrieves the current directory of the current process */
853 const char *initial_path = __surf_get_initial_path();
854 xbt_assert((initial_path),
855 "__surf_get_initial_path() failed! Can't resolves current Windows directory");
857 surf_path = xbt_dynar_new(sizeof(char *), NULL);
858 xbt_cfg_setdefault_string(_sg_cfg_set, "path", initial_path);
863 sg_config_cmd_line(argc, argv);
865 xbt_mallocator_initialization_is_done(SIMIX_context_is_parallel());
868 XBT_WARN("Call to sg_config_init() after initialization ignored");
872 void sg_config_finalize(void)
874 if (!_sg_init_status)
875 return; /* Not initialized yet. Nothing to do */
877 xbt_cfg_free(&_sg_cfg_set);
881 /* Pick the right models for CPU, net and workstation, and call their model_init_preparse */
882 void surf_config_models_setup()
884 char *workstation_model_name;
885 int workstation_id = -1;
886 char *network_model_name = NULL;
887 char *cpu_model_name = NULL;
889 char *storage_model_name = NULL;
891 workstation_model_name =
892 xbt_cfg_get_string(_sg_cfg_set, "workstation/model");
893 network_model_name = xbt_cfg_get_string(_sg_cfg_set, "network/model");
894 cpu_model_name = xbt_cfg_get_string(_sg_cfg_set, "cpu/model");
895 storage_model_name = xbt_cfg_get_string(_sg_cfg_set, "storage/model");
897 /* Check whether we use a net/cpu model differing from the default ones, in which case
898 * we should switch to the "compound" workstation model to correctly dispatch stuff to
899 * the right net/cpu models.
902 if((!xbt_cfg_is_default_value(_sg_cfg_set, "network/model") ||
903 !xbt_cfg_is_default_value(_sg_cfg_set, "cpu/model")) &&
904 xbt_cfg_is_default_value(_sg_cfg_set, "workstation/model"))
906 const char *val = "compound";
908 ("Switching workstation model to compound since you changed the network and/or cpu model(s)");
909 xbt_cfg_set_string(_sg_cfg_set, "workstation/model", val);
910 workstation_model_name = (char *) "compound";
913 XBT_DEBUG("Workstation model: %s", workstation_model_name);
915 find_model_description(surf_workstation_model_description,
916 workstation_model_name);
917 if (!strcmp(workstation_model_name, "compound")) {
921 xbt_assert(cpu_model_name,
922 "Set a cpu model to use with the 'compound' workstation model");
924 xbt_assert(network_model_name,
925 "Set a network model to use with the 'compound' workstation model");
928 find_model_description(surf_network_model_description,
931 find_model_description(surf_cpu_model_description, cpu_model_name);
933 surf_cpu_model_description[cpu_id].model_init_preparse();
934 surf_network_model_description[network_id].model_init_preparse();
937 XBT_DEBUG("Call workstation_model_init");
938 surf_workstation_model_description[workstation_id].model_init_preparse();
940 XBT_DEBUG("Call storage_model_init");
941 storage_id = find_model_description(surf_storage_model_description, storage_model_name);
942 surf_storage_model_description[storage_id].model_init_preparse();
944 /* ********************************************************************* */
945 /* TUTORIAL: New model */
946 int new_model_id = -1;
947 char *new_model_name = NULL;
948 new_model_name = xbt_cfg_get_string(_sg_cfg_set, "new_model/model");
949 XBT_DEBUG("Call new model_init");
950 new_model_id = find_model_description(surf_new_model_description, new_model_name);
951 surf_new_model_description[new_model_id].model_init_preparse();
952 /* ********************************************************************* */
955 int sg_cfg_get_int(const char* name)
957 return xbt_cfg_get_int(_sg_cfg_set,name);
959 double sg_cfg_get_double(const char* name)
961 return xbt_cfg_get_double(_sg_cfg_set,name);
963 char* sg_cfg_get_string(const char* name)
965 return xbt_cfg_get_string(_sg_cfg_set,name);
967 int sg_cfg_get_boolean(const char* name)
969 return xbt_cfg_get_boolean(_sg_cfg_set,name);
971 void sg_cfg_get_peer(const char *name, char **peer, int *port)
973 xbt_cfg_get_peer(_sg_cfg_set,name, peer, port);
975 xbt_dynar_t sg_cfg_get_dynar(const char* name)
977 return xbt_cfg_get_dynar(_sg_cfg_set,name);