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