Merge pull request #202 from Takishipp/clear_fct

Turn paje_value to a class

diff --git a/src/include/instr/instr_interface.h b/src/include/instr/instr_interface.h
index 8bb38ce..4e6ff0b 100644 (file)
--- a/src/include/instr/instr_interface.h
+++ b/src/include/instr/instr_interface.h
@@ -12,7 +12,7 @@ SG_BEGIN_DECL()
 
 XBT_PUBLIC(int) TRACE_start ();
 XBT_PUBLIC(int) TRACE_end ();
-XBT_PUBLIC(void) TRACE_global_init(int *argc, char **argv);
+XBT_PUBLIC(void) TRACE_global_init();
 XBT_PUBLIC(void) TRACE_help(int detailed);
 XBT_PUBLIC(void) TRACE_surf_resource_utilization_alloc();
 XBT_PUBLIC(void) TRACE_surf_resource_utilization_release();

diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp
index 82b951f..8455e27 100644 (file)
--- a/src/instr/instr_config.cpp
+++ b/src/instr/instr_config.cpp
@@ -315,7 +315,7 @@ char *TRACE_get_viva_cat_conf ()
   return xbt_cfg_get_string(OPT_VIVA_CAT_CONF);
 }
 
-void TRACE_global_init(int *argc, char **argv)
+void TRACE_global_init()
 {
   static int is_initialised = 0;
   if (is_initialised)

diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp
index 43c2b18..7c17b84 100644 (file)
--- a/src/instr/instr_interface.cpp
+++ b/src/instr/instr_interface.cpp
@@ -196,7 +196,7 @@ void TRACE_declare_mark_value_with_color (const char *mark_type, const char *mar
     mark_color = white;
 
   XBT_DEBUG("MARK,declare_value %s %s %s", mark_type, mark_value, mark_color);
-  PJ_value_new (mark_value, mark_color, type);
+  s_val rett(mark_value, mark_color, type);
 }
 
 /** \ingroup TRACE_mark
@@ -247,7 +247,7 @@ void TRACE_mark(const char *mark_type, const char *mark_value)
     THROWF (tracing_error, 1, "mark_type with name (%s) is not declared", mark_type);
   }
 
-  val_t value = PJ_value_get (mark_value, type);
+  val_t value = s_val::PJ_value_get (mark_value, type);
   XBT_DEBUG("MARK %s %s", mark_type, mark_value);
   new NewEvent (MSG_get_clock(), PJ_container_get_root(), type, value);
 }
@@ -950,7 +950,7 @@ void TRACE_host_set_state (const char *host, const char *state, const char *valu
 {
   container_t container = PJ_container_get(host);
   type_t type = PJ_type_get (state, container->type);
-  val_t val = PJ_value_get_or_new (value, nullptr, type); /* if user didn't declare a value with a color, use nullptr color */
+  val_t val = s_val::PJ_value_get_or_new (value, nullptr, type); /* if user didn't declare a value with a color, use nullptr color */
   new SetStateEvent(MSG_get_clock(), container, type, val);
 }
 
@@ -969,7 +969,7 @@ void TRACE_host_push_state (const char *host, const char *state, const char *val
 {
   container_t container = PJ_container_get(host);
   type_t type = PJ_type_get (state, container->type);
-  val_t val = PJ_value_get_or_new (value, nullptr, type); /* if user didn't declare a value with a color, use nullptr color */
+  val_t val = s_val::PJ_value_get_or_new (value, nullptr, type); /* if user didn't declare a value with a color, use nullptr color */
   new PushStateEvent(MSG_get_clock(), container, type, val);
 }
 

diff --git a/src/instr/instr_paje_containers.cpp b/src/instr/instr_paje_containers.cpp
index b5d9800..6f2331d 100644 (file)
--- a/src/instr/instr_paje_containers.cpp
+++ b/src/instr/instr_paje_containers.cpp
@@ -53,7 +53,7 @@ container_t PJ_container_new (const char *name, e_container_types kind, containe
   snprintf (id_str, INSTR_DEFAULT_STR_SIZE, "%lld", container_id);
   container_id++;
 
-  container_t newContainer = xbt_new0(s_container_t, 1);
+  container_t newContainer = xbt_new0(s_container, 1);
   newContainer->name = xbt_strdup (name); // name of the container
   newContainer->id = xbt_strdup (id_str); // id (or alias) of the container
   newContainer->father = father;

diff --git a/src/instr/instr_paje_types.cpp b/src/instr/instr_paje_types.cpp
index 333e806..872e890 100644 (file)
--- a/src/instr/instr_paje_types.cpp
+++ b/src/instr/instr_paje_types.cpp
@@ -26,7 +26,7 @@ static type_t newType (const char *typeNameBuff, const char *key, const char *co
     THROWF(tracing_error, 0, "can't create a new type with name or key equal nullptr");
   }
 
-  type_t ret = xbt_new0(s_type_t, 1);
+  type_t ret = xbt_new0(s_type, 1);
   ret->name = xbt_strdup (typeNameBuff);
   ret->father = father;
   ret->kind = kind;

diff --git a/src/instr/instr_paje_values.cpp b/src/instr/instr_paje_values.cpp
index 88ad1bb..10060e2 100644 (file)
--- a/src/instr/instr_paje_values.cpp
+++ b/src/instr/instr_paje_values.cpp
@@ -10,40 +10,38 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_paje_values, instr, "Paje tracing event system (values)");
 
-val_t PJ_value_new (const char *name, const char *color, type_t father)
-{
+s_val::s_val(const char *name, const char *color, type_t father){
   if (name == nullptr || father == nullptr){
     THROWF (tracing_error, 0, "can't create a value with a nullptr name (or a nullptr father)");
   }
-
-  val_t ret = xbt_new0(s_val_t, 1);
-  ret->name = xbt_strdup (name);
-  ret->father = father;
-  ret->color = xbt_strdup (color);
+  this->ret = xbt_new0(s_val, 1);
+  this->ret->name = xbt_strdup (name);
+  this->ret->father = father;
+  this->ret->color = xbt_strdup (color);
 
   char str_id[INSTR_DEFAULT_STR_SIZE];
   snprintf (str_id, INSTR_DEFAULT_STR_SIZE, "%lld", instr_new_paje_id());
-  ret->id = xbt_strdup (str_id);
+  this->ret->id = xbt_strdup (str_id);
 
   xbt_dict_set (father->values, name, ret, nullptr);
   XBT_DEBUG("new value %s, child of %s", ret->name, ret->father->name);
-  LogEntityValue(ret);
-  return ret;
-}
+  LogEntityValue(this->ret);
+};
 
-val_t PJ_value_get_or_new (const char *name, const char *color, type_t father)
+val_t s_val::PJ_value_get_or_new (const char *name, const char *color, type_t father)
 {
   val_t ret = 0;
   try {
-    ret = PJ_value_get(name, father);
+    ret = s_val::PJ_value_get(name, father);
   }
   catch(xbt_ex& e) {
-    ret = PJ_value_new(name, color, father);
+    s_val rett(name, color, father);
+    ret = rett.ret;
   }
   return ret;
 }
 
-val_t PJ_value_get (const char *name, type_t father)
+val_t s_val::PJ_value_get (const char *name, type_t father)
 {
   if (name == nullptr || father == nullptr){
     THROWF (tracing_error, 0, "can't get a value with a nullptr name (or a nullptr father)");

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index d3d45c2..17f635c 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -81,8 +81,12 @@ class s_val {
   char *name;
   char *color;
   type_t father;
+  val_t ret;
+  s_val(const char *name, const char *color, type_t father);
+  static val_t PJ_value_get_or_new (const char *name, const char *color, type_t father);
+  static val_t PJ_value_get (const char *name, type_t father);
 };
-typedef s_val s_val_t;
+
 
 //--------------------------------------------------
 typedef enum {
@@ -143,6 +147,7 @@ class DefineStateTypeEvent : public PajeEvent  {
 
 
 class SetVariableEvent : public PajeEvent  {
+  private:
   container_t container;
   type_t type;
   double value;
@@ -153,6 +158,7 @@ class SetVariableEvent : public PajeEvent  {
 
 
 class AddVariableEvent:public PajeEvent {
+  private:
   container_t container;
   type_t type;
   double value;
@@ -165,7 +171,7 @@ class AddVariableEvent:public PajeEvent {
 
 
 class SubVariableEvent : public PajeEvent  {
-  public:
+  private:
   container_t container;
   type_t type;
   double value;
@@ -176,7 +182,7 @@ class SubVariableEvent : public PajeEvent  {
 //--------------------------------------------------
 
 class SetStateEvent : public PajeEvent  {
-  public:
+  private:
   container_t container;
   type_t type;
   val_t value;
@@ -351,11 +357,6 @@ XBT_PRIVATE XBT_PRIVATE void PJ_type_free (type_t type);
 /* instr_config.c */
 XBT_PRIVATE void recursiveDestroyType (type_t type);
 
-/* instr_paje_values.c */
-XBT_PUBLIC(val_t)  PJ_value_new (const char *name, const char *color, type_t father);
-XBT_PUBLIC(val_t)  PJ_value_get_or_new (const char *name, const char *color, type_t father);
-XBT_PUBLIC(val_t)  PJ_value_get (const char *name, const type_t father);
-
 XBT_PRIVATE void TRACE_TI_start();
 XBT_PRIVATE void TRACE_TI_end();
 

diff --git a/src/instr/instr_smpi.h b/src/instr/instr_smpi.h
index 974d10f..cd6faa5 100644 (file)
--- a/src/instr/instr_smpi.h
+++ b/src/instr/instr_smpi.h
@@ -17,8 +17,8 @@ SG_BEGIN_DECL()
 
 XBT_PRIVATE void TRACE_internal_smpi_set_category(const char* category);
 XBT_PRIVATE const char* TRACE_internal_smpi_get_category();
-XBT_PRIVATE void TRACE_smpi_collective_in(int rank, int root, const char* operation, instr_extra_data extra);
-XBT_PRIVATE void TRACE_smpi_collective_out(int rank, int root, const char* operation);
+XBT_PRIVATE void TRACE_smpi_collective_in(int rank, const char* operation, instr_extra_data extra);
+XBT_PRIVATE void TRACE_smpi_collective_out(int rank, const char* operation);
 XBT_PRIVATE void TRACE_smpi_computing_init(int rank);
 XBT_PRIVATE void TRACE_smpi_computing_out(int rank);
 XBT_PRIVATE void TRACE_smpi_computing_in(int rank, instr_extra_data extra);
@@ -29,10 +29,10 @@ XBT_PRIVATE void TRACE_smpi_testing_out(int rank);
 XBT_PRIVATE void TRACE_smpi_testing_in(int rank, instr_extra_data extra);
 XBT_PRIVATE void TRACE_smpi_alloc();
 XBT_PRIVATE void TRACE_smpi_release();
-XBT_PRIVATE void TRACE_smpi_ptp_in(int rank, int src, int dst, const char* operation, instr_extra_data extra);
-XBT_PRIVATE void TRACE_smpi_ptp_out(int rank, int src, int dst, const char* operation);
+XBT_PRIVATE void TRACE_smpi_ptp_in(int rank, const char* operation, instr_extra_data extra);
+XBT_PRIVATE void TRACE_smpi_ptp_out(int rank, int dst, const char* operation);
 XBT_PRIVATE void TRACE_smpi_send(int rank, int src, int dst, int tag, int size);
-XBT_PRIVATE void TRACE_smpi_recv(int rank, int src, int dst, int tag);
+XBT_PRIVATE void TRACE_smpi_recv(int src, int dst, int tag);
 XBT_PRIVATE void TRACE_smpi_init(int rank);
 XBT_PRIVATE void TRACE_smpi_finalize(int rank);
 XBT_PRIVATE char* smpi_container(int rank, char* container, int n);

diff --git a/src/msg/instr_msg_process.cpp b/src/msg/instr_msg_process.cpp
index 21a1355..b0ad430 100644 (file)
--- a/src/msg/instr_msg_process.cpp
+++ b/src/msg/instr_msg_process.cpp
@@ -24,7 +24,7 @@ char *instr_process_id_2 (const char *process_name, int process_pid, char *str,
 /*
  * Instrumentation functions to trace MSG processes (msg_process_t)
  */
-void TRACE_msg_process_change_host(msg_process_t process, msg_host_t old_host, msg_host_t new_host)
+void TRACE_msg_process_change_host(msg_process_t process, msg_host_t new_host)
 {
   if (TRACE_msg_process_is_enabled()){
     static long long int counter = 0;
@@ -94,7 +94,7 @@ void TRACE_msg_process_suspend(msg_process_t process)
 
     container_t process_container = PJ_container_get (instr_process_id(process, str, len));
     type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
-    val_t value = PJ_value_get ("suspend", type);
+    val_t value = s_val::PJ_value_get ("suspend", type);
     new PushStateEvent (MSG_get_clock(), process_container, type, value);
   }
 }
@@ -119,7 +119,7 @@ void TRACE_msg_process_sleep_in(msg_process_t process)
 
     container_t process_container = PJ_container_get (instr_process_id(process, str, len));
     type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
-    val_t value = PJ_value_get ("sleep", type);
+    val_t value = s_val::PJ_value_get ("sleep", type);
     new PushStateEvent (MSG_get_clock(), process_container, type, value);
   }
 }

diff --git a/src/msg/instr_msg_task.cpp b/src/msg/instr_msg_task.cpp
index fb58628..c1190d8 100644 (file)
--- a/src/msg/instr_msg_task.cpp
+++ b/src/msg/instr_msg_task.cpp
@@ -54,7 +54,7 @@ void TRACE_msg_task_execute_start(msg_task_t task)
 
     container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
     type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
-    val_t value = PJ_value_get ("task_execute", type);
+    val_t value = s_val::PJ_value_get ("task_execute", type);
     new PushStateEvent (MSG_get_clock(), process_container, type, value);
   }
 }
@@ -94,7 +94,7 @@ void TRACE_msg_task_get_start()
 
     container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
     type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
-    val_t value = PJ_value_get ("receive", type);
+    val_t value = s_val::PJ_value_get ("receive", type);
     new PushStateEvent (MSG_get_clock(), process_container, type, value);
   }
 }
@@ -129,7 +129,7 @@ int TRACE_msg_task_put_start(msg_task_t task)
 
     container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
     type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
-    val_t value = PJ_value_get ("send", type);
+    val_t value = s_val::PJ_value_get ("send", type);
     new PushStateEvent (MSG_get_clock(), process_container, type, value);
 
     char key[INSTR_DEFAULT_STR_SIZE];

diff --git a/src/msg/msg_global.cpp b/src/msg/msg_global.cpp
index 011f6f6..4a0509d 100644 (file)
--- a/src/msg/msg_global.cpp
+++ b/src/msg/msg_global.cpp
@@ -32,7 +32,7 @@ static void _sg_cfg_cb_msg_debug_multiple_use(const char *name)
  */
 void MSG_init_nocheck(int *argc, char **argv) {
 
-  TRACE_global_init(argc, argv);
+  TRACE_global_init();
 
   if (not msg_global) {
 

diff --git a/src/msg/msg_private.h b/src/msg/msg_private.h
index 9734130..6d20389 100644 (file)
--- a/src/msg/msg_private.h
+++ b/src/msg/msg_private.h
@@ -125,7 +125,7 @@ XBT_PRIVATE void TRACE_msg_task_put_end();
 /* declaration of instrumentation functions from msg_process_instr.c */
 XBT_PRIVATE char *instr_process_id (msg_process_t proc, char *str, int len);
 XBT_PRIVATE char *instr_process_id_2 (const char *process_name, int process_pid, char *str, int len);
-XBT_PRIVATE void TRACE_msg_process_change_host(msg_process_t process, msg_host_t old_host, msg_host_t new_host);
+XBT_PRIVATE void TRACE_msg_process_change_host(msg_process_t process, msg_host_t new_host);
 XBT_PRIVATE void TRACE_msg_process_create (const char *process_name, int process_pid, msg_host_t host);
 XBT_PRIVATE void TRACE_msg_process_destroy (const char *process_name, int process_pid);
 XBT_PRIVATE void TRACE_msg_process_kill(smx_process_exit_status_t status, msg_process_t process);

diff --git a/src/msg/msg_process.cpp b/src/msg/msg_process.cpp
index 17b20f9..b3ea3c9 100644 (file)
--- a/src/msg/msg_process.cpp
+++ b/src/msg/msg_process.cpp
@@ -211,7 +211,7 @@ msg_error_t MSG_process_join(msg_process_t process, double timeout){
  */
 msg_error_t MSG_process_migrate(msg_process_t process, msg_host_t host)
 {
-  TRACE_msg_process_change_host(process, MSG_process_get_host(process), host);
+  TRACE_msg_process_change_host(process, host);
   process->migrate(host);
   return MSG_OK;
 }

diff --git a/src/msg/msg_vm.cpp b/src/msg/msg_vm.cpp
index 2eb403d..f82eb11 100644 (file)
--- a/src/msg/msg_vm.cpp
+++ b/src/msg/msg_vm.cpp
@@ -215,7 +215,7 @@ void MSG_vm_start(msg_vm_t vm)
   if (TRACE_msg_vm_is_enabled()) {
     container_t vm_container = PJ_container_get(vm->getCname());
     type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
-    val_t value              = PJ_value_get_or_new("start", "0 0 1", type); // start is blue
+    val_t value              = s_val::PJ_value_get_or_new("start", "0 0 1", type); // start is blue
     new PushStateEvent(MSG_get_clock(), vm_container, type, value);
   }
 }
@@ -815,7 +815,7 @@ void MSG_vm_suspend(msg_vm_t vm)
   if (TRACE_msg_vm_is_enabled()) {
     container_t vm_container = PJ_container_get(vm->getCname());
     type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
-    val_t value              = PJ_value_get_or_new("suspend", "1 0 0", type); // suspend is red
+    val_t value              = s_val::PJ_value_get_or_new("suspend", "1 0 0", type); // suspend is red
     new PushStateEvent(MSG_get_clock(), vm_container, type, value);
   }
 }

diff --git a/src/s4u/s4u_engine.cpp b/src/s4u/s4u_engine.cpp
index 0e983e8..71a2345 100644 (file)
--- a/src/s4u/s4u_engine.cpp
+++ b/src/s4u/s4u_engine.cpp
@@ -35,7 +35,7 @@ Engine::Engine(int *argc, char **argv) {
   s4u::Engine::instance_ = this;
   pimpl                  = new kernel::EngineImpl();
 
-  TRACE_global_init(argc, argv);
+  TRACE_global_init();
   SIMIX_global_init(argc, argv);
 }
 

diff --git a/src/smpi/bindings/smpi_pmpi.cpp b/src/smpi/bindings/smpi_pmpi.cpp
index b939d4c..ff6a248 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi.cpp
+++ b/src/smpi/bindings/smpi_pmpi.cpp
@@ -41,8 +41,8 @@ int PMPI_Init(int *argc, char ***argv)
     TRACE_smpi_computing_init(rank);
     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
     extra->type = TRACING_INIT;
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
     smpi_bench_begin();
   }
 
@@ -57,11 +57,11 @@ int PMPI_Finalize()
   int rank = smpi_process()->index();
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_FINALIZE;
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
   smpi_process()->finalize();
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   TRACE_smpi_finalize(smpi_process()->index());
   return MPI_SUCCESS;
 }

diff --git a/src/smpi/bindings/smpi_pmpi_coll.cpp b/src/smpi/bindings/smpi_pmpi_coll.cpp
index 7459567..26c85d3 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_coll.cpp
+++ b/src/smpi/bindings/smpi_pmpi_coll.cpp
@@ -39,12 +39,12 @@ int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm c
     if (known == 0)
       dt_size_send   = datatype->size();
     extra->send_size = count * dt_size_send;
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
     if (comm->size() > 1)
       simgrid::smpi::Colls::bcast(buf, count, datatype, root, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -62,7 +62,7 @@ int PMPI_Barrier(MPI_Comm comm)
     int rank               = comm != MPI_COMM_NULL ? smpi_process()->index() : -1;
     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
     extra->type            = TRACING_BARRIER;
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::barrier(comm);
 
@@ -71,7 +71,7 @@ int PMPI_Barrier(MPI_Comm comm)
 
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -118,12 +118,12 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbu
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
 
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::gather(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, root, comm);
 
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -177,10 +177,10 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recv
       for (int i = 0; i < size; i++) // copy data to avoid bad free
         extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
     }
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     retval = simgrid::smpi::Colls::gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root, comm);
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -223,11 +223,11 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -275,11 +275,11 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
     for (i                 = 0; i < size; i++) // copy data to avoid bad free
       extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -323,11 +323,11 @@ int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
     if (known == 0)
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -375,11 +375,11 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
     if (known == 0)
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     retval = simgrid::smpi::Colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
 
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -409,12 +409,12 @@ int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
     extra->send_size = count * dt_size_send;
     extra->root      = root_traced;
 
-    TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
 
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -464,7 +464,7 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatyp
       dt_size_send   = datatype->size();
     extra->send_size = count * dt_size_send;
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::allreduce(sendtmpbuf, recvbuf, count, datatype, op, comm);
 
@@ -472,7 +472,7 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatyp
       xbt_free(sendtmpbuf);
 
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -502,11 +502,11 @@ int PMPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MP
       dt_size_send   = datatype->size();
     extra->send_size = count * dt_size_send;
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     retval = simgrid::smpi::Colls::scan(sendbuf, recvbuf, count, datatype, op, comm);
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -539,11 +539,11 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
       sendtmpbuf = static_cast<void*>(xbt_malloc(count * datatype->size()));
       memcpy(sendtmpbuf, recvbuf, count * datatype->size());
     }
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     retval = simgrid::smpi::Colls::exscan(sendtmpbuf, recvbuf, count, datatype, op, comm);
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
     if (sendbuf == MPI_IN_PLACE)
       xbt_free(sendtmpbuf);
   }
@@ -590,11 +590,11 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datat
       memcpy(sendtmpbuf, recvbuf, totalcount * datatype->size());
     }
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Colls::reduce_scatter(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm);
     retval = MPI_SUCCESS;
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
 
     if (sendbuf == MPI_IN_PLACE)
       xbt_free(sendtmpbuf);
@@ -640,7 +640,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
       memcpy(sendtmpbuf, recvbuf, recvcount * count * datatype->size());
     }
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     int* recvcounts = static_cast<int*>(xbt_malloc(count * sizeof(int)));
     for (int i      = 0; i < count; i++)
@@ -649,7 +649,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
     xbt_free(recvcounts);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
 
     if (sendbuf == MPI_IN_PLACE)
       xbt_free(sendtmpbuf);
@@ -696,11 +696,11 @@ int PMPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* rec
     else
       extra->recv_size = recvcount;
 
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
     retval = simgrid::smpi::Colls::alltoall(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, comm);
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
 
     if (sendbuf == MPI_IN_PLACE)
       xbt_free(sendtmpbuf);
@@ -768,10 +768,10 @@ int PMPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype
       extra->sendcounts[i] = sendtmpcounts[i] * dt_size_send;
     }
     extra->num_processes = size;
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
     retval = simgrid::smpi::Colls::alltoallv(sendtmpbuf, sendtmpcounts, sendtmpdisps, sendtmptype, recvbuf, recvcounts,
                                     recvdisps, recvtype, comm);
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
 
     if (sendbuf == MPI_IN_PLACE) {
       xbt_free(sendtmpbuf);

diff --git a/src/smpi/bindings/smpi_pmpi_request.cpp b/src/smpi/bindings/smpi_pmpi_request.cpp
index 71cdf1b..40cc76e 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_request.cpp
+++ b/src/smpi/bindings/smpi_pmpi_request.cpp
@@ -170,12 +170,12 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MP
     if(known==0)
       dt_size_send = datatype->size();
     extra->send_size = count*dt_size_send;
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
 
     *request = simgrid::smpi::Request::irecv(buf, count, datatype, src, tag, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -218,13 +218,13 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MP
     if(known==0)
       dt_size_send = datatype->size();
     extra->send_size = count*dt_size_send;
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
     TRACE_smpi_send(rank, rank, dst_traced, tag, count*datatype->size());
 
     *request = simgrid::smpi::Request::isend(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -266,13 +266,13 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M
     if(known==0)
       dt_size_send = datatype->size();
     extra->send_size = count*dt_size_send;
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
     TRACE_smpi_send(rank, rank, dst_traced, tag, count*datatype->size());
 
     *request = simgrid::smpi::Request::issend(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -313,7 +313,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI
     if (known == 0)
       dt_size_send   = datatype->size();
     extra->send_size = count * dt_size_send;
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Request::recv(buf, count, datatype, src, tag, comm, status);
     retval = MPI_SUCCESS;
@@ -322,10 +322,10 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI
     if (status != MPI_STATUS_IGNORE) {
       src_traced = comm->group()->index(status->MPI_SOURCE);
       if (not TRACE_smpi_view_internals()) {
-        TRACE_smpi_recv(rank, src_traced, rank, tag);
+        TRACE_smpi_recv(src_traced, rank, tag);
       }
     }
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -364,7 +364,7 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI
       dt_size_send = datatype->size();
     }
     extra->send_size = count*dt_size_send;
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
     if (not TRACE_smpi_view_internals()) {
       TRACE_smpi_send(rank, rank, dst_traced, tag,count*datatype->size());
     }
@@ -372,7 +372,7 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI
     simgrid::smpi::Request::send(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -410,13 +410,13 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP
       dt_size_send = datatype->size();
     }
     extra->send_size = count*dt_size_send;
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
     TRACE_smpi_send(rank, rank, dst_traced, tag,count*datatype->size());
 
     simgrid::smpi::Request::ssend(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
 
   smpi_bench_begin();
@@ -467,15 +467,15 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst,
     dt_size_recv = recvtype->size();
   extra->recv_size = recvcount*dt_size_recv;
 
-  TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
   TRACE_smpi_send(rank, rank, dst_traced, sendtag,sendcount*sendtype->size());
 
   simgrid::smpi::Request::sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm,
                     status);
   retval = MPI_SUCCESS;
 
-  TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
-  TRACE_smpi_recv(rank, src_traced, rank, recvtag);
+  TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
+  TRACE_smpi_recv(src_traced, rank, recvtag);
   }
 
   smpi_bench_begin();
@@ -623,19 +623,19 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status)
     int is_wait_for_receive = ((*request)->flags() & RECV);
     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
     extra->type = TRACING_WAIT;
-    TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
 
     simgrid::smpi::Request::wait(request, status);
     retval = MPI_SUCCESS;
 
     //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
-    TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
     if (is_wait_for_receive) {
       if(src_traced==MPI_ANY_SOURCE)
         src_traced = (status!=MPI_STATUS_IGNORE) ?
           comm->group()->rank(status->MPI_SOURCE) :
           src_traced;
-      TRACE_smpi_recv(rank, src_traced, dst_traced, tag_traced);
+      TRACE_smpi_recv(src_traced, dst_traced, tag_traced);
     }
   }
 
@@ -671,7 +671,7 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_WAITANY;
   extra->send_size=count;
-  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
+  TRACE_smpi_ptp_in(rank_traced, __FUNCTION__,extra);
 
   *index = simgrid::smpi::Request::waitany(count, requests, status);
 
@@ -685,9 +685,9 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta
         src_traced = (status != MPI_STATUSES_IGNORE)
                          ? savedvals[*index].comm->group()->rank(status->MPI_SOURCE)
                          : savedvals[*index].src;
-      TRACE_smpi_recv(rank_traced, src_traced, dst_traced, savedvals[*index].tag);
+      TRACE_smpi_recv(src_traced, dst_traced, savedvals[*index].tag);
     }
-    TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank_traced, dst_traced, __FUNCTION__);
   }
   xbt_free(savedvals);
 
@@ -721,7 +721,7 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_WAITALL;
   extra->send_size=count;
-  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
+  TRACE_smpi_ptp_in(rank_traced, __FUNCTION__,extra);
 
   int retval = simgrid::smpi::Request::waitall(count, requests, status);
 
@@ -735,11 +735,11 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
         if(src_traced==MPI_ANY_SOURCE)
         src_traced = (status!=MPI_STATUSES_IGNORE) ?
                           savedvals[i].comm->group()->rank(status[i].MPI_SOURCE) : savedvals[i].src;
-        TRACE_smpi_recv(rank_traced, src_traced, dst_traced,savedvals[i].tag);
+        TRACE_smpi_recv(src_traced, dst_traced,savedvals[i].tag);
       }
     }
   }
-  TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank_traced, -1, __FUNCTION__);
   xbt_free(savedvals);
 
   smpi_bench_begin();

diff --git a/src/smpi/bindings/smpi_pmpi_win.cpp b/src/smpi/bindings/smpi_pmpi_win.cpp
index aa82058..983ed25 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_win.cpp
+++ b/src/smpi/bindings/smpi_pmpi_win.cpp
@@ -166,9 +166,9 @@ int PMPI_Win_fence( int assert,  MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
   int rank = smpi_process()->index();
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
+  TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
   retval = win->fence(assert);
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -196,13 +196,12 @@ int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                            target_datatype);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -233,13 +232,12 @@ int PMPI_Rget( void *origin_addr, int origin_count, MPI_Datatype origin_datatype
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                            target_datatype, request);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -268,13 +266,13 @@ int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
     MPI_Group group;
     win->get_group(&group);
     int dst_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
     TRACE_smpi_send(rank, rank, dst_traced, SMPI_RMA_TAG, origin_count*origin_datatype->size());
 
     retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                            target_datatype);
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -306,13 +304,13 @@ int PMPI_Rput( void *origin_addr, int origin_count, MPI_Datatype origin_datatype
     MPI_Group group;
     win->get_group(&group);
     int dst_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
     TRACE_smpi_send(rank, rank, dst_traced, SMPI_RMA_TAG, origin_count*origin_datatype->size());
 
     retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                            target_datatype, request);
 
-    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -342,13 +340,11 @@ int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_da
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
-
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
     retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                                   target_datatype, op);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -381,13 +377,12 @@ int PMPI_Raccumulate( void *origin_addr, int origin_count, MPI_Datatype origin_d
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
                                   target_datatype, op, request);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -420,14 +415,13 @@ MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
                                   result_count, result_datatype, target_rank, target_disp,
                                   target_count, target_datatype, op);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -464,14 +458,13 @@ MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request){
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
                                   result_count, result_datatype, target_rank, target_disp,
                                   target_count, target_datatype, op, request);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -503,13 +496,12 @@ int PMPI_Compare_and_swap(void *origin_addr, void *compare_addr,
     int rank = smpi_process()->index();
     MPI_Group group;
     win->get_group(&group);
-    int src_traced = group->index(target_rank);
-    TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, nullptr);
+    TRACE_smpi_ptp_in(rank, __FUNCTION__, nullptr);
 
     retval = win->compare_and_swap( origin_addr, compare_addr, result_addr, datatype,
                                   target_rank, target_disp);
 
-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -524,9 +516,9 @@ int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
     retval = MPI_ERR_GROUP;
   } else {
     int rank = smpi_process()->index();
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
     retval = win->post(group,assert);
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -541,9 +533,9 @@ int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
     retval = MPI_ERR_GROUP;
   } else {
     int rank = smpi_process()->index();
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
     retval = win->start(group,assert);
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -556,11 +548,11 @@ int PMPI_Win_complete(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int rank = smpi_process()->index();
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
 
     retval = win->complete();
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -573,11 +565,11 @@ int PMPI_Win_wait(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int rank = smpi_process()->index();
-    TRACE_smpi_collective_in(rank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(rank, __FUNCTION__, nullptr);
 
     retval = win->wait();
 
-    TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(rank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -595,9 +587,9 @@ int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->lock(lock_type,rank,assert);
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -612,9 +604,9 @@ int PMPI_Win_unlock(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->unlock(rank);
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -627,9 +619,9 @@ int PMPI_Win_lock_all(int assert, MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->lock_all(assert);
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -642,9 +634,9 @@ int PMPI_Win_unlock_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->unlock_all();
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -659,9 +651,9 @@ int PMPI_Win_flush(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->flush(rank);
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -676,9 +668,9 @@ int PMPI_Win_flush_local(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->flush_local(rank);
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -691,9 +683,9 @@ int PMPI_Win_flush_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->flush_all();
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;
@@ -706,9 +698,9 @@ int PMPI_Win_flush_local_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
-    TRACE_smpi_collective_in(myrank, -1, __FUNCTION__, nullptr);
+    TRACE_smpi_collective_in(myrank, __FUNCTION__, nullptr);
     retval = win->flush_local_all();
-    TRACE_smpi_collective_out(myrank, -1, __FUNCTION__);
+    TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }
   smpi_bench_begin();
   return retval;

diff --git a/src/smpi/colls/smpi_automatic_selector.cpp b/src/smpi/colls/smpi_automatic_selector.cpp
index b69b56c..e336785 100644 (file)
--- a/src/smpi/colls/smpi_automatic_selector.cpp
+++ b/src/smpi/colls/smpi_automatic_selector.cpp
@@ -22,7 +22,7 @@
     }                                                                                                                  \
     char cont_name[25];                                                                                                \
     snprintf(cont_name, 25, "rank-%d", smpi_process()->index());                                                       \
-    val_t value = PJ_value_get_or_new(Colls::mpi_coll_##cat##_description[i].name, "1.0 1.0 1.0", type);               \
+    val_t value = s_val::PJ_value_get_or_new(Colls::mpi_coll_##cat##_description[i].name, "1.0 1.0 1.0", type);               \
     new NewEvent(SIMIX_get_clock(), PJ_container_get(cont_name), type, value);                                         \
   }
 

diff --git a/src/smpi/internals/instr_smpi.cpp b/src/smpi/internals/instr_smpi.cpp
index eb3b141..0eeccfa 100644 (file)
--- a/src/smpi/internals/instr_smpi.cpp
+++ b/src/smpi/internals/instr_smpi.cpp
@@ -233,7 +233,7 @@ void TRACE_smpi_finalize(int rank)
   PJ_container_free (container);
 }
 
-void TRACE_smpi_collective_in(int rank, int root, const char *operation, instr_extra_data extra)
+void TRACE_smpi_collective_in(int rank, const char *operation, instr_extra_data extra)
 {
   if (not TRACE_smpi_is_enabled()) {
     cleanup_extra_data(extra);
@@ -245,11 +245,11 @@ void TRACE_smpi_collective_in(int rank, int root, const char *operation, instr_e
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
   const char *color = instr_find_color (operation);
-  val_t value = PJ_value_get_or_new (operation, color, type);
+  val_t value = s_val::PJ_value_get_or_new (operation, color, type);
   new PushStateEvent (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
-void TRACE_smpi_collective_out(int rank, int root, const char *operation)
+void TRACE_smpi_collective_out(int rank, const char *operation)
 {
   if (not TRACE_smpi_is_enabled())
     return;
@@ -273,7 +273,7 @@ void TRACE_smpi_computing_init(int rank)
  container_t container = PJ_container_get(str);
  type_t type           = PJ_type_get("MPI_STATE", container->type);
  const char* color     = instr_find_color("computing");
- val_t value           = PJ_value_get_or_new("computing", color, type);
+ val_t value           = s_val::PJ_value_get_or_new("computing", color, type);
  new PushStateEvent(SIMIX_get_clock(), container, type, value);
 }
 
@@ -289,7 +289,7 @@ void TRACE_smpi_computing_in(int rank, instr_extra_data extra)
   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
-  val_t value = PJ_value_get_or_new ("computing", nullptr, type);
+  val_t value = s_val::PJ_value_get_or_new ("computing", nullptr, type);
   new PushStateEvent  (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
@@ -315,7 +315,7 @@ void TRACE_smpi_sleeping_init(int rank)
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
   const char *color = instr_find_color ("sleeping");
-  val_t value = PJ_value_get_or_new ("sleeping", color, type);
+  val_t value = s_val::PJ_value_get_or_new ("sleeping", color, type);
   new PushStateEvent (SIMIX_get_clock(), container, type, value);
 }
 
@@ -331,7 +331,7 @@ void TRACE_smpi_sleeping_in(int rank, instr_extra_data extra)
   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
-  val_t value = PJ_value_get_or_new ("sleeping", nullptr, type);
+  val_t value = s_val::PJ_value_get_or_new ("sleeping", nullptr, type);
   new PushStateEvent  (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
@@ -358,7 +358,7 @@ void TRACE_smpi_testing_in(int rank, instr_extra_data extra)
   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
-  val_t value = PJ_value_get_or_new ("test", nullptr, type);
+  val_t value = s_val::PJ_value_get_or_new ("test", nullptr, type);
   new PushStateEvent  (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
@@ -373,7 +373,7 @@ void TRACE_smpi_testing_out(int rank)
   new PopStateEvent (SIMIX_get_clock(), container, type);
 }
 
-void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, instr_extra_data extra)
+void TRACE_smpi_ptp_in(int rank, const char *operation, instr_extra_data extra)
 {
   if (not TRACE_smpi_is_enabled()) {
     cleanup_extra_data(extra);
@@ -385,11 +385,11 @@ void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, instr_
   container_t container = PJ_container_get (str);
   type_t type = PJ_type_get ("MPI_STATE", container->type);
   const char *color = instr_find_color (operation);
-  val_t value = PJ_value_get_or_new (operation, color, type);
+  val_t value = s_val::PJ_value_get_or_new (operation, color, type);
   new PushStateEvent (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
-void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
+void TRACE_smpi_ptp_out(int rank, int dst, const char *operation)
 {
   if (not TRACE_smpi_is_enabled())
     return;
@@ -418,7 +418,7 @@ void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
   new StartLinkEvent (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key, size);
 }
 
-void TRACE_smpi_recv(int rank, int src, int dst, int tag)
+void TRACE_smpi_recv(int src, int dst, int tag)
 {
   if (not TRACE_smpi_is_enabled())
     return;

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index efa6db5..47fa986 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -538,7 +538,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
     return 0;
   }
 
-  TRACE_global_init(&argc, argv);
+  TRACE_global_init();
 
   SIMIX_global_init(&argc, argv);
   MSG_init(&argc,argv);

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index c41904e..77162fa 100644 (file)
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -235,7 +235,7 @@ static void action_send(const char *const *action)
   extra->src = rank;
   extra->dst = dst_traced;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
   if (not TRACE_smpi_view_internals())
     TRACE_smpi_send(rank, rank, dst_traced, 0, size*MPI_CURRENT_TYPE->size());
 
@@ -243,7 +243,7 @@ static void action_send(const char *const *action)
 
   log_timed_action (action, clock);
 
-  TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
 }
 
 static void action_Isend(const char *const *action)
@@ -266,13 +266,13 @@ static void action_Isend(const char *const *action)
   extra->src = rank;
   extra->dst = dst_traced;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
   if (not TRACE_smpi_view_internals())
     TRACE_smpi_send(rank, rank, dst_traced, 0, size*MPI_CURRENT_TYPE->size());
 
   MPI_Request request = Request::isend(nullptr, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
 
-  TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
 
   get_reqq_self()->push_back(request);
 
@@ -300,7 +300,7 @@ static void action_recv(const char *const *action) {
   extra->src = src_traced;
   extra->dst = rank;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
 
   //unknown size from the receiver point of view
   if(size<=0.0){
@@ -310,9 +310,9 @@ static void action_recv(const char *const *action) {
 
   Request::recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
 
-  TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   if (not TRACE_smpi_view_internals()) {
-    TRACE_smpi_recv(rank, src_traced, rank, 0);
+    TRACE_smpi_recv(src_traced, rank, 0);
   }
 
   log_timed_action (action, clock);
@@ -338,7 +338,7 @@ static void action_Irecv(const char *const *action)
   extra->src = src_traced;
   extra->dst = rank;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
   MPI_Status status;
   //unknow size from the receiver pov
   if(size<=0.0){
@@ -348,7 +348,7 @@ static void action_Irecv(const char *const *action)
 
   MPI_Request request = Request::irecv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD);
 
-  TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);
   get_reqq_self()->push_back(request);
 
   log_timed_action (action, clock);
@@ -404,13 +404,13 @@ static void action_wait(const char *const *action){
   int is_wait_for_receive = (request->flags() & RECV);
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_WAIT;
-  TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
+  TRACE_smpi_ptp_in(rank, __FUNCTION__, extra);
 
   Request::wait(&request, &status);
 
-  TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank, dst_traced, __FUNCTION__);
   if (is_wait_for_receive)
-    TRACE_smpi_recv(rank, src_traced, dst_traced, 0);
+    TRACE_smpi_recv(src_traced, dst_traced, 0);
   log_timed_action (action, clock);
 }
 
@@ -426,7 +426,7 @@ static void action_waitall(const char *const *action){
    instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
    extra->type = TRACING_WAITALL;
    extra->send_size=count_requests;
-   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
+   TRACE_smpi_ptp_in(rank_traced, __FUNCTION__,extra);
    int recvs_snd[count_requests];
    int recvs_rcv[count_requests];
    unsigned int i=0;
@@ -442,9 +442,9 @@ static void action_waitall(const char *const *action){
 
    for (i=0; i<count_requests;i++){
      if (recvs_snd[i]!=-100)
-       TRACE_smpi_recv(rank_traced, recvs_snd[i], recvs_rcv[i],0);
+       TRACE_smpi_recv(recvs_snd[i], recvs_rcv[i],0);
    }
-   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
+   TRACE_smpi_ptp_out(rank_traced, -1, __FUNCTION__);
   }
   log_timed_action (action, clock);
 }
@@ -454,11 +454,11 @@ static void action_barrier(const char *const *action){
   int rank = smpi_process()->index();
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_BARRIER;
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
 
   Colls::barrier(MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -485,12 +485,12 @@ static void action_bcast(const char *const *action)
   extra->send_size = size;
   extra->root = root_traced;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
   void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
 
   Colls::bcast(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -518,14 +518,14 @@ static void action_reduce(const char *const *action)
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->root = root_traced;
 
-  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   Colls::reduce(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD);
   smpi_execute_flops(comp_size);
 
-  TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -546,14 +546,14 @@ static void action_allReduce(const char *const *action) {
   extra->send_size = comm_size;
   extra->comp_size = comp_size;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   Colls::allreduce(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
   smpi_execute_flops(comp_size);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -583,11 +583,11 @@ static void action_allToAll(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   Colls::alltoall(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -631,11 +631,11 @@ static void action_gather(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
-  TRACE_smpi_collective_in(smpi_process()->index(), root, __FUNCTION__, extra);
+  TRACE_smpi_collective_in(smpi_process()->index(), __FUNCTION__, extra);
 
   Colls::gather(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(smpi_process()->index(), -1, __FUNCTION__);
+  TRACE_smpi_collective_out(smpi_process()->index(), __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -689,11 +689,11 @@ static void action_gatherv(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
-  TRACE_smpi_collective_in(smpi_process()->index(), root, __FUNCTION__, extra);
+  TRACE_smpi_collective_in(smpi_process()->index(), __FUNCTION__, extra);
 
   Colls::gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(smpi_process()->index(), -1, __FUNCTION__);
+  TRACE_smpi_collective_out(smpi_process()->index(), __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -732,7 +732,7 @@ static void action_reducescatter(const char *const *action) {
   extra->comp_size = comp_size;
   extra->num_processes = comm_size;
 
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
   void *recvbuf = smpi_get_tmp_recvbuffer(size* MPI_CURRENT_TYPE->size());
@@ -740,7 +740,7 @@ static void action_reducescatter(const char *const *action) {
   Colls::reduce_scatter(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
   smpi_execute_flops(comp_size);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -778,11 +778,11 @@ static void action_allgather(const char *const *action) {
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = MPI_COMM_WORLD->size();
 
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   Colls::allgather(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -830,12 +830,12 @@ static void action_allgatherv(const char *const *action) {
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = comm_size;
 
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   Colls::allgatherv(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2,
                           MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -894,12 +894,12 @@ static void action_allToAllv(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
+  TRACE_smpi_collective_in(rank, __FUNCTION__,extra);
 
   Colls::alltoallv(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps,
                          MPI_CURRENT_TYPE, MPI_COMM_WORLD);
 
-  TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_out(rank, __FUNCTION__);
   log_timed_action (action, clock);
 }
 
@@ -917,8 +917,8 @@ void smpi_replay_init(int* argc, char*** argv)
   TRACE_smpi_computing_init(rank);
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_INIT;
-  TRACE_smpi_collective_in(rank, -1, "smpi_replay_run_init", extra);
-  TRACE_smpi_collective_out(rank, -1, "smpi_replay_run_init");
+  TRACE_smpi_collective_in(rank, "smpi_replay_run_init", extra);
+  TRACE_smpi_collective_out(rank, "smpi_replay_run_init");
   xbt_replay_action_register("init",       simgrid::smpi::action_init);
   xbt_replay_action_register("finalize",   simgrid::smpi::action_finalize);
   xbt_replay_action_register("comm_size",  simgrid::smpi::action_comm_size);
@@ -988,11 +988,11 @@ void smpi_replay_main(int* argc, char*** argv)
 
   instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1);
   extra_fin->type = TRACING_FINALIZE;
-  TRACE_smpi_collective_in(smpi_process()->index(), -1, "smpi_replay_run_finalize", extra_fin);
+  TRACE_smpi_collective_in(smpi_process()->index(), "smpi_replay_run_finalize", extra_fin);
 
   smpi_process()->finalize();
 
-  TRACE_smpi_collective_out(smpi_process()->index(), -1, "smpi_replay_run_finalize");
+  TRACE_smpi_collective_out(smpi_process()->index(), "smpi_replay_run_finalize");
   TRACE_smpi_finalize(smpi_process()->index());
 }
 

diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp
index a4c0a36..0d846a1 100644 (file)
--- a/src/smpi/mpi/smpi_request.cpp
+++ b/src/smpi/mpi/smpi_request.cpp
@@ -719,7 +719,7 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
   if (TRACE_smpi_view_internals() && ((req->flags_ & RECV) != 0)){
     int rank = smpi_process()->index();
     int src_traced = (req->src_ == MPI_ANY_SOURCE ? req->real_src_ : req->src_);
-    TRACE_smpi_recv(rank, src_traced, rank,req->tag_);
+    TRACE_smpi_recv(src_traced, rank,req->tag_);
   }
   if(req->detached_sender_ != nullptr){
     //integrate pseudo-timing for buffering of small messages, do not bother to execute the simcall if 0

diff --git a/src/surf/instr_routing.cpp b/src/surf/instr_routing.cpp
index 420221a..fab1c56 100644 (file)
--- a/src/surf/instr_routing.cpp
+++ b/src/surf/instr_routing.cpp
@@ -267,11 +267,11 @@ static void sg_instr_new_host(simgrid::s4u::Host& host)
     if (msg_process == nullptr){
       msg_process = PJ_type_container_new("MSG_PROCESS", container->type);
       type_t state = PJ_type_state_new ("MSG_PROCESS_STATE", msg_process);
-      PJ_value_new ("suspend", "1 0 1", state);
-      PJ_value_new ("sleep", "1 1 0", state);
-      PJ_value_new ("receive", "1 0 0", state);
-      PJ_value_new ("send", "0 0 1", state);
-      PJ_value_new ("task_execute", "0 1 1", state);
+      s_val PJ_value("suspend", "1 0 1", state);
+      s_val::PJ_value_get_or_new("sleep", "1 1 0", state);
+      s_val::PJ_value_get_or_new("receive", "1 0 0", state);
+      s_val::PJ_value_get_or_new("send", "0 0 1", state);
+      s_val::PJ_value_get_or_new("task_execute", "0 1 1", state);
       PJ_type_link_new ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
       PJ_type_link_new ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
     }
@@ -282,11 +282,11 @@ static void sg_instr_new_host(simgrid::s4u::Host& host)
     if (msg_vm == nullptr){
       msg_vm = PJ_type_container_new("MSG_VM", container->type);
       type_t state = PJ_type_state_new ("MSG_VM_STATE", msg_vm);
-      PJ_value_new ("suspend", "1 0 1", state);
-      PJ_value_new ("sleep", "1 1 0", state);
-      PJ_value_new ("receive", "1 0 0", state);
-      PJ_value_new ("send", "0 0 1", state);
-      PJ_value_new ("task_execute", "0 1 1", state);
+      s_val PJ_value("suspend", "1 0 1", state);
+      s_val::PJ_value_get_or_new ("sleep", "1 1 0", state);
+      s_val::PJ_value_get_or_new ("receive", "1 0 0", state);
+      s_val::PJ_value_get_or_new ("send", "0 0 1", state);
+      s_val::PJ_value_get_or_new ("task_execute", "0 1 1", state);
       PJ_type_link_new ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
       PJ_type_link_new ("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm);
     }
@@ -403,7 +403,7 @@ void instr_new_user_state_type (const char *father_type, const char *new_typenam
 static void recursiveNewValueForUserStateType (const char *type_name, const char *value, const char *color, type_t root)
 {
   if (not strcmp(root->name, type_name)) {
-    PJ_value_new (value, color, root);
+    s_val PJ_value (value, color, root);
   }
   xbt_dict_cursor_t cursor = nullptr;
   type_t child_type;