Use CHECK_ARGS for more collectives.

[simgrid.git] / src / smpi / bindings / smpi_pmpi_coll.cpp

diff --git a/src/smpi/bindings/smpi_pmpi_coll.cpp b/src/smpi/bindings/smpi_pmpi_coll.cpp
index b487d2b..6d57fef 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_coll.cpp
+++ b/src/smpi/bindings/smpi_pmpi_coll.cpp
@@ -16,9 +16,18 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
 #define CHECK_ARGS(test, errcode, ...)                                                                                 \
   if (test) {                                                                                                          \
     XBT_WARN(__VA_ARGS__);                                                                                             \
-    return errcode;                                                                                                    \
+    return (errcode);                                                                                                  \
   }
 
+  static const void* smpi_get_in_place_buf(const void* inplacebuf, const void* otherbuf,std::unique_ptr<unsigned char[]>& tmp_sendbuf, int count, MPI_Datatype datatype){
+  if (inplacebuf == MPI_IN_PLACE) {
+      tmp_sendbuf.reset(new unsigned char[count * datatype->get_extent()]);
+      simgrid::smpi::Datatype::copy(otherbuf, count, datatype, tmp_sendbuf.get(), count, datatype);
+    return tmp_sendbuf.get();
+  }else{
+    return inplacebuf;
+  }
+}
 /* PMPI User level calls */
 
 int PMPI_Barrier(MPI_Comm comm)
@@ -38,11 +47,11 @@ int PMPI_Ibarrier(MPI_Comm comm, MPI_Request *request)
   TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Barrier" : "PMPI_Ibarrier",
                      new simgrid::instr::NoOpTIData(request == MPI_REQUEST_IGNORED ? "barrier" : "ibarrier"));
   if (request == MPI_REQUEST_IGNORED) {
-    simgrid::smpi::Colls::barrier(comm);
+    simgrid::smpi::colls::barrier(comm);
     // Barrier can be used to synchronize RMA calls. Finish all requests from comm before.
     comm->finish_rma_calls();
   } else
-    simgrid::smpi::Colls::ibarrier(comm, request);
+    simgrid::smpi::colls::ibarrier(comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -78,9 +87,9 @@ int PMPI_Ibcast(void *buf, int count, MPI_Datatype datatype,
                                                     simgrid::smpi::Datatype::encode(datatype), ""));
   if (comm->size() > 1) {
     if (request == MPI_REQUEST_IGNORED)
-      simgrid::smpi::Colls::bcast(buf, count, datatype, root, comm);
+      simgrid::smpi::colls::bcast(buf, count, datatype, root, comm);
     else
-      simgrid::smpi::Colls::ibcast(buf, count, datatype, root, comm, request);
+      simgrid::smpi::colls::ibcast(buf, count, datatype, root, comm, request);
   } else {
     if (request != MPI_REQUEST_IGNORED)
       *request = MPI_REQUEST_NULL;
@@ -130,9 +139,9 @@ int PMPI_Igather(const void* sendbuf, int sendcount, MPI_Datatype sendtype, void
                          (comm->rank() != root || recvtype->is_replayable()) ? recvcount : recvcount * recvtype->size(),
                          simgrid::smpi::Datatype::encode(real_sendtype), simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::gather(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, root, comm);
+    simgrid::smpi::colls::gather(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, root, comm);
   else
-    simgrid::smpi::Colls::igather(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, root, comm,
+    simgrid::smpi::colls::igather(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, root, comm,
                                   request);
 
   TRACE_smpi_comm_out(rank);
@@ -194,10 +203,10 @@ int PMPI_Igatherv(const void* sendbuf, int sendcount, MPI_Datatype sendtype, voi
                          nullptr, dt_size_recv, trace_recvcounts, simgrid::smpi::Datatype::encode(real_sendtype),
                          simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::gatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
+    simgrid::smpi::colls::gatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
                                   root, comm);
   else
-    simgrid::smpi::Colls::igatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
+    simgrid::smpi::colls::igatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
                                    root, comm, request);
 
   TRACE_smpi_comm_out(rank);
@@ -213,17 +222,22 @@ int PMPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
 int PMPI_Iallgather(const void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
                     MPI_Datatype recvtype, MPI_Comm comm, MPI_Request* request)
 {
-  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM, "Iallgather: the communicator cannot be MPI_COMM_NULL");
-  CHECK_ARGS(recvbuf == nullptr && recvcount > 0, MPI_ERR_BUFFER, "Iallgather: param 4 recvbuf cannot be NULL");
+  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM,
+             "(I)Allgather: the communicator cannot be MPI_COMM_NULL");
+  CHECK_ARGS(recvbuf == nullptr && recvcount > 0, MPI_ERR_BUFFER,
+             "(I)Allgather: param 4 recvbuf cannot be NULL");
   CHECK_ARGS(sendbuf == nullptr && sendcount > 0, MPI_ERR_BUFFER,
-             "Iallgather: param 1 sendbuf cannot be NULL when sendcound > 0");
+             "(I)Allgather: param 1 sendbuf cannot be NULL when sendcount > 0");
   CHECK_ARGS((sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL), MPI_ERR_TYPE,
-             "Iallgather: param 3 sendtype cannot be MPI_DATATYPE_NULL when sendbuff is not MPI_IN_PLACE");
-  CHECK_ARGS(recvtype == MPI_DATATYPE_NULL, MPI_ERR_TYPE, "Iallgather: param 6 recvtype cannot be MPI_DATATYPE_NULL");
-  CHECK_ARGS(recvcount < 0, MPI_ERR_COUNT, "Iallgather: param 5 recvcount cannot be negative");
+             "(I)Allgather: param 3 sendtype cannot be MPI_DATATYPE_NULL when sendbuff is not MPI_IN_PLACE");
+  CHECK_ARGS(recvtype == MPI_DATATYPE_NULL, MPI_ERR_TYPE,
+             "(I)Allgather: param 6 recvtype cannot be MPI_DATATYPE_NULL");
+  CHECK_ARGS(recvcount < 0, MPI_ERR_COUNT,
+             "(I)Allgather: param 5 recvcount cannot be negative");
   CHECK_ARGS((sendbuf != MPI_IN_PLACE) && (sendcount < 0), MPI_ERR_COUNT,
-             "Iallgather: param 2 sendcount cannot be negative when sendbuf is not MPI_IN_PLACE");
-  CHECK_ARGS(request == nullptr, MPI_ERR_ARG, "Iallgather: param 8 request cannot be NULL");
+             "(I)Allgather: param 2 sendcount cannot be negative when sendbuf is not MPI_IN_PLACE");
+  CHECK_ARGS(request == nullptr, MPI_ERR_ARG,
+             "Iallgather: param 8 request cannot be NULL");
 
   smpi_bench_end();
   if (sendbuf == MPI_IN_PLACE) {
@@ -240,9 +254,9 @@ int PMPI_Iallgather(const void* sendbuf, int sendcount, MPI_Datatype sendtype, v
                          recvtype->is_replayable() ? recvcount : recvcount * recvtype->size(),
                          simgrid::smpi::Datatype::encode(sendtype), simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
+    simgrid::smpi::colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
   else
-    simgrid::smpi::Colls::iallgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request);
+    simgrid::smpi::colls::iallgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -257,18 +271,22 @@ int PMPI_Allgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
 int PMPI_Iallgatherv(const void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, const int* recvcounts, const int* displs,
                      MPI_Datatype recvtype, MPI_Comm comm, MPI_Request* request)
 {
-  if (comm == MPI_COMM_NULL)
-    return MPI_ERR_COMM;
-  if (sendbuf == nullptr && sendcount > 0)
-    return MPI_ERR_BUFFER;
-  if (((sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) || (recvtype == MPI_DATATYPE_NULL))
-    return MPI_ERR_TYPE;
-  if ((sendbuf != MPI_IN_PLACE) && (sendcount < 0))
-    return MPI_ERR_COUNT;
-  if (recvcounts == nullptr || displs == nullptr)
-    return MPI_ERR_ARG;
-  if (request == nullptr)
-    return MPI_ERR_ARG;
+  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM,
+             "(I)Allgatherv: the communicator cannot be MPI_COMM_NULL");
+  CHECK_ARGS(sendbuf == nullptr && sendcount > 0, MPI_ERR_BUFFER,
+             "(I)Allgatherv: param 1 sendbuf cannot be NULL when sendcount > 0");
+  CHECK_ARGS((sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL), MPI_ERR_TYPE,
+             "(I)Allgatherv: param 3 sendtype cannot be MPI_DATATYPE_NULL when sendbuff is not MPI_IN_PLACE");
+  CHECK_ARGS(recvtype == MPI_DATATYPE_NULL, MPI_ERR_TYPE,
+             "(I)Allgatherv: param 7 recvtype cannot be MPI_DATATYPE_NULL");
+  CHECK_ARGS(recvcounts == nullptr, MPI_ERR_COUNT,
+             "(I)Allgatherv: param 5 recvcounts cannot be null");
+  CHECK_ARGS(displs == nullptr, MPI_ERR_ARG,
+             "(I)Allgatherv: param 6 displs cannot be null");
+  CHECK_ARGS((sendbuf != MPI_IN_PLACE) && (sendcount < 0), MPI_ERR_COUNT,
+             "(I)Allgatherv: param 2 sendcount cannot be negative when sendbuf is not MPI_IN_PLACE");
+  CHECK_ARGS(request == nullptr, MPI_ERR_ARG,
+             "Iallgatherv: param 9 request cannot be NULL");
 
   for (int i = 0; i < comm->size(); i++) {
     if (recvcounts[i] < 0)
@@ -298,9 +316,9 @@ int PMPI_Iallgatherv(const void* sendbuf, int sendcount, MPI_Datatype sendtype,
                                         dt_size_recv, trace_recvcounts, simgrid::smpi::Datatype::encode(sendtype),
                                         simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
+    simgrid::smpi::colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
   else
-    simgrid::smpi::Colls::iallgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm,
+    simgrid::smpi::colls::iallgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm,
                                       request);
 
   TRACE_smpi_comm_out(rank);
@@ -316,20 +334,27 @@ int PMPI_Scatter(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
 int PMPI_Iscatter(const void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
                   MPI_Datatype recvtype, int root, MPI_Comm comm, MPI_Request* request)
 {
-  if (comm == MPI_COMM_NULL)
-    return MPI_ERR_COMM;
-  if (((comm->rank() == root) && (sendtype == MPI_DATATYPE_NULL || not sendtype->is_valid())) ||
-      ((recvbuf != MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL || not recvtype->is_valid())))
-    return MPI_ERR_TYPE;
-  if (((comm->rank() == root) && (sendcount < 0)) || ((recvbuf != MPI_IN_PLACE) && (recvcount < 0)))
-    return MPI_ERR_COUNT;
-  if ((sendbuf == recvbuf) || ((comm->rank() == root) && sendcount > 0 && (sendbuf == nullptr)) ||
-      (recvcount > 0 && recvbuf == nullptr))
-    return MPI_ERR_BUFFER;
-  if (root < 0 || root >= comm->size())
-    return MPI_ERR_ROOT;
-  if (request == nullptr)
-    return MPI_ERR_ARG;
+  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM,
+             "(I)Scatter: the communicator cannot be MPI_COMM_NULL");
+  CHECK_ARGS(recvbuf == nullptr && recvcount > 0, MPI_ERR_BUFFER,
+             "(I)Scatter: param 4 recvbuf cannot be NULL");
+  CHECK_ARGS(((sendbuf == recvbuf) || ((comm->rank() == root) && sendcount > 0 && (sendbuf == nullptr))), MPI_ERR_BUFFER,
+             "(I)Scatter: param 1 sendbuf cannot be NULL when sendcount > 0");
+  CHECK_ARGS(((comm->rank() == root) && (sendtype == MPI_DATATYPE_NULL || not sendtype->is_valid())), MPI_ERR_TYPE,
+             "(I)Scatter: param 3 sendtype cannot be MPI_DATATYPE_NULL or invalid on root");
+  CHECK_ARGS(((recvbuf != MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL || not recvtype->is_valid())), MPI_ERR_TYPE,
+             "(I)Scatter: param 6 recvtype cannot be MPI_DATATYPE_NULL or invalid when recvbuf is not MPI_IN_PLACE");
+  CHECK_ARGS(((comm->rank() == root) && (sendcount < 0)), MPI_ERR_COUNT,
+             "(I)Scatter: param 2 sendcount cannot be negative");
+  CHECK_ARGS(((recvbuf != MPI_IN_PLACE) && (recvcount < 0)), MPI_ERR_COUNT,
+             "(I)Scatter: param 5 recvcount cannot be negative");
+  CHECK_ARGS(root < 0, MPI_ERR_ROOT,
+             "(I)Scatter: root cannot be negative");
+  CHECK_ARGS(root >= comm->size(), MPI_ERR_ROOT,
+             "(I)Scatter: root (=%d) is larger than communicator size (=%d)", root,
+             comm->size());
+  CHECK_ARGS(request == nullptr, MPI_ERR_ARG,
+             "Iscatter: param 9 request cannot be NULL");
 
   smpi_bench_end();
   if (recvbuf == MPI_IN_PLACE) {
@@ -345,9 +370,9 @@ int PMPI_Iscatter(const void* sendbuf, int sendcount, MPI_Datatype sendtype, voi
                          recvtype->is_replayable() ? recvcount : recvcount * recvtype->size(),
                          simgrid::smpi::Datatype::encode(sendtype), simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
+    simgrid::smpi::colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
   else
-    simgrid::smpi::Colls::iscatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request);
+    simgrid::smpi::colls::iscatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -362,20 +387,24 @@ int PMPI_Scatterv(const void *sendbuf, const int *sendcounts, const int *displs,
 int PMPI_Iscatterv(const void* sendbuf, const int* sendcounts, const int* displs, MPI_Datatype sendtype, void* recvbuf, int recvcount,
                    MPI_Datatype recvtype, int root, MPI_Comm comm, MPI_Request* request)
 {
-  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM, "Iscatterv: the communicator cannot be MPI_COMM_NULL");
+  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM,
+             "(I)Scatterv: the communicator cannot be MPI_COMM_NULL");
   CHECK_ARGS((comm->rank() == root) && (sendcounts == nullptr), MPI_ERR_ARG,
-             "Iscatterv: param 2 sendcounts cannot be NULL on the root rank");
+             "(I)Scatterv: param 2 sendcounts cannot be NULL on the root rank");
   CHECK_ARGS((comm->rank() == root) && (displs == nullptr), MPI_ERR_ARG,
-             "Iscatterv: param 3 displs cannot be NULL on the root rank");
+             "(I)Scatterv: param 3 displs cannot be NULL on the root rank");
   CHECK_ARGS((comm->rank() == root) && (sendtype == MPI_DATATYPE_NULL), MPI_ERR_TYPE,
-             "Iscatterv: The sendtype cannot be NULL on the root rank");
+             "(I)Scatterv: The sendtype cannot be NULL on the root rank");
   CHECK_ARGS((recvbuf != MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL), MPI_ERR_TYPE,
-             "Iscatterv: the recvtype cannot be NULL when not receiving in place");
-  CHECK_ARGS(request == nullptr, MPI_ERR_ARG, "Iscatterv: param 10 request cannot be NULL");
+             "(I)Scatterv: the recvtype cannot be NULL when not receiving in place");
+  CHECK_ARGS(request == nullptr, MPI_ERR_ARG,
+             "Iscatterv: param 10 request cannot be NULL");
   CHECK_ARGS(recvbuf != MPI_IN_PLACE && recvcount < 0, MPI_ERR_COUNT,
-             "Iscatterv: When not receiving in place, the recvcound cannot be negative");
-  CHECK_ARGS(root < 0, MPI_ERR_ROOT, "Iscatterv: root cannot be negative");
-  CHECK_ARGS(root >= comm->size(), MPI_ERR_ROOT, "Iscatterv: root (=%d) is larger than communicator size (=%d)", root,
+             "(I)Scatterv: When not receiving in place, the recvcount cannot be negative");
+  CHECK_ARGS(root < 0, MPI_ERR_ROOT,
+             "(I)Scatterv: root cannot be negative");
+  CHECK_ARGS(root >= comm->size(), MPI_ERR_ROOT,
+             "(I)Scatterv: root (=%d) is larger than communicator size (=%d)", root,
              comm->size());
 
   if (comm->rank() == root) {
@@ -407,9 +436,9 @@ int PMPI_Iscatterv(const void* sendbuf, const int* sendcounts, const int* displs
                          nullptr, simgrid::smpi::Datatype::encode(sendtype),
                          simgrid::smpi::Datatype::encode(recvtype)));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
+    simgrid::smpi::colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
   else
-    simgrid::smpi::Colls::iscatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm,
+    simgrid::smpi::colls::iscatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm,
                                     request);
 
   TRACE_smpi_comm_out(rank);
@@ -424,20 +453,25 @@ int PMPI_Reduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype data
 
 int PMPI_Ireduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm, MPI_Request* request)
 {
-  if (comm == MPI_COMM_NULL)
-    return MPI_ERR_COMM;
-  if ((sendbuf == nullptr && count > 0) || ((comm->rank() == root) && recvbuf == nullptr))
-    return MPI_ERR_BUFFER;
-  if (datatype == MPI_DATATYPE_NULL || not datatype->is_valid())
-    return MPI_ERR_TYPE;
-  if (op == MPI_OP_NULL)
-    return MPI_ERR_OP;
-  if (request == nullptr)
-    return MPI_ERR_ARG;
-  if (root < 0 || root >= comm->size())
-    return MPI_ERR_ROOT;
-  if (count < 0)
-    return MPI_ERR_COUNT;
+  CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM,
+             "(I)Reduce: the communicator cannot be MPI_COMM_NULL");
+  CHECK_ARGS(((comm->rank() == root) && recvbuf == nullptr), MPI_ERR_BUFFER,
+             "(I)Reduce: param 2 recvbuf cannot be NULL");
+  CHECK_ARGS((sendbuf == nullptr && count > 0), MPI_ERR_BUFFER,
+             "(I)Reduce: param 1 sendbuf cannot be NULL when count > 0");
+  CHECK_ARGS((datatype == MPI_DATATYPE_NULL || not datatype->is_valid()), MPI_ERR_TYPE,
+             "(I)Reduce: param 4 datatype cannot be MPI_DATATYPE_NULL or invalid");
+  CHECK_ARGS(count < 0, MPI_ERR_COUNT,
+             "(I)Reduce: param 3 count cannot be negative");
+  CHECK_ARGS(request == nullptr, MPI_ERR_ARG,
+             "Ireduce: param 8 request cannot be NULL");
+  CHECK_ARGS(op == MPI_OP_NULL, MPI_ERR_OP,
+             "(I)Reduce: param 5 op cannot be MPI_OP_NULL");
+  CHECK_ARGS(root < 0, MPI_ERR_ROOT,
+             "(I)Reduce: root cannot be negative");
+  CHECK_ARGS(root >= comm->size(), MPI_ERR_ROOT,
+             "(I)Reduce: root (=%d) is larger than communicator size (=%d)", root,
+             comm->size());
 
   smpi_bench_end();
   int rank = simgrid::s4u::this_actor::get_pid();
@@ -447,9 +481,9 @@ int PMPI_Ireduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype dat
                                                     datatype->is_replayable() ? count : count * datatype->size(), -1,
                                                     simgrid::smpi::Datatype::encode(datatype), ""));
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
+    simgrid::smpi::colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
   else
-    simgrid::smpi::Colls::ireduce(sendbuf, recvbuf, count, datatype, op, root, comm, request);
+    simgrid::smpi::colls::ireduce(sendbuf, recvbuf, count, datatype, op, root, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -492,13 +526,9 @@ int PMPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype
     return MPI_ERR_ARG;
 
   smpi_bench_end();
-  const void* real_sendbuf = sendbuf;
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
-  if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[count * datatype->get_extent()]);
-    simgrid::smpi::Datatype::copy(recvbuf, count, datatype, tmp_sendbuf.get(), count, datatype);
-    real_sendbuf = tmp_sendbuf.get();
-  }
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, count, datatype);
+
   int rank = simgrid::s4u::this_actor::get_pid();
 
   TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Allreduce" : "PMPI_Iallreduce",
@@ -507,9 +537,9 @@ int PMPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype
                                                     simgrid::smpi::Datatype::encode(datatype), ""));
 
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::allreduce(real_sendbuf, recvbuf, count, datatype, op, comm);
+    simgrid::smpi::colls::allreduce(real_sendbuf, recvbuf, count, datatype, op, comm);
   else
-    simgrid::smpi::Colls::iallreduce(real_sendbuf, recvbuf, count, datatype, op, comm, request);
+    simgrid::smpi::colls::iallreduce(real_sendbuf, recvbuf, count, datatype, op, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -538,12 +568,9 @@ int PMPI_Iscan(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datat
 
   smpi_bench_end();
   int rank         = simgrid::s4u::this_actor::get_pid();
-  const void* real_sendbuf = sendbuf;
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
-  if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[count * datatype->size()]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, count * datatype->size());
-  }
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, count, datatype);
+
   TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Scan" : "PMPI_Iscan",
                      new simgrid::instr::Pt2PtTIData(request == MPI_REQUEST_IGNORED ? "scan" : "iscan", -1,
                                                      datatype->is_replayable() ? count : count * datatype->size(),
@@ -551,9 +578,9 @@ int PMPI_Iscan(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datat
 
   int retval;
   if (request == MPI_REQUEST_IGNORED)
-    retval = simgrid::smpi::Colls::scan(real_sendbuf, recvbuf, count, datatype, op, comm);
+    retval = simgrid::smpi::colls::scan(real_sendbuf, recvbuf, count, datatype, op, comm);
   else
-    retval = simgrid::smpi::Colls::iscan(real_sendbuf, recvbuf, count, datatype, op, comm, request);
+    retval = simgrid::smpi::colls::iscan(real_sendbuf, recvbuf, count, datatype, op, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -581,12 +608,8 @@ int PMPI_Iexscan(const void *sendbuf, void *recvbuf, int count, MPI_Datatype dat
 
   smpi_bench_end();
   int rank         = simgrid::s4u::this_actor::get_pid();
-  const void* real_sendbuf = sendbuf;
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
-  if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[count * datatype->size()]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, count * datatype->size());
-  }
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, count, datatype);
 
   TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Exscan" : "PMPI_Iexscan",
                      new simgrid::instr::Pt2PtTIData(request == MPI_REQUEST_IGNORED ? "exscan" : "iexscan", -1,
@@ -595,9 +618,9 @@ int PMPI_Iexscan(const void *sendbuf, void *recvbuf, int count, MPI_Datatype dat
 
   int retval;
   if (request == MPI_REQUEST_IGNORED)
-    retval = simgrid::smpi::Colls::exscan(real_sendbuf, recvbuf, count, datatype, op, comm);
+    retval = simgrid::smpi::colls::exscan(real_sendbuf, recvbuf, count, datatype, op, comm);
   else
-    retval = simgrid::smpi::Colls::iexscan(real_sendbuf, recvbuf, count, datatype, op, comm, request);
+    retval = simgrid::smpi::colls::iexscan(real_sendbuf, recvbuf, count, datatype, op, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -639,13 +662,8 @@ int PMPI_Ireduce_scatter(const void *sendbuf, void *recvbuf, const int *recvcoun
     trace_recvcounts->push_back(recvcounts[i] * dt_send_size);
     totalcount += recvcounts[i];
   }
-
-  const void* real_sendbuf = sendbuf;
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
-  if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[totalcount * datatype->size()]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, totalcount * datatype->size());
-  }
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, totalcount, datatype);
 
   TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Reduce_scatter" : "PMPI_Ireduce_scatter",
                      new simgrid::instr::VarCollTIData(
@@ -653,9 +671,9 @@ int PMPI_Ireduce_scatter(const void *sendbuf, void *recvbuf, const int *recvcoun
                          -1, trace_recvcounts, simgrid::smpi::Datatype::encode(datatype), ""));
 
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::reduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm);
+    simgrid::smpi::colls::reduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm);
   else
-    simgrid::smpi::Colls::ireduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm, request);
+    simgrid::smpi::colls::ireduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm, request);
 
   TRACE_smpi_comm_out(rank);
   smpi_bench_begin();
@@ -688,13 +706,8 @@ int PMPI_Ireduce_scatter_block(const void* sendbuf, void* recvbuf, int recvcount
   int rank                           = simgrid::s4u::this_actor::get_pid();
   int dt_send_size                   = datatype->is_replayable() ? 1 : datatype->size();
   std::vector<int>* trace_recvcounts = new std::vector<int>(recvcount * dt_send_size); // copy data to avoid bad free
-
-  const void* real_sendbuf = sendbuf;
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
-  if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[recvcount * count * datatype->size()]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, recvcount * count * datatype->size());
-  }
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, recvcount * count, datatype);
 
   TRACE_smpi_comm_in(
       rank, request == MPI_REQUEST_IGNORED ? "PMPI_Reduce_scatter_block" : "PMPI_Ireduce_scatter_block",
@@ -705,9 +718,9 @@ int PMPI_Ireduce_scatter_block(const void* sendbuf, void* recvbuf, int recvcount
   for (int i      = 0; i < count; i++)
     recvcounts[i] = recvcount;
   if (request == MPI_REQUEST_IGNORED)
-    simgrid::smpi::Colls::reduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm);
+    simgrid::smpi::colls::reduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm);
   else
-    simgrid::smpi::Colls::ireduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm, request);
+    simgrid::smpi::colls::ireduce_scatter(real_sendbuf, recvbuf, recvcounts, datatype, op, comm, request);
   delete[] recvcounts;
 
   TRACE_smpi_comm_out(rank);
@@ -736,16 +749,13 @@ int PMPI_Ialltoall(const void* sendbuf, int sendcount, MPI_Datatype sendtype, vo
 
   smpi_bench_end();
   int rank                 = simgrid::s4u::this_actor::get_pid();
-  const void* real_sendbuf = sendbuf;
   int real_sendcount         = sendcount;
   MPI_Datatype real_sendtype = sendtype;
+  
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, recvcount * comm->size(), recvtype);
+
   if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[recvcount * comm->size() * recvtype->size()]);
-    // memcpy(??,nullptr,0) is actually undefined behavor, even if harmless.
-    if (recvbuf != nullptr)
-      memcpy(tmp_sendbuf.get(), recvbuf, recvcount * comm->size() * recvtype->size());
-    real_sendbuf = tmp_sendbuf.get();
     real_sendcount = recvcount;
     real_sendtype  = recvtype;
   }
@@ -759,9 +769,9 @@ int PMPI_Ialltoall(const void* sendbuf, int sendcount, MPI_Datatype sendtype, vo
   int retval;
   if (request == MPI_REQUEST_IGNORED)
     retval =
-        simgrid::smpi::Colls::alltoall(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, comm);
+        simgrid::smpi::colls::alltoall(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype, comm);
   else
-    retval = simgrid::smpi::Colls::ialltoall(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype,
+    retval = simgrid::smpi::colls::ialltoall(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype,
                                              comm, request);
 
   TRACE_smpi_comm_out(rank);
@@ -804,7 +814,6 @@ int PMPI_Ialltoallv(const void* sendbuf, const int* sendcounts, const int* sendd
   std::vector<int>* trace_recvcounts = new std::vector<int>;
   int dt_size_recv                   = recvtype->size();
 
-  const void* real_sendbuf   = sendbuf;
   const int* real_sendcounts = sendcounts;
   const int* real_senddisps  = senddisps;
   MPI_Datatype real_sendtype = sendtype;
@@ -819,9 +828,8 @@ int PMPI_Ialltoallv(const void* sendbuf, const int* sendcounts, const int* sendd
   std::unique_ptr<unsigned char[]> tmp_sendbuf;
   std::unique_ptr<int[]> tmp_sendcounts;
   std::unique_ptr<int[]> tmp_senddisps;
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, maxsize, MPI_CHAR);
   if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[maxsize]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, maxsize);
     tmp_sendcounts.reset(new int[size]);
     std::copy(recvcounts, recvcounts + size, tmp_sendcounts.get());
     real_sendcounts = tmp_sendcounts.get();
@@ -846,10 +854,10 @@ int PMPI_Ialltoallv(const void* sendbuf, const int* sendcounts, const int* sendd
 
   int retval;
   if (request == MPI_REQUEST_IGNORED)
-    retval = simgrid::smpi::Colls::alltoallv(real_sendbuf, real_sendcounts, real_senddisps, real_sendtype, recvbuf,
+    retval = simgrid::smpi::colls::alltoallv(real_sendbuf, real_sendcounts, real_senddisps, real_sendtype, recvbuf,
                                              recvcounts, recvdisps, recvtype, comm);
   else
-    retval = simgrid::smpi::Colls::ialltoallv(real_sendbuf, real_sendcounts, real_senddisps, real_sendtype, recvbuf,
+    retval = simgrid::smpi::colls::ialltoallv(real_sendbuf, real_sendcounts, real_senddisps, real_sendtype, recvbuf,
                                               recvcounts, recvdisps, recvtype, comm, request);
 
   TRACE_smpi_comm_out(rank);
@@ -890,7 +898,6 @@ int PMPI_Ialltoallw(const void* sendbuf, const int* sendcounts, const int* sendd
   std::vector<int>* trace_sendcounts = new std::vector<int>;
   std::vector<int>* trace_recvcounts = new std::vector<int>;
 
-  const void* real_sendbuf           = sendbuf;
   const int* real_sendcounts         = sendcounts;
   const int* real_senddisps          = senddisps;
   const MPI_Datatype* real_sendtypes = sendtypes;
@@ -911,9 +918,8 @@ int PMPI_Ialltoallw(const void* sendbuf, const int* sendcounts, const int* sendd
   std::unique_ptr<int[]> tmp_sendcounts;
   std::unique_ptr<int[]> tmp_senddisps;
   std::unique_ptr<MPI_Datatype[]> tmp_sendtypes;
+  const void* real_sendbuf = smpi_get_in_place_buf(sendbuf, recvbuf, tmp_sendbuf, maxsize, MPI_CHAR);
   if (sendbuf == MPI_IN_PLACE) {
-    tmp_sendbuf.reset(new unsigned char[maxsize]);
-    real_sendbuf = memcpy(tmp_sendbuf.get(), recvbuf, maxsize);
     tmp_sendcounts.reset(new int[size]);
     std::copy(recvcounts, recvcounts + size, tmp_sendcounts.get());
     real_sendcounts = tmp_sendcounts.get();
@@ -938,10 +944,10 @@ int PMPI_Ialltoallw(const void* sendbuf, const int* sendcounts, const int* sendd
 
   int retval;
   if (request == MPI_REQUEST_IGNORED)
-    retval = simgrid::smpi::Colls::alltoallw(real_sendbuf, real_sendcounts, real_senddisps, real_sendtypes, recvbuf,
+    retval = simgrid::smpi::colls::alltoallw(real_sendbuf, real_sendcounts, real_senddisps, real_sendtypes, recvbuf,
                                              recvcounts, recvdisps, recvtypes, comm);
   else
-    retval = simgrid::smpi::Colls::ialltoallw(real_sendbuf, real_sendcounts, real_senddisps, real_sendtypes, recvbuf,
+    retval = simgrid::smpi::colls::ialltoallw(real_sendbuf, real_sendcounts, real_senddisps, real_sendtypes, recvbuf,
                                               recvcounts, recvdisps, recvtypes, comm, request);
 
   TRACE_smpi_comm_out(rank);