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