[SMPI] Replay: Remove static communicator_size variable

[simgrid.git] / src / smpi / internals / smpi_replay.cpp

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index e8630b9..0657505 100644 (file)
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -22,7 +22,6 @@ using simgrid::s4u::Actor;
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI");
 
-static int communicator_size = 0;
 static int active_processes  = 0;
 static std::unordered_map<int, std::vector<MPI_Request>*> reqq;
 
@@ -69,11 +68,12 @@ namespace smpi {
 namespace Replay {
 class ActionArgParser {
 public:
-  virtual void parse(simgrid::xbt::ReplayAction& action){};
+  virtual void parse(simgrid::xbt::ReplayAction& action) { CHECK_ACTION_PARAMS(action, 0, 0) }
 };
 
 class SendRecvParser : public ActionArgParser {
 public:
+  /* communication partner; if we send, this is the receiver and vice versa */
   int partner;
   double size;
   MPI_Datatype datatype1 = MPI_DEFAULT_TYPE;
@@ -88,27 +88,32 @@ public:
   }
 };
 
+class ComputeParser : public ActionArgParser {
+public:
+  /* communication partner; if we send, this is the receiver and vice versa */
+  double flops;
+
+  void parse(simgrid::xbt::ReplayAction& action) override
+  {
+    CHECK_ACTION_PARAMS(action, 1, 0)
+    flops = parse_double(action[2]);
+  }
+};
+
 template <class T> class ReplayAction {
 protected:
   const std::string name;
   T args;
 
-  /*
-   * Used to compute the duration of this action.
-   */
-  double start_time;
-
   int my_proc_id;
 
 public:
-  explicit ReplayAction(std::string name) : name(name), start_time(0), my_proc_id(simgrid::s4u::Actor::self()->getPid())
-  {
-  }
+  explicit ReplayAction(std::string name) : name(name), my_proc_id(simgrid::s4u::Actor::self()->getPid()) {}
 
   virtual void execute(simgrid::xbt::ReplayAction& action)
   {
     // Needs to be re-initialized for every action, hence here
-    start_time = smpi_process()->simulated_elapsed();
+    double start_time = smpi_process()->simulated_elapsed();
     args.parse(action);
     kernel(action);
     log_timed_action(action, start_time);
@@ -212,6 +217,17 @@ public:
   }
 };
 
+class ComputeAction : public ReplayAction<ComputeParser> {
+public:
+  ComputeAction() : ReplayAction("compute") {}
+  void kernel(simgrid::xbt::ReplayAction& action) override
+  {
+    TRACE_smpi_computing_in(my_proc_id, args.flops);
+    smpi_execute_flops(args.flops);
+    TRACE_smpi_computing_out(my_proc_id);
+  }
+};
+
 } // Replay Namespace
 
 static void action_init(simgrid::xbt::ReplayAction& action)
@@ -238,7 +254,6 @@ static void action_finalize(simgrid::xbt::ReplayAction& action)
 
 static void action_comm_size(simgrid::xbt::ReplayAction& action)
 {
-  communicator_size = parse_double(action[2]);
   log_timed_action (action, smpi_process()->simulated_elapsed());
 }
 
@@ -254,36 +269,7 @@ static void action_comm_dup(simgrid::xbt::ReplayAction& action)
 
 static void action_compute(simgrid::xbt::ReplayAction& action)
 {
-  CHECK_ACTION_PARAMS(action, 1, 0)
-  double clock = smpi_process()->simulated_elapsed();
-  double flops= parse_double(action[2]);
-  int my_proc_id = Actor::self()->getPid();
-
-  TRACE_smpi_computing_in(my_proc_id, flops);
-  smpi_execute_flops(flops);
-  TRACE_smpi_computing_out(my_proc_id);
-
-  log_timed_action (action, clock);
-}
-
-static void action_send(simgrid::xbt::ReplayAction& action)
-{
-  Replay::SendAction("send").execute(action);
-}
-
-static void action_Isend(simgrid::xbt::ReplayAction& action)
-{
-  Replay::SendAction("Isend").execute(action);
-}
-
-static void action_recv(simgrid::xbt::ReplayAction& action)
-{
-  Replay::RecvAction("recv").execute(action);
-}
-
-static void action_Irecv(simgrid::xbt::ReplayAction& action)
-{
-  Replay::RecvAction("Irecv").execute(action);
+  Replay::ComputeAction().execute(action);
 }
 
 static void action_test(simgrid::xbt::ReplayAction& action)
@@ -822,12 +808,22 @@ void smpi_replay_init(int* argc, char*** argv)
   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);
-  xbt_replay_action_register("send",       simgrid::smpi::action_send);
-  xbt_replay_action_register("Isend",      simgrid::smpi::action_Isend);
-  xbt_replay_action_register("recv",       simgrid::smpi::action_recv);
-  xbt_replay_action_register("Irecv",      simgrid::smpi::action_Irecv);
-  xbt_replay_action_register("test",       simgrid::smpi::action_test);
+
+  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);
@@ -844,7 +840,7 @@ void smpi_replay_init(int* argc, char*** argv)
   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::smpi::action_compute);
 
   //if we have a delayed start, sleep here.
   if(*argc>2){