not consider the time spent on SMPI tracing as part of application execution

[simgrid.git] / src / smpi / smpi_mpi.c

diff --git a/src/smpi/smpi_mpi.c b/src/smpi/smpi_mpi.c
index 75cbab6..37518f9 100644 (file)
--- a/src/smpi/smpi_mpi.c
+++ b/src/smpi/smpi_mpi.c
@@ -1,4 +1,8 @@
-/* $Id$tag */
+/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "private.h"
 #include "smpi_coll_private.h"
@@ -11,12 +15,18 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi, smpi,
 
 int MPI_Init(int* argc, char*** argv) {
   smpi_process_init(argc, argv);
+#ifdef HAVE_TRACING
+  TRACE_smpi_init(smpi_process_index());
+#endif
   smpi_bench_begin(-1, NULL);
   return MPI_SUCCESS;
 }
 
 int MPI_Finalize(void) {
   smpi_bench_end(-1, NULL);
+#ifdef HAVE_TRACING
+  TRACE_smpi_finalize(smpi_process_index());
+#endif
   smpi_process_destroy();
   return MPI_SUCCESS;
 }
@@ -100,7 +110,7 @@ int MPI_Type_free(MPI_Datatype* datatype) {
   return retval;
 }
 
-int MPI_Type_size(MPI_Datatype datatype, size_t* size) {
+int MPI_Type_size(MPI_Datatype datatype, int* size) {
   int retval;
 
   smpi_bench_end(-1, NULL);
@@ -109,7 +119,7 @@ int MPI_Type_size(MPI_Datatype datatype, size_t* size) {
   } else if(size == NULL) {
     retval = MPI_ERR_ARG;
   } else {
-    *size = smpi_datatype_size(datatype);
+    *size = (int)smpi_datatype_size(datatype);
     retval = MPI_SUCCESS;
   }
   smpi_bench_begin(-1, NULL);
@@ -681,11 +691,97 @@ int MPI_Comm_free(MPI_Comm* comm) {
   return retval;
 }
 
+int MPI_Send_init(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
+  int retval;
+  int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
+
+  smpi_bench_end(rank, "Send_init");
+  if(request == NULL) {
+    retval = MPI_ERR_ARG;
+  } else if (comm == MPI_COMM_NULL) {
+    retval = MPI_ERR_COMM;
+  } else {
+    *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm);
+    retval = MPI_SUCCESS;
+  }
+  smpi_bench_begin(rank, "Send_init");
+  return retval;
+}
+
+int MPI_Recv_init(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request) {
+  int retval;
+  int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
+
+  smpi_bench_end(rank, "Recv_init");
+  if(request == NULL) {
+    retval = MPI_ERR_ARG;
+  } else if (comm == MPI_COMM_NULL) {
+    retval = MPI_ERR_COMM;
+  } else {
+    *request = smpi_mpi_recv_init(buf, count, datatype, src, tag, comm);
+    retval = MPI_SUCCESS;
+  }
+  smpi_bench_begin(rank, "Recv_init");
+  return retval;
+}
+
+int MPI_Start(MPI_Request* request) {
+  int retval;
+  MPI_Comm comm = (*request)->comm;
+  int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
+
+  smpi_bench_end(rank, "Start");
+  if(request == NULL) {
+    retval = MPI_ERR_ARG;
+  } else {
+    smpi_mpi_start(*request);
+    retval = MPI_SUCCESS;
+  }
+  smpi_bench_begin(rank, "Start");
+  return retval;
+}
+
+int MPI_Startall(int count, MPI_Request* requests) {
+  int retval;
+  MPI_Comm comm = count > 0 && requests ? requests[0]->comm : MPI_COMM_NULL;
+  int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
+
+  smpi_bench_end(rank, "Startall");
+  if(requests == NULL) {
+    retval = MPI_ERR_ARG;
+  } else {
+    smpi_mpi_startall(count, requests);
+    retval = MPI_SUCCESS;
+  }
+  smpi_bench_begin(rank, "Startall");
+  return retval;
+}
+
+int MPI_Request_free(MPI_Request* request) {
+  int retval;
+  MPI_Comm comm = (*request)->comm;
+  int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
+
+  smpi_bench_end(rank, "Request_free");
+  if(request == NULL) {
+    retval = MPI_ERR_ARG;
+  } else {
+    smpi_mpi_request_free(request);
+    retval = MPI_SUCCESS;
+  }
+  smpi_bench_begin(rank, "Request_free");
+  return retval;
+}
+
 int MPI_Irecv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request) {
   int retval;
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Irecv");
+#ifdef HAVE_TRACING
+  int src_traced = smpi_group_rank(smpi_comm_group(comm), src);
+  TRACE_smpi_ptp_in (rank, src_traced, rank, __FUNCTION__);
+#endif
   if(request == NULL) {
     retval = MPI_ERR_ARG;
   } else if (comm == MPI_COMM_NULL) {
@@ -694,6 +790,10 @@ int MPI_Irecv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI
     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, src_traced, rank, __FUNCTION__);
+  (*request)->recv = 1;
+#endif
   smpi_bench_begin(rank, "Irecv");
   return retval;
 }
@@ -703,6 +803,11 @@ int MPI_Isend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Isend");
+#ifdef HAVE_TRACING
+  int dst_traced = smpi_group_rank(smpi_comm_group(comm), dst);
+  TRACE_smpi_ptp_in (rank, rank, dst_traced, __FUNCTION__);
+  TRACE_smpi_send (rank, rank, dst_traced);
+#endif
   if(request == NULL) {
     retval = MPI_ERR_ARG;
   } else if (comm == MPI_COMM_NULL) {
@@ -711,6 +816,10 @@ int MPI_Isend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI
     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, rank, dst_traced, __FUNCTION__);
+  (*request)->send = 1;
+#endif
   smpi_bench_begin(rank, "Isend");
   return retval;
 }
@@ -720,12 +829,20 @@ int MPI_Recv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Recv");
+#ifdef HAVE_TRACING
+  int src_traced = smpi_group_rank(smpi_comm_group(comm), src);
+  TRACE_smpi_ptp_in (rank, src_traced, rank, __FUNCTION__);
+#endif
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else {
     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, src_traced, rank, __FUNCTION__);
+  TRACE_smpi_recv (rank, src_traced, rank);
+#endif
   smpi_bench_begin(rank, "Recv");
   return retval;
 }
@@ -735,12 +852,20 @@ int MPI_Send(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Send");
+#ifdef HAVE_TRACING
+  int dst_traced = smpi_group_rank(smpi_comm_group(comm), dst);
+  TRACE_smpi_ptp_in (rank, rank, dst_traced, __FUNCTION__);
+  TRACE_smpi_send (rank, rank, dst_traced);
+#endif
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else {
     smpi_mpi_send(buf, count, datatype, dst, tag, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, rank, dst_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Send");
   return retval;
 }
@@ -750,6 +875,13 @@ int MPI_Sendrecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, int dst, i
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Sendrecv");
+#ifdef HAVE_TRACING
+  int dst_traced = smpi_group_rank(smpi_comm_group(comm), dst);
+  int src_traced = smpi_group_rank(smpi_comm_group(comm), src);
+  TRACE_smpi_ptp_in (rank, src_traced, dst_traced, __FUNCTION__);
+  TRACE_smpi_send (rank, rank, dst_traced);
+  TRACE_smpi_send (rank, src_traced, rank);
+#endif
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -758,6 +890,11 @@ int MPI_Sendrecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, int dst, i
     smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm, status);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, src_traced, dst_traced, __FUNCTION__);
+  TRACE_smpi_recv (rank, rank, dst_traced);
+  TRACE_smpi_recv (rank, src_traced, rank);
+#endif
   smpi_bench_begin(rank, "Sendrecv");
   return retval;
 }
@@ -815,6 +952,13 @@ int MPI_Wait(MPI_Request* request, MPI_Status* status) {
              : -1;
 
   smpi_bench_end(rank, "Wait");
+#ifdef HAVE_TRACING
+  MPI_Group group = smpi_comm_group((*request)->comm);
+  int src_traced = smpi_group_rank (group , (*request)->src);
+  int dst_traced = smpi_group_rank (group , (*request)->dst);
+  int is_wait_for_receive = (*request)->recv;
+  TRACE_smpi_ptp_in (rank, src_traced, dst_traced, __FUNCTION__);
+#endif
   if(request == NULL) {
     retval = MPI_ERR_ARG;
   } else if(*request == MPI_REQUEST_NULL) {
@@ -823,6 +967,12 @@ int MPI_Wait(MPI_Request* request, MPI_Status* status) {
     smpi_mpi_wait(request, status);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_ptp_out (rank, src_traced, dst_traced, __FUNCTION__);
+  if (is_wait_for_receive){
+    TRACE_smpi_recv (rank, src_traced, dst_traced);
+  }
+#endif
   smpi_bench_begin(rank, "Wait");
   return retval;
 }
@@ -831,19 +981,113 @@ int MPI_Waitany(int count, MPI_Request requests[], int* index, MPI_Status* statu
   int retval;
 
   smpi_bench_end(-1, NULL); //FIXME
+#ifdef HAVE_TRACING
+  //save requests information for tracing
+  int i;
+  xbt_dynar_t srcs = xbt_dynar_new (sizeof(int), xbt_free);
+  xbt_dynar_t dsts = xbt_dynar_new (sizeof(int), xbt_free);
+  xbt_dynar_t recvs = xbt_dynar_new (sizeof(int), xbt_free);
+  for (i = 0; i < count; i++){
+    MPI_Request req = requests[i]; //already received requests are no longer valid
+    if (req){
+      int *asrc = xbt_new(int, 1);
+      int *adst = xbt_new(int, 1);
+      int *arecv = xbt_new(int, 1);
+      *asrc = req->src;
+      *adst = req->dst;
+      *arecv = req->recv;
+      xbt_dynar_insert_at (srcs, i, asrc);
+      xbt_dynar_insert_at (dsts, i, adst);
+      xbt_dynar_insert_at (recvs, i, arecv);
+    }else{
+      int *t = xbt_new(int, 1);
+      xbt_dynar_insert_at (srcs, i, t);
+      xbt_dynar_insert_at (dsts, i, t);
+      xbt_dynar_insert_at (recvs, i, t);
+    }
+  }
+
+  //search for a suitable request to give the rank of current mpi proc
+  MPI_Request req = NULL;
+  for (i = 0; i < count && req == NULL; i++) {
+    req = requests[i];
+  }
+  MPI_Comm comm = (req)->comm;
+  int rank_traced = smpi_comm_rank(comm);
+  TRACE_smpi_ptp_in (rank_traced, -1, -1, __FUNCTION__);
+#endif
   if(index == NULL) {
     retval = MPI_ERR_ARG;
   } else {
     *index = smpi_mpi_waitany(count, requests, status);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  int src_traced, dst_traced, is_wait_for_receive;
+  xbt_dynar_get_cpy (srcs, *index, &src_traced);
+  xbt_dynar_get_cpy (dsts, *index, &dst_traced);
+  xbt_dynar_get_cpy (recvs, *index, &is_wait_for_receive);
+  if (is_wait_for_receive){
+    TRACE_smpi_recv (rank_traced, src_traced, dst_traced);
+  }
+  TRACE_smpi_ptp_out (rank_traced, src_traced, dst_traced, __FUNCTION__);
+  //clean-up of dynars
+  xbt_free (srcs);
+  xbt_free (dsts);
+  xbt_free (recvs);
+#endif
   smpi_bench_begin(-1, NULL);
   return retval;
 }
 
 int MPI_Waitall(int count, MPI_Request requests[],  MPI_Status status[]) {
+
   smpi_bench_end(-1, NULL); //FIXME
+#ifdef HAVE_TRACING
+  //save information from requests
+  int i;
+  xbt_dynar_t srcs = xbt_dynar_new (sizeof(int), xbt_free);
+  xbt_dynar_t dsts = xbt_dynar_new (sizeof(int), xbt_free);
+  xbt_dynar_t recvs = xbt_dynar_new (sizeof(int), xbt_free);
+  for (i = 0; i < count; i++){
+    MPI_Request req = requests[i]; //all req should be valid in Waitall
+    int *asrc = xbt_new(int, 1);
+    int *adst = xbt_new(int, 1);
+    int *arecv = xbt_new(int, 1);
+    *asrc = req->src;
+    *adst = req->dst;
+    *arecv = req->recv;
+    xbt_dynar_insert_at (srcs, i, asrc);
+    xbt_dynar_insert_at (dsts, i, adst);
+    xbt_dynar_insert_at (recvs, i, arecv);
+  }
+
+//  find my rank inside one of MPI_Comm's of the requests
+  MPI_Request req = NULL;
+  for (i = 0; i < count && req == NULL; i++) {
+    req = requests[i];
+  }
+  MPI_Comm comm = (req)->comm;
+  int rank_traced = smpi_comm_rank(comm);
+  TRACE_smpi_ptp_in (rank_traced, -1, -1, __FUNCTION__);
+#endif
   smpi_mpi_waitall(count, requests, status);
+#ifdef HAVE_TRACING
+  for (i = 0; i < count; i++){
+    int src_traced, dst_traced, is_wait_for_receive;
+    xbt_dynar_get_cpy (srcs, i, &src_traced);
+    xbt_dynar_get_cpy (dsts, i, &dst_traced);
+    xbt_dynar_get_cpy (recvs, i, &is_wait_for_receive);
+    if (is_wait_for_receive){
+      TRACE_smpi_recv (rank_traced, src_traced, dst_traced);
+    }
+  }
+  TRACE_smpi_ptp_out (rank_traced, -1, -1, __FUNCTION__);
+  //clean-up of dynars
+  xbt_free (srcs);
+  xbt_free (dsts);
+  xbt_free (recvs);
+#endif
   smpi_bench_begin(-1, NULL);
   return MPI_SUCCESS;
 }
@@ -867,12 +1111,19 @@ int MPI_Bcast(void* buf, int count, MPI_Datatype datatype, int root, MPI_Comm co
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Bcast");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else {
     smpi_mpi_bcast(buf, count, datatype, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Bcast");
   return retval;
 }
@@ -882,12 +1133,18 @@ int MPI_Barrier(MPI_Comm comm) {
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Barrier");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else {
     smpi_mpi_barrier(comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Barrier");
   return retval;
 }
@@ -897,6 +1154,10 @@ int MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbu
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Gather");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -905,6 +1166,9 @@ int MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbu
     smpi_mpi_gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Gather");
   return retval;
 }
@@ -914,6 +1178,10 @@ int MPI_Gatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvb
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Gatherv");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -924,6 +1192,9 @@ int MPI_Gatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvb
     smpi_mpi_gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Gatherv");
   return retval;
 }
@@ -933,6 +1204,9 @@ int MPI_Allgather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* rec
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Allgather");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -941,6 +1215,9 @@ int MPI_Allgather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* rec
     smpi_mpi_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Allgather");
   return retval;
 }
@@ -950,6 +1227,9 @@ int MPI_Allgatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* re
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Allgatherv");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -960,6 +1240,9 @@ int MPI_Allgatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* re
     smpi_mpi_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Allgatherv");
   return retval;
 }
@@ -969,6 +1252,10 @@ int MPI_Scatter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvb
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Scatter");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -977,6 +1264,9 @@ int MPI_Scatter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvb
     smpi_mpi_scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Scatter");
   return retval;
 }
@@ -986,6 +1276,10 @@ int MPI_Scatterv(void* sendbuf, int* sendcounts, int* displs, MPI_Datatype sendt
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Scatterv");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -996,6 +1290,9 @@ int MPI_Scatterv(void* sendbuf, int* sendcounts, int* displs, MPI_Datatype sendt
     smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Scatterv");
   return retval;
 }
@@ -1005,6 +1302,10 @@ int MPI_Reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, M
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Reduce");
+#ifdef HAVE_TRACING
+  int root_traced = smpi_group_rank(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in (rank, root_traced, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
@@ -1013,6 +1314,9 @@ int MPI_Reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, M
     smpi_mpi_reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, root_traced, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Reduce");
   return retval;
 }
@@ -1022,6 +1326,9 @@ int MPI_Allreduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Allreduce");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(datatype == MPI_DATATYPE_NULL) {
@@ -1032,6 +1339,9 @@ int MPI_Allreduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype
     smpi_mpi_allreduce(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Allreduce");
   return retval;
 }
@@ -1041,6 +1351,9 @@ int MPI_Scan(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Scan");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(datatype == MPI_DATATYPE_NULL) {
@@ -1051,6 +1364,9 @@ int MPI_Scan(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI
     smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Scan");
   return retval;
 }
@@ -1061,6 +1377,9 @@ int MPI_Reduce_scatter(void* sendbuf, void* recvbuf, int* recvcounts, MPI_Dataty
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Reduce_scatter");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(datatype == MPI_DATATYPE_NULL) {
@@ -1084,6 +1403,9 @@ int MPI_Reduce_scatter(void* sendbuf, void* recvbuf, int* recvcounts, MPI_Dataty
     xbt_free(displs);
     retval = MPI_SUCCESS;
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Reduce_scatter");
   return retval;
 }
@@ -1093,6 +1415,9 @@ int MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recv
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Alltoall");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -1108,6 +1433,9 @@ int MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recv
       retval = smpi_coll_tuned_alltoall_pairwise(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
     }
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Alltoall");
   return retval;
 }
@@ -1117,6 +1445,9 @@ int MPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype s
   int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
 
   smpi_bench_end(rank, "Alltoallv");
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_in (rank, -1, __FUNCTION__);
+#endif
   if(comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
@@ -1126,13 +1457,17 @@ int MPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype s
   } else {
     retval = smpi_coll_basic_alltoallv(sendbuf, sendcounts, senddisps, sendtype, recvbuf, recvcounts, recvdisps, recvtype, comm);
   }
+#ifdef HAVE_TRACING
+  TRACE_smpi_collective_out (rank, -1, __FUNCTION__);
+#endif
   smpi_bench_begin(rank, "Alltoallv");
   return retval;
 }
 
 
-int MPI_Get_processor_name( char *name, int *resultlen ) {
+int MPI_Get_processor_name(char* name, int* resultlen) {
   int retval = MPI_SUCCESS;
+
   smpi_bench_end(-1, NULL);
   strncpy( name , SIMIX_host_get_name(SIMIX_host_self()), MPI_MAX_PROCESSOR_NAME-1);
   *resultlen= strlen(name) > MPI_MAX_PROCESSOR_NAME ? MPI_MAX_PROCESSOR_NAME : strlen(name);
@@ -1141,3 +1476,25 @@ int MPI_Get_processor_name( char *name, int *resultlen ) {
   return retval;
 }
 
+int MPI_Get_count(MPI_Status* status, MPI_Datatype datatype, int* count) {
+  int retval = MPI_SUCCESS;
+  size_t size;
+
+  smpi_bench_end(-1, NULL);
+  if (status == NULL || count == NULL) {
+    retval = MPI_ERR_ARG;
+  } else if (datatype == MPI_DATATYPE_NULL) {
+    retval = MPI_ERR_TYPE;
+  } else {
+    size = smpi_datatype_size(datatype);
+    if (size == 0) {
+       *count = 0;
+    } else if (status->count % size != 0) {
+       retval = MPI_UNDEFINED;
+    } else {
+       *count = smpi_mpi_get_count(status, datatype);
+    }
+  }
+  smpi_bench_begin(-1, NULL);
+  return retval;
+}