Empty status when request is NULL.

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

diff --git a/src/smpi/smpi_pmpi.c b/src/smpi/smpi_pmpi.c
index f3269fd..f9a06a5 100644 (file)
--- a/src/smpi/smpi_pmpi.c
+++ b/src/smpi/smpi_pmpi.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2007-2013. The SimGrid Team.

  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it


@@ -83,7 +83,7 @@ int PMPI_Init_thread(int *argc, char ***argv, int required, int *provided)
 
 int PMPI_Query_thread(int *provided)
 {
 
 int PMPI_Query_thread(int *provided)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (provided == NULL) {
 
   smpi_bench_end();
   if (provided == NULL) {


@@ -98,7 +98,7 @@ int PMPI_Query_thread(int *provided)
 
 int PMPI_Is_thread_main(int *flag)
 {
 
 int PMPI_Is_thread_main(int *flag)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (flag == NULL) {
 
   smpi_bench_end();
   if (flag == NULL) {


@@ -127,12 +127,10 @@ int PMPI_Abort(MPI_Comm comm, int errorcode)
 double PMPI_Wtime(void)
 {
   double time;
 double PMPI_Wtime(void)
 {
   double time;

-
-  smpi_bench_end();

   time = SIMIX_get_clock();
   time = SIMIX_get_clock();

-  smpi_bench_begin();

   return time;
 }
   return time;
 }

+

 extern double sg_maxmin_precision;
 double PMPI_Wtick(void)
 {
 extern double sg_maxmin_precision;
 double PMPI_Wtick(void)
 {


@@ -141,7 +139,7 @@ double PMPI_Wtick(void)
 
 int PMPI_Address(void *location, MPI_Aint * address)
 {
 
 int PMPI_Address(void *location, MPI_Aint * address)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (!address) {
 
   smpi_bench_end();
   if (!address) {


@@ -161,7 +159,7 @@ int PMPI_Get_address(void *location, MPI_Aint * address)
 
 int PMPI_Type_free(MPI_Datatype * datatype)
 {
 
 int PMPI_Type_free(MPI_Datatype * datatype)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (!datatype) {
 
   smpi_bench_end();
   if (!datatype) {


@@ -176,7 +174,7 @@ int PMPI_Type_free(MPI_Datatype * datatype)
 
 int PMPI_Type_size(MPI_Datatype datatype, int *size)
 {
 
 int PMPI_Type_size(MPI_Datatype datatype, int *size)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {


@@ -193,7 +191,7 @@ int PMPI_Type_size(MPI_Datatype datatype, int *size)
 
 int PMPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 {
 
 int PMPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {


@@ -214,7 +212,7 @@ int PMPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * e
 
 int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
 {
 
 int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {


@@ -231,7 +229,7 @@ int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
 
 int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
 {
 
 int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {


@@ -248,7 +246,7 @@ int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
 
 int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
 {
 
 int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (datatype == MPI_DATATYPE_NULL) {


@@ -265,7 +263,7 @@ int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
 
 int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
 {
 
 int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (function == NULL || op == NULL) {
 
   smpi_bench_end();
   if (function == NULL || op == NULL) {


@@ -280,7 +278,7 @@ int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
 
 int PMPI_Op_free(MPI_Op * op)
 {
 
 int PMPI_Op_free(MPI_Op * op)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (op == NULL) {
 
   smpi_bench_end();
   if (op == NULL) {


@@ -298,7 +296,7 @@ int PMPI_Op_free(MPI_Op * op)
 
 int PMPI_Group_free(MPI_Group * group)
 {
 
 int PMPI_Group_free(MPI_Group * group)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (group == NULL) {
 
   smpi_bench_end();
   if (group == NULL) {


@@ -314,7 +312,7 @@ int PMPI_Group_free(MPI_Group * group)
 
 int PMPI_Group_size(MPI_Group group, int *size)
 {
 
 int PMPI_Group_size(MPI_Group group, int *size)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (group == MPI_GROUP_NULL) {
 
   smpi_bench_end();
   if (group == MPI_GROUP_NULL) {


@@ -331,7 +329,7 @@ int PMPI_Group_size(MPI_Group group, int *size)
 
 int PMPI_Group_rank(MPI_Group group, int *rank)
 {
 
 int PMPI_Group_rank(MPI_Group group, int *rank)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (group == MPI_GROUP_NULL) {
 
   smpi_bench_end();
   if (group == MPI_GROUP_NULL) {


@@ -370,7 +368,7 @@ int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1,
 
 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
 {
 
 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 
   smpi_bench_end();
   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {


@@ -717,7 +715,7 @@ int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3],
 
 int PMPI_Comm_rank(MPI_Comm comm, int *rank)
 {
 
 int PMPI_Comm_rank(MPI_Comm comm, int *rank)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -734,7 +732,7 @@ int PMPI_Comm_rank(MPI_Comm comm, int *rank)
 
 int PMPI_Comm_size(MPI_Comm comm, int *size)
 {
 
 int PMPI_Comm_size(MPI_Comm comm, int *size)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -751,7 +749,7 @@ int PMPI_Comm_size(MPI_Comm comm, int *size)
 
 int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 {
 
 int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL)  {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL)  {


@@ -768,7 +766,7 @@ int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 
 int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 {
 
 int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -790,7 +788,7 @@ int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 
 int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 {
 
 int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {


@@ -816,7 +814,7 @@ int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 
 int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 {
 
 int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -833,7 +831,7 @@ int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 
 int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 {
 
 int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -856,7 +854,7 @@ int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 
 int PMPI_Comm_free(MPI_Comm * comm)
 {
 
 int PMPI_Comm_free(MPI_Comm * comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == NULL) {
 
   smpi_bench_end();
   if (comm == NULL) {


@@ -875,7 +873,7 @@ int PMPI_Comm_free(MPI_Comm * comm)
 int PMPI_Comm_disconnect(MPI_Comm * comm)
 {
   /* TODO: wait until all communication in comm are done */
 int PMPI_Comm_disconnect(MPI_Comm * comm)
 {
   /* TODO: wait until all communication in comm are done */

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == NULL) {
 
   smpi_bench_end();
   if (comm == NULL) {


@@ -893,7 +891,7 @@ int PMPI_Comm_disconnect(MPI_Comm * comm)
 
 int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 {
 
 int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm_out == NULL) {
 
   smpi_bench_end();
   if (comm_out == NULL) {


@@ -911,7 +909,7 @@ int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
                   int tag, MPI_Comm comm, MPI_Request * request)
 {
 int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
                   int tag, MPI_Comm comm, MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (request == NULL) {
 
   smpi_bench_end();
   if (request == NULL) {


@@ -925,13 +923,14 @@ int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
     retval = MPI_SUCCESS;
   }
   smpi_bench_begin();
     retval = MPI_SUCCESS;
   }
   smpi_bench_begin();

+  if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

   return retval;
 }
 
 int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
                   int tag, MPI_Comm comm, MPI_Request * request)
 {
   return retval;
 }
 
 int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
                   int tag, MPI_Comm comm, MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (request == NULL) {
 
   smpi_bench_end();
   if (request == NULL) {


@@ -945,11 +944,12 @@ int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
     retval = MPI_SUCCESS;
   }
   smpi_bench_begin();
     retval = MPI_SUCCESS;
   }
   smpi_bench_begin();

+  if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

   return retval;
 }
 
 int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
   return retval;
 }
 
 int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {

-  int retval;
+  int retval = 0;

 
     smpi_bench_end();
     if (request == NULL) {
 
     smpi_bench_end();
     if (request == NULL) {


@@ -963,12 +963,13 @@ int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int ta
       retval = MPI_SUCCESS;
     }
     smpi_bench_begin();
       retval = MPI_SUCCESS;
     }
     smpi_bench_begin();

+    if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

     return retval;
 }
 
 int PMPI_Start(MPI_Request * request)
 {
     return retval;
 }
 
 int PMPI_Start(MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (request == NULL || *request == MPI_REQUEST_NULL) {
 
   smpi_bench_end();
   if (request == NULL || *request == MPI_REQUEST_NULL) {


@@ -983,7 +984,7 @@ int PMPI_Start(MPI_Request * request)
 
 int PMPI_Startall(int count, MPI_Request * requests)
 {
 
 int PMPI_Startall(int count, MPI_Request * requests)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (requests == NULL) {
 
   smpi_bench_end();
   if (requests == NULL) {


@@ -998,7 +999,7 @@ int PMPI_Startall(int count, MPI_Request * requests)
 
 int PMPI_Request_free(MPI_Request * request)
 {
 
 int PMPI_Request_free(MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (*request == MPI_REQUEST_NULL) {
 
   smpi_bench_end();
   if (*request == MPI_REQUEST_NULL) {


@@ -1015,7 +1016,7 @@ int PMPI_Request_free(MPI_Request * request)
 int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
               int tag, MPI_Comm comm, MPI_Request * request)
 {
 int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
               int tag, MPI_Comm comm, MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
 
   smpi_bench_end();
 


@@ -1041,7 +1042,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);

-  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
+  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, count*smpi_datatype_size(datatype));

 #endif
 
     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
 #endif
 
     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);


@@ -1054,6 +1055,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
   }
 
   smpi_bench_begin();
   }
 
   smpi_bench_begin();

+  if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

   return retval;
 }
 
   return retval;
 }
 


@@ -1061,7 +1063,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
 int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
               int tag, MPI_Comm comm, MPI_Request * request)
 {
 int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
               int tag, MPI_Comm comm, MPI_Request * request)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (request == NULL) {
 
   smpi_bench_end();
   if (request == NULL) {


@@ -1087,8 +1089,8 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);

-  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
-  TRACE_smpi_send(rank, rank, dst_traced);
+  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, count*smpi_datatype_size(datatype));
+  TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));

 #endif
 
     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
 #endif
 
     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);


@@ -1102,11 +1104,12 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
   }
 
   smpi_bench_begin();
   }
 
   smpi_bench_begin();

+  if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

   return retval;
 }
 
 int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
   return retval;
 }
 
 int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (request == NULL) {
 
   smpi_bench_end();
   if (request == NULL) {


@@ -1132,8 +1135,8 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);

-  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
-  TRACE_smpi_send(rank, rank, dst_traced);
+  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, count*smpi_datatype_size(datatype));
+  TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));

 #endif
 
     *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
 #endif
 
     *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);


@@ -1147,13 +1150,14 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M
   }
 
   smpi_bench_begin();
   }
 
   smpi_bench_begin();

+  if(retval!=MPI_SUCCESS)*request=MPI_REQUEST_NULL;

   return retval;
 }
 
 int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
              MPI_Comm comm, MPI_Status * status)
 {
   return retval;
 }
 
 int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
              MPI_Comm comm, MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {
 
   smpi_bench_end();
   if (comm == MPI_COMM_NULL) {


@@ -1177,8 +1181,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
   TRACE_smpi_computing_out(rank);
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
   TRACE_smpi_computing_out(rank);

-
-  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
+  TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, count*smpi_datatype_size(datatype));

 #endif
 
     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
 #endif
 
     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);


@@ -1200,7 +1203,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
 int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
              MPI_Comm comm)
 {
 int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
              MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
 
   smpi_bench_end();
 


@@ -1224,8 +1227,8 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);

-  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
-  TRACE_smpi_send(rank, rank, dst_traced);
+  TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, count*smpi_datatype_size(datatype));
+  TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));

 #endif
 
     smpi_mpi_send(buf, count, datatype, dst, tag, comm);
 #endif
 
     smpi_mpi_send(buf, count, datatype, dst, tag, comm);


@@ -1244,7 +1247,7 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
 
 
 int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
 
 
 int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {

-  int retval;
+  int retval = 0;

 
    smpi_bench_end();
 
 
    smpi_bench_end();
 


@@ -1268,8 +1271,8 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP
    int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
    TRACE_smpi_computing_out(rank);
    int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
    int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
    TRACE_smpi_computing_out(rank);
    int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);

-   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
-   TRACE_smpi_send(rank, rank, dst_traced);
+   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, count*smpi_datatype_size(datatype));
+   TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));

  #endif
 
      smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
  #endif
 
      smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);


@@ -1290,7 +1293,7 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                  MPI_Datatype recvtype, int src, int recvtag,
                  MPI_Comm comm, MPI_Status * status)
 {
                  MPI_Datatype recvtype, int src, int recvtag,
                  MPI_Comm comm, MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
 
   smpi_bench_end();
 


@@ -1319,8 +1322,8 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
   TRACE_smpi_computing_out(rank);
   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
   int src_traced = smpi_group_index(smpi_comm_group(comm), src);

-  TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
-  TRACE_smpi_send(rank, rank, dst_traced);
+  TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, sendcount*smpi_datatype_size(sendtype));
+  TRACE_smpi_send(rank, rank, dst_traced,sendcount*smpi_datatype_size(sendtype));

 #endif
 
 
 #endif
 
 


@@ -1346,7 +1349,7 @@ int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype,
 {
   //TODO: suboptimal implementation
   void *recvbuf;
 {
   //TODO: suboptimal implementation
   void *recvbuf;

-  int retval;
+  int retval = 0;

   if (datatype == MPI_DATATYPE_NULL) {
       retval = MPI_ERR_TYPE;
   } else if (count < 0) {
   if (datatype == MPI_DATATYPE_NULL) {
       retval = MPI_ERR_TYPE;
   } else if (count < 0) {


@@ -1368,13 +1371,14 @@ int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype,
 
 int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
 {
 
 int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-  if (request == MPI_REQUEST_NULL || flag == NULL) {
+  if (request == NULL || flag == NULL) {

     retval = MPI_ERR_ARG;
   } else if (*request == MPI_REQUEST_NULL) {
     *flag= TRUE;
     retval = MPI_ERR_ARG;
   } else if (*request == MPI_REQUEST_NULL) {
     *flag= TRUE;

+    smpi_empty_status(status);

     retval = MPI_ERR_REQUEST;
   } else {
     *flag = smpi_mpi_test(request, status);
     retval = MPI_ERR_REQUEST;
   } else {
     *flag = smpi_mpi_test(request, status);


@@ -1387,7 +1391,7 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
 int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
                 MPI_Status * status)
 {
 int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
                 MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (index == NULL || flag == NULL) {
 
   smpi_bench_end();
   if (index == NULL || flag == NULL) {


@@ -1402,7 +1406,7 @@ int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
 
 int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses)
 {
 
 int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (flag == NULL) {
 
   smpi_bench_end();
   if (flag == NULL) {


@@ -1416,7 +1420,7 @@ int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* status
 }
 
 int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
 }
 
 int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {

-  int retval;
+  int retval = 0;

   smpi_bench_end();
 
   if (status == NULL) {
   smpi_bench_end();
 
   if (status == NULL) {


@@ -1437,7 +1441,7 @@ int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
 
 
 int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {
 
 
 int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {

-  int retval;
+  int retval = 0;

   smpi_bench_end();
 
   if (flag == NULL) {
   smpi_bench_end();
 
   if (flag == NULL) {


@@ -1461,10 +1465,12 @@ int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* statu
 
 int PMPI_Wait(MPI_Request * request, MPI_Status * status)
 {
 
 int PMPI_Wait(MPI_Request * request, MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
 
   smpi_bench_end();
 

+  smpi_empty_status(status);
+

   if (request == NULL) {
     retval = MPI_ERR_ARG;
   } else if (*request == MPI_REQUEST_NULL) {
   if (request == NULL) {
     retval = MPI_ERR_ARG;
   } else if (*request == MPI_REQUEST_NULL) {


@@ -1472,26 +1478,32 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status)
   } else {
 
 #ifdef HAVE_TRACING
   } else {
 
 #ifdef HAVE_TRACING

-  int rank = request && (*request)->comm != MPI_COMM_NULL
+    int rank = request && (*request)->comm != MPI_COMM_NULL

       ? smpi_process_index()
       : -1;
       ? smpi_process_index()
       : -1;

-  TRACE_smpi_computing_out(rank);
+    TRACE_smpi_computing_out(rank);

 
 

-  int src_traced = (*request)->src;
-  int dst_traced = (*request)->dst;
-  int is_wait_for_receive = (*request)->recv;
-  TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
+    int src_traced = (*request)->src;
+    int dst_traced = (*request)->dst;
+    MPI_Comm comm = (*request)->comm;
+    int is_wait_for_receive = (*request)->recv;
+    TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__,-1);

 #endif
 
     smpi_mpi_wait(request, status);
     retval = MPI_SUCCESS;
 
 #ifdef HAVE_TRACING
 #endif
 
     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);
-  }
-  TRACE_smpi_computing_in(rank);
+    //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__);
+    if (is_wait_for_receive) {
+      if(src_traced==MPI_ANY_SOURCE)
+        src_traced = (status!=MPI_STATUS_IGNORE) ?
+          smpi_group_rank(smpi_comm_group(comm), status->MPI_SOURCE) :
+          src_traced;
+      TRACE_smpi_recv(rank, src_traced, dst_traced);
+    }
+    TRACE_smpi_computing_in(rank);

 #endif
 
   }
 #endif
 
   }


@@ -1502,7 +1514,7 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status)
 
 int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
 {
 
 int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 #ifdef HAVE_TRACING
 
   smpi_bench_end();
 #ifdef HAVE_TRACING


@@ -1511,18 +1523,21 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta
   int *srcs = xbt_new(int, count);
   int *dsts = xbt_new(int, count);
   int *recvs = xbt_new(int, count);
   int *srcs = xbt_new(int, count);
   int *dsts = xbt_new(int, count);
   int *recvs = xbt_new(int, count);

+  MPI_Comm *comms = xbt_new(MPI_Comm, count);
+

   for (i = 0; i < count; i++) {
     MPI_Request req = requests[i];      //already received requests are no longer valid
     if (req) {
       srcs[i] = req->src;
       dsts[i] = req->dst;
       recvs[i] = req->recv;
   for (i = 0; i < count; i++) {
     MPI_Request req = requests[i];      //already received requests are no longer valid
     if (req) {
       srcs[i] = req->src;
       dsts[i] = req->dst;
       recvs[i] = req->recv;

+      comms[i] = req->comm;

     }
   }
   int rank_traced = smpi_process_index();
   TRACE_smpi_computing_out(rank_traced);
 
     }
   }
   int rank_traced = smpi_process_index();
   TRACE_smpi_computing_out(rank_traced);
 

-  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
+  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,count);

 
 #endif
   if (index == NULL) {
 
 #endif
   if (index == NULL) {


@@ -1534,15 +1549,22 @@ int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * sta
 #ifdef HAVE_TRACING
   if(*index!=MPI_UNDEFINED){
     int src_traced = srcs[*index];
 #ifdef HAVE_TRACING
   if(*index!=MPI_UNDEFINED){
     int src_traced = srcs[*index];

+    //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)

     int dst_traced = dsts[*index];
     int is_wait_for_receive = recvs[*index];
     if (is_wait_for_receive) {
     int dst_traced = dsts[*index];
     int is_wait_for_receive = recvs[*index];
     if (is_wait_for_receive) {

+      if(srcs[*index]==MPI_ANY_SOURCE)
+        src_traced = (status!=MPI_STATUSES_IGNORE) ?
+                      smpi_group_rank(smpi_comm_group(comms[*index]), status->MPI_SOURCE) :
+                      srcs[*index];

       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
     }
     TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
     xbt_free(srcs);
     xbt_free(dsts);
     xbt_free(recvs);
       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
     }
     TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
     xbt_free(srcs);
     xbt_free(dsts);
     xbt_free(recvs);

+    xbt_free(comms);
+

   }
   TRACE_smpi_computing_in(rank_traced);
 #endif
   }
   TRACE_smpi_computing_in(rank_traced);
 #endif


@@ -1560,35 +1582,52 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
   int *srcs = xbt_new(int, count);
   int *dsts = xbt_new(int, count);
   int *recvs = xbt_new(int, count);
   int *srcs = xbt_new(int, count);
   int *dsts = xbt_new(int, count);
   int *recvs = xbt_new(int, count);

-  int valid_count = 0;
+  int *valid = xbt_new(int, count);
+  MPI_Comm *comms = xbt_new(MPI_Comm, count);
+
+  //int valid_count = 0;

   for (i = 0; i < count; i++) {
     MPI_Request req = requests[i];
     if(req!=MPI_REQUEST_NULL){
   for (i = 0; i < count; i++) {
     MPI_Request req = requests[i];
     if(req!=MPI_REQUEST_NULL){

-      srcs[valid_count] = req->src;
-      dsts[valid_count] = req->dst;
-      recvs[valid_count] = req->recv;
-      valid_count++;
+      srcs[i] = req->src;
+      dsts[i] = req->dst;
+      recvs[i] = req->recv;
+      comms[i] = req->comm;
+      valid[i]=1;;
+    }else{
+      valid[i]=0;

     }
   }
   int rank_traced = smpi_process_index();
   TRACE_smpi_computing_out(rank_traced);
 
     }
   }
   int rank_traced = smpi_process_index();
   TRACE_smpi_computing_out(rank_traced);
 

-  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
+  TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,count);

 #endif
   int retval = smpi_mpi_waitall(count, requests, status);
 #ifdef HAVE_TRACING
 #endif
   int retval = smpi_mpi_waitall(count, requests, status);
 #ifdef HAVE_TRACING

-  for (i = 0; i < valid_count; i++) {
-    int src_traced = srcs[i];
-    int dst_traced = dsts[i];
-    int is_wait_for_receive = recvs[i];
-    if (is_wait_for_receive) {
-      TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
+  for (i = 0; i < count; i++) {
+    if(valid[i]){
+    //int src_traced = srcs[*index];
+    //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
+      int src_traced = srcs[i];
+      int dst_traced = dsts[i];
+      int is_wait_for_receive = recvs[i];
+      if (is_wait_for_receive) {
+        if(src_traced==MPI_ANY_SOURCE)
+        src_traced = (status!=MPI_STATUSES_IGNORE) ?
+                          smpi_group_rank(smpi_comm_group(comms[i]), status[i].MPI_SOURCE) :
+                          srcs[i];
+        TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
+      }

     }
   }
   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
   xbt_free(srcs);
   xbt_free(dsts);
   xbt_free(recvs);
     }
   }
   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
   xbt_free(srcs);
   xbt_free(dsts);
   xbt_free(recvs);

+  xbt_free(valid);
+  xbt_free(comms);
+

   TRACE_smpi_computing_in(rank_traced);
 #endif
   smpi_bench_begin();
   TRACE_smpi_computing_in(rank_traced);
 #endif
   smpi_bench_begin();


@@ -1598,7 +1637,7 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
 int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
                  int *indices, MPI_Status status[])
 {
 int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
                  int *indices, MPI_Status status[])
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (outcount == NULL) {
 
   smpi_bench_end();
   if (outcount == NULL) {


@@ -1614,7 +1653,7 @@ int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
 int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
                  int* indices, MPI_Status status[])
 {
 int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
                  int* indices, MPI_Status status[])
 {

-  int retval;
+  int retval = 0;

 
    smpi_bench_end();
    if (outcount == NULL) {
 
    smpi_bench_end();
    if (outcount == NULL) {


@@ -1630,49 +1669,53 @@ int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
 
 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
 {
 
 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

+
+  if (comm == MPI_COMM_NULL) {
+    retval = MPI_ERR_COMM;
+  } else {

 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
   int root_traced = smpi_group_index(smpi_comm_group(comm), root);

-  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, count*smpi_datatype_size(datatype));

 #endif
 #endif

-  if (comm == MPI_COMM_NULL) {
-    retval = MPI_ERR_COMM;
-  } else {

     mpi_coll_bcast_fun(buf, count, datatype, root, comm);
     retval = MPI_SUCCESS;
     mpi_coll_bcast_fun(buf, count, datatype, root, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Barrier(MPI_Comm comm)
 {
   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Barrier(MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

+
+  if (comm == MPI_COMM_NULL) {
+    retval = MPI_ERR_COMM;
+  } else {

 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);
 #ifdef HAVE_TRACING
   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
   TRACE_smpi_computing_out(rank);

-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, smpi_comm_size(comm));

 #endif
 #endif

-  if (comm == MPI_COMM_NULL) {
-    retval = MPI_ERR_COMM;
-  } else {

     mpi_coll_barrier_fun(comm);
     retval = MPI_SUCCESS;
     mpi_coll_barrier_fun(comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1681,15 +1724,10 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                void *recvbuf, int recvcount, MPI_Datatype recvtype,
                int root, MPI_Comm comm)
 {
                void *recvbuf, int recvcount, MPI_Datatype recvtype,
                int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  int root_traced = smpi_group_index(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 ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||


@@ -1707,17 +1745,23 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
       sendtmpcount=0;
       sendtmptype=recvtype;
     }
       sendtmpcount=0;
       sendtmptype=recvtype;
     }

-
+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int root_traced = smpi_group_index(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,sendcount*smpi_datatype_size(sendtmptype));
+#endif

     mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount,
                     recvtype, root, comm);
 
 
     retval = MPI_SUCCESS;
     mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount,
                     recvtype, root, comm);
 
 
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1726,15 +1770,10 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                 void *recvbuf, int *recvcounts, int *displs,
                 MPI_Datatype recvtype, int root, MPI_Comm comm)
 {
                 void *recvbuf, int *recvcounts, int *displs,
                 MPI_Datatype recvtype, int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  int root_traced = smpi_group_index(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 ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||


@@ -1745,7 +1784,6 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
   } else if (recvcounts == NULL || displs == NULL) {
     retval = MPI_ERR_ARG;
   } else {
   } else if (recvcounts == NULL || displs == NULL) {
     retval = MPI_ERR_ARG;
   } else {

-

     char* sendtmpbuf = (char*) sendbuf;
     int sendtmpcount = sendcount;
     MPI_Datatype sendtmptype = sendtype;
     char* sendtmpbuf = (char*) sendbuf;
     int sendtmpcount = sendcount;
     MPI_Datatype sendtmptype = sendtype;


@@ -1754,14 +1792,21 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
       sendtmptype=recvtype;
     }
 
       sendtmptype=recvtype;
     }
 

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int root_traced = smpi_group_index(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,sendcount*smpi_datatype_size(sendtmptype));
+#endif

     smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts,
                      displs, recvtype, root, comm);
     retval = MPI_SUCCESS;
     smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts,
                      displs, recvtype, root, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1770,14 +1815,10 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                   void *recvbuf, int recvcount, MPI_Datatype recvtype,
                   MPI_Comm comm)
 {
                   void *recvbuf, int recvcount, MPI_Datatype recvtype,
                   MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||


@@ -1787,20 +1828,24 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
             (recvcount <0)){
     retval = MPI_ERR_COUNT;
   } else {
             (recvcount <0)){
     retval = MPI_ERR_COUNT;
   } else {

-

     if(sendbuf == MPI_IN_PLACE) {
       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm);
       sendcount=recvcount;
       sendtype=recvtype;
     }
     if(sendbuf == MPI_IN_PLACE) {
       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm);
       sendcount=recvcount;
       sendtype=recvtype;
     }

-
+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,sendcount*smpi_datatype_size(sendtype));
+#endif

     mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
                            recvtype, comm);
     retval = MPI_SUCCESS;
     mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
                            recvtype, comm);
     retval = MPI_SUCCESS;

-  }
+

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
 #endif

+  }

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1809,14 +1854,10 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                    void *recvbuf, int *recvcounts, int *displs,
                    MPI_Datatype recvtype, MPI_Comm comm)
 {
                    void *recvbuf, int *recvcounts, int *displs,
                    MPI_Datatype recvtype, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||


@@ -1833,15 +1874,20 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
       sendcount=recvcounts[smpi_comm_rank(comm)];
       sendtype=recvtype;
     }
       sendcount=recvcounts[smpi_comm_rank(comm)];
       sendtype=recvtype;
     }

-
+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__,sendcount*smpi_datatype_size(sendtype));
+#endif

     mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts,
                         displs, recvtype, comm);
     retval = MPI_SUCCESS;
     mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts,
                         displs, recvtype, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1850,34 +1896,37 @@ int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                 void *recvbuf, int recvcount, MPI_Datatype recvtype,
                 int root, MPI_Comm comm)
 {
                 void *recvbuf, int recvcount, MPI_Datatype recvtype,
                 int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  int root_traced = smpi_group_index(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 (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
     retval = MPI_ERR_TYPE;
   } else {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
     retval = MPI_ERR_TYPE;
   } else {

+

     if (recvbuf == MPI_IN_PLACE) {
         recvtype=sendtype;
         recvcount=sendcount;
     }
     if (recvbuf == MPI_IN_PLACE) {
         recvtype=sendtype;
         recvcount=sendcount;
     }

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int root_traced = smpi_group_index(smpi_comm_group(comm), root);
+
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,sendcount*smpi_datatype_size(recvtype));
+#endif

     mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
                      recvtype, root, comm);
     retval = MPI_SUCCESS;
     mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
                      recvtype, root, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1886,15 +1935,10 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
                  MPI_Datatype sendtype, void *recvbuf, int recvcount,
                  MPI_Datatype recvtype, int root, MPI_Comm comm)
 {
                  MPI_Datatype sendtype, void *recvbuf, int recvcount,
                  MPI_Datatype recvtype, int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  int root_traced = smpi_group_index(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 (sendcounts == NULL || displs == NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (sendcounts == NULL || displs == NULL) {


@@ -1907,14 +1951,23 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
         recvtype=sendtype;
         recvcount=sendcounts[smpi_comm_rank(comm)];
     }
         recvtype=sendtype;
         recvcount=sendcounts[smpi_comm_rank(comm)];
     }

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int root_traced = smpi_group_index(smpi_comm_group(comm), root);
+  int count=0, i;
+  for(i=0; i<smpi_comm_size(comm);i++)count+=sendcounts[i];
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, count*smpi_datatype_size(sendtype));
+#endif

     smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf,
                       recvcount, recvtype, root, comm);
     retval = MPI_SUCCESS;
     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__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -1922,36 +1975,37 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count,
                MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
 {
 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count,
                MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  int root_traced = smpi_group_index(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) {
     retval = MPI_ERR_ARG;
   } else {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
     retval = MPI_ERR_ARG;
   } else {

-
+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int root_traced = smpi_group_index(smpi_comm_group(comm), root);
+  TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, count*smpi_datatype_size(datatype));
+#endif

     mpi_coll_reduce_fun(sendbuf, recvbuf, count, datatype, op, root, comm);
 
     retval = MPI_SUCCESS;
     mpi_coll_reduce_fun(sendbuf, recvbuf, count, datatype, op, root, comm);
 
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
     MPI_Datatype datatype, MPI_Op op){
   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
     MPI_Datatype datatype, MPI_Op op){

-  int retval;
+  int retval = 0;

 
     smpi_bench_end();
     if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
 
     smpi_bench_end();
     if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {


@@ -1967,14 +2021,10 @@ int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {
 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {


@@ -1988,7 +2038,11 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
     }
       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
     }

-
+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, count*smpi_datatype_size(datatype));
+#endif

     mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm);
 
     if( sendbuf == MPI_IN_PLACE ) {
     mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm);
 
     if( sendbuf == MPI_IN_PLACE ) {


@@ -1996,12 +2050,12 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
     }
 
     retval = MPI_SUCCESS;
     }
 
     retval = MPI_SUCCESS;

-
-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2009,14 +2063,10 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
 int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {
 int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {


@@ -2024,27 +2074,29 @@ int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
   } else if (op == MPI_OP_NULL) {
     retval = MPI_ERR_OP;
   } else {
   } else if (op == MPI_OP_NULL) {
     retval = MPI_ERR_OP;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, count*smpi_datatype_size(datatype));
+#endif

     smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;
     smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
                 MPI_Op op, MPI_Comm comm){
   smpi_bench_begin();
   return retval;
 }
 
 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
                 MPI_Op op, MPI_Comm comm){

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {


@@ -2052,13 +2104,19 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
   } else if (op == MPI_OP_NULL) {
     retval = MPI_ERR_OP;
   } else {
   } else if (op == MPI_OP_NULL) {
     retval = MPI_ERR_OP;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, count*smpi_datatype_size(datatype));
+#endif

     smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;
     smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2066,13 +2124,9 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {
 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

   smpi_bench_end();
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {


@@ -2082,6 +2136,13 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
   } else if (recvcounts == NULL) {
     retval = MPI_ERR_ARG;
   } else {
   } else if (recvcounts == NULL) {
     retval = MPI_ERR_ARG;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int count=0, i;
+  for(i=0; i<smpi_comm_size(comm);i++)count+=recvcounts[i];
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, count*smpi_datatype_size(datatype));
+#endif

     void* sendtmpbuf=sendbuf;
     if(sendbuf==MPI_IN_PLACE){
       sendtmpbuf=recvbuf;
     void* sendtmpbuf=sendbuf;
     if(sendbuf==MPI_IN_PLACE){
       sendtmpbuf=recvbuf;


@@ -2090,11 +2151,12 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
     mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts,
                        datatype,  op, comm);
     retval = MPI_SUCCESS;
     mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts,
                        datatype,  op, comm);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2104,11 +2166,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
 {
   int retval,i;
   smpi_bench_end();
 {
   int retval,i;
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (datatype == MPI_DATATYPE_NULL) {


@@ -2118,6 +2176,11 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
   } else if (recvcount < 0) {
     retval = MPI_ERR_ARG;
   } else {
   } else if (recvcount < 0) {
     retval = MPI_ERR_ARG;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, recvcount*smpi_comm_size(comm)*smpi_datatype_size(datatype));
+#endif

     int count=smpi_comm_size(comm);
     int* recvcounts=(int*)xbt_malloc(count);
     for (i=0; i<count;i++)recvcounts[i]=recvcount;
     int count=smpi_comm_size(comm);
     int* recvcounts=(int*)xbt_malloc(count);
     for (i=0; i<count;i++)recvcounts[i]=recvcount;


@@ -2125,11 +2188,12 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
                        datatype,  op, comm);
     xbt_free(recvcounts);
     retval = MPI_SUCCESS;
                        datatype,  op, comm);
     xbt_free(recvcounts);
     retval = MPI_SUCCESS;

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2138,26 +2202,28 @@ int PMPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                  void *recvbuf, int recvcount, MPI_Datatype recvtype,
                  MPI_Comm comm)
 {
                  void *recvbuf, int recvcount, MPI_Datatype recvtype,
                  MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  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) {
     retval = MPI_ERR_TYPE;
   } else {
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (sendtype == MPI_DATATYPE_NULL
              || recvtype == MPI_DATATYPE_NULL) {
     retval = MPI_ERR_TYPE;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, sendcount*smpi_datatype_size(sendtype));
+#endif

     retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
     retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2166,14 +2232,10 @@ int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,
                   MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
 {
                   MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
 {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-#ifdef HAVE_TRACING
-  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
-  TRACE_smpi_computing_out(rank);
-  TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
-#endif
+

   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (sendtype == MPI_DATATYPE_NULL
   if (comm == MPI_COMM_NULL) {
     retval = MPI_ERR_COMM;
   } else if (sendtype == MPI_DATATYPE_NULL


@@ -2183,15 +2245,23 @@ int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,
              || recvdisps == NULL) {
     retval = MPI_ERR_ARG;
   } else {
              || recvdisps == NULL) {
     retval = MPI_ERR_ARG;
   } else {

+#ifdef HAVE_TRACING
+  int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
+  TRACE_smpi_computing_out(rank);
+  int i, size=0;
+  for(i=0; i< smpi_comm_size(comm);i++)size+=sendcounts[i];
+  TRACE_smpi_collective_in(rank, -1, __FUNCTION__, size*smpi_datatype_size(sendtype));
+#endif

     retval =
         mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype,
                                   recvbuf, recvcounts, recvdisps, recvtype,
                                   comm);
     retval =
         mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype,
                                   recvbuf, recvcounts, recvdisps, recvtype,
                                   comm);

-  }

 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif
 #ifdef HAVE_TRACING
   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
   TRACE_smpi_computing_in(rank);
 #endif

+  }
+

   smpi_bench_begin();
   return retval;
 }
   smpi_bench_begin();
   return retval;
 }


@@ -2239,7 +2309,7 @@ int PMPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count)
 }
 
 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {
 }
 
 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2254,10 +2324,10 @@ int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_typ
 }
 
 int PMPI_Type_commit(MPI_Datatype* datatype) {
 }
 
 int PMPI_Type_commit(MPI_Datatype* datatype) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
 
   smpi_bench_end();

-  if (datatype == MPI_DATATYPE_NULL) {
+  if (datatype == NULL || *datatype == MPI_DATATYPE_NULL) {

     retval = MPI_ERR_TYPE;
   } else {
     smpi_datatype_commit(datatype);
     retval = MPI_ERR_TYPE;
   } else {
     smpi_datatype_commit(datatype);


@@ -2269,7 +2339,7 @@ int PMPI_Type_commit(MPI_Datatype* datatype) {
 
 
 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
 
 
 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2284,7 +2354,7 @@ int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type,
 }
 
 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
 }
 
 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2303,7 +2373,7 @@ int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datat
 }
 
 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
 }
 
 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2318,7 +2388,7 @@ int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_
 }
 
 int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
 }
 
 int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2352,7 +2422,7 @@ int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI
 
 
 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
 
 
 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {
 
   smpi_bench_end();
   if (old_type == MPI_DATATYPE_NULL) {


@@ -2390,7 +2460,7 @@ int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indice
 
 
 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
 
 
 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {

-  int retval;
+  int retval = 0;

 
   smpi_bench_end();
   if (count<0){
 
   smpi_bench_end();
   if (count<0){


@@ -2530,6 +2600,10 @@ int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
    NOT_YET_IMPLEMENTED
 }
 
    NOT_YET_IMPLEMENTED
 }
 

+int PMPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler* errhandler) {
+   NOT_YET_IMPLEMENTED
+}
+

 int PMPI_Cancel(MPI_Request* request) {
    NOT_YET_IMPLEMENTED
 }
 int PMPI_Cancel(MPI_Request* request) {
    NOT_YET_IMPLEMENTED
 }


@@ -2823,10 +2897,6 @@ int PMPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status)
   NOT_YET_IMPLEMENTED
 }
 
   NOT_YET_IMPLEMENTED
 }
 

-int MPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
-  NOT_YET_IMPLEMENTED
-}
-

 int PMPI_Grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request){
   NOT_YET_IMPLEMENTED
 }
 int PMPI_Grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request){
   NOT_YET_IMPLEMENTED
 }