XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
+#define CHECK_ARGS(test, errcode, ...) \
+ if (test) { \
+ XBT_WARN(__VA_ARGS__); \
+ return errcode; \
+ }
+
/* PMPI User level calls */
int PMPI_Barrier(MPI_Comm comm)
{
if (comm == MPI_COMM_NULL)
return MPI_ERR_COMM;
- if ((sendbuf == nullptr) || ((comm->rank() == root) && recvbuf == nullptr))
+ if ((sendbuf == nullptr && sendcount > 0) || ((comm->rank() == root) && recvbuf == nullptr && recvcount > 0))
return MPI_ERR_BUFFER;
if (((sendbuf != MPI_IN_PLACE && sendcount > 0) && (sendtype == MPI_DATATYPE_NULL)) ||
((comm->rank() == root) && (recvtype == MPI_DATATYPE_NULL)))
return MPI_ERR_ARG;
smpi_bench_end();
- const char* sendtmpbuf = static_cast<const char*>(sendbuf);
- int sendtmpcount = sendcount;
- MPI_Datatype sendtmptype = sendtype;
+ const void* real_sendbuf = sendbuf;
+ int real_sendcount = sendcount;
+ MPI_Datatype real_sendtype = sendtype;
if ((comm->rank() == root) && (sendbuf == MPI_IN_PLACE)) {
- sendtmpcount = 0;
- sendtmptype = recvtype;
+ real_sendcount = 0;
+ real_sendtype = recvtype;
}
int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Gather" : "PMPI_Igather",
new simgrid::instr::CollTIData(
request == MPI_REQUEST_IGNORED ? "gather" : "igather", root, -1.0,
- sendtmptype->is_replayable() ? sendtmpcount : sendtmpcount * sendtmptype->size(),
+ real_sendtype->is_replayable() ? real_sendcount : real_sendcount * real_sendtype->size(),
(comm->rank() != root || recvtype->is_replayable()) ? recvcount : recvcount * recvtype->size(),
- simgrid::smpi::Datatype::encode(sendtmptype), simgrid::smpi::Datatype::encode(recvtype)));
+ simgrid::smpi::Datatype::encode(real_sendtype), simgrid::smpi::Datatype::encode(recvtype)));
if (request == MPI_REQUEST_IGNORED)
- simgrid::smpi::Colls::gather(sendtmpbuf, sendtmpcount, sendtmptype, 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(sendtmpbuf, sendtmpcount, sendtmptype, 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);
}
smpi_bench_end();
- const char* sendtmpbuf = static_cast<const char*>(sendbuf);
- int sendtmpcount = sendcount;
- MPI_Datatype sendtmptype = sendtype;
+ const void* real_sendbuf = sendbuf;
+ int real_sendcount = sendcount;
+ MPI_Datatype real_sendtype = sendtype;
if ((comm->rank() == root) && (sendbuf == MPI_IN_PLACE)) {
- sendtmpcount = 0;
- sendtmptype = recvtype;
+ real_sendcount = 0;
+ real_sendtype = recvtype;
}
int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Gatherv" : "PMPI_Igatherv",
new simgrid::instr::VarCollTIData(
request == MPI_REQUEST_IGNORED ? "gatherv" : "igatherv", root,
- sendtmptype->is_replayable() ? sendtmpcount : sendtmpcount * sendtmptype->size(), nullptr,
- dt_size_recv, trace_recvcounts, simgrid::smpi::Datatype::encode(sendtmptype),
+ real_sendtype->is_replayable() ? real_sendcount : real_sendcount * real_sendtype->size(),
+ 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(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root,
- comm);
+ simgrid::smpi::Colls::gatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
+ root, comm);
else
- simgrid::smpi::Colls::igatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root,
- comm, request);
+ simgrid::smpi::Colls::igatherv(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcounts, displs, recvtype,
+ root, comm, request);
TRACE_smpi_comm_out(rank);
smpi_bench_begin();
int PMPI_Iallgather(const void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
MPI_Datatype recvtype, MPI_Comm comm, MPI_Request* request)
{
- if (comm == MPI_COMM_NULL)
- return MPI_ERR_COMM;
- if ((sendbuf == nullptr && sendcount > 0) || (recvbuf == nullptr))
- 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)) || (recvcount < 0))
- return MPI_ERR_COUNT;
- if (request == nullptr)
- return MPI_ERR_ARG;
+ 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(sendbuf == nullptr && sendcount > 0, MPI_ERR_BUFFER,
+ "Iallgather: param 1 sendbuf cannot be NULL when sendcound > 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");
+ 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");
smpi_bench_end();
if (sendbuf == MPI_IN_PLACE) {
{
if (comm == MPI_COMM_NULL)
return MPI_ERR_COMM;
- if ((sendbuf == nullptr && sendcount > 0) || (recvbuf == nullptr))
+ 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 (request == nullptr)
return MPI_ERR_ARG;
- for (int i = 0; i < comm->size(); i++) { // copy data to avoid bad free
+ for (int i = 0; i < comm->size(); i++) {
if (recvcounts[i] < 0)
return MPI_ERR_COUNT;
+ else if (recvcounts[i] > 0 && recvbuf == nullptr)
+ return MPI_ERR_BUFFER;
}
smpi_bench_end();
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)
{
- if (comm == MPI_COMM_NULL)
- return MPI_ERR_COMM;
- if (sendcounts == nullptr || displs == nullptr)
- return MPI_ERR_ARG;
- if (((comm->rank() == root) && (sendtype == MPI_DATATYPE_NULL)) ||
- ((recvbuf != MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL)))
- return MPI_ERR_TYPE;
- if (request == nullptr)
- return MPI_ERR_ARG;
- if (recvbuf != MPI_IN_PLACE && recvcount < 0)
- return MPI_ERR_COUNT;
- if (root < 0 || root >= comm->size())
- return MPI_ERR_ROOT;
+ CHECK_ARGS(comm == MPI_COMM_NULL, MPI_ERR_COMM, "Iscatterv: 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");
+ CHECK_ARGS((comm->rank() == root) && (displs == nullptr), MPI_ERR_ARG,
+ "Iscatterv: 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");
+ 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");
+ 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,
+ comm->size());
if (comm->rank() == root) {
if (recvbuf == MPI_IN_PLACE) {
recvtype = sendtype;
recvcount = sendcounts[comm->rank()];
}
- for (int i = 0; i < comm->size(); i++) {
- if (sendcounts[i] < 0)
- return MPI_ERR_COUNT;
- }
+ for (int i = 0; i < comm->size(); i++)
+ CHECK_ARGS(sendcounts[i] < 0, MPI_ERR_COUNT, "Iscatterv: sendcounts[%d]=%d but this cannot be negative", i,
+ sendcounts[i]);
}
smpi_bench_end();
smpi_bench_end();
int rank = simgrid::s4u::this_actor::get_pid();
const void* real_sendbuf = sendbuf;
- int sendtmpcount = sendcount;
- MPI_Datatype sendtmptype = sendtype;
+ int real_sendcount = sendcount;
+ MPI_Datatype real_sendtype = sendtype;
std::unique_ptr<unsigned char[]> tmp_sendbuf;
if (sendbuf == MPI_IN_PLACE) {
tmp_sendbuf.reset(new unsigned char[recvcount * comm->size() * recvtype->size()]);
if (recvbuf != nullptr)
memcpy(tmp_sendbuf.get(), recvbuf, recvcount * comm->size() * recvtype->size());
real_sendbuf = tmp_sendbuf.get();
- sendtmpcount = recvcount;
- sendtmptype = recvtype;
+ real_sendcount = recvcount;
+ real_sendtype = recvtype;
}
TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Alltoall" : "PMPI_Ialltoall",
new simgrid::instr::CollTIData(
request == MPI_REQUEST_IGNORED ? "alltoall" : "ialltoall", -1, -1.0,
- sendtmptype->is_replayable() ? sendtmpcount : sendtmpcount * sendtmptype->size(),
+ real_sendtype->is_replayable() ? real_sendcount : real_sendcount * real_sendtype->size(),
recvtype->is_replayable() ? recvcount : recvcount * recvtype->size(),
- simgrid::smpi::Datatype::encode(sendtmptype), simgrid::smpi::Datatype::encode(recvtype)));
+ simgrid::smpi::Datatype::encode(real_sendtype), simgrid::smpi::Datatype::encode(recvtype)));
int retval;
if (request == MPI_REQUEST_IGNORED)
retval =
- simgrid::smpi::Colls::alltoall(real_sendbuf, sendtmpcount, sendtmptype, 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, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype,
+ retval = simgrid::smpi::Colls::ialltoall(real_sendbuf, real_sendcount, real_sendtype, recvbuf, recvcount, recvtype,
comm, request);
TRACE_smpi_comm_out(rank);
const void* real_sendbuf = sendbuf;
const int* real_sendcounts = sendcounts;
const int* real_senddisps = senddisps;
- MPI_Datatype sendtmptype = sendtype;
+ MPI_Datatype real_sendtype = sendtype;
int maxsize = 0;
for (int i = 0; i < size; i++) { // copy data to avoid bad free
recv_size += recvcounts[i] * dt_size_recv;
tmp_senddisps.reset(new int[size]);
std::copy(recvdisps, recvdisps + size, tmp_senddisps.get());
real_senddisps = tmp_senddisps.get();
- sendtmptype = recvtype;
+ real_sendtype = recvtype;
}
- int dt_size_send = sendtmptype->size();
+ int dt_size_send = real_sendtype->size();
for (int i = 0; i < size; i++) { // copy data to avoid bad free
send_size += real_sendcounts[i] * dt_size_send;
TRACE_smpi_comm_in(rank, request == MPI_REQUEST_IGNORED ? "PMPI_Alltoallv" : "PMPI_Ialltoallv",
new simgrid::instr::VarCollTIData(request == MPI_REQUEST_IGNORED ? "alltoallv" : "ialltoallv", -1,
send_size, trace_sendcounts, recv_size, trace_recvcounts,
- simgrid::smpi::Datatype::encode(sendtmptype),
+ simgrid::smpi::Datatype::encode(real_sendtype),
simgrid::smpi::Datatype::encode(recvtype)));
int retval;
if (request == MPI_REQUEST_IGNORED)
- retval = simgrid::smpi::Colls::alltoallv(real_sendbuf, real_sendcounts, real_senddisps, sendtmptype, 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, sendtmptype, 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);
smpi_bench_end();
int rank = simgrid::s4u::this_actor::get_pid();
int size = comm->size();
- for (int i = 0; i < size; i++) { // copy data to avoid bad free
+ for (int i = 0; i < size; i++) {
if (recvcounts[i] < 0 || (sendbuf != MPI_IN_PLACE && sendcounts[i] < 0))
return MPI_ERR_COUNT;
}