instr: merge the TI output in the converted code (WIP)

The TI output is a pimple added at some point to trick the TRACING
infrastructure into generating a Time Independent trace of the
executed MPI application, so that this trace can later be replayed
with smpi_replay.

This was done in pure C, with a large amount of pointers to functions.
This cannot be cleanly ported to C++ without a large amount of
factories so that we can subclass each class of event and pick the
right one at runtime.

Instead, this was converted in a ugly way, with a global defining the
type of output that we want today, and each print() function checking
that global to adapt its code.

The bug that I'm chasing is still there, as the replay does not look
for the file that was actually generated, but it's getting better
already.

We will soon rewrite the whole tracing infrastructure with many signals
that are fired at the places that we want to observe. Then, both the
TRACING and the TI modules will register functions in these signals to
be informed of what's going on in the simulation. But they will not
share any code anymore.

Soon...

diff --git a/src/instr/instr_TI_trace.cpp b/src/instr/instr_TI_trace.cpp
deleted file mode 100644 (file)
index c6e7ea8..0000000
--- a/src/instr/instr_TI_trace.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-/* Copyright (c) 2010-2015. The SimGrid Team. All rights reserved.          */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#include "src/instr/instr_private.h"
-#include "xbt/virtu.h" /* sg_cmdline */
-#include "xbt/xbt_os_time.h"
-#include "simgrid/sg_config.h"
-
-#include <errno.h>
-#include <string.h>
-#include <sys/stat.h>
-
-#ifdef WIN32
-#include <direct.h> // _mkdir
-#endif
-
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_TI_trace, instr, "tracing event system");
-
-extern FILE *tracing_file;
-double prefix=0.0;
-
-xbt_dict_t tracing_files = nullptr;
-
-extern s_instr_trace_writer_t active_writer;
-
-void TRACE_TI_init()
-{
-  active_writer.print_PushState        = &print_TIPushState;
-  active_writer.print_CreateContainer  = &print_TICreateContainer;
-  active_writer.print_DestroyContainer = &print_TIDestroyContainer;
-}
-
-void TRACE_TI_start()
-{
-  char *filename = TRACE_get_filename();
-  tracing_file = fopen(filename, "w");
-  if (tracing_file == nullptr) {
-    THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename);
-  }
-
-  XBT_DEBUG("Filename %s is open for writing", filename);
-
-  /* output one line comment */
-  dump_comment(TRACE_get_comment());
-
-  /* output comment file */
-  dump_comment_file(TRACE_get_comment_file());
-}
-
-void TRACE_TI_end()
-{
-  xbt_dict_free(&tracing_files);
-  fclose(tracing_file);
-  char *filename = TRACE_get_filename();
-  XBT_DEBUG("Filename %s is closed", filename);
-}
-
-void print_TICreateContainer(PajeEvent* event)
-{
-  //if we are in the mode with only one file
-  static FILE *temp = nullptr;
-
-  if (tracing_files == nullptr) {
-    tracing_files = xbt_dict_new_homogeneous(nullptr);
-    //generate unique run id with time
-    prefix = xbt_os_time();
-  }
-
-  if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || temp == nullptr) {
-    char *folder_name = bprintf("%s_files", TRACE_get_filename());
-    char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix,
-     static_cast<CreateContainerEvent*>(event)->container->name);
-#ifdef WIN32
-    _mkdir(folder_name);
-#else
-    mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
-#endif
-    temp = fopen(filename, "w");
-    xbt_assert(temp, "Tracefile %s could not be opened for writing: %s", filename, strerror(errno));
-    fprintf(tracing_file, "%s\n", filename);
-
-    xbt_free(folder_name);
-    xbt_free(filename);
-  }
-
-  xbt_dict_set(tracing_files, ((CreateContainerEvent*) event)->container->name, (void *) temp, nullptr);
-}
-
-void print_TIDestroyContainer(PajeEvent* event)
-{
-  if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file")|| xbt_dict_length(tracing_files) == 1) {
-    FILE* f = (FILE*)xbt_dict_get_or_null(tracing_files, ((DestroyContainerEvent *) event)->container->name);
-    fclose(f);
-  }
-  xbt_dict_remove(tracing_files, ((DestroyContainerEvent*) event)->container->name);
-}
-
-void print_TIPushState(PajeEvent* event)
-{
-  int i;
-
-  //char* function=nullptr;
-  if (((PushStateEvent*) event->data)->extra == nullptr)
-    return;
-  instr_extra_data extra = (instr_extra_data) (((PushStateEvent*) event->data)->extra);
-
-  char *process_id = nullptr;
-  //FIXME: dirty extract "rank-" from the name, as we want the bare process id here
-  if (strstr(((PushStateEvent*) event->data)->container->name, "rank-") == nullptr)
-    process_id = xbt_strdup(((PushStateEvent*) event->data)->container->name);
-  else
-    process_id = xbt_strdup(((PushStateEvent*) event->data)->container->name + 5);
-
-  FILE* trace_file =  (FILE* )xbt_dict_get(tracing_files, ((PushStateEvent*) event)->container->name);
-
-  switch (extra->type) {
-  case TRACING_INIT:
-    fprintf(trace_file, "%s init\n", process_id);
-    break;
-  case TRACING_FINALIZE:
-    fprintf(trace_file, "%s finalize\n", process_id);
-    break;
-  case TRACING_SEND:
-    fprintf(trace_file, "%s send %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
-    break;
-  case TRACING_ISEND:
-    fprintf(trace_file, "%s Isend %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
-    break;
-  case TRACING_RECV:
-    fprintf(trace_file, "%s recv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
-    break;
-  case TRACING_IRECV:
-    fprintf(trace_file, "%s Irecv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
-    break;
-  case TRACING_TEST:
-    fprintf(trace_file, "%s test\n", process_id);
-    break;
-  case TRACING_WAIT:
-    fprintf(trace_file, "%s wait\n", process_id);
-    break;
-  case TRACING_WAITALL:
-    fprintf(trace_file, "%s waitAll\n", process_id);
-    break;
-  case TRACING_BARRIER:
-    fprintf(trace_file, "%s barrier\n", process_id);
-    break;
-  case TRACING_BCAST:          // rank bcast size (root) (datatype)
-    fprintf(trace_file, "%s bcast %d ", process_id, extra->send_size);
-    if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
-      fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
-    fprintf(trace_file, "\n");
-    break;
-  case TRACING_REDUCE:         // rank reduce comm_size comp_size (root) (datatype)
-    fprintf(trace_file, "%s reduce %d %f ", process_id, extra->send_size, extra->comp_size);
-    if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
-      fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
-    fprintf(trace_file, "\n");
-    break;
-  case TRACING_ALLREDUCE:      // rank allreduce comm_size comp_size (datatype)
-    fprintf(trace_file, "%s allReduce %d %f %s\n", process_id, extra->send_size, extra->comp_size, extra->datatype1);
-    break;
-  case TRACING_ALLTOALL:       // rank alltoall send_size recv_size (sendtype) (recvtype)
-    fprintf(trace_file, "%s allToAll %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->datatype1,
-            extra->datatype2);
-    break;
-  case TRACING_ALLTOALLV:      // rank alltoallv send_size [sendcounts] recv_size [recvcounts] (sendtype) (recvtype)
-    fprintf(trace_file, "%s allToAllV %d ", process_id, extra->send_size);
-    for (i = 0; i < extra->num_processes; i++)
-      fprintf(trace_file, "%d ", extra->sendcounts[i]);
-    fprintf(trace_file, "%d ", extra->recv_size);
-    for (i = 0; i < extra->num_processes; i++)
-      fprintf(trace_file, "%d ", extra->recvcounts[i]);
-    fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
-    break;
-  case TRACING_GATHER:         // rank gather send_size recv_size root (sendtype) (recvtype)
-    fprintf(trace_file, "%s gather %d %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->root,
-            extra->datatype1, extra->datatype2);
-    break;
-  case TRACING_ALLGATHERV:     // rank allgatherv send_size [recvcounts] (sendtype) (recvtype)
-    fprintf(trace_file, "%s allGatherV %d ", process_id, extra->send_size);
-    for (i = 0; i < extra->num_processes; i++)
-      fprintf(trace_file, "%d ", extra->recvcounts[i]);
-    fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
-    break;
-  case TRACING_REDUCE_SCATTER: // rank reducescatter [recvcounts] comp_size (sendtype)
-    fprintf(trace_file, "%s reduceScatter ", process_id);
-    for (i = 0; i < extra->num_processes; i++)
-      fprintf(trace_file, "%d ", extra->recvcounts[i]);
-    fprintf(trace_file, "%f %s\n", extra->comp_size, extra->datatype1);
-    break;
-  case TRACING_COMPUTING:
-    fprintf(trace_file, "%s compute %f\n", process_id, extra->comp_size);
-    break;
-  case TRACING_SLEEPING:
-    fprintf(trace_file, "%s sleep %f\n", process_id, extra->sleep_duration);
-    break;
-  case TRACING_GATHERV: // rank gatherv send_size [recvcounts] root (sendtype) (recvtype)
-    fprintf(trace_file, "%s gatherV %d ", process_id, extra->send_size);
-    for (i = 0; i < extra->num_processes; i++)
-      fprintf(trace_file, "%d ", extra->recvcounts[i]);
-    fprintf(trace_file, "%d %s %s\n", extra->root, extra->datatype1, extra->datatype2);
-    break;
-  case TRACING_WAITANY:
-  case TRACING_SENDRECV:
-  case TRACING_SCATTER:
-  case TRACING_SCATTERV:
-  case TRACING_ALLGATHER:
-  case TRACING_SCAN:
-  case TRACING_EXSCAN:
-  case TRACING_COMM_SIZE:
-  case TRACING_COMM_SPLIT:
-  case TRACING_COMM_DUP:
-  case TRACING_SSEND:
-  case TRACING_ISSEND:
-  default:
-    XBT_WARN ("Call from %s impossible to translate into replay command : Not implemented (yet)",
-         ((PushStateEvent*) event->data)->value->name);
-    break;
-  }
-
-  if (extra->recvcounts != nullptr)
-    xbt_free(extra->recvcounts);
-  if (extra->sendcounts != nullptr)
-    xbt_free(extra->sendcounts);
-  xbt_free(process_id);
-  xbt_free(extra);
-}

diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp
index b586f95..8b923a6 100644 (file)
--- a/src/instr/instr_config.cpp
+++ b/src/instr/instr_config.cpp
@@ -63,6 +63,8 @@ static int trace_precision;
 static bool trace_configured = false;
 static bool trace_active     = false;
 
+instr_fmt_type_t instr_fmt_type = instr_fmt_paje;
+
 static void TRACE_getopts()
 {
   trace_enabled             = xbt_cfg_get_boolean(OPT_TRACING);
@@ -106,7 +108,7 @@ int TRACE_start()
     if(!strcmp(format, "Paje")){
       TRACE_paje_start();
     }else if (!strcmp(format, "TI")){
-      TRACE_TI_init();
+      instr_fmt_type = instr_fmt_TI;
       TRACE_TI_start();
     }else{
       xbt_die("Unknown trace format :%s ", format);

diff --git a/src/instr/instr_paje_trace.cpp b/src/instr/instr_paje_trace.cpp
index 3e92c07..e4a73c7 100644 (file)
--- a/src/instr/instr_paje_trace.cpp
+++ b/src/instr/instr_paje_trace.cpp
@@ -9,19 +9,27 @@
 #include "src/smpi/private.hpp"
 #include "typeinfo"
 #include "xbt/virtu.h" /* sg_cmdline */
+#include "simgrid/sg_config.h"
+
 #include <sstream>
 #include <vector>
 #include <iomanip> /** std::setprecision **/
-#include "simgrid/sg_config.h"
+#include <sys/stat.h>
+#ifdef WIN32
+#include <direct.h> // _mkdir
+#endif
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr, "tracing event system");
 
-extern FILE * tracing_file;
 extern s_instr_trace_writer_t active_writer;
 
 static std::stringstream stream;
 FILE *tracing_file = nullptr;
 
+static xbt_dict_t tracing_files = nullptr; // TI specific
+static double prefix=0.0; // TI specific
+
+
 void print_NULL(PajeEvent* event){}
 
 /* The active set of functions for the selected trace format
@@ -359,21 +367,51 @@ CreateContainerEvent::CreateContainerEvent (container_t container)
 
   XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event_type, this->timestamp);
 
-  //print it
   print();
 }
 
 void CreateContainerEvent::print() {
-  XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
-  stream << std::fixed << std::setprecision(TRACE_precision());
-  stream << (int)this->event_type;
-  print_timestamp(this);
-  stream << " "   << container->id
-         << " "   << container->type->id
-         << " "   << container->father->id
-         << " \"" << container->name << "\"";
+       if (instr_fmt_type == instr_fmt_paje) {
+               XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
+               stream << std::fixed << std::setprecision(TRACE_precision());
+               stream << (int)this->event_type;
+               print_timestamp(this);
+               stream << " "   << container->id
+                               << " "   << container->type->id
+                               << " "   << container->father->id
+                               << " \"" << container->name << "\"";
+
+               print_row();
+       } else if (instr_fmt_type == instr_fmt_TI) {
+               //if we are in the mode with only one file
+               static FILE *temp = nullptr;
+
+               if (tracing_files == nullptr) {
+                       tracing_files = xbt_dict_new_homogeneous(nullptr);
+                       //generate unique run id with time
+                       prefix = xbt_os_time();
+               }
+
+               if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || temp == nullptr) {
+                       char *folder_name = bprintf("%s_files", TRACE_get_filename());
+                       char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix, container->name);
+#ifdef WIN32
+                       _mkdir(folder_name);
+#else
+                       mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
+#endif
+                       temp = fopen(filename, "w");
+                       xbt_assert(temp, "Tracefile %s could not be opened for writing: %s", filename, strerror(errno));
+                       fprintf(tracing_file, "%s\n", filename);
 
-  print_row();
+                       xbt_free(folder_name);
+                       xbt_free(filename);
+               }
+
+               xbt_dict_set(tracing_files, container->name, (void *) temp, nullptr);
+       } else {
+               THROW_IMPOSSIBLE;
+       }
 }
 
 DestroyContainerEvent::DestroyContainerEvent (container_t container)
@@ -388,14 +426,24 @@ DestroyContainerEvent::DestroyContainerEvent (container_t container)
 }
 
 void DestroyContainerEvent::print() {
-  XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
-  stream << std::fixed << std::setprecision(TRACE_precision());
-  stream << (int)this->event_type;
-  print_timestamp(this);
-  stream << " "   << container->type->id
-         << " "   << container->id;
-
-  print_row();
+       if (instr_fmt_type == instr_fmt_paje) {
+               XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
+               stream << std::fixed << std::setprecision(TRACE_precision());
+               stream << (int)this->event_type;
+               print_timestamp(this);
+               stream << " "   << container->type->id
+                               << " "   << container->id;
+
+               print_row();
+       } else if (instr_fmt_type == instr_fmt_TI) {
+               if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file")|| xbt_dict_length(tracing_files) == 1) {
+                       FILE* f = (FILE*)xbt_dict_get_or_null(tracing_files, container->name);
+                       fclose(f);
+               }
+               xbt_dict_remove(tracing_files, container->name);
+       } else {
+               THROW_IMPOSSIBLE;
+       }
 }
 
 SetVariableEvent::SetVariableEvent (double timestamp, container_t container, type_t type, double value)
@@ -515,7 +563,7 @@ PushStateEvent::PushStateEvent (double timestamp, container_t container, type_t
   this->type = type;
   this->container = container;
   this->value     = value;
-  this->extra     = extra;
+  this->extra_     = extra;
 
 #if HAVE_SMPI
   if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
@@ -534,38 +582,168 @@ PushStateEvent::PushStateEvent (double timestamp, container_t container, type_t
  : PushStateEvent(timestamp, container, type, value, nullptr)
 {}
 void PushStateEvent::print() {
-  XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
-  stream << std::fixed << std::setprecision(TRACE_precision());
-  stream << (int)this->event_type;
-  print_timestamp(this);
-  stream << " " << type->id
-         << " " << container->id;
-  stream << " " <<value->id;
-
-  if (TRACE_display_sizes()) {
-    stream << " ";
-    if (extra != nullptr) {
-      stream << static_cast<instr_extra_data>(extra)->send_size;
-    }
-    else {
-      stream << 0;
-    }
-  }
+       if (instr_fmt_type == instr_fmt_paje) {
+               XBT_DEBUG("%s: event_type=%d, timestamp=%.*f", __FUNCTION__, (int)event_type, TRACE_precision(), timestamp);
+               stream << std::fixed << std::setprecision(TRACE_precision());
+               stream << (int)this->event_type;
+               print_timestamp(this);
+               stream << " " << type->id
+                               << " " << container->id;
+               stream << " " <<value->id;
+
+               if (TRACE_display_sizes()) {
+                       stream << " ";
+                       if (extra_ != nullptr) {
+                               stream << static_cast<instr_extra_data>(extra_)->send_size;
+                       }
+                       else {
+                               stream << 0;
+                       }
+               }
 #if HAVE_SMPI
-  if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
-    stream << " \"" << filename
-           << "\" " << linenumber;
-  }
+               if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
+                       stream << " \"" << filename
+                                       << "\" " << linenumber;
+               }
 #endif
-  print_row();
-
-  if (extra != nullptr) {
-    if (static_cast<instr_extra_data>(extra)->sendcounts != nullptr)
-      xbt_free(static_cast<instr_extra_data>(extra)->sendcounts);
-    if (static_cast<instr_extra_data>(extra)->recvcounts != nullptr)
-      xbt_free(static_cast<instr_extra_data>(extra)->recvcounts);
-    xbt_free(extra);
-  }
+               print_row();
+
+               if (extra_ != nullptr) {
+                       if (static_cast<instr_extra_data>(extra_)->sendcounts != nullptr)
+                               xbt_free(static_cast<instr_extra_data>(extra_)->sendcounts);
+                       if (static_cast<instr_extra_data>(extra_)->recvcounts != nullptr)
+                               xbt_free(static_cast<instr_extra_data>(extra_)->recvcounts);
+                       xbt_free(extra_);
+               }
+       } else if (instr_fmt_type == instr_fmt_TI) {
+                 if (extra_ == nullptr)
+                   return;
+                 instr_extra_data extra = (instr_extra_data)extra_;
+
+                 char *process_id = nullptr;
+                 //FIXME: dirty extract "rank-" from the name, as we want the bare process id here
+                 if (strstr(container->name, "rank-") == nullptr)
+                   process_id = xbt_strdup(container->name);
+                 else
+                   process_id = xbt_strdup(container->name + 5);
+
+                 FILE* trace_file =  (FILE* )xbt_dict_get(tracing_files, container->name);
+
+                 switch (extra->type) {
+                 case TRACING_INIT:
+                   fprintf(trace_file, "%s init\n", process_id);
+                   break;
+                 case TRACING_FINALIZE:
+                   fprintf(trace_file, "%s finalize\n", process_id);
+                   break;
+                 case TRACING_SEND:
+                   fprintf(trace_file, "%s send %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
+                   break;
+                 case TRACING_ISEND:
+                   fprintf(trace_file, "%s Isend %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1);
+                   break;
+                 case TRACING_RECV:
+                   fprintf(trace_file, "%s recv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
+                   break;
+                 case TRACING_IRECV:
+                   fprintf(trace_file, "%s Irecv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1);
+                   break;
+                 case TRACING_TEST:
+                   fprintf(trace_file, "%s test\n", process_id);
+                   break;
+                 case TRACING_WAIT:
+                   fprintf(trace_file, "%s wait\n", process_id);
+                   break;
+                 case TRACING_WAITALL:
+                   fprintf(trace_file, "%s waitAll\n", process_id);
+                   break;
+                 case TRACING_BARRIER:
+                   fprintf(trace_file, "%s barrier\n", process_id);
+                   break;
+                 case TRACING_BCAST:          // rank bcast size (root) (datatype)
+                   fprintf(trace_file, "%s bcast %d ", process_id, extra->send_size);
+                   if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
+                     fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
+                   fprintf(trace_file, "\n");
+                   break;
+                 case TRACING_REDUCE:         // rank reduce comm_size comp_size (root) (datatype)
+                   fprintf(trace_file, "%s reduce %d %f ", process_id, extra->send_size, extra->comp_size);
+                   if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, "")))
+                     fprintf(trace_file, "%d %s", extra->root, extra->datatype1);
+                   fprintf(trace_file, "\n");
+                   break;
+                 case TRACING_ALLREDUCE:      // rank allreduce comm_size comp_size (datatype)
+                   fprintf(trace_file, "%s allReduce %d %f %s\n", process_id, extra->send_size, extra->comp_size, extra->datatype1);
+                   break;
+                 case TRACING_ALLTOALL:       // rank alltoall send_size recv_size (sendtype) (recvtype)
+                   fprintf(trace_file, "%s allToAll %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->datatype1,
+                           extra->datatype2);
+                   break;
+                 case TRACING_ALLTOALLV:      // rank alltoallv send_size [sendcounts] recv_size [recvcounts] (sendtype) (recvtype)
+                   fprintf(trace_file, "%s allToAllV %d ", process_id, extra->send_size);
+                   for (int i = 0; i < extra->num_processes; i++)
+                     fprintf(trace_file, "%d ", extra->sendcounts[i]);
+                   fprintf(trace_file, "%d ", extra->recv_size);
+                   for (int i = 0; i < extra->num_processes; i++)
+                     fprintf(trace_file, "%d ", extra->recvcounts[i]);
+                   fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
+                   break;
+                 case TRACING_GATHER:         // rank gather send_size recv_size root (sendtype) (recvtype)
+                   fprintf(trace_file, "%s gather %d %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->root,
+                           extra->datatype1, extra->datatype2);
+                   break;
+                 case TRACING_ALLGATHERV:     // rank allgatherv send_size [recvcounts] (sendtype) (recvtype)
+                   fprintf(trace_file, "%s allGatherV %d ", process_id, extra->send_size);
+                   for (int i = 0; i < extra->num_processes; i++)
+                     fprintf(trace_file, "%d ", extra->recvcounts[i]);
+                   fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2);
+                   break;
+                 case TRACING_REDUCE_SCATTER: // rank reducescatter [recvcounts] comp_size (sendtype)
+                   fprintf(trace_file, "%s reduceScatter ", process_id);
+                   for (int i = 0; i < extra->num_processes; i++)
+                     fprintf(trace_file, "%d ", extra->recvcounts[i]);
+                   fprintf(trace_file, "%f %s\n", extra->comp_size, extra->datatype1);
+                   break;
+                 case TRACING_COMPUTING:
+                   fprintf(trace_file, "%s compute %f\n", process_id, extra->comp_size);
+                   break;
+                 case TRACING_SLEEPING:
+                   fprintf(trace_file, "%s sleep %f\n", process_id, extra->sleep_duration);
+                   break;
+                 case TRACING_GATHERV: // rank gatherv send_size [recvcounts] root (sendtype) (recvtype)
+                   fprintf(trace_file, "%s gatherV %d ", process_id, extra->send_size);
+                   for (int i = 0; i < extra->num_processes; i++)
+                     fprintf(trace_file, "%d ", extra->recvcounts[i]);
+                   fprintf(trace_file, "%d %s %s\n", extra->root, extra->datatype1, extra->datatype2);
+                   break;
+                 case TRACING_WAITANY:
+                 case TRACING_SENDRECV:
+                 case TRACING_SCATTER:
+                 case TRACING_SCATTERV:
+                 case TRACING_ALLGATHER:
+                 case TRACING_SCAN:
+                 case TRACING_EXSCAN:
+                 case TRACING_COMM_SIZE:
+                 case TRACING_COMM_SPLIT:
+                 case TRACING_COMM_DUP:
+                 case TRACING_SSEND:
+                 case TRACING_ISSEND:
+                 default:
+                   XBT_WARN ("Call from %s impossible to translate into replay command : Not implemented (yet)",
+                        value->name);
+                   break;
+                 }
+
+                 if (extra->recvcounts != nullptr)
+                   xbt_free(extra->recvcounts);
+                 if (extra->sendcounts != nullptr)
+                   xbt_free(extra->sendcounts);
+                 xbt_free(process_id);
+                 xbt_free(extra);
+
+       } else {
+               THROW_IMPOSSIBLE;
+       }
 }
 
 
@@ -706,3 +884,29 @@ void NewEvent::print () {
          << " " << value->id;
   print_row();
 }
+
+
+void TRACE_TI_start()
+{
+  char *filename = TRACE_get_filename();
+  tracing_file = fopen(filename, "w");
+  if (tracing_file == nullptr)
+    THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename);
+
+  XBT_DEBUG("Filename %s is open for writing", filename);
+
+  /* output one line comment */
+  dump_comment(TRACE_get_comment());
+
+  /* output comment file */
+  dump_comment_file(TRACE_get_comment_file());
+}
+
+void TRACE_TI_end()
+{
+  xbt_dict_free(&tracing_files);
+  fclose(tracing_file);
+  char *filename = TRACE_get_filename();
+  XBT_DEBUG("Filename %s is closed", filename);
+}
+

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index 0102392..81be1f4 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -244,7 +244,7 @@ class PushStateEvent : public PajeEvent  {
   int size;
   const char* filename;
   int linenumber;
-  void* extra;
+  void* extra_;
   public:
   PushStateEvent (double timestamp, container_t container, type_t type, val_t value);
   PushStateEvent (double timestamp, container_t container, type_t type, val_t value,
@@ -422,12 +422,8 @@ XBT_PRIVATE void print_pajeStartLink(PajeEvent* event);
 XBT_PRIVATE void print_pajeEndLink(PajeEvent* event);
 XBT_PRIVATE void print_pajeNewEvent (PajeEvent* event);
 
-XBT_PRIVATE void print_TIPushState(PajeEvent* event);
-XBT_PRIVATE void print_TICreateContainer(PajeEvent* event);
-XBT_PRIVATE void print_TIDestroyContainer(PajeEvent* event);
 XBT_PRIVATE void TRACE_TI_start();
 XBT_PRIVATE void TRACE_TI_end();
-XBT_PRIVATE void TRACE_TI_init();
 
 XBT_PRIVATE void print_NULL (PajeEvent* event);
 XBT_PRIVATE void TRACE_paje_dump_buffer (int force);
@@ -510,6 +506,14 @@ typedef struct s_instr_extra_data {
   int num_processes;
 } s_instr_extra_data_t;
 
+/* Format of TRACING output.
+ *   - paje is the regular format, that we all know
+ *   - TI is a trick to reuse the tracing functions to generate a time independent trace during the execution. Such trace can easily be replayed with smpi_replay afterward.
+ *     This trick should be removed and replaced by some code using the signal that we will create to cleanup the TRACING
+ */
+typedef enum { instr_fmt_paje, instr_fmt_TI } instr_fmt_type_t;
+extern instr_fmt_type_t instr_fmt_type;
+
 SG_END_DECL()
 
 #endif

diff --git a/src/xbt/log.c b/src/xbt/log.c
index d24eb8c..84aef42 100644 (file)
--- a/src/xbt/log.c
+++ b/src/xbt/log.c
@@ -146,7 +146,6 @@ static void xbt_log_connect_categories(void)
   XBT_LOG_CONNECT(instr_resource);
   XBT_LOG_CONNECT(instr_routing);
   XBT_LOG_CONNECT(instr_surf);
-  XBT_LOG_CONNECT(instr_TI_trace);
 
   /* jedule */
 #if HAVE_JEDULE

diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake
index bb0c2b5..9cc3fc3 100644 (file)
--- a/tools/cmake/DefinePackages.cmake
+++ b/tools/cmake/DefinePackages.cmake
@@ -533,7 +533,6 @@ set(LUA_SRC
   )
 
 set(TRACING_SRC
-  src/instr/instr_TI_trace.cpp
   src/instr/instr_config.cpp
   src/instr/instr_interface.cpp
   src/instr/instr_paje_containers.cpp