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