src/instr/instr_trace.cpp

   1 /* Copyright (c) 2010-2015. 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 "src/instr/instr_private.h"
   8 #include "src/instr/instr_smpi.h"
   9 #include "xbt/virtu.h" /* sg_cmdline */
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_trace, instr, "tracing event system");
  12
  13 FILE *tracing_file = NULL;
  14
  15 void print_NULL(paje_event_t event){}
  16
  17 /* The active set of functions for the selected trace format
  18  * By default, they all do nothing, hence the print_NULL to avoid segfaults */
  19
  20 s_instr_trace_writer_t active_writer = {
  21     print_NULL, print_NULL, print_NULL, print_NULL,
  22     print_NULL, print_NULL, print_NULL, print_NULL,
  23     print_NULL, print_NULL, print_NULL, print_NULL,
  24     print_NULL, print_NULL, print_NULL, print_NULL,
  25     print_NULL, print_NULL
  26 };
  27
  28 xbt_dynar_t buffer = NULL;
  29
  30 void dump_comment (const char *comment)
  31 {
  32   if (!strlen(comment)) return;
  33   fprintf (tracing_file, "# %s\n", comment);
  34 }
  35
  36 void dump_comment_file (const char *filename)
  37 {
  38   if (!strlen(filename)) return;
  39   FILE *file = fopen (filename, "r");
  40   if (!file){
  41     THROWF (system_error, 1, "Comment file %s could not be opened for reading.", filename);
  42   }
  43   while (!feof(file)){
  44     char c;
  45     c = fgetc(file);
  46     if (feof(file)) break;
  47     fprintf (tracing_file, "# ");
  48     while (c != '\n'){
  49       fprintf (tracing_file, "%c", c);
  50       c = fgetc(file);
  51       if (feof(file)) break;
  52     }
  53     fprintf (tracing_file, "\n");
  54   }
  55   fclose(file);
  56 }
  57
  58 void TRACE_init()
  59 {
  60   buffer = xbt_dynar_new(sizeof(paje_event_t), NULL);
  61 }
  62
  63 void TRACE_finalize()
  64 {
  65   xbt_dynar_free(&buffer);
  66 }
  67
  68 double TRACE_last_timestamp_to_dump = 0;
  69 //dumps the trace file until the timestamp TRACE_last_timestamp_to_dump
  70 void TRACE_paje_dump_buffer (int force)
  71 {
  72   if (!TRACE_is_enabled()) return;
  73   XBT_DEBUG("%s: dump until %f. starts", __FUNCTION__, TRACE_last_timestamp_to_dump);
  74   if (force){
  75     paje_event_t event;
  76     unsigned int i;
  77     xbt_dynar_foreach(buffer, i, event){
  78       event->print (event);
  79       event->free (event);
  80     }
  81     xbt_dynar_free (&buffer);
  82     buffer = xbt_dynar_new (sizeof(paje_event_t), NULL);
  83   }else{
  84     paje_event_t event;
  85     unsigned int cursor;
  86     xbt_dynar_foreach(buffer, cursor, event) {
  87       double head_timestamp = event->timestamp;
  88       if (head_timestamp > TRACE_last_timestamp_to_dump){
  89         break;
  90       }
  91       event->print (event);
  92       event->free (event);
  93     }
  94     xbt_dynar_remove_n_at(buffer, cursor, 0);
  95   }
  96   XBT_DEBUG("%s: ends", __FUNCTION__);
  97 }
  98
  99 /* internal do the instrumentation module */
 100 static void insert_into_buffer (paje_event_t tbi)
 101 {
 102   if (TRACE_buffer() == 0){
 103     tbi->print (tbi);
 104     tbi->free (tbi);
 105     return;
 106   }
 107
 108   XBT_DEBUG("%s: insert event_type=%d, timestamp=%f, buffersize=%lu)",
 109       __FUNCTION__, (int)tbi->event_type, tbi->timestamp, xbt_dynar_length(buffer));
 110
 111   unsigned int i;
 112   for (i = xbt_dynar_length(buffer); i > 0; i--) {
 113     paje_event_t e1 = *(paje_event_t*)xbt_dynar_get_ptr(buffer, i - 1);
 114     if (e1->timestamp <= tbi->timestamp)
 115       break;
 116   }
 117   xbt_dynar_insert_at(buffer, i, &tbi);
 118   if (i == 0)
 119     XBT_DEBUG("%s: inserted at beginning", __FUNCTION__);
 120   else
 121     XBT_DEBUG("%s: inserted at%s %u", __FUNCTION__, (i == xbt_dynar_length(buffer) - 1 ? " end, pos =" : ""), i);
 122 }
 123
 124 static void free_paje_event (paje_event_t event)
 125 {
 126   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 127   switch (event->event_type){
 128   case PAJE_StartLink:
 129     xbt_free (((startLink_t)(event->data))->value);
 130     xbt_free (((startLink_t)(event->data))->key);
 131     break;
 132   case PAJE_EndLink:
 133     xbt_free (((endLink_t)(event->data))->value);
 134     xbt_free (((endLink_t)(event->data))->key);
 135     break;
 136   default:
 137     break;
 138   }
 139   xbt_free (event->data);
 140   xbt_free (event);
 141 }
 142
 143 void new_pajeDefineContainerType(type_t type)
 144 {
 145   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 146   event->event_type = PAJE_DefineContainerType;
 147   event->timestamp = 0;
 148   event->print = active_writer.print_DefineContainerType;
 149   event->free = free_paje_event;
 150   event->data = xbt_new0(s_defineContainerType_t, 1);
 151   ((defineContainerType_t)(event->data))->type = type;
 152
 153   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 154
 155   //print it
 156   event->print (event);
 157   event->free (event);
 158 }
 159
 160 void new_pajeDefineVariableType(type_t type)
 161 {
 162   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 163   event->event_type = PAJE_DefineVariableType;
 164   event->timestamp = 0;
 165   event->print = active_writer.print_DefineVariableType;
 166   event->free = free_paje_event;
 167   event->data = xbt_new0(s_defineVariableType_t, 1);
 168   ((defineVariableType_t)(event->data))->type = type;
 169
 170   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 171
 172   //print it
 173   event->print (event);
 174   event->free (event);
 175 }
 176
 177 void new_pajeDefineStateType(type_t type)
 178 {
 179   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 180   event->event_type = PAJE_DefineStateType;
 181   event->timestamp = 0;
 182   event->print = active_writer.print_DefineStateType;
 183   event->free = free_paje_event;
 184   event->data = xbt_new0(s_defineStateType_t, 1);
 185   ((defineStateType_t)(event->data))->type = type;
 186
 187   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 188
 189   //print it
 190   event->print (event);
 191   event->free (event);
 192 }
 193
 194 void new_pajeDefineEventType(type_t type)
 195 {
 196   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 197   event->event_type = PAJE_DefineEventType;
 198   event->timestamp = 0;
 199   event->print = active_writer.print_DefineEventType;
 200   event->free = free_paje_event;
 201   event->data = xbt_new0(s_defineEventType_t, 1);
 202   ((defineEventType_t)(event->data))->type = type;
 203
 204   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 205
 206   //print it
 207   event->print (event);
 208   event->free (event);
 209 }
 210
 211 void new_pajeDefineLinkType(type_t type, type_t source, type_t dest)
 212 {
 213   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 214   event->event_type = PAJE_DefineLinkType;
 215   event->timestamp = 0;
 216   event->print = active_writer.print_DefineLinkType;
 217   event->free = free_paje_event;
 218   event->data = xbt_new0(s_defineLinkType_t, 1);
 219   ((defineLinkType_t)(event->data))->type = type;
 220   ((defineLinkType_t)(event->data))->source = source;
 221   ((defineLinkType_t)(event->data))->dest = dest;
 222
 223   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 224
 225   //print it
 226   event->print (event);
 227   event->free (event);
 228 }
 229
 230 void new_pajeDefineEntityValue (val_t value)
 231 {
 232   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 233   event->event_type = PAJE_DefineEntityValue;
 234   event->timestamp = 0;
 235   event->print = active_writer.print_DefineEntityValue;
 236   event->free = free_paje_event;
 237   event->data = xbt_new0(s_defineEntityValue_t, 1);
 238   ((defineEntityValue_t)(event->data))->value = value;
 239
 240   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type);
 241
 242   //print it
 243   event->print (event);
 244   event->free (event);
 245 }
 246
 247 void new_pajeCreateContainer (container_t container)
 248 {
 249   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 250   event->event_type = PAJE_CreateContainer;
 251   event->timestamp = SIMIX_get_clock();
 252   event->print = active_writer.print_CreateContainer;
 253   event->free = free_paje_event;
 254   event->data = xbt_new0(s_createContainer_t, 1);
 255   ((createContainer_t)(event->data))->container = container;
 256
 257   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 258
 259   //print it
 260   event->print (event);
 261   event->free (event);
 262 }
 263
 264 void new_pajeDestroyContainer (container_t container)
 265 {
 266   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 267   event->event_type = PAJE_DestroyContainer;
 268   event->timestamp = SIMIX_get_clock();
 269   event->print = active_writer.print_DestroyContainer;
 270   event->free = free_paje_event;
 271   event->data = xbt_new0(s_destroyContainer_t, 1);
 272   ((destroyContainer_t)(event->data))->container = container;
 273
 274   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 275
 276   //print it
 277   event->print (event);
 278   event->free (event);
 279 }
 280
 281 void new_pajeSetVariable (double timestamp, container_t container, type_t type, double value)
 282 {
 283   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 284   event->event_type = PAJE_SetVariable;
 285   event->timestamp = timestamp;
 286   event->print = active_writer.print_SetVariable;
 287   event->free = free_paje_event;
 288   event->data = xbt_new0(s_setVariable_t, 1);
 289   ((setVariable_t)(event->data))->type = type;
 290   ((setVariable_t)(event->data))->container = container;
 291   ((setVariable_t)(event->data))->value = value;
 292
 293   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 294
 295   insert_into_buffer (event);
 296 }
 297
 298
 299 void new_pajeAddVariable (double timestamp, container_t container, type_t type, double value)
 300 {
 301   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 302   event->event_type = PAJE_AddVariable;
 303   event->timestamp = timestamp;
 304   event->print = active_writer.print_AddVariable;
 305   event->free = free_paje_event;
 306   event->data = xbt_new0(s_addVariable_t, 1);
 307   ((addVariable_t)(event->data))->type = type;
 308   ((addVariable_t)(event->data))->container = container;
 309   ((addVariable_t)(event->data))->value = value;
 310
 311   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 312
 313   insert_into_buffer (event);
 314 }
 315
 316 void new_pajeSubVariable (double timestamp, container_t container, type_t type, double value)
 317 {
 318   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 319   event->event_type = PAJE_SubVariable;
 320   event->timestamp = timestamp;
 321   event->print = active_writer.print_SubVariable;
 322   event->free = free_paje_event;
 323   event->data = xbt_new0(s_subVariable_t, 1);
 324   ((subVariable_t)(event->data))->type = type;
 325   ((subVariable_t)(event->data))->container = container;
 326   ((subVariable_t)(event->data))->value = value;
 327
 328   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 329
 330   insert_into_buffer (event);
 331 }
 332
 333 void new_pajeSetState (double timestamp, container_t container, type_t type, val_t value)
 334 {
 335   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 336   event->event_type = PAJE_SetState;
 337   event->timestamp = timestamp;
 338   event->print = active_writer.print_SetState;
 339   event->free = free_paje_event;
 340   event->data = xbt_new0(s_setState_t, 1);
 341   ((setState_t)(event->data))->type = type;
 342   ((setState_t)(event->data))->container = container;
 343   ((setState_t)(event->data))->value = value;
 344
 345   if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
 346     smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
 347     ((setState_t)(event->data))->filename   = loc->filename;
 348     ((setState_t)(event->data))->linenumber = loc->linenumber;
 349   }
 350
 351   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 352
 353   insert_into_buffer (event);
 354 }
 355
 356
 357 void new_pajePushStateWithExtra (double timestamp, container_t container, type_t type, val_t value, void* extra)
 358 {
 359   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 360   event->event_type = PAJE_PushState;
 361   event->timestamp = timestamp;
 362   event->print = active_writer.print_PushState;
 363   event->free = free_paje_event;
 364   event->data = xbt_new0(s_pushState_t, 1);
 365   ((pushState_t)(event->data))->type = type;
 366   ((pushState_t)(event->data))->container = container;
 367   ((pushState_t)(event->data))->value = value;
 368   ((pushState_t)(event->data))->extra = extra;
 369
 370   if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
 371     smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
 372     ((pushState_t)(event->data))->filename   = loc->filename;
 373     ((pushState_t)(event->data))->linenumber = loc->linenumber;
 374   }
 375
 376   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 377
 378   insert_into_buffer (event);
 379 }
 380
 381
 382 void new_pajePushState (double timestamp, container_t container, type_t type, val_t value)
 383 {
 384   new_pajePushStateWithExtra(timestamp, container, type, value, nullptr);
 385 }
 386
 387 void new_pajePopState (double timestamp, container_t container, type_t type)
 388 {
 389   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 390   event->event_type = PAJE_PopState;
 391   event->timestamp = timestamp;
 392   event->print = active_writer.print_PopState;
 393   event->free = free_paje_event;
 394   event->data = xbt_new0(s_popState_t, 1);
 395   ((popState_t)(event->data))->type = type;
 396   ((popState_t)(event->data))->container = container;
 397
 398   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 399
 400   insert_into_buffer (event);
 401 }
 402
 403
 404 void new_pajeResetState (double timestamp, container_t container, type_t type)
 405 {
 406   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 407   event->event_type = PAJE_ResetState;
 408   event->timestamp = timestamp;
 409   event->print = active_writer.print_ResetState;
 410   event->free = free_paje_event;
 411   event->data = xbt_new0(s_resetState_t, 1);
 412   ((resetState_t)(event->data))->type = type;
 413   ((resetState_t)(event->data))->container = container;
 414
 415   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 416
 417   insert_into_buffer (event);
 418 }
 419
 420 void new_pajeStartLink (double timestamp, container_t container, type_t type, container_t sourceContainer,
 421                         const char *value, const char *key)
 422 {
 423   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 424   event->event_type = PAJE_StartLink;
 425   event->timestamp = timestamp;
 426   event->print = active_writer.print_StartLink;
 427   event->free = free_paje_event;
 428   event->data = xbt_new0(s_startLink_t, 1);
 429   ((startLink_t)(event->data))->type = type;
 430   ((startLink_t)(event->data))->container = container;
 431   ((startLink_t)(event->data))->sourceContainer = sourceContainer;
 432   ((startLink_t)(event->data))->value = xbt_strdup(value);
 433   ((startLink_t)(event->data))->key = xbt_strdup(key);
 434   ((startLink_t)(event->data))->size = -1;
 435   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 436
 437   insert_into_buffer (event);
 438 }
 439
 440 void new_pajeStartLinkWithSize (double timestamp, container_t container, type_t type, container_t sourceContainer,
 441                                 const char *value, const char *key, int size)
 442 {
 443   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 444   event->event_type = PAJE_StartLink;
 445   event->timestamp = timestamp;
 446   event->print = active_writer.print_StartLink;
 447   event->free = free_paje_event;
 448   event->data = xbt_new0(s_startLink_t, 1);
 449   ((startLink_t)(event->data))->type = type;
 450   ((startLink_t)(event->data))->container = container;
 451   ((startLink_t)(event->data))->sourceContainer = sourceContainer;
 452   ((startLink_t)(event->data))->value = xbt_strdup(value);
 453   ((startLink_t)(event->data))->key = xbt_strdup(key);
 454   ((startLink_t)(event->data))->size = size;
 455
 456   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 457
 458   insert_into_buffer (event);
 459 }
 460
 461 void new_pajeEndLink (double timestamp, container_t container, type_t type, container_t destContainer,
 462                       const char *value, const char *key)
 463 {
 464   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 465   event->event_type = PAJE_EndLink;
 466   event->timestamp = timestamp;
 467   event->print = active_writer.print_EndLink;
 468   event->free = free_paje_event;
 469   event->data = xbt_new0(s_endLink_t, 1);
 470   ((endLink_t)(event->data))->type = type;
 471   ((endLink_t)(event->data))->container = container;
 472   ((endLink_t)(event->data))->destContainer = destContainer;
 473   ((endLink_t)(event->data))->value = xbt_strdup(value);
 474   ((endLink_t)(event->data))->key = xbt_strdup(key);
 475
 476   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 477
 478   insert_into_buffer (event);
 479 }
 480
 481 void new_pajeNewEvent (double timestamp, container_t container, type_t type, val_t value)
 482 {
 483   paje_event_t event = xbt_new0(s_paje_event_t, 1);
 484   event->event_type = PAJE_NewEvent;
 485   event->timestamp = timestamp;
 486   event->print = active_writer.print_NewEvent;
 487   event->free = free_paje_event;
 488   event->data = xbt_new0(s_newEvent_t, 1);
 489   ((newEvent_t)(event->data))->type = type;
 490   ((newEvent_t)(event->data))->container = container;
 491   ((newEvent_t)(event->data))->value = value;
 492
 493   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
 494
 495   insert_into_buffer (event);
 496 }