/*
* This function starts a request returned by init functions such as
* MPI_Send_init(), MPI_Ssend_init (see above), and friends.
* They should already have performed sanity checks.
*/
int PMPI_Start(MPI_Request * request)
{
int retval = 0;
smpi_bench_end();
if (request == nullptr || *request == MPI_REQUEST_NULL) {
retval = MPI_ERR_REQUEST;
} else {
MPI_Request req = *request;
int my_proc_id = (req->comm() != MPI_COMM_NULL) ? simgrid::s4u::this_actor::get_pid() : -1;
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("Start", req->dst(),
req->size(),
req->tag(),
simgrid::smpi::Datatype::encode(req->type())));
if (not TRACE_smpi_view_internals() && req->flags() & MPI_REQ_SEND)
TRACE_smpi_send(my_proc_id, my_proc_id, getPid(req->comm(), req->dst()), req->tag(), req->size());
req->start();
if (not TRACE_smpi_view_internals() && req->flags() & MPI_REQ_RECV)
TRACE_smpi_recv(getPid(req->comm(), req->src()), my_proc_id, req->tag());
retval = MPI_SUCCESS;
TRACE_smpi_comm_out(my_proc_id);
}
smpi_bench_begin();
return retval;
}
static void action_Isend(const char *const *action)
{
CHECK_ACTION_PARAMS(action, 2, 1);
int to = atoi(action[2]);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
MPI_Request request;
if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
int rank = smpi_process_index();
int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_ISEND;
extra->send_size = size;
extra->src = rank;
extra->dst = dst_traced;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
if (!TRACE_smpi_view_internals()) {
TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE));
}
request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
request->send = 1;
xbt_dynar_push(get_reqq_self(),&request);
log_timed_action (action, clock);
}
int PMPI_Startall(int count, MPI_Request * requests)
{
int retval;
smpi_bench_end();
if (requests == nullptr) {
retval = MPI_ERR_ARG;
} else {
retval = MPI_SUCCESS;
for (int i = 0; i < count; i++) {
if(requests[i] == MPI_REQUEST_NULL) {
retval = MPI_ERR_REQUEST;
}
}
if(retval != MPI_ERR_REQUEST) {
int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Startall"));
MPI_Request req = MPI_REQUEST_NULL;
if (not TRACE_smpi_view_internals())
for (int i = 0; i < count; i++) {
req = requests[i];
if (req->flags() & MPI_REQ_SEND)
TRACE_smpi_send(my_proc_id, my_proc_id, getPid(req->comm(), req->dst()), req->tag(), req->size());
}
simgrid::smpi::Request::startall(count, requests);
if (not TRACE_smpi_view_internals())
for (int i = 0; i < count; i++) {
req = requests[i];
if (req->flags() & MPI_REQ_RECV)
TRACE_smpi_recv(getPid(req->comm(), req->src()), my_proc_id, req->tag());
}
TRACE_smpi_comm_out(my_proc_id);
}
}
smpi_bench_begin();
return retval;
}
int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status * status)
{
int retval = 0;
smpi_bench_end();
if (comm == MPI_COMM_NULL) {
retval = MPI_ERR_COMM;
} else if (src == MPI_PROC_NULL) {
if(status != MPI_STATUS_IGNORE){
simgrid::smpi::Status::empty(status);
status->MPI_SOURCE = MPI_PROC_NULL;
}
retval = MPI_SUCCESS;
} else if (src!=MPI_ANY_SOURCE && (src >= comm->group()->size() || src <0)){
retval = MPI_ERR_RANK;
} else if ((count < 0) || (buf==nullptr && count > 0)) {
retval = MPI_ERR_COUNT;
} else if (datatype==MPI_DATATYPE_NULL || not datatype->is_valid()) {
retval = MPI_ERR_TYPE;
} else if(tag<0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("recv", src,
datatype->is_replayable() ? count : count * datatype->size(),
tag, simgrid::smpi::Datatype::encode(datatype)));
simgrid::smpi::Request::recv(buf, count, datatype, src, tag, comm, status);
retval = MPI_SUCCESS;
// the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
int src_traced=0;
if (status != MPI_STATUS_IGNORE)
src_traced = getPid(comm, status->MPI_SOURCE);
else
src_traced = getPid(comm, src);
if (not TRACE_smpi_view_internals()) {
TRACE_smpi_recv(src_traced, my_proc_id, tag);
}
TRACE_smpi_comm_out(my_proc_id);
}
smpi_bench_begin();
return retval;
}
int PMPI_Send(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
int retval = 0;
smpi_bench_end();
if (comm == MPI_COMM_NULL) {
retval = MPI_ERR_COMM;
} else if (dst == MPI_PROC_NULL) {
retval = MPI_SUCCESS;
} else if (dst >= comm->group()->size() || dst <0){
retval = MPI_ERR_RANK;
} else if ((count < 0) || (buf == nullptr && count > 0)) {
retval = MPI_ERR_COUNT;
} else if (datatype==MPI_DATATYPE_NULL || not datatype->is_valid()) {
retval = MPI_ERR_TYPE;
} else if(tag < 0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
int my_proc_id = simgrid::s4u::this_actor::get_pid();
int dst_traced = getPid(comm, dst);
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("send", dst,
datatype->is_replayable() ? count : count * datatype->size(),
tag, simgrid::smpi::Datatype::encode(datatype)));
if (not TRACE_smpi_view_internals()) {
TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, tag, count * datatype->size());
}
simgrid::smpi::Request::send(buf, count, datatype, dst, tag, comm);
retval = MPI_SUCCESS;
TRACE_smpi_comm_out(my_proc_id);
}
smpi_bench_begin();
return retval;
}
static void action_recv(const char *const *action) {
CHECK_ACTION_PARAMS(action, 2, 1);
int from = atoi(action[2]);
double size=parse_double(action[3]);
double clock = smpi_process_simulated_elapsed();
MPI_Status status;
if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
int rank = smpi_process_index();
int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from);
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_RECV;
extra->send_size = size;
extra->src = src_traced;
extra->dst = rank;
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
//unknow size from the receiver pov
if(size==-1){
smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
size=status.count;
}
smpi_mpi_recv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
if (!TRACE_smpi_view_internals()) {
TRACE_smpi_recv(rank, src_traced, rank);
}
log_timed_action (action, clock);
}
