/* * 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) { 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; #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__); TRACE_smpi_send(rank, rank, dst_traced); #endif request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD); #ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); request->send = 1; TRACE_smpi_computing_in(rank); #endif xbt_dynar_push(reqq[smpi_comm_rank(MPI_COMM_WORLD)],&request); log_timed_action (action, clock); }
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_Ssend(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("Ssend", dst, datatype->is_replayable() ? count : count * datatype->size(), tag, simgrid::smpi::Datatype::encode(datatype))); TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, tag, count * datatype->size()); simgrid::smpi::Request::ssend(buf, count, datatype, dst, tag, comm); retval = MPI_SUCCESS; TRACE_smpi_comm_out(my_proc_id); } smpi_bench_begin(); return retval; }
static void action_send(const char *const *action) { int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__); TRACE_smpi_send(rank, rank, dst_traced); #endif smpi_mpi_send(NULL, size, MPI_BYTE, to , 0, MPI_COMM_WORLD); if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){ char *name = xbt_str_join_array(action, " "); XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock); free(name); } #ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); TRACE_smpi_computing_in(rank); #endif }
static void action_Isend(const char *const *action) { int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); smpi_replay_globals_t globals = (smpi_replay_globals_t) smpi_process_get_user_data(); #ifdef HAVE_TRACING int rank = smpi_comm_rank(MPI_COMM_WORLD); TRACE_smpi_computing_out(rank); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__); TRACE_smpi_send(rank, rank, dst_traced); #endif MPI_Request request = smpi_mpi_isend(NULL, size, MPI_BYTE, to, 0, MPI_COMM_WORLD); #ifdef HAVE_TRACING TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__); request->send = 1; TRACE_smpi_computing_in(rank); #endif xbt_dynar_push(globals->isends,&request); //TODO do the asynchronous cleanup if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){ char *name = xbt_str_join_array(action, " "); XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock); free(name); } }
int PMPI_Sendrecv(const void* sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int sendtag, void* recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status* status) { int retval = 0; smpi_bench_end(); if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; } else if (not sendtype->is_valid() || not recvtype->is_valid()) { retval = MPI_ERR_TYPE; } else if (src == MPI_PROC_NULL) { if(status!=MPI_STATUS_IGNORE){ simgrid::smpi::Status::empty(status); status->MPI_SOURCE = MPI_PROC_NULL; } if(dst != MPI_PROC_NULL) simgrid::smpi::Request::send(sendbuf, sendcount, sendtype, dst, sendtag, comm); retval = MPI_SUCCESS; }else if (dst == MPI_PROC_NULL){ simgrid::smpi::Request::recv(recvbuf, recvcount, recvtype, src, recvtag, comm, status); retval = MPI_SUCCESS; }else if (dst >= comm->group()->size() || dst <0 || (src!=MPI_ANY_SOURCE && (src >= comm->group()->size() || src <0))){ retval = MPI_ERR_RANK; } else if ((sendcount < 0 || recvcount<0) || (sendbuf==nullptr && sendcount > 0) || (recvbuf==nullptr && recvcount>0)) { retval = MPI_ERR_COUNT; } else if((sendtag<0 && sendtag != MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){ retval = MPI_ERR_TAG; } else { int my_proc_id = simgrid::s4u::this_actor::get_pid(); int dst_traced = getPid(comm, dst); int src_traced = getPid(comm, src); // FIXME: Hack the way to trace this one std::vector<int>* dst_hack = new std::vector<int>; std::vector<int>* src_hack = new std::vector<int>; dst_hack->push_back(dst_traced); src_hack->push_back(src_traced); TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::VarCollTIData( "sendRecv", -1, sendtype->is_replayable() ? sendcount : sendcount * sendtype->size(), dst_hack, recvtype->is_replayable() ? recvcount : recvcount * recvtype->size(), src_hack, simgrid::smpi::Datatype::encode(sendtype), simgrid::smpi::Datatype::encode(recvtype))); TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, sendtag, sendcount * sendtype->size()); simgrid::smpi::Request::sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm, status); retval = MPI_SUCCESS; TRACE_smpi_recv(src_traced, my_proc_id, recvtag); TRACE_smpi_comm_out(my_proc_id); } smpi_bench_begin(); return retval; }
int PMPI_Rput(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){ int retval = 0; smpi_bench_end(); if (win == MPI_WIN_NULL) { retval = MPI_ERR_WIN; } else if (target_rank == MPI_PROC_NULL) { *request = MPI_REQUEST_NULL; retval = MPI_SUCCESS; } else if (target_rank <0){ retval = MPI_ERR_RANK; } else if (win->dynamic()==0 && target_disp <0){ //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address retval = MPI_ERR_ARG; } else if ((origin_count < 0 || target_count < 0) || (origin_addr==nullptr && origin_count > 0)){ retval = MPI_ERR_COUNT; } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) || ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) { retval = MPI_ERR_TYPE; } else if(request == nullptr){ retval = MPI_ERR_REQUEST; } else { int my_proc_id = simgrid::s4u::this_actor::get_pid(); MPI_Group group; win->get_group(&group); int dst_traced = group->actor(target_rank)->get_pid(); TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData( "Rput", target_rank, origin_datatype->is_replayable() ? origin_count : origin_count * origin_datatype->size(), simgrid::smpi::Datatype::encode(origin_datatype))); TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size()); retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, request); TRACE_smpi_comm_out(my_proc_id); } smpi_bench_begin(); return retval; }
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; }