}
};
+class BcastArgParser : public ActionArgParser {
+public:
+ double size;
+ int root;
+ MPI_Datatype datatype = MPI_DEFAULT_TYPE;
+ void parse(simgrid::xbt::ReplayAction& action) override
+ {
+ CHECK_ACTION_PARAMS(action, 1, 2)
+ size = parse_double(action[2]);
+ root = (action.size() > 3) ? std::stoi(action[3]) : 0;
+ if (action.size() > 4)
+ datatype = simgrid::smpi::Datatype::decode(action[4]);
+ }
+};
+
template <class T> class ReplayAction {
protected:
const std::string name;
double start_time = smpi_process()->simulated_elapsed();
args.parse(action);
kernel(action);
- log_timed_action(action, start_time);
+ if (name != "Init")
+ log_timed_action(action, start_time);
}
virtual void kernel(simgrid::xbt::ReplayAction& action) = 0;
WaitAction() : ReplayAction("Wait") {}
void kernel(simgrid::xbt::ReplayAction& action) override
{
- CHECK_ACTION_PARAMS(action, 0, 0)
- MPI_Status status;
-
std::string s = boost::algorithm::join(action, " ");
xbt_assert(get_reqq_self()->size(), "action wait not preceded by any irecv or isend: %s", s.c_str());
MPI_Request request = get_reqq_self()->back();
int rank = request->comm() != MPI_COMM_NULL ? request->comm()->rank() : -1;
- MPI_Group group = request->comm()->group();
- int src_traced = group->rank(request->src());
- int dst_traced = group->rank(request->dst());
+ // Must be taken before Request::wait() since the request may be set to
+ // MPI_REQUEST_NULL by Request::wait!
+ int src = request->comm()->group()->rank(request->src());
+ int dst = request->comm()->group()->rank(request->dst());
bool is_wait_for_receive = (request->flags() & RECV);
// TODO: Here we take the rank while we normally take the process id (look for my_proc_id)
TRACE_smpi_comm_in(rank, __FUNCTION__, new simgrid::instr::NoOpTIData("wait"));
+ MPI_Status status;
Request::wait(&request, &status);
TRACE_smpi_comm_out(rank);
if (is_wait_for_receive)
- TRACE_smpi_recv(src_traced, dst_traced, 0);
+ TRACE_smpi_recv(src, dst, 0);
}
};
}
};
-} // Replay Namespace
-
-static void action_init(simgrid::xbt::ReplayAction& action)
-{
- XBT_DEBUG("Initialize the counters");
- CHECK_ACTION_PARAMS(action, 0, 1)
- if (action.size() > 2)
- MPI_DEFAULT_TYPE = MPI_DOUBLE; // default MPE datatype
- else
- MPI_DEFAULT_TYPE = MPI_BYTE; // default TAU datatype
-
- /* start a simulated timer */
- smpi_process()->simulated_start();
- /*initialize the number of active processes */
- active_processes = smpi_process_count();
-
- set_reqq_self(new std::vector<MPI_Request>);
-}
-
-static void action_finalize(simgrid::xbt::ReplayAction& action)
-{
- /* Nothing to do */
-}
-
-static void action_comm_size(simgrid::xbt::ReplayAction& action)
-{
- log_timed_action (action, smpi_process()->simulated_elapsed());
-}
-
-static void action_comm_split(simgrid::xbt::ReplayAction& action)
-{
- log_timed_action (action, smpi_process()->simulated_elapsed());
-}
-
-static void action_comm_dup(simgrid::xbt::ReplayAction& action)
-{
- log_timed_action (action, smpi_process()->simulated_elapsed());
-}
-
-static void action_compute(simgrid::xbt::ReplayAction& action)
-{
- Replay::ComputeAction().execute(action);
-}
-
-static void action_test(simgrid::xbt::ReplayAction& action)
-{
- CHECK_ACTION_PARAMS(action, 0, 0)
- double clock = smpi_process()->simulated_elapsed();
- MPI_Status status;
-
- MPI_Request request = get_reqq_self()->back();
- get_reqq_self()->pop_back();
- //if request is null here, this may mean that a previous test has succeeded
- //Different times in traced application and replayed version may lead to this
- //In this case, ignore the extra calls.
- if(request!=nullptr){
- int my_proc_id = Actor::self()->getPid();
- TRACE_smpi_testing_in(my_proc_id);
-
- int flag = Request::test(&request, &status);
+class InitAction : public ReplayAction<ActionArgParser> {
+public:
+ InitAction() : ReplayAction("Init") {}
+ void kernel(simgrid::xbt::ReplayAction& action) override
+ {
+ CHECK_ACTION_PARAMS(action, 0, 1)
+ MPI_DEFAULT_TYPE = (action.size() > 2) ? MPI_DOUBLE // default MPE datatype
+ : MPI_BYTE; // default TAU datatype
- XBT_DEBUG("MPI_Test result: %d", flag);
- /* push back request in vector to be caught by a subsequent wait. if the test did succeed, the request is now nullptr.*/
- get_reqq_self()->push_back(request);
+ /* start a simulated timer */
+ smpi_process()->simulated_start();
+ /*initialize the number of active processes */
+ active_processes = smpi_process_count();
- TRACE_smpi_testing_out(my_proc_id);
+ set_reqq_self(new std::vector<MPI_Request>);
}
- log_timed_action (action, clock);
-}
-
-static void action_waitall(simgrid::xbt::ReplayAction& action)
-{
- CHECK_ACTION_PARAMS(action, 0, 0)
- double clock = smpi_process()->simulated_elapsed();
- const unsigned int count_requests = get_reqq_self()->size();
+};
- if (count_requests>0) {
- MPI_Status status[count_requests];
+class CommunicatorAction : public ReplayAction<ActionArgParser> {
+public:
+ CommunicatorAction() : ReplayAction("Comm") {}
+ void kernel(simgrid::xbt::ReplayAction& action) override { /* nothing to do */}
+};
- int my_proc_id_traced = Actor::self()->getPid();
- TRACE_smpi_comm_in(my_proc_id_traced, __FUNCTION__,
- new simgrid::instr::Pt2PtTIData("waitAll", -1, count_requests, ""));
- int recvs_snd[count_requests];
- int recvs_rcv[count_requests];
- for (unsigned int i = 0; i < count_requests; i++) {
- const auto& req = (*get_reqq_self())[i];
- if (req && (req->flags() & RECV)) {
- recvs_snd[i] = req->src();
- recvs_rcv[i] = req->dst();
- } else
- recvs_snd[i] = -100;
- }
- Request::waitall(count_requests, &(*get_reqq_self())[0], status);
-
- for (unsigned i = 0; i < count_requests; i++) {
- if (recvs_snd[i]!=-100)
- TRACE_smpi_recv(recvs_snd[i], recvs_rcv[i],0);
- }
- TRACE_smpi_comm_out(my_proc_id_traced);
+class WaitAllAction : public ReplayAction<ActionArgParser> {
+public:
+ WaitAllAction() : ReplayAction("waitAll") {}
+ void kernel(simgrid::xbt::ReplayAction& action) override
+ {
+ const unsigned int count_requests = get_reqq_self()->size();
+
+ if (count_requests > 0) {
+ TRACE_smpi_comm_in(my_proc_id, __FUNCTION__,
+ new simgrid::instr::Pt2PtTIData("waitAll", -1, count_requests, ""));
+ std::vector<std::pair</*sender*/int,/*recv*/int>> sender_receiver;
+ for (const auto& req : (*get_reqq_self())) {
+ if (req && (req->flags() & RECV)) {
+ sender_receiver.push_back({req->src(), req->dst()});
+ }
+ }
+ MPI_Status status[count_requests];
+ Request::waitall(count_requests, &(*get_reqq_self())[0], status);
+
+ for (auto& pair : sender_receiver) {
+ TRACE_smpi_recv(pair.first, pair.second, 0);
+ }
+ TRACE_smpi_comm_out(my_proc_id);
+ }
}
- log_timed_action (action, clock);
-}
-
-static void action_barrier(simgrid::xbt::ReplayAction& action)
-{
- double clock = smpi_process()->simulated_elapsed();
- int my_proc_id = Actor::self()->getPid();
- TRACE_smpi_comm_in(my_proc_id, __FUNCTION__, new simgrid::instr::NoOpTIData("barrier"));
-
- Colls::barrier(MPI_COMM_WORLD);
+};
- TRACE_smpi_comm_out(my_proc_id);
- log_timed_action (action, clock);
-}
+class BarrierAction : public ReplayAction<ActionArgParser> {
+public:
+ BarrierAction() : ReplayAction("barrier") {}
+ void kernel(simgrid::xbt::ReplayAction& action) override
+ {
+ TRACE_smpi_comm_in(my_proc_id, __FUNCTION__, new simgrid::instr::NoOpTIData("barrier"));
+ Colls::barrier(MPI_COMM_WORLD);
+ TRACE_smpi_comm_out(my_proc_id);
+ }
+};
-static void action_bcast(simgrid::xbt::ReplayAction& action)
-{
- CHECK_ACTION_PARAMS(action, 1, 2)
- double size = parse_double(action[2]);
- double clock = smpi_process()->simulated_elapsed();
- int root = (action.size() > 3) ? std::stoi(action[3]) : 0;
- /* Initialize MPI_CURRENT_TYPE in order to decrease the number of the checks */
- MPI_Datatype MPI_CURRENT_TYPE = (action.size() > 4) ? simgrid::smpi::Datatype::decode(action[4]) : MPI_DEFAULT_TYPE;
+class BcastAction : public ReplayAction<BcastArgParser> {
+public:
+ BcastAction() : ReplayAction("bcast") {}
+ void kernel(simgrid::xbt::ReplayAction& action) override
+ {
+ TRACE_smpi_comm_in(my_proc_id, "action_bcast",
+ new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor(args.root)->getPid(),
+ -1.0, args.size, -1, Datatype::encode(args.datatype), ""));
- int my_proc_id = Actor::self()->getPid();
- TRACE_smpi_comm_in(my_proc_id, __FUNCTION__,
- new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor(root)->getPid(), -1.0, size,
- -1, Datatype::encode(MPI_CURRENT_TYPE), ""));
+ void* sendbuf = smpi_get_tmp_sendbuffer(args.size * args.datatype->size());
- void *sendbuf = smpi_get_tmp_sendbuffer(size* MPI_CURRENT_TYPE->size());
+ Colls::bcast(sendbuf, args.size, args.datatype, args.root, MPI_COMM_WORLD);
- Colls::bcast(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
+ TRACE_smpi_comm_out(my_proc_id);
+ }
+};
- TRACE_smpi_comm_out(my_proc_id);
- log_timed_action (action, clock);
-}
static void action_reduce(simgrid::xbt::ReplayAction& action)
{
new simgrid::instr::CollTIData("reduce", MPI_COMM_WORLD->group()->actor(root)->getPid(), comp_size,
comm_size, -1, Datatype::encode(MPI_CURRENT_TYPE), ""));
- void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
- void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* MPI_CURRENT_TYPE->size());
+ void* recvbuf = smpi_get_tmp_recvbuffer(comm_size * MPI_CURRENT_TYPE->size());
+ void* sendbuf = smpi_get_tmp_sendbuffer(comm_size * MPI_CURRENT_TYPE->size());
Colls::reduce(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD);
smpi_execute_flops(comp_size);
TRACE_smpi_computing_init(my_proc_id);
TRACE_smpi_comm_in(my_proc_id, "smpi_replay_run_init", new simgrid::instr::NoOpTIData("init"));
TRACE_smpi_comm_out(my_proc_id);
- xbt_replay_action_register("init", simgrid::smpi::action_init);
- xbt_replay_action_register("finalize", simgrid::smpi::action_finalize);
- xbt_replay_action_register("comm_size", simgrid::smpi::action_comm_size);
- xbt_replay_action_register("comm_split", simgrid::smpi::action_comm_split);
- xbt_replay_action_register("comm_dup", simgrid::smpi::action_comm_dup);
-
- std::shared_ptr<simgrid::smpi::Replay::SendAction> isend(new simgrid::smpi::Replay::SendAction("Isend"));
- std::shared_ptr<simgrid::smpi::Replay::SendAction> send(new simgrid::smpi::Replay::SendAction("send"));
- std::shared_ptr<simgrid::smpi::Replay::RecvAction> irecv(new simgrid::smpi::Replay::RecvAction("Irecv"));
- std::shared_ptr<simgrid::smpi::Replay::RecvAction> recv(new simgrid::smpi::Replay::RecvAction("recv"));
- std::shared_ptr<simgrid::smpi::Replay::WaitAction> wait(new simgrid::smpi::Replay::WaitAction());
-
- xbt_replay_action_register("send",
- std::bind(&simgrid::smpi::Replay::SendAction::execute, send, std::placeholders::_1));
- xbt_replay_action_register("Isend",
- std::bind(&simgrid::smpi::Replay::SendAction::execute, isend, std::placeholders::_1));
- xbt_replay_action_register("recv",
- std::bind(&simgrid::smpi::Replay::RecvAction::execute, recv, std::placeholders::_1));
- xbt_replay_action_register("Irecv",
- std::bind(&simgrid::smpi::Replay::RecvAction::execute, irecv, std::placeholders::_1));
- xbt_replay_action_register("test", simgrid::smpi::action_test);
- xbt_replay_action_register("wait",
- std::bind(&simgrid::smpi::Replay::WaitAction::execute, wait, std::placeholders::_1));
- xbt_replay_action_register("waitAll", simgrid::smpi::action_waitall);
- xbt_replay_action_register("barrier", simgrid::smpi::action_barrier);
- xbt_replay_action_register("bcast", simgrid::smpi::action_bcast);
+ xbt_replay_action_register("init", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::InitAction().execute(action); });
+ xbt_replay_action_register("finalize", [](simgrid::xbt::ReplayAction& action) { /* nothing to do */ });
+ xbt_replay_action_register("comm_size", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::CommunicatorAction().execute(action); });
+ xbt_replay_action_register("comm_split",[](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::CommunicatorAction().execute(action); });
+ xbt_replay_action_register("comm_dup", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::CommunicatorAction().execute(action); });
+
+ xbt_replay_action_register("send", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::SendAction("send").execute(action); });
+ xbt_replay_action_register("Isend", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::SendAction("Isend").execute(action); });
+ xbt_replay_action_register("recv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::RecvAction("recv").execute(action); });
+ xbt_replay_action_register("Irecv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::RecvAction("Irecv").execute(action); });
+ xbt_replay_action_register("test", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::TestAction().execute(action); });
+ xbt_replay_action_register("wait", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::WaitAction().execute(action); });
+ xbt_replay_action_register("waitAll", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::WaitAllAction().execute(action); });
+ xbt_replay_action_register("barrier", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::BarrierAction().execute(action); });
+ xbt_replay_action_register("bcast", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::BcastAction().execute(action); });
xbt_replay_action_register("reduce", simgrid::smpi::action_reduce);
xbt_replay_action_register("allReduce", simgrid::smpi::action_allReduce);
xbt_replay_action_register("allToAll", simgrid::smpi::action_allToAll);
xbt_replay_action_register("allGather", simgrid::smpi::action_allgather);
xbt_replay_action_register("allGatherV", simgrid::smpi::action_allgatherv);
xbt_replay_action_register("reduceScatter", simgrid::smpi::action_reducescatter);
- xbt_replay_action_register("compute", simgrid::smpi::action_compute);
+ xbt_replay_action_register("compute", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::Replay::ComputeAction().execute(action); });
//if we have a delayed start, sleep here.
if(*argc>2){