Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Disable uninteresting events in TI mode
[simgrid.git] / src / instr / instr_paje_trace.cpp
1 /* Copyright (c) 2010-2016. 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 "typeinfo"
11 #include "xbt/virtu.h" /* sg_cmdline */
12 #include "simgrid/sg_config.h"
13
14 #include <sstream>
15 #include <vector>
16 #include <iomanip> /** std::setprecision **/
17 #include <sys/stat.h>
18 #ifdef WIN32
19 #include <direct.h> // _mkdir
20 #endif
21
22 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr, "tracing event system");
23
24 extern s_instr_trace_writer_t active_writer;
25
26 static std::stringstream stream;
27 FILE *tracing_file = nullptr;
28
29 static xbt_dict_t tracing_files = nullptr; // TI specific
30 static double prefix=0.0; // TI specific
31
32
33 void print_NULL(PajeEvent* event){}
34
35 /* The active set of functions for the selected trace format
36  * By default, they all do nothing, hence the print_NULL to avoid segfaults */
37
38 s_instr_trace_writer_t active_writer = {&print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL,
39                                         &print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL,
40                                         &print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL, &print_NULL};
41
42 std::vector<PajeEvent*> buffer;
43 void buffer_debug(std::vector<PajeEvent*> *buf);
44
45 void dump_comment (const char *comment)
46 {
47   if (!strlen(comment)) return;
48   fprintf (tracing_file, "# %s\n", comment);
49 }
50
51 void dump_comment_file (const char *filename)
52 {
53   if (!strlen(filename)) return;
54   FILE *file = fopen (filename, "r");
55   if (!file){
56     THROWF (system_error, 1, "Comment file %s could not be opened for reading.", filename);
57   }
58   while (!feof(file)){
59     char c;
60     c = fgetc(file);
61     if (feof(file)) break;
62     fprintf (tracing_file, "# ");
63     while (c != '\n'){
64       fprintf (tracing_file, "%c", c);
65       c = fgetc(file);
66       if (feof(file)) break;
67     }
68     fprintf (tracing_file, "\n");
69   }
70   fclose(file);
71 }
72
73 double TRACE_last_timestamp_to_dump = 0;
74 //dumps the trace file until the timestamp TRACE_last_timestamp_to_dump
75 void TRACE_paje_dump_buffer (int force)
76 {
77   if (!TRACE_is_enabled()) return;
78   XBT_DEBUG("%s: dump until %f. starts", __FUNCTION__, TRACE_last_timestamp_to_dump);
79   if (force){
80     for (auto event : buffer){
81       event->print();
82       delete event;
83     }
84     buffer.clear();
85   }else{
86     std::vector<PajeEvent*>::iterator i = buffer.begin();
87     for (auto event :buffer){
88       double head_timestamp = event->timestamp;
89       if (head_timestamp > TRACE_last_timestamp_to_dump)
90         break;
91       event->print();
92       delete event;
93       ++i;
94     }
95     buffer.erase(buffer.begin(), i);
96   }
97   XBT_DEBUG("%s: ends", __FUNCTION__);
98 }
99
100 void buffer_debug(std::vector<PajeEvent*> *buf);
101 void buffer_debug(std::vector<PajeEvent*> *buf) {
102   return;
103   XBT_DEBUG(">>>>>> Dump the state of the buffer. %zu events", buf->size());
104   for (auto event :*buf){
105     event->print();
106     XBT_DEBUG("%p %s", event, stream.str().c_str());
107     stream.str("");
108     stream.clear();
109   }
110   XBT_DEBUG("<<<<<<");
111 }
112
113 static void print_row() {
114   stream << std::endl;
115   fprintf(tracing_file, "%s", stream.str().c_str());
116   XBT_DEBUG("Dump %s", stream.str().c_str());
117   stream.str("");
118   stream.clear();
119 }
120
121 static void print_timestamp(PajeEvent* event) {
122   stream << " ";
123   /* prevent 0.0000 in the trace - this was the behavior before the transition to c++ */
124   if (event->timestamp < 1e-12)
125     stream << 0;
126   else 
127     stream << event->timestamp;
128 }  
129
130 /* internal do the instrumentation module */
131 static void insert_into_buffer (PajeEvent* tbi)
132 {
133   if (TRACE_buffer() == 0){
134     tbi->print ();
135     delete tbi;
136     return;
137   }
138   buffer_debug(&buffer);
139
140   XBT_DEBUG("%s: insert event_type=%d, timestamp=%f, buffersize=%zu)",
141       __FUNCTION__, (int)tbi->event_type, tbi->timestamp, buffer.size());
142   std::vector<PajeEvent*>::reverse_iterator i;
143   for (i = buffer.rbegin(); i != buffer.rend(); ++i) {
144     PajeEvent* e1 = *i;
145     XBT_DEBUG("compare to %p is of type %d; timestamp:%f", e1,
146         (int)e1->event_type, e1->timestamp);
147     if (e1->timestamp <= tbi->timestamp)
148       break;
149   }
150   buffer.insert(i.base(), tbi);
151   if (i == buffer.rend())
152     XBT_DEBUG("%s: inserted at beginning", __FUNCTION__);
153   else if (i == buffer.rbegin())
154     XBT_DEBUG("%s: inserted at end", __FUNCTION__);
155   else
156     XBT_DEBUG("%s: inserted at pos= %zd from its end", __FUNCTION__,
157         std::distance(buffer.rbegin(),i));
158
159   buffer_debug(&buffer);
160 }
161
162 PajeEvent:: ~PajeEvent()
163 {
164   XBT_DEBUG("%s not implemented for %p: event_type=%d, timestamp=%f", __FUNCTION__,
165       this, (int)event_type, timestamp);
166 //  xbt_backtrace_display_current();
167
168  /* switch (event->event_type){
169   case PAJE_StartLink:
170     xbt_free (((startLink_t)(event->data))->value);
171     xbt_free (((startLink_t)(event->data))->key);
172     break;
173   case PAJE_EndLink:
174     xbt_free (((endLink_t)(event->data))->value);
175     xbt_free (((endLink_t)(event->data))->key);
176     break;
177   default:
178     break;
179   }*/
180 }
181
182 void TRACE_paje_start() {
183   char *filename = TRACE_get_filename();
184   tracing_file = fopen(filename, "w");
185   if (tracing_file == nullptr){
186     THROWF (system_error, 1, "Tracefile %s could not be opened for writing.", filename);
187   }
188
189   XBT_DEBUG("Filename %s is open for writing", filename);
190
191   /* output generator version */
192   fprintf (tracing_file, "#This file was generated using SimGrid-%d.%d.%d\n",
193            SIMGRID_VERSION_MAJOR, SIMGRID_VERSION_MINOR, SIMGRID_VERSION_PATCH);
194   fprintf (tracing_file, "#[");
195   unsigned int cpt;
196   char *str;
197   xbt_dynar_foreach (xbt_cmdline, cpt, str){
198     fprintf(tracing_file, "%s ",str);
199   }
200   fprintf (tracing_file, "]\n");
201
202   /* output one line comment */
203   dump_comment (TRACE_get_comment());
204
205   /* output comment file */
206   dump_comment_file (TRACE_get_comment_file());
207
208   /* output header */
209   TRACE_header(TRACE_basic(),TRACE_display_sizes());
210 }
211
212 void TRACE_paje_end() {
213   fclose(tracing_file);
214   char *filename = TRACE_get_filename();
215   XBT_DEBUG("Filename %s is closed", filename);
216 }
217
218 DefineContainerEvent::DefineContainerEvent(type_t type)
219 {
220
221   event_type                            = PAJE_DefineContainerType;
222   timestamp                             = 0;
223   this->type = type;
224   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
225   //print it
226   print ();
227 }
228
229 void DefineContainerEvent::print() {
230         if (instr_fmt_type == instr_fmt_paje) {
231                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
232                 stream << std::fixed << std::setprecision(TRACE_precision());
233                 stream << (int)this->event_type;
234                 stream << " " << type->id
235                                 << " " << type->father->id
236                                 << " " << type->name;
237                 print_row();
238         } else if (instr_fmt_type == instr_fmt_TI) {
239                 /* Nothing to do */
240         } else {
241                 THROW_IMPOSSIBLE;
242         }
243
244 }
245
246
247
248 DefineVariableTypeEvent::DefineVariableTypeEvent(type_t type)
249 {
250   this->event_type                           = PAJE_DefineVariableType;
251   this->timestamp                            = 0;
252   this->type = type;
253
254   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
255
256   //print it
257   print ();
258 }
259
260 void DefineVariableTypeEvent::print() {
261         if (instr_fmt_type == instr_fmt_paje) {
262                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
263                 stream << std::fixed << std::setprecision(TRACE_precision());
264                 stream << (int)this->event_type;
265                 stream << " " << type->id
266                                 << " " << type->father->id
267                                 << " " << type->name;
268                 if (type->color)
269                         stream << " \"" << type->color << "\"";
270                 print_row();
271         } else if (instr_fmt_type == instr_fmt_TI) {
272                 /* Nothing to do */
273         } else {
274                 THROW_IMPOSSIBLE;
275         }
276 }
277
278 DefineStateTypeEvent::DefineStateTypeEvent(type_t type)
279 {
280   this->event_type                        = PAJE_DefineStateType;
281   this->timestamp                         = 0;
282   this->type = type;
283
284   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
285
286   //print it
287   print();
288 }
289
290
291 DefineEventTypeEvent::DefineEventTypeEvent(type_t type)
292 {
293   this->event_type                        = PAJE_DefineEventType;
294   this->timestamp                         = 0;
295   this->type = type;
296
297   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
298
299   //print it
300   print();
301 }
302
303
304 void DefineStateTypeEvent::print() {
305         if (instr_fmt_type == instr_fmt_paje) {
306                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
307                 stream << std::fixed << std::setprecision(TRACE_precision());
308                 stream << (int)this->event_type;
309                 stream << " " << type->id
310                                 << " " << type->father->id
311                                 << " " << type->name;
312                 print_row();
313         } else if (instr_fmt_type == instr_fmt_TI) {
314                 /* Nothing to do */
315         } else {
316                 THROW_IMPOSSIBLE;
317         }
318 }
319
320 void DefineEventTypeEvent::print() {
321         if (instr_fmt_type == instr_fmt_paje) {
322                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
323                 stream << std::fixed << std::setprecision(TRACE_precision());
324                 stream << (int)this->event_type;
325                 stream << " " << type->id
326                                 << " " << type->father->id
327                                 << " " << type->name;
328                 print_row();
329         } else if (instr_fmt_type == instr_fmt_TI) {
330                 /* Nothing to do */
331         } else {
332                 THROW_IMPOSSIBLE;
333         }
334 }
335
336 DefineLinkTypeEvent::DefineLinkTypeEvent(type_t type, type_t source, type_t dest)
337 {
338   this->event_type                         = PAJE_DefineLinkType;
339   this->timestamp                          = 0;
340   this->type   = type;
341   this->source = source;
342   this->dest   = dest;
343
344   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
345
346   //print it
347   print();
348 }
349
350 void DefineLinkTypeEvent::print() {
351         if (instr_fmt_type == instr_fmt_paje) {
352                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
353                 stream << std::fixed << std::setprecision(TRACE_precision());
354                 stream << (int)this->event_type;
355                 stream << " " << type->id
356                                 << " " << type->father->id
357                                 << " " << source->id
358                                 << " " << dest->id
359                                 << " " << type->name;
360                 print_row();
361         } else if (instr_fmt_type == instr_fmt_TI) {
362                 /* Nothing to do */
363         } else {
364                 THROW_IMPOSSIBLE;
365         }
366 }
367
368 DefineEntityValueEvent::DefineEntityValueEvent (val_t value)
369 {
370   this->event_type                           = PAJE_DefineEntityValue;
371   this->timestamp                            = 0;
372   this->value = value;
373
374   XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event_type);
375
376   //print it
377   print();
378 }
379
380
381 void DefineEntityValueEvent::print() {
382         if (instr_fmt_type == instr_fmt_paje) {
383                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
384                 stream << std::fixed << std::setprecision(TRACE_precision());
385                 stream << (int)this->event_type;
386                 stream << " "   << value->id
387                                 << " "   << value->father->id
388                                 << " "   << value->name;
389                 if(value->color)
390                         stream << " \"" << value->color << "\"";
391                 print_row();
392         } else if (instr_fmt_type == instr_fmt_TI) {
393                 /* Nothing to do */
394         } else {
395                 THROW_IMPOSSIBLE;
396         }
397 }
398
399 CreateContainerEvent::CreateContainerEvent (container_t container)
400 {
401   this->event_type                             = PAJE_CreateContainer;
402   this->timestamp                              = SIMIX_get_clock();
403   this->container = container;
404
405   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
406
407   print();
408 }
409
410 void CreateContainerEvent::print() {
411         if (instr_fmt_type == instr_fmt_paje) {
412                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
413                 stream << std::fixed << std::setprecision(TRACE_precision());
414                 stream << (int)this->event_type;
415                 print_timestamp(this);
416                 stream << " "   << container->id
417                                 << " "   << container->type->id
418                                 << " "   << container->father->id
419                                 << " \"" << container->name << "\"";
420
421                 print_row();
422         } else if (instr_fmt_type == instr_fmt_TI) {
423                 //if we are in the mode with only one file
424                 static FILE *ti_unique_file = nullptr;
425
426                 if (tracing_files == nullptr) {
427                         tracing_files = xbt_dict_new_homogeneous(nullptr);
428                         //generate unique run id with time
429                         prefix = xbt_os_time();
430                 }
431
432                 if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || ti_unique_file == nullptr) {
433                         char *folder_name = bprintf("%s_files", TRACE_get_filename());
434                         char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix, container->name);
435 #ifdef WIN32
436                         _mkdir(folder_name);
437 #else
438                         mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
439 #endif
440                         ti_unique_file = fopen(filename, "w");
441                         xbt_assert(ti_unique_file, "Tracefile %s could not be opened for writing: %s", filename, strerror(errno));
442                         fprintf(tracing_file, "%s\n", filename);
443
444                         xbt_free(folder_name);
445                         xbt_free(filename);
446                 }
447
448                 xbt_dict_set(tracing_files, container->name, (void *) ti_unique_file, nullptr);
449         } else {
450                 THROW_IMPOSSIBLE;
451         }
452 }
453
454 DestroyContainerEvent::DestroyContainerEvent (container_t container)
455 {
456   this->event_type                              = PAJE_DestroyContainer;
457   this->timestamp                               = SIMIX_get_clock();
458   this->container = container;
459
460   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
461
462   print();
463 }
464
465 void DestroyContainerEvent::print() {
466         if (instr_fmt_type == instr_fmt_paje) {
467                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
468                 stream << std::fixed << std::setprecision(TRACE_precision());
469                 stream << (int)this->event_type;
470                 print_timestamp(this);
471                 stream << " "   << container->type->id
472                                 << " "   << container->id;
473
474                 print_row();
475         } else if (instr_fmt_type == instr_fmt_TI) {
476                 if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file")|| xbt_dict_length(tracing_files) == 1) {
477                         FILE* f = (FILE*)xbt_dict_get_or_null(tracing_files, container->name);
478                         fclose(f);
479                 }
480                 xbt_dict_remove(tracing_files, container->name);
481         } else {
482                 THROW_IMPOSSIBLE;
483         }
484 }
485
486 SetVariableEvent::SetVariableEvent (double timestamp, container_t container, type_t type, double value)
487 {
488   this->event_type                         = PAJE_SetVariable;
489   this->timestamp                          = timestamp;
490   this->type      = type;
491   this->container = container;
492   this->value     = value;
493
494   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
495
496   insert_into_buffer (this);
497 }
498
499 void SetVariableEvent::print() {
500         if (instr_fmt_type == instr_fmt_paje) {
501                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
502                 stream << std::fixed << std::setprecision(TRACE_precision());
503                 stream << (int)this->event_type;
504                 print_timestamp(this);
505                 stream << " " << type->id
506                                 << " " << container->id
507                                 << " " << value;
508                 print_row();
509         } else if (instr_fmt_type == instr_fmt_TI) {
510                 /* Nothing to do */
511         } else {
512                 THROW_IMPOSSIBLE;
513         }
514 }
515
516 AddVariableEvent::AddVariableEvent (double timestamp, container_t container, type_t type, double value)
517 {
518   this->event_type                         = PAJE_AddVariable;
519   this->timestamp                          = timestamp;
520   this->type      = type;
521   this->container = container;
522   this->value     = value;
523
524   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
525
526   insert_into_buffer (this);
527 }
528
529 void AddVariableEvent::print() {
530         if (instr_fmt_type == instr_fmt_paje) {
531                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
532                 stream << std::fixed << std::setprecision(TRACE_precision());
533                 stream << (int)this->event_type;
534                 print_timestamp(this);
535                 stream << " " << type->id
536                                 << " " << container->id
537                                 << " " << value;
538                 print_row();
539         } else if (instr_fmt_type == instr_fmt_TI) {
540                 /* Nothing to do */
541         } else {
542                 THROW_IMPOSSIBLE;
543         }
544 }
545
546 SubVariableEvent::SubVariableEvent (double timestamp, container_t container, type_t type, double value)
547 {
548   this->event_type                         = PAJE_SubVariable;
549   this->timestamp                          = timestamp;
550   this->type      = type;
551   this->container = container;
552   this->value     = value;
553
554   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
555
556   insert_into_buffer (this);
557 }
558
559 void SubVariableEvent::print() {
560         if (instr_fmt_type == instr_fmt_paje) {
561                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
562                 stream << std::fixed << std::setprecision(TRACE_precision());
563                 stream << (int)this->event_type;
564                 print_timestamp(this);
565                 stream << " " << type->id
566                                 << " " << container->id
567                                 << " " << value;
568                 print_row();
569         } else if (instr_fmt_type == instr_fmt_TI) {
570                 /* Nothing to do */
571         } else {
572                 THROW_IMPOSSIBLE;
573         }
574 }
575
576 SetStateEvent::SetStateEvent (double timestamp, container_t container, type_t type, val_t value)
577 {
578   this->event_type                      = PAJE_SetState;
579   this->timestamp                       = timestamp;
580   this->type      = type;
581   this->container = container;
582   this->value     = value;
583
584 #if HAVE_SMPI
585   if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
586     smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
587     filename   = loc->filename;
588     linenumber = loc->linenumber;
589   }
590 #endif
591
592   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
593
594   insert_into_buffer (this);
595 }
596
597 void SetStateEvent::print() {
598         if (instr_fmt_type == instr_fmt_paje) {
599                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
600                 stream << std::fixed << std::setprecision(TRACE_precision());
601                 stream << (int)this->event_type;
602                 print_timestamp(this);
603                 stream << " " << type->id
604                                 << " " << container->id;
605                 stream << " " <<value->id;
606 #if HAVE_SMPI
607                 if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
608                         stream << " \"" << filename
609                                         << "\" " << linenumber;
610                 }
611 #endif
612                 print_row();
613         } else if (instr_fmt_type == instr_fmt_TI) {
614                 /* Nothing to do */
615         } else {
616                 THROW_IMPOSSIBLE;
617         }
618 }
619
620 PushStateEvent::PushStateEvent (double timestamp, container_t container, type_t type, val_t value, void* extra)
621 {
622   this->event_type                  = PAJE_PushState;
623   this->timestamp                   = timestamp;
624   this->type = type;
625   this->container = container;
626   this->value     = value;
627   this->extra_     = extra;
628
629 #if HAVE_SMPI
630   if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
631     smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
632     filename   = loc->filename;
633     linenumber = loc->linenumber;
634   }
635 #endif
636
637   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
638
639   insert_into_buffer (this);
640 }
641
642 PushStateEvent::PushStateEvent (double timestamp, container_t container, type_t type, val_t value)
643  : PushStateEvent(timestamp, container, type, value, nullptr)
644 {}
645 void PushStateEvent::print() {
646         if (instr_fmt_type == instr_fmt_paje) {
647                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
648                 stream << std::fixed << std::setprecision(TRACE_precision());
649                 stream << (int)this->event_type;
650                 print_timestamp(this);
651                 stream << " " << type->id
652                                 << " " << container->id;
653                 stream << " " <<value->id;
654
655                 if (TRACE_display_sizes()) {
656                         stream << " ";
657                         if (extra_ != nullptr) {
658                                 stream << static_cast<instr_extra_data>(extra_)->send_size;
659                         }
660                         else {
661                                 stream << 0;
662                         }
663                 }
664 #if HAVE_SMPI
665                 if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
666                         stream << " \"" << filename
667                                         << "\" " << linenumber;
668                 }
669 #endif
670                 print_row();
671
672                 if (extra_ != nullptr) {
673                         if (static_cast<instr_extra_data>(extra_)->sendcounts != nullptr)
674                                 xbt_free(static_cast<instr_extra_data>(extra_)->sendcounts);
675                         if (static_cast<instr_extra_data>(extra_)->recvcounts != nullptr)
676                                 xbt_free(static_cast<instr_extra_data>(extra_)->recvcounts);
677                         xbt_free(extra_);
678                 }
679         } else if (instr_fmt_type == instr_fmt_TI) {
680                   if (extra_ == nullptr)
681                     return;
682                   instr_extra_data extra = (instr_extra_data)extra_;
683
684                   char *process_id = nullptr;
685                   //FIXME: dirty extract "rank-" from the name, as we want the bare process id here
686                   if (strstr(container->name, "rank-") == nullptr)
687                     process_id = xbt_strdup(container->name);
688                   else
689                     process_id = xbt_strdup(container->name + 5);
690
691                   FILE* trace_file =  (FILE* )xbt_dict_get(tracing_files, container->name);
692
693                   switch (extra->type) {
694                   case TRACING_INIT:
695                     fprintf(trace_file, "%s init\n", process_id);
696                     break;
697                   case TRACING_FINALIZE:
698                     fprintf(trace_file, "%s finalize\n", process_id);
699                     break;
700                   case TRACING_SEND:
701                     fprintf(trace_file, "%s send %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
702                     break;
703                   case TRACING_ISEND:
704                     fprintf(trace_file, "%s Isend %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
705                     break;
706                   case TRACING_RECV:
707                     fprintf(trace_file, "%s recv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
708                     break;
709                   case TRACING_IRECV:
710                     fprintf(trace_file, "%s Irecv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
711                     break;
712                   case TRACING_TEST:
713                     fprintf(trace_file, "%s test\n", process_id);
714                     break;
715                   case TRACING_WAIT:
716                     fprintf(trace_file, "%s wait\n", process_id);
717                     break;
718                   case TRACING_WAITALL:
719                     fprintf(trace_file, "%s waitAll\n", process_id);
720                     break;
721                   case TRACING_BARRIER:
722                     fprintf(trace_file, "%s barrier\n", process_id);
723                     break;
724                   case TRACING_BCAST:          // rank bcast size (root) (datatype)
725                     fprintf(trace_file, "%s bcast %d ", process_id, extra->send_size);
726                     if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
727                       fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
728                     fprintf(trace_file, "\n");
729                     break;
730                   case TRACING_REDUCE:         // rank reduce comm_size comp_size (root) (datatype)
731                     fprintf(trace_file, "%s reduce %d %f ", process_id, extra->send_size, extra->comp_size);
732                     if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
733                       fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
734                     fprintf(trace_file, "\n");
735                     break;
736                   case TRACING_ALLREDUCE:      // rank allreduce comm_size comp_size (datatype)
737                     fprintf(trace_file, "%s allReduce %d %f %s\n", process_id, extra->send_size, extra->comp_size, extra->datatype1);
738                     break;
739                   case TRACING_ALLTOALL:       // rank alltoall send_size recv_size (sendtype) (recvtype)
740                     fprintf(trace_file, "%s allToAll %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->datatype1,
741                             extra->datatype2);
742                     break;
743                   case TRACING_ALLTOALLV:      // rank alltoallv send_size [sendcounts] recv_size [recvcounts] (sendtype) (recvtype)
744                     fprintf(trace_file, "%s allToAllV %d ", process_id, extra->send_size);
745                     for (int i = 0; i < extra->num_processes; i++)
746                       fprintf(trace_file, "%d ", extra->sendcounts[i]);
747                     fprintf(trace_file, "%d ", extra->recv_size);
748                     for (int i = 0; i < extra->num_processes; i++)
749                       fprintf(trace_file, "%d ", extra->recvcounts[i]);
750                     fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
751                     break;
752                   case TRACING_GATHER:         // rank gather send_size recv_size root (sendtype) (recvtype)
753                     fprintf(trace_file, "%s gather %d %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->root,
754                             extra->datatype1, extra->datatype2);
755                     break;
756                   case TRACING_ALLGATHERV:     // rank allgatherv send_size [recvcounts] (sendtype) (recvtype)
757                     fprintf(trace_file, "%s allGatherV %d ", process_id, extra->send_size);
758                     for (int i = 0; i < extra->num_processes; i++)
759                       fprintf(trace_file, "%d ", extra->recvcounts[i]);
760                     fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
761                     break;
762                   case TRACING_REDUCE_SCATTER: // rank reducescatter [recvcounts] comp_size (sendtype)
763                     fprintf(trace_file, "%s reduceScatter ", process_id);
764                     for (int i = 0; i < extra->num_processes; i++)
765                       fprintf(trace_file, "%d ", extra->recvcounts[i]);
766                     fprintf(trace_file, "%f %s\n", extra->comp_size, extra->datatype1);
767                     break;
768                   case TRACING_COMPUTING:
769                     fprintf(trace_file, "%s compute %f\n", process_id, extra->comp_size);
770                     break;
771                   case TRACING_SLEEPING:
772                     fprintf(trace_file, "%s sleep %f\n", process_id, extra->sleep_duration);
773                     break;
774                   case TRACING_GATHERV: // rank gatherv send_size [recvcounts] root (sendtype) (recvtype)
775                     fprintf(trace_file, "%s gatherV %d ", process_id, extra->send_size);
776                     for (int i = 0; i < extra->num_processes; i++)
777                       fprintf(trace_file, "%d ", extra->recvcounts[i]);
778                     fprintf(trace_file, "%d %s %s\n", extra->root, extra->datatype1, extra->datatype2);
779                     break;
780                   case TRACING_WAITANY:
781                   case TRACING_SENDRECV:
782                   case TRACING_SCATTER:
783                   case TRACING_SCATTERV:
784                   case TRACING_ALLGATHER:
785                   case TRACING_SCAN:
786                   case TRACING_EXSCAN:
787                   case TRACING_COMM_SIZE:
788                   case TRACING_COMM_SPLIT:
789                   case TRACING_COMM_DUP:
790                   case TRACING_SSEND:
791                   case TRACING_ISSEND:
792                   default:
793                     XBT_WARN ("Call from %s impossible to translate into replay command : Not implemented (yet)",
794                          value->name);
795                     break;
796                   }
797
798                   if (extra->recvcounts != nullptr)
799                     xbt_free(extra->recvcounts);
800                   if (extra->sendcounts != nullptr)
801                     xbt_free(extra->sendcounts);
802                   xbt_free(process_id);
803                   xbt_free(extra);
804
805         } else {
806                 THROW_IMPOSSIBLE;
807         }
808 }
809
810
811 PopStateEvent::PopStateEvent (double timestamp, container_t container, type_t type)
812 {
813   this->event_type                      = PAJE_PopState;
814   this->timestamp                       = timestamp;
815   this->type      = type;
816   this->container = container;
817
818   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
819
820   insert_into_buffer (this);
821 }
822
823 void PopStateEvent::print() {
824         if (instr_fmt_type == instr_fmt_paje) {
825                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
826                 stream << std::fixed << std::setprecision(TRACE_precision());
827                 stream << (int)this->event_type;
828                 print_timestamp(this);
829                 stream << " " << type->id
830                                 << " " << container->id;
831                 print_row();
832         } else if (instr_fmt_type == instr_fmt_TI) {
833                 /* Nothing to do */
834         } else {
835                 THROW_IMPOSSIBLE;
836         }
837 }
838
839 ResetStateEvent::ResetStateEvent (double timestamp, container_t container, type_t type)
840 {
841   this->event_type                        = PAJE_ResetState;
842   this->timestamp                         = timestamp;
843   this->type      = type;
844   this->container = container;
845
846   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
847
848   insert_into_buffer (this);
849 }
850
851 void ResetStateEvent::print() {
852         if (instr_fmt_type == instr_fmt_paje) {
853                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
854                 stream << std::fixed << std::setprecision(TRACE_precision());
855                 stream << (int)this->event_type;
856                 print_timestamp(this);
857                 stream << " " << type->id
858                                 << " " << container->id;
859                 print_row();
860         } else if (instr_fmt_type == instr_fmt_TI) {
861                 /* Nothing to do */
862         } else {
863                 THROW_IMPOSSIBLE;
864         }
865 }
866
867 StartLinkEvent::StartLinkEvent (double timestamp, container_t container,
868     type_t type, container_t sourceContainer, const char *value, const char *key)
869   : StartLinkEvent(timestamp, container, type, sourceContainer, value, key, -1)
870 {}
871
872 StartLinkEvent::StartLinkEvent (double timestamp, container_t container, type_t type, container_t sourceContainer,
873                                 const char *value, const char *key, int size)
874 {
875   event_type                             = PAJE_StartLink;
876   this->timestamp       = timestamp;
877   this->type            = type;
878   this->container       = container;
879   this->sourceContainer = sourceContainer;
880   this->value           = xbt_strdup(value);
881   this->key             = xbt_strdup(key);
882   this->size            = size;
883
884   XBT_DEBUG("%s: event_type=%d, timestamp=%f, value:%s", __FUNCTION__,
885       (int)event_type, this->timestamp, this->value);
886
887   insert_into_buffer (this);
888 }
889
890 void StartLinkEvent::print() {
891         if (instr_fmt_type == instr_fmt_paje) {
892                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
893                 stream << std::fixed << std::setprecision(TRACE_precision());
894                 stream << (int)this->event_type;
895                 print_timestamp(this);
896                 stream << " " <<type->id
897                                 << " " <<container->id
898                                 << " " <<value;
899                 stream << " " << sourceContainer->id
900                                 << " " << key;
901
902                 if (TRACE_display_sizes()) {
903                         stream << " " << size;
904                 }
905                 print_row();
906         } else if (instr_fmt_type == instr_fmt_TI) {
907                 /* Nothing to do */
908         } else {
909                 THROW_IMPOSSIBLE;
910         }
911 }
912
913 EndLinkEvent::EndLinkEvent (double timestamp, container_t container, type_t type, container_t destContainer,
914                       const char *value, const char *key)
915 {
916   this->event_type                         = PAJE_EndLink;
917   this->timestamp                          = timestamp;
918   this->type          = type;
919   this->container     = container;
920   this->destContainer = destContainer;
921   this->value         = xbt_strdup(value);
922   this->key           = xbt_strdup(key);
923
924   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
925
926   insert_into_buffer (this);
927 }
928
929
930 void EndLinkEvent::print() {
931         if (instr_fmt_type == instr_fmt_paje) {
932                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
933                 stream << std::fixed << std::setprecision(TRACE_precision());
934                 stream << (int)this->event_type;
935                 print_timestamp(this);
936                 stream << " " <<type->id
937                                 << " " <<container->id
938                                 << " " <<value;
939                 stream << " " << destContainer->id
940                                 << " " << key;
941                 print_row();
942         } else if (instr_fmt_type == instr_fmt_TI) {
943                 /* Nothing to do */
944         } else {
945                 THROW_IMPOSSIBLE;
946         }
947 }
948
949 NewEvent::NewEvent (double timestamp, container_t container, type_t type, val_t value)
950 {
951   this->event_type                      = PAJE_NewEvent;
952   this->timestamp                       = timestamp;
953   this->type      = type;
954   this->container = container;
955   this->value     = value;
956
957   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
958
959   insert_into_buffer (this);
960 }
961
962 void NewEvent::print () {
963         if (instr_fmt_type == instr_fmt_paje) {
964                 XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
965                 stream << std::fixed << std::setprecision(TRACE_precision());
966                 stream << (int)this->event_type;
967                 print_timestamp(this);
968                 stream << " " << type->id
969                                 << " " << container->id
970                                 << " " << value->id;
971                 print_row();
972         } else if (instr_fmt_type == instr_fmt_TI) {
973                 /* Nothing to do */
974         } else {
975                 THROW_IMPOSSIBLE;
976         }
977 }
978
979
980 void TRACE_TI_start()
981 {
982   char *filename = TRACE_get_filename();
983   tracing_file = fopen(filename, "w");
984   if (tracing_file == nullptr)
985     THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename);
986
987   XBT_DEBUG("Filename %s is open for writing", filename);
988
989   /* output one line comment */
990   dump_comment(TRACE_get_comment());
991
992   /* output comment file */
993   dump_comment_file(TRACE_get_comment_file());
994 }
995
996 void TRACE_TI_end()
997 {
998   xbt_dict_free(&tracing_files);
999   fclose(tracing_file);
1000   char *filename = TRACE_get_filename();
1001   XBT_DEBUG("Filename %s is closed", filename);
1002 }
1003