cosmetics : I activated -pedantic for a quick pass

[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 2172bf4..b0c8bd9 100644 (file)
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -61,7 +61,7 @@ public:
 };
 }
 
-typedef std::tuple</*sender*/ int, /* reciever */ int, /* tag */int> req_key_t;
+typedef std::tuple</*sender*/ int, /* receiver */ int, /* tag */ int> req_key_t;
 typedef std::unordered_map<req_key_t, MPI_Request, hash_tuple::hash<std::tuple<int,int,int>>> req_storage_t;
 
 void log_timed_action(simgrid::xbt::ReplayAction& action, double clock)
@@ -73,7 +73,7 @@ void log_timed_action(simgrid::xbt::ReplayAction& action, double clock)
 }
 
 /* Helper function */
-static double parse_double(std::string string)
+static double parse_double(const std::string& string)
 {
   return xbt_str_parse_double(string.c_str(), "%s is not a double");
 }
@@ -141,7 +141,7 @@ public:
     }
 };
 
-void WaitTestParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void WaitTestParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 3, 0)
   src = std::stoi(action[2]);
@@ -149,7 +149,7 @@ void WaitTestParser::parse(simgrid::xbt::ReplayAction& action, std::string)
   tag = std::stoi(action[4]);
 }
 
-void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 3, 1)
   partner = std::stoi(action[2]);
@@ -159,13 +159,26 @@ void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype1 = simgrid::smpi::Datatype::decode(action[5]);
 }
 
-void ComputeParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void ComputeParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 1, 0)
   flops = parse_double(action[2]);
 }
 
-void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void SleepParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
+{
+  CHECK_ACTION_PARAMS(action, 1, 0)
+  time = parse_double(action[2]);
+}
+
+void LocationParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
+{
+  CHECK_ACTION_PARAMS(action, 2, 0)
+  filename = std::string(action[2]);
+  line = std::stoi(action[3]);
+}
+
+void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 1, 2)
   size = parse_double(action[2]);
@@ -174,7 +187,7 @@ void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype1 = simgrid::smpi::Datatype::decode(action[4]);
 }
 
-void ReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void ReduceArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 2)
   comm_size = parse_double(action[2]);
@@ -184,7 +197,7 @@ void ReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype1 = simgrid::smpi::Datatype::decode(action[5]);
 }
 
-void AllReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void AllReduceArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 1)
   comm_size = parse_double(action[2]);
@@ -193,7 +206,7 @@ void AllReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype1 = simgrid::smpi::Datatype::decode(action[4]);
 }
 
-void AllToAllArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void AllToAllArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 1)
   comm_size = MPI_COMM_WORLD->size();
@@ -206,7 +219,7 @@ void AllToAllArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype2 = simgrid::smpi::Datatype::decode(action[5]);
 }
 
-void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string& name)
 {
   /* The structure of the gather action for the rank 0 (total 4 processes) is the following:
         0 gather 68 68 0 0 0
@@ -236,7 +249,7 @@ void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name
   }
 }
 
-void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string& name)
 {
   /* The structure of the gatherv action for the rank 0 (total 4 processes) is the following:
        0 gather 68 68 10 10 10 0 0 0
@@ -260,13 +273,12 @@ void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string nam
     if (action.size() > 5 + comm_size)
       datatype2 = simgrid::smpi::Datatype::decode(action[5 + comm_size]);
   } else {
-    int datatype_index = 0;
     int disp_index     = 0;
     /* The 3 comes from "0 gather <sendcount>", which must always be present.
      * The + comm_size is the recvcounts array, which must also be present
      */
     if (action.size() > 3 + comm_size + comm_size) { /* datatype + disp are specified */
-      datatype_index = 3 + comm_size;
+      int datatype_index = 3 + comm_size;
       disp_index     = datatype_index + 1;
       datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
       datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
@@ -274,7 +286,7 @@ void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string nam
                3 + comm_size + 2) { /* disps specified; datatype is not specified; use the default one */
       disp_index = 3 + comm_size;
     } else if (action.size() > 3 + comm_size) { /* only datatype, no disp specified */
-      datatype_index = 3 + comm_size;
+      int datatype_index = 3 + comm_size;
       datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
       datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
     }
@@ -291,7 +303,7 @@ void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string nam
   recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
 }
 
-void ScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void ScatterArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   /* The structure of the scatter action for the rank 0 (total 4 processes) is the following:
         0 gather 68 68 0 0 0
@@ -313,7 +325,7 @@ void ScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
     datatype2 = simgrid::smpi::Datatype::decode(action[6]);
 }
 
-void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   /* The structure of the scatterv action for the rank 0 (total 4 processes) is the following:
      0 gather 68 10 10 10 68 0 0 0
@@ -341,7 +353,7 @@ void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
   root          = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
 }
 
-void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   /* The structure of the reducescatter action for the rank 0 (total 4 processes) is the following:
        0 reducescatter 275427 275427 275427 204020 11346849 0
@@ -363,7 +375,7 @@ void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::stri
   recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
 }
 
-void AllToAllVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string)
+void AllToAllVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   /* The structure of the alltoallv action for the rank 0 (total 4 processes) is the following:
         0 alltoallv 100 1 7 10 12 100 1 70 10 5
@@ -457,13 +469,15 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
     args.size = status.count;
   }
 
-  bool is_recv = false;
+  bool is_recv = false; // Help analyzers understanding that status is not used unintialized
   if (name == "recv") {
-    Request::recv(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD, &status);
     is_recv = true;
+    Request::recv(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD, &status);
   } else if (name == "irecv") {
     MPI_Request request = Request::irecv(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD);
     req_storage.add(request);
+  } else {
+    THROW_IMPOSSIBLE;
   }
 
   TRACE_smpi_comm_out(my_proc_id);
@@ -475,9 +489,23 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
 
 void ComputeAction::kernel(simgrid::xbt::ReplayAction&)
 {
-  TRACE_smpi_computing_in(my_proc_id, args.flops);
-  smpi_execute_flops(args.flops);
-  TRACE_smpi_computing_out(my_proc_id);
+  if (simgrid::config::get_value<bool>("smpi/simulate-computation")) {
+    smpi_execute_flops(args.flops/smpi_adjust_comp_speed());
+  }
+}
+
+void SleepAction::kernel(simgrid::xbt::ReplayAction&)
+{
+  XBT_DEBUG("Sleep for: %lf secs", args.time);
+  int rank = simgrid::s4u::this_actor::get_pid();
+  TRACE_smpi_sleeping_in(rank, args.time);
+  simgrid::s4u::this_actor::sleep_for(args.time/smpi_adjust_comp_speed());
+  TRACE_smpi_sleeping_out(rank);
+}
+
+void LocationAction::kernel(simgrid::xbt::ReplayAction&)
+{
+  smpi_trace_set_call_location(args.filename.c_str(), args.line);
 }
 
 void TestAction::kernel(simgrid::xbt::ReplayAction&)
@@ -491,7 +519,8 @@ void TestAction::kernel(simgrid::xbt::ReplayAction&)
     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("test"));
 
     MPI_Status status;
-    int flag = Request::test(&request, &status);
+    int flag = 0;
+    Request::test(&request, &status, &flag);
 
     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
@@ -534,8 +563,7 @@ void WaitAllAction::kernel(simgrid::xbt::ReplayAction&)
         sender_receiver.push_back({req->src(), req->dst()});
       }
     }
-    MPI_Status status[count_requests];
-    Request::waitall(count_requests, &(reqs.data())[0], status);
+    Request::waitall(count_requests, &(reqs.data())[0], MPI_STATUSES_IGNORE);
     req_storage.get_store().clear();
 
     for (auto& pair : sender_receiver) {
@@ -548,7 +576,7 @@ void WaitAllAction::kernel(simgrid::xbt::ReplayAction&)
 void BarrierAction::kernel(simgrid::xbt::ReplayAction&)
 {
   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("barrier"));
-  Colls::barrier(MPI_COMM_WORLD);
+  colls::barrier(MPI_COMM_WORLD);
   TRACE_smpi_comm_out(my_proc_id);
 }
 
@@ -558,7 +586,7 @@ void BcastAction::kernel(simgrid::xbt::ReplayAction&)
       new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(),
         -1.0, args.size, -1, Datatype::encode(args.datatype1), ""));
 
-  Colls::bcast(send_buffer(args.size * args.datatype1->size()), args.size, args.datatype1, args.root, MPI_COMM_WORLD);
+  colls::bcast(send_buffer(args.size * args.datatype1->size()), args.size, args.datatype1, args.root, MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -570,9 +598,10 @@ void ReduceAction::kernel(simgrid::xbt::ReplayAction&)
         args.comp_size, args.comm_size, -1,
         Datatype::encode(args.datatype1), ""));
 
-  Colls::reduce(send_buffer(args.comm_size * args.datatype1->size()),
-      recv_buffer(args.comm_size * args.datatype1->size()), args.comm_size, args.datatype1, MPI_OP_NULL, args.root, MPI_COMM_WORLD);
-  smpi_execute_flops(args.comp_size);
+  colls::reduce(send_buffer(args.comm_size * args.datatype1->size()),
+                recv_buffer(args.comm_size * args.datatype1->size()), args.comm_size, args.datatype1, MPI_OP_NULL,
+                args.root, MPI_COMM_WORLD);
+  private_execute_flops(args.comp_size);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -582,9 +611,10 @@ void AllReduceAction::kernel(simgrid::xbt::ReplayAction&)
   TRACE_smpi_comm_in(my_proc_id, "action_allreduce", new simgrid::instr::CollTIData("allreduce", -1, args.comp_size, args.comm_size, -1,
         Datatype::encode(args.datatype1), ""));
 
-  Colls::allreduce(send_buffer(args.comm_size * args.datatype1->size()),
-      recv_buffer(args.comm_size * args.datatype1->size()), args.comm_size, args.datatype1, MPI_OP_NULL, MPI_COMM_WORLD);
-  smpi_execute_flops(args.comp_size);
+  colls::allreduce(send_buffer(args.comm_size * args.datatype1->size()),
+                   recv_buffer(args.comm_size * args.datatype1->size()), args.comm_size, args.datatype1, MPI_OP_NULL,
+                   MPI_COMM_WORLD);
+  private_execute_flops(args.comp_size);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -596,9 +626,9 @@ void AllToAllAction::kernel(simgrid::xbt::ReplayAction&)
         Datatype::encode(args.datatype1),
         Datatype::encode(args.datatype2)));
 
-  Colls::alltoall(send_buffer(args.send_size * args.comm_size * args.datatype1->size()), args.send_size,
-      args.datatype1, recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()),
-      args.recv_size, args.datatype2, MPI_COMM_WORLD);
+  colls::alltoall(send_buffer(args.send_size * args.comm_size * args.datatype1->size()), args.send_size, args.datatype1,
+                  recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()), args.recv_size, args.datatype2,
+                  MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -610,12 +640,14 @@ void GatherAction::kernel(simgrid::xbt::ReplayAction&)
 
   if (name == "gather") {
     int rank = MPI_COMM_WORLD->rank();
-    Colls::gather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-        (rank == args.root) ? recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()) : nullptr, args.recv_size, args.datatype2, args.root, MPI_COMM_WORLD);
+    colls::gather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
+                  (rank == args.root) ? recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()) : nullptr,
+                  args.recv_size, args.datatype2, args.root, MPI_COMM_WORLD);
   }
   else
-    Colls::allgather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-        recv_buffer(args.recv_size * args.datatype2->size()), args.recv_size, args.datatype2, MPI_COMM_WORLD);
+    colls::allgather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
+                     recv_buffer(args.recv_size * args.datatype2->size()), args.recv_size, args.datatype2,
+                     MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -629,14 +661,14 @@ void GatherVAction::kernel(simgrid::xbt::ReplayAction&)
         Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
 
   if (name == "gatherv") {
-    Colls::gatherv(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-        (rank == args.root) ? recv_buffer(args.recv_size_sum * args.datatype2->size()) : nullptr,
-        args.recvcounts->data(), args.disps.data(), args.datatype2, args.root, MPI_COMM_WORLD);
+    colls::gatherv(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
+                   (rank == args.root) ? recv_buffer(args.recv_size_sum * args.datatype2->size()) : nullptr,
+                   args.recvcounts->data(), args.disps.data(), args.datatype2, args.root, MPI_COMM_WORLD);
   }
   else {
-    Colls::allgatherv(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-        recv_buffer(args.recv_size_sum * args.datatype2->size()), args.recvcounts->data(),
-        args.disps.data(), args.datatype2, MPI_COMM_WORLD);
+    colls::allgatherv(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
+                      recv_buffer(args.recv_size_sum * args.datatype2->size()), args.recvcounts->data(),
+                      args.disps.data(), args.datatype2, MPI_COMM_WORLD);
   }
 
   TRACE_smpi_comm_out(my_proc_id);
@@ -649,8 +681,9 @@ void ScatterAction::kernel(simgrid::xbt::ReplayAction&)
         Datatype::encode(args.datatype1),
         Datatype::encode(args.datatype2)));
 
-  Colls::scatter(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-      (rank == args.root) ? recv_buffer(args.recv_size * args.datatype2->size()) : nullptr, args.recv_size, args.datatype2, args.root, MPI_COMM_WORLD);
+  colls::scatter(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
+                 (rank == args.root) ? recv_buffer(args.recv_size * args.datatype2->size()) : nullptr, args.recv_size,
+                 args.datatype2, args.root, MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -662,10 +695,10 @@ void ScatterVAction::kernel(simgrid::xbt::ReplayAction&)
         nullptr, Datatype::encode(args.datatype1),
         Datatype::encode(args.datatype2)));
 
-  Colls::scatterv((rank == args.root) ? send_buffer(args.send_size_sum * args.datatype1->size()) : nullptr,
-      args.sendcounts->data(), args.disps.data(), args.datatype1,
-      recv_buffer(args.recv_size * args.datatype2->size()), args.recv_size, args.datatype2, args.root,
-      MPI_COMM_WORLD);
+  colls::scatterv((rank == args.root) ? send_buffer(args.send_size_sum * args.datatype1->size()) : nullptr,
+                  args.sendcounts->data(), args.disps.data(), args.datatype1,
+                  recv_buffer(args.recv_size * args.datatype2->size()), args.recv_size, args.datatype2, args.root,
+                  MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -677,11 +710,11 @@ void ReduceScatterAction::kernel(simgrid::xbt::ReplayAction&)
         std::to_string(args.comp_size), /* ugly hack to print comp_size */
         Datatype::encode(args.datatype1)));
 
-  Colls::reduce_scatter(send_buffer(args.recv_size_sum * args.datatype1->size()),
-      recv_buffer(args.recv_size_sum * args.datatype1->size()), args.recvcounts->data(),
-      args.datatype1, MPI_OP_NULL, MPI_COMM_WORLD);
+  colls::reduce_scatter(send_buffer(args.recv_size_sum * args.datatype1->size()),
+                        recv_buffer(args.recv_size_sum * args.datatype1->size()), args.recvcounts->data(),
+                        args.datatype1, MPI_OP_NULL, MPI_COMM_WORLD);
 
-  smpi_execute_flops(args.comp_size);
+  private_execute_flops(args.comp_size);
   TRACE_smpi_comm_out(my_proc_id);
 }
 
@@ -692,8 +725,9 @@ void AllToAllVAction::kernel(simgrid::xbt::ReplayAction&)
         "alltoallv", -1, args.send_size_sum, args.sendcounts, args.recv_size_sum, args.recvcounts,
         Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
 
-  Colls::alltoallv(send_buffer(args.send_buf_size * args.datatype1->size()), args.sendcounts->data(), args.senddisps.data(), args.datatype1,
-      recv_buffer(args.recv_buf_size * args.datatype2->size()), args.recvcounts->data(), args.recvdisps.data(), args.datatype2, MPI_COMM_WORLD);
+  colls::alltoallv(send_buffer(args.send_buf_size * args.datatype1->size()), args.sendcounts->data(),
+                   args.senddisps.data(), args.datatype1, recv_buffer(args.recv_buf_size * args.datatype2->size()),
+                   args.recvcounts->data(), args.recvdisps.data(), args.datatype2, MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(my_proc_id);
 }
@@ -704,11 +738,12 @@ static std::unordered_map<aid_t, simgrid::smpi::replay::RequestStorage> storage;
 /** @brief Only initialize the replay, don't do it for real */
 void smpi_replay_init(const char* instance_id, int rank, double start_delay_flops)
 {
-  if (not smpi_process()->initializing()){
-    simgrid::s4u::Actor::self()->set_property("instance_id", instance_id);
-    simgrid::s4u::Actor::self()->set_property("rank", std::to_string(rank));
-    simgrid::smpi::ActorExt::init();
-  }
+  xbt_assert(not smpi_process()->initializing());
+
+  simgrid::s4u::Actor::self()->set_property("instance_id", instance_id);
+  simgrid::s4u::Actor::self()->set_property("rank", std::to_string(rank));
+  simgrid::smpi::ActorExt::init();
+
   smpi_process()->mark_as_initialized();
   smpi_process()->set_replaying(true);
 
@@ -744,11 +779,13 @@ void smpi_replay_init(const char* instance_id, int rank, double start_delay_flop
   xbt_replay_action_register("allgatherv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::GatherVAction("allgatherv").execute(action); });
   xbt_replay_action_register("reducescatter", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::ReduceScatterAction().execute(action); });
   xbt_replay_action_register("compute", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::ComputeAction().execute(action); });
+  xbt_replay_action_register("sleep", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::SleepAction().execute(action); });
+  xbt_replay_action_register("location", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::LocationAction().execute(action); });
 
   //if we have a delayed start, sleep here.
   if (start_delay_flops > 0) {
     XBT_VERB("Delayed start for instance - Sleeping for %f flops ", start_delay_flops);
-    smpi_execute_flops(start_delay_flops);
+    private_execute_flops(start_delay_flops);
   } else {
     // Wait for the other actors to initialize also
     simgrid::s4u::this_actor::yield();
@@ -769,15 +806,15 @@ void smpi_replay_main(int rank, const char* trace_filename)
   unsigned int count_requests = storage[simgrid::s4u::this_actor::get_pid()].size();
   XBT_DEBUG("There are %ud elements in reqq[*]", count_requests);
   if (count_requests > 0) {
-    MPI_Request requests[count_requests];
-    MPI_Status status[count_requests];
+    MPI_Request* requests= new MPI_Request[count_requests];
     unsigned int i=0;
 
     for (auto const& pair : storage[simgrid::s4u::this_actor::get_pid()].get_store()) {
       requests[i] = pair.second;
       i++;
     }
-    simgrid::smpi::Request::waitall(count_requests, requests, status);
+    simgrid::smpi::Request::waitall(count_requests, requests, MPI_STATUSES_IGNORE);
+    delete[] requests;
   }
   active_processes--;
 
@@ -793,7 +830,6 @@ void smpi_replay_main(int rank, const char* trace_filename)
   smpi_process()->finalize();
 
   TRACE_smpi_comm_out(simgrid::s4u::this_actor::get_pid());
-  TRACE_smpi_finalize(simgrid::s4u::this_actor::get_pid());
 }
 
 /** @brief chain a replay initialization and a replay start */