delete unused parameters

diff --git a/src/instr/instr_smpi.h b/src/instr/instr_smpi.h
index 699e29b..1549b10 100644 (file)
--- a/src/instr/instr_smpi.h
+++ b/src/instr/instr_smpi.h
@@ -17,7 +17,7 @@ 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_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_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_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);


@@ -29,8 +29,8 @@ 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_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_init(int rank);
 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_init(int rank);

diff --git a/src/smpi/bindings/smpi_pmpi.cpp b/src/smpi/bindings/smpi_pmpi.cpp
index a891002..ff6a248 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi.cpp
+++ b/src/smpi/bindings/smpi_pmpi.cpp
@@ -41,7 +41,7 @@ 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_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_in(rank, __FUNCTION__, extra);

     TRACE_smpi_collective_out(rank, __FUNCTION__);
     smpi_bench_begin();
   }
     TRACE_smpi_collective_out(rank, __FUNCTION__);
     smpi_bench_begin();
   }


@@ -57,7 +57,7 @@ int PMPI_Finalize()
   int rank = smpi_process()->index();
   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
   extra->type = TRACING_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();
 
 
   smpi_process()->finalize();
 

diff --git a/src/smpi/bindings/smpi_pmpi_coll.cpp b/src/smpi/bindings/smpi_pmpi_coll.cpp
index c191471..26c85d3 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_coll.cpp
+++ b/src/smpi/bindings/smpi_pmpi_coll.cpp
@@ -39,7 +39,7 @@ 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;
     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;
     if (comm->size() > 1)
       simgrid::smpi::Colls::bcast(buf, count, datatype, root, comm);
     retval = MPI_SUCCESS;


@@ -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;
     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);
 
 
     simgrid::smpi::Colls::barrier(comm);
 


@@ -118,7 +118,7 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbu
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
 
       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);
 
 
     simgrid::smpi::Colls::gather(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, root, comm);
 


@@ -177,7 +177,7 @@ 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;
     }
       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, __FUNCTION__);
 
     retval = simgrid::smpi::Colls::gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root, comm);
     TRACE_smpi_collective_out(rank, __FUNCTION__);


@@ -223,7 +223,7 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
 
       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;
 
     simgrid::smpi::Colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
     retval = MPI_SUCCESS;


@@ -275,7 +275,7 @@ 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;
 
     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;
 
     simgrid::smpi::Colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
     retval = MPI_SUCCESS;


@@ -323,7 +323,7 @@ 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;
     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;
 
     simgrid::smpi::Colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;


@@ -375,7 +375,7 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
     if (known == 0)
       dt_size_recv   = recvtype->size();
     extra->recv_size = recvcount * dt_size_recv;
     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);
 
 
     retval = simgrid::smpi::Colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
 


@@ -409,7 +409,7 @@ int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
     extra->send_size = count * dt_size_send;
     extra->root      = root_traced;
 
     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);
 
 
     simgrid::smpi::Colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
 


@@ -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;
 
       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);
 
 
     simgrid::smpi::Colls::allreduce(sendtmpbuf, recvbuf, count, datatype, op, comm);
 


@@ -502,7 +502,7 @@ 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;
 
       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);
 
 
     retval = simgrid::smpi::Colls::scan(sendbuf, recvbuf, count, datatype, op, comm);
 


@@ -539,7 +539,7 @@ 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());
     }
       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);
 
 
     retval = simgrid::smpi::Colls::exscan(sendtmpbuf, recvbuf, count, datatype, op, comm);
 


@@ -590,7 +590,7 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datat
       memcpy(sendtmpbuf, recvbuf, totalcount * datatype->size());
     }
 
       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;
 
     simgrid::smpi::Colls::reduce_scatter(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm);
     retval = MPI_SUCCESS;


@@ -640,7 +640,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
       memcpy(sendtmpbuf, recvbuf, recvcount * count * datatype->size());
     }
 
       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++)
 
     int* recvcounts = static_cast<int*>(xbt_malloc(count * sizeof(int)));
     for (int i      = 0; i < count; i++)


@@ -696,7 +696,7 @@ int PMPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* rec
     else
       extra->recv_size = recvcount;
 
     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);
 
 
     retval = simgrid::smpi::Colls::alltoall(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, comm);
 


@@ -768,7 +768,7 @@ int PMPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype
       extra->sendcounts[i] = sendtmpcounts[i] * dt_size_send;
     }
     extra->num_processes = size;
       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, __FUNCTION__);
     retval = simgrid::smpi::Colls::alltoallv(sendtmpbuf, sendtmpcounts, sendtmpdisps, sendtmptype, recvbuf, recvcounts,
                                     recvdisps, recvtype, comm);
     TRACE_smpi_collective_out(rank, __FUNCTION__);

diff --git a/src/smpi/bindings/smpi_pmpi_request.cpp b/src/smpi/bindings/smpi_pmpi_request.cpp
index 71cdf1b..e7d88fe 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;
     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;
 
 
     *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();
   }
 
   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;
     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_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();
   }
 
   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;
     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_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();
   }
 
   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;
     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;
 
     simgrid::smpi::Request::recv(buf, count, datatype, src, tag, comm, status);
     retval = MPI_SUCCESS;


@@ -325,7 +325,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI
         TRACE_smpi_recv(rank, src_traced, rank, tag);
       }
     }
         TRACE_smpi_recv(rank, src_traced, rank, tag);
       }
     }

-    TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
+    TRACE_smpi_ptp_out(rank, rank, __FUNCTION__);

   }
 
   smpi_bench_begin();
   }
 
   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;
       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());
     }
     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;
 
     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();
   }
 
   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;
       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_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();
   }
 
   smpi_bench_begin();


@@ -467,14 +467,14 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst,
     dt_size_recv = recvtype->size();
   extra->recv_size = recvcount*dt_size_recv;
 
     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_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_ptp_out(rank, dst_traced, __FUNCTION__);

   TRACE_smpi_recv(rank, src_traced, rank, recvtag);
   }
 
   TRACE_smpi_recv(rank, src_traced, rank, recvtag);
   }
 


@@ -623,13 +623,13 @@ 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;
     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)
 
     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) ?
     if (is_wait_for_receive) {
       if(src_traced==MPI_ANY_SOURCE)
         src_traced = (status!=MPI_STATUS_IGNORE) ?


@@ -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;
   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);
 
 
   *index = simgrid::smpi::Request::waitany(count, requests, status);
 


@@ -687,7 +687,7 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta
                          : savedvals[*index].src;
       TRACE_smpi_recv(rank_traced, src_traced, dst_traced, savedvals[*index].tag);
     }
                          : savedvals[*index].src;
       TRACE_smpi_recv(rank_traced, 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);
 
   }
   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;
   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);
 
 
   int retval = simgrid::smpi::Request::waitall(count, requests, status);
 


@@ -739,7 +739,7 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
       }
     }
   }
       }
     }
   }

-  TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
+  TRACE_smpi_ptp_out(rank_traced, -1, __FUNCTION__);

   xbt_free(savedvals);
 
   smpi_bench_begin();
   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 7411b32..983ed25 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_win.cpp
+++ b/src/smpi/bindings/smpi_pmpi_win.cpp
@@ -166,7 +166,7 @@ int PMPI_Win_fence( int assert,  MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
   int rank = smpi_process()->index();
     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, __FUNCTION__);
   }
   retval = win->fence(assert);
   TRACE_smpi_collective_out(rank, __FUNCTION__);
   }


@@ -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 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);
 
 
     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;
   }
   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 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);
 
 
     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;
   }
   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);
     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_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;
   }
   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);
     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_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;
   }
   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 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);
 
     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;
   }
   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 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);
 
 
     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;
   }
   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 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);
 
 
     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;
   }
   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 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);
 
 
     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;
   }
   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 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);
 
 
     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;
   }
   smpi_bench_begin();
   return retval;


@@ -524,7 +516,7 @@ int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
     retval = MPI_ERR_GROUP;
   } else {
     int rank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->post(group,assert);
     TRACE_smpi_collective_out(rank, __FUNCTION__);
   }


@@ -541,7 +533,7 @@ int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
     retval = MPI_ERR_GROUP;
   } else {
     int rank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->start(group,assert);
     TRACE_smpi_collective_out(rank, __FUNCTION__);
   }


@@ -556,7 +548,7 @@ int PMPI_Win_complete(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int rank = smpi_process()->index();
     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();
 
 
     retval = win->complete();
 


@@ -573,7 +565,7 @@ int PMPI_Win_wait(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int rank = smpi_process()->index();
     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();
 
 
     retval = win->wait();
 


@@ -595,7 +587,7 @@ int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->lock(lock_type,rank,assert);
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -612,7 +604,7 @@ int PMPI_Win_unlock(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->unlock(rank);
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -627,7 +619,7 @@ int PMPI_Win_lock_all(int assert, MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->lock_all(assert);
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -642,7 +634,7 @@ int PMPI_Win_unlock_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->unlock_all();
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -659,7 +651,7 @@ int PMPI_Win_flush(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->flush(rank);
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -676,7 +668,7 @@ int PMPI_Win_flush_local(int rank, MPI_Win win){
     retval = MPI_SUCCESS;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->flush_local(rank);
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -691,7 +683,7 @@ int PMPI_Win_flush_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->flush_all();
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }


@@ -706,7 +698,7 @@ int PMPI_Win_flush_local_all(MPI_Win win){
     retval = MPI_ERR_WIN;
   } else {
     int myrank = smpi_process()->index();
     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, __FUNCTION__);
   }
     retval = win->flush_local_all();
     TRACE_smpi_collective_out(myrank, __FUNCTION__);
   }

diff --git a/src/smpi/internals/instr_smpi.cpp b/src/smpi/internals/instr_smpi.cpp
index 6f42ba0..42aa150 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);
 }
 
   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);
 {
   if (not TRACE_smpi_is_enabled()) {
     cleanup_extra_data(extra);


@@ -373,7 +373,7 @@ void TRACE_smpi_testing_out(int rank)
   new PopStateEvent (SIMIX_get_clock(), container, type);
 }
 
   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);
 {
   if (not TRACE_smpi_is_enabled()) {
     cleanup_extra_data(extra);


@@ -389,7 +389,7 @@ void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, instr_
   new PushStateEvent (SIMIX_get_clock(), container, type, value, static_cast<void*>(extra));
 }
 
   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;
 {
   if (not TRACE_smpi_is_enabled())
     return;

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index 52db69b..c05410b 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);
   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());
 
   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);
 
 
   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)
 }
 
 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);
   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);
 
   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);
 
 
   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);
   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){
 
   //unknown size from the receiver point of view
   if(size<=0.0){


@@ -310,7 +310,7 @@ static void action_recv(const char *const *action) {
 
   Request::recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
 
 
   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);
   }
   if (not TRACE_smpi_view_internals()) {
     TRACE_smpi_recv(rank, src_traced, rank, 0);
   }


@@ -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);
   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){
   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);
 
 
   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);
   get_reqq_self()->push_back(request);
 
   log_timed_action (action, clock);


@@ -404,11 +404,11 @@ 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;
   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);
 
 
   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);
   log_timed_action (action, clock);
   if (is_wait_for_receive)
     TRACE_smpi_recv(rank, 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;
    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;
    int recvs_snd[count_requests];
    int recvs_rcv[count_requests];
    unsigned int i=0;


@@ -444,7 +444,7 @@ static void action_waitall(const char *const *action){
      if (recvs_snd[i]!=-100)
        TRACE_smpi_recv(rank_traced, recvs_snd[i], recvs_rcv[i],0);
    }
      if (recvs_snd[i]!=-100)
        TRACE_smpi_recv(rank_traced, 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);
 }
   }
   log_timed_action (action, clock);
 }


@@ -454,7 +454,7 @@ 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;
   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);
 
 
   Colls::barrier(MPI_COMM_WORLD);
 


@@ -485,7 +485,7 @@ static void action_bcast(const char *const *action)
   extra->send_size = size;
   extra->root = root_traced;
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   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);
   void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
 
   Colls::bcast(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);


@@ -518,7 +518,7 @@ static void action_reduce(const char *const *action)
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->root = root_traced;
 
   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());
 
   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());


@@ -546,7 +546,7 @@ 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);
   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());
 
   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());


@@ -583,7 +583,7 @@ static void action_allToAll(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   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);
 
 
   Colls::alltoall(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
 


@@ -631,7 +631,7 @@ static void action_gather(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   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);
 
 
   Colls::gather(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
 


@@ -689,7 +689,7 @@ static void action_gatherv(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   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);
 
 
   Colls::gatherv(send, send_size, MPI_CURRENT_TYPE, recv, recvcounts, disps, MPI_CURRENT_TYPE2, root, MPI_COMM_WORLD);
 


@@ -732,7 +732,7 @@ static void action_reducescatter(const char *const *action) {
   extra->comp_size = comp_size;
   extra->num_processes = comm_size;
 
   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());
 
   void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
   void *recvbuf = smpi_get_tmp_recvbuffer(size* MPI_CURRENT_TYPE->size());


@@ -778,7 +778,7 @@ static void action_allgather(const char *const *action) {
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = MPI_COMM_WORLD->size();
 
   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);
 
 
   Colls::allgather(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
 


@@ -830,7 +830,7 @@ static void action_allgatherv(const char *const *action) {
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = comm_size;
 
   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);
 
   Colls::allgatherv(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2,
                           MPI_COMM_WORLD);


@@ -894,7 +894,7 @@ static void action_allToAllv(const char *const *action) {
   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   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);
 
   Colls::alltoallv(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,recvbuf, recvcounts, recvdisps,
                          MPI_CURRENT_TYPE, MPI_COMM_WORLD);


@@ -917,7 +917,7 @@ 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_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_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);
   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);


@@ -988,7 +988,7 @@ 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;
 
   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();
 
 
   smpi_process()->finalize();