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