src/instr/instr_config.c

   1 /* Copyright (c) 2010-2013. 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 #include "instr/instr_private.h"
   8 #include "simgrid/sg_config.h"
   9 #include "surf/surf.h"
  10
  11 #ifdef HAVE_TRACING
  12
  13 XBT_LOG_NEW_CATEGORY(instr, "Logging the behavior of the tracing system (used for Visualization/Analysis of simulations)");
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_config, instr, "Configuration");
  15
  16 #define OPT_TRACING               "tracing"
  17 #define OPT_TRACING_PLATFORM      "tracing/platform"
  18 #define OPT_TRACING_TOPOLOGY      "tracing/platform/topology"
  19 #define OPT_TRACING_SMPI          "tracing/smpi"
  20 #define OPT_TRACING_SMPI_GROUP    "tracing/smpi/group"
  21 #define OPT_TRACING_SMPI_COMPUTING "tracing/smpi/computing"
  22 #define OPT_TRACING_SMPI_INTERNALS "tracing/smpi/internals"
  23 #define OPT_TRACING_DISPLAY_SIZES  "tracing/smpi/display_sizes"
  24 #define OPT_TRACING_CATEGORIZED   "tracing/categorized"
  25 #define OPT_TRACING_UNCATEGORIZED "tracing/uncategorized"
  26 #define OPT_TRACING_MSG_PROCESS   "tracing/msg/process"
  27 #define OPT_TRACING_MSG_VM        "tracing/msg/vm"
  28 #define OPT_TRACING_FILENAME      "tracing/filename"
  29 #define OPT_TRACING_BUFFER        "tracing/buffer"
  30 #define OPT_TRACING_ONELINK_ONLY  "tracing/onelink_only"
  31 #define OPT_TRACING_DISABLE_DESTROY "tracing/disable_destroy"
  32 #define OPT_TRACING_BASIC         "tracing/basic"
  33 #define OPT_TRACING_COMMENT       "tracing/comment"
  34 #define OPT_TRACING_COMMENT_FILE  "tracing/comment_file"
  35 #define OPT_VIVA_UNCAT_CONF      "viva/uncategorized"
  36 #define OPT_VIVA_CAT_CONF        "viva/categorized"
  37 #define OPT_TRACING_DISABLE_LINK        "tracing/disable_link"
  38 #define OPT_TRACING_DISABLE_POWER       "tracing/disable_power"
  39
  40 static int trace_enabled;
  41 static int trace_platform;
  42 static int trace_platform_topology;
  43 static int trace_smpi_enabled;
  44 static int trace_smpi_grouped;
  45 static int trace_smpi_computing;
  46 static int trace_view_internals;
  47 static int trace_categorized;
  48 static int trace_uncategorized;
  49 static int trace_msg_process_enabled;
  50 static int trace_msg_vm_enabled;
  51 static int trace_buffer;
  52 static int trace_onelink_only;
  53 static int trace_disable_destroy;
  54 static int trace_basic;
  55 static int trace_display_sizes = 0;
  56 static int trace_disable_link;
  57 static int trace_disable_power;
  58
  59 static int trace_configured = 0;
  60 static int trace_active = 0;
  61
  62
  63
  64 static void TRACE_getopts(void)
  65 {
  66   trace_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING);
  67   trace_platform = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_PLATFORM);
  68   trace_platform_topology = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_TOPOLOGY);
  69   trace_smpi_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI);
  70   trace_smpi_grouped = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI_GROUP);
  71   trace_smpi_computing = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING);
  72   trace_view_internals = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS);
  73   trace_categorized = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_CATEGORIZED);
  74   trace_uncategorized = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED);
  75   trace_msg_process_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_MSG_PROCESS);
  76   trace_msg_vm_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_MSG_VM);
  77   trace_buffer = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_BUFFER);
  78   trace_onelink_only = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY);
  79   trace_disable_destroy = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY);
  80   trace_basic = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_BASIC);
  81   trace_display_sizes = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES);
  82   trace_disable_link = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_DISABLE_LINK);
  83   trace_disable_power = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_DISABLE_POWER);
  84 }
  85
  86 static xbt_dynar_t TRACE_start_functions = NULL;
  87 void TRACE_add_start_function(void (*func) ())
  88 {
  89   if (TRACE_start_functions == NULL)
  90     TRACE_start_functions = xbt_dynar_new(sizeof(void (*)()), NULL);
  91   xbt_dynar_push(TRACE_start_functions, &func);
  92 }
  93
  94 int TRACE_start()
  95 {
  96   TRACE_getopts();
  97
  98   // tracing system must be:
  99   //    - enabled (with --cfg=tracing:1)
 100   //    - already configured (TRACE_global_init already called)
 101   if (TRACE_is_enabled() && TRACE_is_configured()) {
 102     XBT_DEBUG("Tracing starts");
 103
 104     /* open the trace file */
 105     TRACE_paje_start();
 106
 107     /* activate trace */
 108     if (trace_active == 1) {
 109       THROWF(tracing_error, 0, "Tracing is already active");
 110     }
 111     trace_active = 1;
 112     XBT_DEBUG("Tracing is on");
 113
 114     /* other trace initialization */
 115     created_categories = xbt_dict_new_homogeneous(xbt_free);
 116     declared_marks = xbt_dict_new_homogeneous(xbt_free);
 117     user_host_variables = xbt_dict_new_homogeneous(xbt_free);
 118     user_vm_variables = xbt_dict_new_homogeneous (xbt_free);
 119     user_link_variables = xbt_dict_new_homogeneous(xbt_free);
 120
 121     if (TRACE_start_functions != NULL) {
 122       void (*func) ();
 123       unsigned int iter = xbt_dynar_length(TRACE_start_functions);
 124       xbt_dynar_foreach(TRACE_start_functions, iter, func) {
 125         func();
 126       }
 127     }
 128   }
 129   xbt_dynar_free(&TRACE_start_functions);
 130   return 0;
 131 }
 132
 133 static xbt_dynar_t TRACE_end_functions = NULL;
 134 void TRACE_add_end_function(void (*func) (void))
 135 {
 136   if (TRACE_end_functions == NULL)
 137     TRACE_end_functions = xbt_dynar_new(sizeof(void (*)(void)), NULL);
 138   xbt_dynar_push(TRACE_end_functions, &func);
 139 }
 140
 141 int TRACE_end()
 142 {
 143   int retval;
 144   if (!trace_active) {
 145     retval = 1;
 146   } else {
 147     retval = 0;
 148
 149     TRACE_generate_viva_uncat_conf();
 150     TRACE_generate_viva_cat_conf();
 151
 152     /* dump trace buffer */
 153     TRACE_last_timestamp_to_dump = surf_get_clock();
 154     TRACE_paje_dump_buffer(1);
 155
 156     /* destroy all data structures of tracing (and free) */
 157     PJ_container_free_all();
 158     PJ_type_free_all();
 159     PJ_container_release();
 160     PJ_type_release();
 161
 162     if (TRACE_end_functions != NULL) {
 163       void (*func) (void);
 164       unsigned int iter;
 165       xbt_dynar_foreach(TRACE_end_functions, iter, func) {
 166         func();
 167       }
 168     }
 169
 170     xbt_dict_free(&user_link_variables);
 171     xbt_dict_free(&user_host_variables);
 172     xbt_dict_free(&user_vm_variables);
 173     xbt_dict_free(&declared_marks);
 174     xbt_dict_free(&created_categories);
 175
 176     /* close the trace file */
 177     TRACE_paje_end();
 178
 179     /* de-activate trace */
 180     trace_active = 0;
 181     XBT_DEBUG("Tracing is off");
 182     XBT_DEBUG("Tracing system is shutdown");
 183   }
 184   xbt_dynar_free(&TRACE_start_functions); /* useful when exiting early */
 185   xbt_dynar_free(&TRACE_end_functions);
 186   return retval;
 187 }
 188
 189 int TRACE_needs_platform (void)
 190 {
 191   return TRACE_msg_process_is_enabled() ||
 192          TRACE_msg_vm_is_enabled() ||
 193          TRACE_categorized() ||
 194          TRACE_uncategorized() ||
 195          TRACE_platform () ||
 196          (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped());
 197 }
 198
 199 int TRACE_is_enabled(void)
 200 {
 201   return trace_enabled;
 202 }
 203
 204 int TRACE_platform(void)
 205 {
 206   return trace_platform;
 207 }
 208
 209 int TRACE_platform_topology(void)
 210 {
 211   return trace_platform_topology;
 212 }
 213
 214 int TRACE_is_configured(void)
 215 {
 216   return trace_configured;
 217 }
 218
 219 int TRACE_smpi_is_enabled(void)
 220 {
 221   return (trace_smpi_enabled || TRACE_smpi_is_grouped())
 222     && TRACE_is_enabled();
 223 }
 224
 225 int TRACE_smpi_is_grouped(void)
 226 {
 227   return trace_smpi_grouped;
 228 }
 229
 230 int TRACE_smpi_is_computing(void)
 231 {
 232   return trace_smpi_computing;
 233 }
 234
 235 int TRACE_smpi_view_internals(void)
 236 {
 237   return trace_view_internals;
 238 }
 239
 240 int TRACE_categorized (void)
 241 {
 242   return trace_categorized;
 243 }
 244
 245 int TRACE_uncategorized (void)
 246 {
 247   return trace_uncategorized;
 248 }
 249
 250 int TRACE_msg_process_is_enabled(void)
 251 {
 252   return trace_msg_process_enabled && TRACE_is_enabled();
 253 }
 254
 255 int TRACE_msg_vm_is_enabled(void)
 256 {
 257   return trace_msg_vm_enabled && TRACE_is_enabled();
 258 }
 259
 260 int TRACE_disable_link(void)
 261 {
 262   return trace_disable_link && TRACE_is_enabled();
 263 }
 264
 265 int TRACE_disable_power(void)
 266 {
 267   return trace_disable_power && TRACE_is_enabled();
 268 }
 269
 270 int TRACE_buffer (void)
 271 {
 272   return trace_buffer && TRACE_is_enabled();
 273 }
 274
 275 int TRACE_onelink_only (void)
 276 {
 277   return trace_onelink_only && TRACE_is_enabled();
 278 }
 279
 280 int TRACE_disable_destroy (void)
 281 {
 282   return trace_disable_destroy && TRACE_is_enabled();
 283 }
 284
 285 int TRACE_basic (void)
 286 {
 287   return trace_basic && TRACE_is_enabled();
 288 }
 289
 290 int TRACE_display_sizes (void)
 291 {
 292    return trace_display_sizes && trace_smpi_enabled && TRACE_is_enabled();
 293 }
 294
 295 char *TRACE_get_comment (void)
 296 {
 297   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT);
 298 }
 299
 300 char *TRACE_get_comment_file (void)
 301 {
 302   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE);
 303 }
 304
 305 char *TRACE_get_filename(void)
 306 {
 307   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_FILENAME);
 308 }
 309
 310 char *TRACE_get_viva_uncat_conf (void)
 311 {
 312   return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF);
 313 }
 314
 315 char *TRACE_get_viva_cat_conf (void)
 316 {
 317   return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_CAT_CONF);
 318 }
 319
 320 void TRACE_global_init(int *argc, char **argv)
 321 {
 322   /* name of the tracefile */
 323   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FILENAME,
 324                    "Trace file created by the instrumented SimGrid.",
 325                    xbt_cfgelm_string, 1, 1, NULL, NULL);
 326   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FILENAME, "simgrid.trace");
 327
 328   /* tracing */
 329   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING,
 330                    "Enable Tracing.",
 331                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 332   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING, 0);
 333
 334   /* register platform in the trace */
 335   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_PLATFORM,
 336                    "Register the platform in the trace as a hierarchy.",
 337                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 338   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_PLATFORM, 0);
 339
 340   /* register platform in the trace */
 341   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_TOPOLOGY,
 342                    "Register the platform topology in the trace as a graph.",
 343                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 344   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_TOPOLOGY, 1);
 345
 346   /* smpi */
 347   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI,
 348                    "Tracing of the SMPI interface.",
 349                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 350   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_SMPI, 0);
 351
 352   /* smpi grouped */
 353   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_GROUP,
 354                    "Group MPI processes by host.",
 355                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 356   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_SMPI_GROUP, 0);
 357
 358   /* smpi computing */
 359   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING,
 360                    "Generate states for timing out of SMPI parts of the application",
 361                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 362   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING, 0);
 363
 364   /* smpi internals */
 365   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS,
 366                    "View internal messages sent by Collective communications in SMPI",
 367                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 368   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS, 0);
 369
 370   /* tracing categorized resource utilization traces */
 371   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_CATEGORIZED,
 372                    "Tracing categorized resource utilization of hosts and links.",
 373                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 374   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_CATEGORIZED, 0);
 375
 376   /* tracing uncategorized resource utilization */
 377   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_UNCATEGORIZED,
 378                    "Tracing uncategorized resource utilization of hosts and links.",
 379                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 380   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED, 0);
 381
 382   /* msg process */
 383   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_PROCESS,
 384                    "Tracing of MSG process behavior.",
 385                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 386   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_MSG_PROCESS, 0);
 387
 388   /* msg process */
 389   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_VM,
 390                    "Tracing of MSG process behavior.",
 391                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 392   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_MSG_VM, 0);
 393
 394   /* disable tracing link */
 395   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_LINK,
 396                    "Do not trace link bandwidth and latency.",
 397                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 398   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_DISABLE_LINK, 0);
 399
 400   /* disable tracing link */
 401   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_POWER,
 402                    "Do not trace host power.",
 403                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 404   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_DISABLE_POWER, 0);
 405
 406
 407   /* tracing buffer */
 408   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BUFFER,
 409                    "Buffer trace events to put them in temporal order.",
 410                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 411   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_BUFFER, 1);
 412
 413   /* tracing one link only */
 414   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_ONELINK_ONLY,
 415                    "Use only routes with one link to trace platform.",
 416                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 417   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY, 0);
 418
 419   /* disable destroy */
 420   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY,
 421                    "Disable platform containers destruction.",
 422                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 423   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY, 0);
 424
 425   /* basic -- Avoid extended events (impoverished trace file) */
 426   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BASIC,
 427                    "Avoid extended events (impoverished trace file).",
 428                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 429   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_BASIC, 0);
 430
 431   /* display_sizes -- Extended events with message size information */
 432   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES,
 433                    "(smpi only for now) Extended events with message size information",
 434                    xbt_cfgelm_int, 0, 1, NULL, NULL);
 435   xbt_cfg_setdefault_int(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES, 0);
 436
 437   /* comment */
 438   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT,
 439                    "Comment to be added on the top of the trace file.",
 440                    xbt_cfgelm_string, 1, 1, NULL, NULL);
 441   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT, "");
 442
 443   /* comment_file */
 444   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT_FILE,
 445                    "The contents of the file are added to the top of the trace file as comment.",
 446                    xbt_cfgelm_string, 1, 1, NULL, NULL);
 447   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE, "");
 448
 449   /* Viva graph configuration for uncategorized tracing */
 450   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_UNCAT_CONF,
 451                    "Viva Graph configuration file for uncategorized resource utilization traces.",
 452                    xbt_cfgelm_string, 1, 1, NULL, NULL);
 453   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF, "");
 454
 455   /* Viva graph configuration for uncategorized tracing */
 456   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_CAT_CONF,
 457                    "Viva Graph configuration file for categorized resource utilization traces.",
 458                    xbt_cfgelm_string, 1, 1, NULL, NULL);
 459   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_CAT_CONF, "");
 460
 461   /* instrumentation can be considered configured now */
 462   trace_configured = 1;
 463 }
 464
 465 static void print_line (const char *option, const char *desc, const char *longdesc, int detailed)
 466 {
 467   char str[INSTR_DEFAULT_STR_SIZE];
 468   snprintf (str, INSTR_DEFAULT_STR_SIZE, "--cfg=%s ", option);
 469
 470   int len = strlen (str);
 471   printf ("%s%*.*s %s\n", str, 30-len, 30-len, "", desc);
 472   if (!!longdesc && detailed){
 473     printf ("%s\n\n", longdesc);
 474   }
 475 }
 476
 477 void TRACE_help (int detailed)
 478 {
 479   printf(
 480       "Description of the tracing options accepted by this simulator:\n\n");
 481   print_line (OPT_TRACING, "Enable the tracing system",
 482       "  It activates the tracing system and register the simulation platform\n"
 483       "  in the trace file. You have to enable this option to others take effect.",
 484       detailed);
 485   print_line (OPT_TRACING_CATEGORIZED, "Trace categorized resource utilization",
 486       "  It activates the categorized resource utilization tracing. It should\n"
 487       "  be enabled if tracing categories are used by this simulator.",
 488       detailed);
 489   print_line (OPT_TRACING_UNCATEGORIZED, "Trace uncategorized resource utilization",
 490       "  It activates the uncategorized resource utilization tracing. Use it if\n"
 491       "  this simulator do not use tracing categories and resource use have to be\n"
 492       "  traced.",
 493       detailed);
 494   print_line (OPT_TRACING_FILENAME, "Filename to register traces",
 495       "  A file with this name will be created to register the simulation. The file\n"
 496       "  is in the Paje format and can be analyzed using Viva, Paje, and PajeNG visualization\n"
 497       "  tools. More information can be found in these webpages:\n"
 498       "     http://github.com/schnorr/viva/\n"
 499       "     http://github.com/schnorr/pajeng/\n"
 500       "     http://paje.sourceforge.net/",
 501       detailed);
 502   print_line (OPT_TRACING_SMPI, "Trace the MPI Interface (SMPI)",
 503       "  This option only has effect if this simulator is SMPI-based. Traces the MPI\n"
 504       "  interface and generates a trace that can be analyzed using Gantt-like\n"
 505       "  visualizations. Every MPI function (implemented by SMPI) is transformed in a\n"
 506       "  state, and point-to-point communications can be analyzed with arrows.",
 507       detailed);
 508   print_line (OPT_TRACING_SMPI_GROUP, "Group MPI processes by host (SMPI)",
 509       "  This option only has effect if this simulator is SMPI-based. The processes\n"
 510       "  are grouped by the hosts where they were executed.",
 511       detailed);
 512   print_line (OPT_TRACING_SMPI_COMPUTING, "Generates a \" Computing \" State",
 513       "  This option aims at tracing computations in the application, outside SMPI\n"
 514       "  to allow further study of simulated or real computation time",
 515       detailed);
 516   print_line (OPT_TRACING_SMPI_INTERNALS, "Generates tracing events corresponding",
 517       "  to point-to-point messages sent by collective communications",
 518       detailed);
 519   print_line (OPT_TRACING_MSG_PROCESS, "Trace processes behavior (MSG)",
 520       "  This option only has effect if this simulator is MSG-based. It traces the\n"
 521       "  behavior of all categorized MSG processes, grouping them by hosts. This option\n"
 522       "  can be used to track process location if this simulator has process migration.",
 523       detailed);
 524   print_line (OPT_TRACING_BUFFER, "Buffer events to put them in temporal order",
 525       "  This option put some events in a time-ordered buffer using the insertion\n"
 526       "  sort algorithm. The process of acquiring and releasing locks to access this\n"
 527       "  buffer and the cost of the sorting algorithm make this process slow. The\n"
 528       "  simulator performance can be severely impacted if this option is activated,\n"
 529       "  but you are sure to get a trace file with events sorted.",
 530       detailed);
 531   print_line (OPT_TRACING_ONELINK_ONLY, "Consider only one link routes to trace platform",
 532       "  This option changes the way SimGrid register its platform on the trace file.\n"
 533       "  Normally, the tracing considers all routes (no matter their size) on the\n"
 534       "  platform file to re-create the resource topology. If this option is activated,\n"
 535       "  only the routes with one link are used to register the topology within an AS.\n"
 536       "  Routes among AS continue to be traced as usual.",
 537       detailed);
 538   print_line (OPT_TRACING_DISABLE_DESTROY, "Disable platform containers destruction",
 539       "  Disable the destruction of containers at the end of simulation. This can be\n"
 540       "  used with simulators that have a different notion of time (different from\n"
 541       "  the simulated time).",
 542       detailed);
 543   print_line (OPT_TRACING_BASIC, "Avoid extended events (impoverished trace file).",
 544       "  Some visualization tools are not able to parse correctly the Paje file format.\n"
 545       "  Use this option if you are using one of these tools to visualize the simulation\n"
 546       "  trace. Keep in mind that the trace might be incomplete, without all the\n"
 547       "  information that would be registered otherwise.",
 548       detailed);
 549   print_line (OPT_TRACING_DISPLAY_SIZES, "Only works for SMPI now. Add message size information",
 550       "Message size (in bytes) is added to links, and to states. For collectives, the displayed value \n"
 551       "is the more relevant to the collective (total sent by the process, usually)",
 552       detailed);
 553   print_line (OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.",
 554       "  Use this to add a comment line to the top of the trace file.",
 555       detailed);
 556   print_line (OPT_TRACING_COMMENT_FILE, "File contents added to trace file as comment.",
 557       "  Use this to add the contents of a file to the top of the trace file as comment.",
 558       detailed);
 559   print_line (OPT_VIVA_UNCAT_CONF, "Generate a graph configuration for Viva",
 560       "  This option can be used in all types of simulators build with SimGrid\n"
 561       "  to generate a uncategorized resource utilization graph to be used as\n"
 562       "  configuration for the Viva visualization tool. This option\n"
 563       "  can be used with tracing/categorized:1 and tracing:1 options to\n"
 564       "  analyze an unmodified simulator before changing it to contain\n"
 565       "  categories.",
 566       detailed);
 567   print_line (OPT_VIVA_CAT_CONF, "Generate an uncategorized graph configuration for Viva",
 568       "  This option can be used if this simulator uses tracing categories\n"
 569       "  in its code. The file specified by this option holds a graph configuration\n"
 570       "  file for the Viva visualization tool that can be used to analyze a categorized\n"
 571       "  resource utilization.",
 572       detailed);
 573   print_line (OPT_TRACING_TOPOLOGY, "Register the platform topology as a graph",
 574         "  This option (enabled by default) can be used to disable the tracing of\n"
 575         "  the platform topology in the trace file. Sometimes, such task is really\n"
 576         "  time consuming, since it must get the route from each host ot other hosts\n"
 577         "  within the same Autonomous System (AS).",
 578         detailed);
 579 }
 580
 581 static void output_types (const char *name, xbt_dynar_t types, FILE *file)
 582 {
 583   unsigned int i;
 584   fprintf (file, "  %s = (", name);
 585   for (i = xbt_dynar_length(types); i > 0; i--) {
 586     char *type = *(char**)xbt_dynar_get_ptr(types, i - 1);
 587     fprintf (file, "\"%s\"", type);
 588     if (i - 1 > 0){
 589       fprintf (file, ",");
 590     }else{
 591       fprintf (file, ");\n");
 592     }
 593   }
 594   xbt_dynar_free (&types);
 595 }
 596
 597 static void output_categories (const char *name, xbt_dynar_t cats, FILE *file)
 598 {
 599   unsigned int i;
 600   fprintf (file, "    values = (");
 601   for (i = xbt_dynar_length(cats); i > 0; i--) {
 602     char *cat = *(char**)xbt_dynar_get_ptr(cats, i - 1);
 603     fprintf (file, "\"%s%s\"", name, cat);
 604     if (i - 1 > 0){
 605       fprintf (file, ",");
 606     }else{
 607       fprintf (file, ");\n");
 608     }
 609   }
 610   xbt_dynar_free (&cats);
 611 }
 612
 613 static void uncat_configuration (FILE *file)
 614 {
 615   //register NODE and EDGE types
 616   output_types ("node", TRACE_get_node_types(), file);
 617   output_types ("edge", TRACE_get_edge_types(), file);
 618   fprintf (file, "\n");
 619
 620   //configuration for all nodes
 621   fprintf (file,
 622       "  host = {\n"
 623       "    type = \"square\";\n"
 624       "    size = \"power\";\n"
 625       "    values = (\"power_used\");\n"
 626       "  };\n"
 627       "  link = {\n"
 628       "    type = \"rhombus\";\n"
 629       "    size = \"bandwidth\";\n"
 630       "    values = (\"bandwidth_used\");\n"
 631       "  };\n");
 632   //close
 633 }
 634
 635 static void cat_configuration (FILE *file)
 636 {
 637   //register NODE and EDGE types
 638   output_types ("node", TRACE_get_node_types(), file);
 639   output_types ("edge", TRACE_get_edge_types(), file);
 640   fprintf (file, "\n");
 641
 642   //configuration for all nodes
 643   fprintf (file,
 644            "  host = {\n"
 645            "    type = \"square\";\n"
 646            "    size = \"power\";\n");
 647   output_categories ("p", TRACE_get_categories(), file);
 648   fprintf (file,
 649            "  };\n"
 650            "  link = {\n"
 651            "    type = \"rhombus\";\n"
 652            "    size = \"bandwidth\";\n");
 653   output_categories ("b", TRACE_get_categories(), file);
 654   fprintf (file, "  };\n");
 655   //close
 656 }
 657
 658 static void generate_uncat_configuration (const char *output, const char *name, int brackets)
 659 {
 660   if (output && strlen(output) > 0){
 661     FILE *file = fopen (output, "w");
 662     if (file == NULL){
 663       THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph "
 664           "configuration (uncategorized).", output, name);
 665     }
 666
 667     if (brackets) fprintf (file, "{\n");
 668     uncat_configuration (file);
 669     if (brackets) fprintf (file, "}\n");
 670     fclose (file);
 671   }
 672 }
 673
 674 static void generate_cat_configuration (const char *output, const char *name, int brackets)
 675 {
 676   if (output && strlen(output) > 0){
 677     //check if we do have categories declared
 678     if (xbt_dict_is_empty(created_categories)){
 679       XBT_INFO("No categories declared, ignoring generation of %s graph configuration", name);
 680       return;
 681     }
 682
 683     FILE *file = fopen (output, "w");
 684     if (file == NULL){
 685       THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph "
 686           "configuration (categorized).", output, name);
 687     }
 688
 689     if (brackets) fprintf (file, "{\n");
 690     cat_configuration (file);
 691     if (brackets) fprintf (file, "}\n");
 692     fclose (file);
 693   }
 694 }
 695
 696 void TRACE_generate_viva_uncat_conf (void)
 697 {
 698   generate_uncat_configuration (TRACE_get_viva_uncat_conf (), "viva", 0);
 699 }
 700
 701 void TRACE_generate_viva_cat_conf (void)
 702 {
 703   generate_cat_configuration (TRACE_get_viva_cat_conf(), "viva", 0);
 704 }
 705
 706 static int previous_trace_state = -1;
 707
 708 void instr_pause_tracing (void)
 709 {
 710   previous_trace_state = trace_enabled;
 711   if (!TRACE_is_enabled()){
 712     XBT_DEBUG ("Tracing is already paused, therefore do nothing.");
 713   }else{
 714     XBT_DEBUG ("Tracing is being paused.");
 715   }
 716   trace_enabled = 0;
 717   XBT_DEBUG ("Tracing is paused.");
 718 }
 719
 720 void instr_resume_tracing (void)
 721 {
 722   if (TRACE_is_enabled()){
 723     XBT_DEBUG ("Tracing is already running while trying to resume, therefore do nothing.");
 724   }else{
 725     XBT_DEBUG ("Tracing is being resumed.");
 726   }
 727
 728   if (previous_trace_state != -1){
 729     trace_enabled = previous_trace_state;
 730   }else{
 731     trace_enabled = 1;
 732   }
 733   XBT_DEBUG ("Tracing is resumed.");
 734   previous_trace_state = -1;
 735 }
 736
 737 #undef OPT_TRACING
 738 #undef OPT_TRACING_PLATFORM
 739 #undef OPT_TRACING_TOPOLOGY
 740 #undef OPT_TRACING_SMPI
 741 #undef OPT_TRACING_SMPI_GROUP
 742 #undef OPT_TRACING_CATEGORIZED
 743 #undef OPT_TRACING_UNCATEGORIZED
 744 #undef OPT_TRACING_MSG_PROCESS
 745 #undef OPT_TRACING_FILENAME
 746 #undef OPT_TRACING_BUFFER
 747 #undef OPT_TRACING_ONELINK_ONLY
 748 #undef OPT_TRACING_DISABLE_DESTROY
 749 #undef OPT_TRACING_BASIC
 750 #undef OPT_TRACING_COMMENT
 751 #undef OPT_TRACING_COMMENT_FILE
 752 #undef OPT_VIVA_UNCAT_CONF
 753 #undef OPT_VIVA_CAT_CONF
 754
 755 #endif /* HAVE_TRACING */