X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b13a264343d5efaa1eb9cec5cf0e1dd588efb6f0..246388d21097723092dfc24d709231ff2b493010:/src/smpi/internals/smpi_replay.cpp

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index 8459a7f268..774cec5574 100644
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -3,23 +3,24 @@
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#include "private.hpp"
 #include "smpi_coll.hpp"
 #include "smpi_comm.hpp"
 #include "smpi_datatype.hpp"
 #include "smpi_group.hpp"
-#include "smpi_process.hpp"
 #include "smpi_request.hpp"
 #include "xbt/replay.hpp"
+#include <simgrid/smpi/replay.hpp>
+#include <src/smpi/include/private.hpp>
 
-#include <boost/algorithm/string/join.hpp>
 #include <memory>
 #include <numeric>
 #include <unordered_map>
-#include <sstream>
 #include <vector>
 
 #include <tuple>
+
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay, smpi, "Trace Replay with SMPI");
+
 // From https://stackoverflow.com/questions/7110301/generic-hash-for-tuples-in-unordered-map-unordered-set
 // This is all just to make std::unordered_map work with std::tuple. If we need this in other places,
 // this could go into a header file.
@@ -60,31 +61,10 @@ public:
 };
 }
 
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI");
-
 typedef std::tuple</*sender*/ int, /* reciever */ 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;
 
-static MPI_Datatype MPI_DEFAULT_TYPE;
-
-#define CHECK_ACTION_PARAMS(action, mandatory, optional)                                                               \
-  {                                                                                                                    \
-    if (action.size() < static_cast<unsigned long>(mandatory + 2)) {                                                   \
-      std::stringstream ss;                                                                                            \
-      for (const auto& elem : action) {                                                                                \
-        ss << elem << " ";                                                                                             \
-      }                                                                                                                \
-      THROWF(arg_error, 0, "%s replay failed.\n"                                                                       \
-                           "%zu items were given on the line. First two should be process_id and action.  "            \
-                           "This action needs after them %lu mandatory arguments, and accepts %lu optional ones. \n"   \
-                           "The full line that was given is:\n   %s\n"                                                 \
-                           "Please contact the Simgrid team if support is needed",                                     \
-             __func__, action.size(), static_cast<unsigned long>(mandatory), static_cast<unsigned long>(optional),     \
-             ss.str().c_str());                                                                                        \
-    }                                                                                                                  \
-  }
-
-static void log_timed_action(simgrid::xbt::ReplayAction& action, double clock)
+void log_timed_action(simgrid::xbt::ReplayAction& action, double clock)
 {
   if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){
     std::string s = boost::algorithm::join(action, " ");
@@ -102,6 +82,7 @@ namespace simgrid {
 namespace smpi {
 
 namespace replay {
+MPI_Datatype MPI_DEFAULT_TYPE;
 
 class RequestStorage {
 private:
@@ -157,786 +138,566 @@ public:
     }
 };
 
-/**
- * Base class for all parsers.
- */
-class ActionArgParser {
-public:
-  virtual ~ActionArgParser() = default;
-  virtual void parse(simgrid::xbt::ReplayAction& action, std::string name) { CHECK_ACTION_PARAMS(action, 0, 0) }
-};
-
-class WaitTestParser : public ActionArgParser {
-public:
-  int src;
-  int dst;
-  int tag;
+void WaitTestParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 3, 0)
+  src = std::stoi(action[2]);
+  dst = std::stoi(action[3]);
+  tag = std::stoi(action[4]);
+}
 
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 3, 0)
-    src = std::stoi(action[2]);
-    dst = std::stoi(action[3]);
-    tag = std::stoi(action[4]);
-  }
-};
+void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 3, 1)
+  partner = std::stoi(action[2]);
+  tag     = std::stoi(action[3]);
+  size    = parse_double(action[4]);
+  if (action.size() > 5)
+    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
+}
 
-class SendRecvParser : public ActionArgParser {
-public:
-  /* communication partner; if we send, this is the receiver and vice versa */
-  int partner;
-  double size;
-  int tag;
-  MPI_Datatype datatype1 = MPI_DEFAULT_TYPE;
+void ComputeParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 1, 0)
+  flops = parse_double(action[2]);
+}
 
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 3, 1)
-    partner = std::stoi(action[2]);
-    tag     = std::stoi(action[3]);
-    size    = parse_double(action[4]);
-    if (action.size() > 5)
-      datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-  }
-};
+void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 1, 2)
+  size = parse_double(action[2]);
+  root = (action.size() > 3) ? std::stoi(action[3]) : 0;
+  if (action.size() > 4)
+    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
+}
 
-class ComputeParser : public ActionArgParser {
-public:
-  /* communication partner; if we send, this is the receiver and vice versa */
-  double flops;
+void ReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 2, 2)
+  comm_size = parse_double(action[2]);
+  comp_size = parse_double(action[3]);
+  root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
+  if (action.size() > 5)
+    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
+}
 
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 1, 0)
-    flops = parse_double(action[2]);
-  }
-};
+void AllReduceArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 2, 1)
+  comm_size = parse_double(action[2]);
+  comp_size = parse_double(action[3]);
+  if (action.size() > 4)
+    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
+}
 
-class CollCommParser : public ActionArgParser {
-public:
-  double size;
-  double comm_size;
-  double comp_size;
-  int send_size;
-  int recv_size;
-  int root = 0;
-  MPI_Datatype datatype1 = MPI_DEFAULT_TYPE;
-  MPI_Datatype datatype2 = MPI_DEFAULT_TYPE;
-};
+void AllToAllArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  CHECK_ACTION_PARAMS(action, 2, 1)
+  comm_size = MPI_COMM_WORLD->size();
+  send_size = parse_double(action[2]);
+  recv_size = parse_double(action[3]);
+
+  if (action.size() > 4)
+    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
+  if (action.size() > 5)
+    datatype2 = simgrid::smpi::Datatype::decode(action[5]);
+}
 
-class BcastArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) 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)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4]);
-  }
-};
+void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, 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
+      where:
+        1) 68 is the sendcounts
+        2) 68 is the recvcounts
+        3) 0 is the root node
+        4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
+        5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
+  */
+  CHECK_ACTION_PARAMS(action, 2, 3)
+  comm_size = MPI_COMM_WORLD->size();
+  send_size = parse_double(action[2]);
+  recv_size = parse_double(action[3]);
 
-class ReduceArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 2, 2)
-    comm_size = parse_double(action[2]);
-    comp_size = parse_double(action[3]);
+  if (name == "gather") {
     root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
     if (action.size() > 5)
       datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-  }
-};
-
-class AllReduceArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 2, 1)
-    comm_size = parse_double(action[2]);
-    comp_size = parse_double(action[3]);
-    if (action.size() > 4)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4]);
-  }
-};
-
-class AllToAllArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    CHECK_ACTION_PARAMS(action, 2, 1)
-    comm_size = MPI_COMM_WORLD->size();
-    send_size = parse_double(action[2]);
-    recv_size = parse_double(action[3]);
-
+    if (action.size() > 6)
+      datatype2 = simgrid::smpi::Datatype::decode(action[6]);
+  } else {
     if (action.size() > 4)
       datatype1 = simgrid::smpi::Datatype::decode(action[4]);
     if (action.size() > 5)
       datatype2 = simgrid::smpi::Datatype::decode(action[5]);
   }
-};
-
-class GatherArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* The structure of the gather action for the rank 0 (total 4 processes) is the following:
-          0 gather 68 68 0 0 0
-        where:
-          1) 68 is the sendcounts
-          2) 68 is the recvcounts
-          3) 0 is the root node
-          4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
-          5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
-    */
-    CHECK_ACTION_PARAMS(action, 2, 3)
-    comm_size = MPI_COMM_WORLD->size();
-    send_size = parse_double(action[2]);
-    recv_size = parse_double(action[3]);
-
-    if (name == "gather") {
-      root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
-      if (action.size() > 5)
-        datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-      if (action.size() > 6)
-        datatype2 = simgrid::smpi::Datatype::decode(action[6]);
-    }
-    else {
-      if (action.size() > 4)
-        datatype1 = simgrid::smpi::Datatype::decode(action[4]);
-      if (action.size() > 5)
-        datatype2 = simgrid::smpi::Datatype::decode(action[5]);
-    }
-  }
-};
-
-class GatherVArgParser : public CollCommParser {
-public:
-  int recv_size_sum;
-  std::shared_ptr<std::vector<int>> recvcounts;
-  std::vector<int> disps;
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* 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
-       where:
-         1) 68 is the sendcount
-         2) 68 10 10 10 is the recvcounts
-         3) 0 is the root node
-         4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
-         5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
-    */
-    comm_size = MPI_COMM_WORLD->size();
-    CHECK_ACTION_PARAMS(action, comm_size+1, 2)
-    send_size = parse_double(action[2]);
-    disps     = std::vector<int>(comm_size, 0);
-    recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
-
-    if (name == "gatherV") {
-      root = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
-      if (action.size() > 4 + comm_size)
-        datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
-      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;
-        disp_index     = datatype_index + 1;
-        datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-        datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-      } else if (action.size() > 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;
-        datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-        datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-      }
+}
 
-      if (disp_index != 0) {
-        for (unsigned int i = 0; i < comm_size; i++)
-          disps[i]          = std::stoi(action[disp_index + i]);
-      }
+void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, 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
+     where:
+       1) 68 is the sendcount
+       2) 68 10 10 10 is the recvcounts
+       3) 0 is the root node
+       4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
+       5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
+  */
+  comm_size = MPI_COMM_WORLD->size();
+  CHECK_ACTION_PARAMS(action, comm_size + 1, 2)
+  send_size  = parse_double(action[2]);
+  disps      = std::vector<int>(comm_size, 0);
+  recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
+
+  if (name == "gatherV") {
+    root = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
+    if (action.size() > 4 + comm_size)
+      datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
+    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;
+      disp_index     = datatype_index + 1;
+      datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
+      datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
+    } else if (action.size() >
+               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;
+      datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
+      datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
     }
 
-    for (unsigned int i = 0; i < comm_size; i++) {
-      (*recvcounts)[i] = std::stoi(action[i + 3]);
+    if (disp_index != 0) {
+      for (unsigned int i = 0; i < comm_size; i++)
+        disps[i]          = std::stoi(action[disp_index + i]);
     }
-    recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
   }
-};
 
-class ScatterArgParser : public CollCommParser {
-public:
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* The structure of the scatter action for the rank 0 (total 4 processes) is the following:
-          0 gather 68 68 0 0 0
-        where:
-          1) 68 is the sendcounts
-          2) 68 is the recvcounts
-          3) 0 is the root node
-          4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
-          5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
-    */
-    CHECK_ACTION_PARAMS(action, 2, 3)
-    comm_size   = MPI_COMM_WORLD->size();
-    send_size   = parse_double(action[2]);
-    recv_size   = parse_double(action[3]);
-    root   = (action.size() > 4) ? std::stoi(action[4]) : 0;
-    if (action.size() > 5)
-      datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-    if (action.size() > 6)
-      datatype2 = simgrid::smpi::Datatype::decode(action[6]);
+  for (unsigned int i = 0; i < comm_size; i++) {
+    (*recvcounts)[i] = std::stoi(action[i + 3]);
   }
-};
+  recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
+}
 
-class ScatterVArgParser : public CollCommParser {
-public:
-  int recv_size_sum;
-  int send_size_sum;
-  std::shared_ptr<std::vector<int>> sendcounts;
-  std::vector<int> disps;
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* 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
-        where:
-        1) 68 10 10 10 is the sendcounts
-        2) 68 is the recvcount
+void ScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  /* The structure of the scatter action for the rank 0 (total 4 processes) is the following:
+        0 gather 68 68 0 0 0
+      where:
+        1) 68 is the sendcounts
+        2) 68 is the recvcounts
         3) 0 is the root node
         4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
         5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
-    */
-    CHECK_ACTION_PARAMS(action, comm_size + 1, 2)
-    recv_size  = parse_double(action[2 + comm_size]);
-    disps      = std::vector<int>(comm_size, 0);
-    sendcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
-
-    if (action.size() > 5 + comm_size)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
-    if (action.size() > 5 + comm_size)
-      datatype2 = simgrid::smpi::Datatype::decode(action[5]);
-
-    for (unsigned int i = 0; i < comm_size; i++) {
-      (*sendcounts)[i] = std::stoi(action[i + 2]);
-    }
-    send_size_sum = std::accumulate(sendcounts->begin(), sendcounts->end(), 0);
-    root = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
-  }
-};
-
-class ReduceScatterArgParser : public CollCommParser {
-public:
-  int recv_size_sum;
-  std::shared_ptr<std::vector<int>> recvcounts;
-  std::vector<int> disps;
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* The structure of the reducescatter action for the rank 0 (total 4 processes) is the following:
-         0 reduceScatter 275427 275427 275427 204020 11346849 0
-       where:
-         1) The first four values after the name of the action declare the recvcounts array
-         2) The value 11346849 is the amount of instructions
-         3) The last value corresponds to the datatype, see simgrid::smpi::Datatype::decode().
-    */
-    comm_size = MPI_COMM_WORLD->size();
-    CHECK_ACTION_PARAMS(action, comm_size+1, 1)
-    comp_size = parse_double(action[2+comm_size]);
-    recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
-    if (action.size() > 3 + comm_size)
-      datatype1 = simgrid::smpi::Datatype::decode(action[3 + comm_size]);
-
-    for (unsigned int i = 0; i < comm_size; i++) {
-      recvcounts->push_back(std::stoi(action[i + 2]));
-    }
-    recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
-  }
-};
-
-class AllToAllVArgParser : public CollCommParser {
-public:
-  int recv_size_sum;
-  int send_size_sum;
-  std::shared_ptr<std::vector<int>> recvcounts;
-  std::shared_ptr<std::vector<int>> sendcounts;
-  std::vector<int> senddisps;
-  std::vector<int> recvdisps;
-  int send_buf_size;
-  int recv_buf_size;
-  void parse(simgrid::xbt::ReplayAction& action, std::string name) override
-  {
-    /* 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
-       where:
-        1) 100 is the size of the send buffer *sizeof(int),
-        2) 1 7 10 12 is the sendcounts array
-        3) 100*sizeof(int) is the size of the receiver buffer
-        4)  1 70 10 5 is the recvcounts array
-    */
-    comm_size = MPI_COMM_WORLD->size();
-    CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2)
-    sendcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
-    recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
-    senddisps  = std::vector<int>(comm_size, 0);
-    recvdisps  = std::vector<int>(comm_size, 0);
-
-    if (action.size() > 5 + 2 * comm_size)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4 + 2 * comm_size]);
-    if (action.size() > 5 + 2 * comm_size)
-      datatype2 = simgrid::smpi::Datatype::decode(action[5 + 2 * comm_size]);
-
-    send_buf_size=parse_double(action[2]);
-    recv_buf_size=parse_double(action[3+comm_size]);
-    for (unsigned int i = 0; i < comm_size; i++) {
-      (*sendcounts)[i] = std::stoi(action[3 + i]);
-      (*recvcounts)[i] = std::stoi(action[4 + comm_size + i]);
-    }
-    send_size_sum = std::accumulate(sendcounts->begin(), sendcounts->end(), 0);
-    recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
-  }
-};
-
-/**
- * Base class for all ReplayActions.
- * Note that this class actually implements the behavior of each action
- * while the parsing of the replay arguments is done in the @ActionArgParser class.
- * In other words: The logic goes here, the setup is done by the ActionArgParser.
- */
-template <class T> class ReplayAction {
-protected:
-  const std::string name;
-  const int my_proc_id;
-  T args;
+  */
+  CHECK_ACTION_PARAMS(action, 2, 3)
+  comm_size = MPI_COMM_WORLD->size();
+  send_size = parse_double(action[2]);
+  recv_size = parse_double(action[3]);
+  root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
+  if (action.size() > 5)
+    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
+  if (action.size() > 6)
+    datatype2 = simgrid::smpi::Datatype::decode(action[6]);
+}
 
-public:
-  explicit ReplayAction(std::string name) : name(name), my_proc_id(simgrid::s4u::this_actor::get_pid()) {}
-  virtual ~ReplayAction() = default;
+void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  /* 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
+      where:
+      1) 68 10 10 10 is the sendcounts
+      2) 68 is the recvcount
+      3) 0 is the root node
+      4) 0 is the send datatype id, see simgrid::smpi::Datatype::decode()
+      5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
+  */
+  CHECK_ACTION_PARAMS(action, comm_size + 1, 2)
+  recv_size  = parse_double(action[2 + comm_size]);
+  disps      = std::vector<int>(comm_size, 0);
+  sendcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
+
+  if (action.size() > 5 + comm_size)
+    datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
+  if (action.size() > 5 + comm_size)
+    datatype2 = simgrid::smpi::Datatype::decode(action[5]);
+
+  for (unsigned int i = 0; i < comm_size; i++) {
+    (*sendcounts)[i] = std::stoi(action[i + 2]);
+  }
+  send_size_sum = std::accumulate(sendcounts->begin(), sendcounts->end(), 0);
+  root          = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
+}
 
-  virtual void execute(simgrid::xbt::ReplayAction& action)
-  {
-    // Needs to be re-initialized for every action, hence here
-    double start_time = smpi_process()->simulated_elapsed();
-    args.parse(action, name);
-    kernel(action);
-    if (name != "Init")
-      log_timed_action(action, start_time);
-  }
+void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  /* The structure of the reducescatter action for the rank 0 (total 4 processes) is the following:
+       0 reducescatter 275427 275427 275427 204020 11346849 0
+     where:
+       1) The first four values after the name of the action declare the recvcounts array
+       2) The value 11346849 is the amount of instructions
+       3) The last value corresponds to the datatype, see simgrid::smpi::Datatype::decode().
+  */
+  comm_size = MPI_COMM_WORLD->size();
+  CHECK_ACTION_PARAMS(action, comm_size + 1, 1)
+  comp_size  = parse_double(action[2 + comm_size]);
+  recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
+  if (action.size() > 3 + comm_size)
+    datatype1 = simgrid::smpi::Datatype::decode(action[3 + comm_size]);
+
+  for (unsigned int i = 0; i < comm_size; i++) {
+    recvcounts->push_back(std::stoi(action[i + 2]));
+  }
+  recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
+}
 
-  virtual void kernel(simgrid::xbt::ReplayAction& action) = 0;
+void AllToAllVArgParser::parse(simgrid::xbt::ReplayAction& action, std::string name)
+{
+  /* 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
+     where:
+      1) 100 is the size of the send buffer *sizeof(int),
+      2) 1 7 10 12 is the sendcounts array
+      3) 100*sizeof(int) is the size of the receiver buffer
+      4)  1 70 10 5 is the recvcounts array
+  */
+  comm_size = MPI_COMM_WORLD->size();
+  CHECK_ACTION_PARAMS(action, 2 * comm_size + 2, 2)
+  sendcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
+  recvcounts = std::shared_ptr<std::vector<int>>(new std::vector<int>(comm_size));
+  senddisps  = std::vector<int>(comm_size, 0);
+  recvdisps  = std::vector<int>(comm_size, 0);
+
+  if (action.size() > 5 + 2 * comm_size)
+    datatype1 = simgrid::smpi::Datatype::decode(action[4 + 2 * comm_size]);
+  if (action.size() > 5 + 2 * comm_size)
+    datatype2 = simgrid::smpi::Datatype::decode(action[5 + 2 * comm_size]);
+
+  send_buf_size = parse_double(action[2]);
+  recv_buf_size = parse_double(action[3 + comm_size]);
+  for (unsigned int i = 0; i < comm_size; i++) {
+    (*sendcounts)[i] = std::stoi(action[3 + i]);
+    (*recvcounts)[i] = std::stoi(action[4 + comm_size + i]);
+  }
+  send_size_sum = std::accumulate(sendcounts->begin(), sendcounts->end(), 0);
+  recv_size_sum = std::accumulate(recvcounts->begin(), recvcounts->end(), 0);
+}
 
-  void* send_buffer(int size)
-  {
-    return smpi_get_tmp_sendbuffer(size);
-  }
+void WaitAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  std::string s = boost::algorithm::join(action, " ");
+  xbt_assert(req_storage.size(), "action wait not preceded by any irecv or isend: %s", s.c_str());
+  MPI_Request request = req_storage.find(args.src, args.dst, args.tag);
+  req_storage.remove(request);
 
-  void* recv_buffer(int size)
-  {
-    return smpi_get_tmp_recvbuffer(size);
+  if (request == MPI_REQUEST_NULL) {
+    /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just
+     * return.*/
+    return;
   }
-};
-
-class WaitAction : public ReplayAction<WaitTestParser> {
-private:
-  RequestStorage& req_storage;
 
-public:
-  explicit WaitAction(RequestStorage& storage) : ReplayAction("Wait"), req_storage(storage) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    std::string s = boost::algorithm::join(action, " ");
-    xbt_assert(req_storage.size(), "action wait not preceded by any irecv or isend: %s", s.c_str());
-    MPI_Request request = req_storage.find(args.src, args.dst, args.tag);
-    req_storage.remove(request);
-
-    if (request == MPI_REQUEST_NULL) {
-      /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just
-       * return.*/
-      return;
-    }
+  int rank = request->comm() != MPI_COMM_NULL ? request->comm()->rank() : -1;
 
-    int rank = request->comm() != MPI_COMM_NULL ? request->comm()->rank() : -1;
+  // Must be taken before Request::wait() since the request may be set to
+  // MPI_REQUEST_NULL by Request::wait!
+  bool is_wait_for_receive = (request->flags() & MPI_REQ_RECV);
+  // TODO: Here we take the rank while we normally take the process id (look for my_proc_id)
+  TRACE_smpi_comm_in(rank, __func__, new simgrid::instr::WaitTIData(args.src, args.dst, args.tag));
 
-    // Must be taken before Request::wait() since the request may be set to
-    // MPI_REQUEST_NULL by Request::wait!
-    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, __func__, new simgrid::instr::NoOpTIData("wait"));
+  MPI_Status status;
+  Request::wait(&request, &status);
 
-    MPI_Status status;
-    Request::wait(&request, &status);
+  TRACE_smpi_comm_out(rank);
+  if (is_wait_for_receive)
+    TRACE_smpi_recv(args.src, args.dst, args.tag);
+}
 
-    TRACE_smpi_comm_out(rank);
-    if (is_wait_for_receive)
-      TRACE_smpi_recv(args.src, args.dst, args.tag);
+void SendAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  int dst_traced = MPI_COMM_WORLD->group()->actor(args.partner)->get_pid();
+
+  TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData(name, args.partner, args.size,
+        args.tag, Datatype::encode(args.datatype1)));
+  if (not TRACE_smpi_view_internals())
+    TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, args.tag, args.size * args.datatype1->size());
+
+  if (name == "send") {
+    Request::send(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD);
+  } else if (name == "Isend") {
+    MPI_Request request = Request::isend(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD);
+    req_storage.add(request);
+  } else {
+    xbt_die("Don't know this action, %s", name.c_str());
   }
-};
 
-class SendAction : public ReplayAction<SendRecvParser> {
-private:
-  RequestStorage& req_storage;
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-public:
-  explicit SendAction(std::string name, RequestStorage& storage) : ReplayAction(name), req_storage(storage) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    int dst_traced = MPI_COMM_WORLD->group()->actor(args.partner)->get_pid();
+void RecvAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  int src_traced = MPI_COMM_WORLD->group()->actor(args.partner)->get_pid();
 
-    TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData(name, args.partner, args.size,
-                                                                             args.tag, Datatype::encode(args.datatype1)));
-    if (not TRACE_smpi_view_internals())
-      TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, args.tag, args.size * args.datatype1->size());
+  TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData(name, args.partner, args.size,
+        args.tag, Datatype::encode(args.datatype1)));
 
-    if (name == "send") {
-      Request::send(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD);
-    } else if (name == "Isend") {
-      MPI_Request request = Request::isend(nullptr, args.size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD);
-      req_storage.add(request);
-    } else {
-      xbt_die("Don't know this action, %s", name.c_str());
-    }
+  MPI_Status status;
+  // unknown size from the receiver point of view
+  if (args.size <= 0.0) {
+    Request::probe(args.partner, args.tag, MPI_COMM_WORLD, &status);
+    args.size = status.count;
+  }
 
-    TRACE_smpi_comm_out(my_proc_id);
+  if (name == "recv") {
+    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);
   }
-};
 
-class RecvAction : public ReplayAction<SendRecvParser> {
-private:
-  RequestStorage& req_storage;
+  TRACE_smpi_comm_out(my_proc_id);
+  // TODO: Check why this was only activated in the "recv" case and not in the "Irecv" case
+  if (name == "recv" && not TRACE_smpi_view_internals()) {
+    TRACE_smpi_recv(src_traced, my_proc_id, args.tag);
+  }
+}
 
-public:
-  explicit RecvAction(std::string name, RequestStorage& storage) : ReplayAction(name), req_storage(storage) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    int src_traced = MPI_COMM_WORLD->group()->actor(args.partner)->get_pid();
+void ComputeAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_computing_in(my_proc_id, args.flops);
+  smpi_execute_flops(args.flops);
+  TRACE_smpi_computing_out(my_proc_id);
+}
 
-    TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData(name, args.partner, args.size,
-                                                                             args.tag, Datatype::encode(args.datatype1)));
+void TestAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  MPI_Request request = req_storage.find(args.src, args.dst, args.tag);
+  req_storage.remove(request);
+  // 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 != MPI_REQUEST_NULL) {
+    TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("test"));
 
     MPI_Status status;
-    // unknown size from the receiver point of view
-    if (args.size <= 0.0) {
-      Request::probe(args.partner, args.tag, MPI_COMM_WORLD, &status);
-      args.size = status.count;
-    }
+    int flag = Request::test(&request, &status);
 
-    if (name == "recv") {
-      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);
+    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.*/
+    if (request == MPI_REQUEST_NULL)
+      req_storage.addNullRequest(args.src, args.dst, args.tag);
+    else
       req_storage.add(request);
-    }
 
     TRACE_smpi_comm_out(my_proc_id);
-    // TODO: Check why this was only activated in the "recv" case and not in the "Irecv" case
-    if (name == "recv" && not TRACE_smpi_view_internals()) {
-      TRACE_smpi_recv(src_traced, my_proc_id, args.tag);
-    }
-  }
-};
-
-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);
   }
-};
-
-class TestAction : public ReplayAction<WaitTestParser> {
-private:
-  RequestStorage& req_storage;
-
-public:
-  explicit TestAction(RequestStorage& storage) : ReplayAction("Test"), req_storage(storage) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    MPI_Request request = req_storage.find(args.src, args.dst, args.tag);
-    req_storage.remove(request);
-    // 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 != MPI_REQUEST_NULL) {
-      TRACE_smpi_testing_in(my_proc_id);
-
-      MPI_Status status;
-      int flag = Request::test(&request, &status);
-
-      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.*/
-      if (request == MPI_REQUEST_NULL)
-        req_storage.addNullRequest(args.src, args.dst, args.tag);
-      else
-        req_storage.add(request);
-
-      TRACE_smpi_testing_out(my_proc_id);
-    }
-  }
-};
+}
 
-class InitAction : public ReplayAction<ActionArgParser> {
-public:
-  InitAction() : ReplayAction("Init") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    CHECK_ACTION_PARAMS(action, 0, 1)
+void InitAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  CHECK_ACTION_PARAMS(action, 0, 1)
     MPI_DEFAULT_TYPE = (action.size() > 2) ? MPI_DOUBLE // default MPE datatype
-                                           : MPI_BYTE;  // default TAU datatype
+    : MPI_BYTE;  // default TAU datatype
 
-    /* start a simulated timer */
-    smpi_process()->simulated_start();
-  }
-};
-
-class CommunicatorAction : public ReplayAction<ActionArgParser> {
-public:
-  CommunicatorAction() : ReplayAction("Comm") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override { /* nothing to do */}
-};
+  /* start a simulated timer */
+  smpi_process()->simulated_start();
+}
 
-class WaitAllAction : public ReplayAction<ActionArgParser> {
-private:
-  RequestStorage& req_storage;
+void CommunicatorAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  /* nothing to do */
+}
 
-public:
-  explicit WaitAllAction(RequestStorage& storage) : ReplayAction("waitAll"), req_storage(storage) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    const unsigned int count_requests = req_storage.size();
-
-    if (count_requests > 0) {
-      TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData("waitAll", -1, count_requests, ""));
-      std::vector<std::pair</*sender*/int,/*recv*/int>> sender_receiver;
-      std::vector<MPI_Request> reqs;
-      req_storage.get_requests(reqs);
-      for (const auto& req : reqs) {
-        if (req && (req->flags() & RECV)) {
-          sender_receiver.push_back({req->src(), req->dst()});
-        }
-      }
-      MPI_Status status[count_requests];
-      Request::waitall(count_requests, &(reqs.data())[0], status);
-      req_storage.get_store().clear();
+void WaitAllAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  const unsigned int count_requests = req_storage.size();
 
-      for (auto& pair : sender_receiver) {
-        TRACE_smpi_recv(pair.first, pair.second, 0);
+  if (count_requests > 0) {
+    TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::Pt2PtTIData("waitall", -1, count_requests, ""));
+    std::vector<std::pair</*sender*/int,/*recv*/int>> sender_receiver;
+    std::vector<MPI_Request> reqs;
+    req_storage.get_requests(reqs);
+    for (const auto& req : reqs) {
+      if (req && (req->flags() & MPI_REQ_RECV)) {
+        sender_receiver.push_back({req->src(), req->dst()});
       }
-      TRACE_smpi_comm_out(my_proc_id);
     }
-  }
-};
+    MPI_Status status[count_requests];
+    Request::waitall(count_requests, &(reqs.data())[0], status);
+    req_storage.get_store().clear();
 
-class BarrierAction : public ReplayAction<ActionArgParser> {
-public:
-  BarrierAction() : ReplayAction("barrier") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("barrier"));
-    Colls::barrier(MPI_COMM_WORLD);
+    for (auto& pair : sender_receiver) {
+      TRACE_smpi_recv(pair.first, pair.second, 0);
+    }
     TRACE_smpi_comm_out(my_proc_id);
   }
-};
+}
 
-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)->get_pid(),
-                                                      -1.0, args.size, -1, Datatype::encode(args.datatype1), ""));
+void BarrierAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("barrier"));
+  Colls::barrier(MPI_COMM_WORLD);
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    Colls::bcast(send_buffer(args.size * args.datatype1->size()), args.size, args.datatype1, args.root, MPI_COMM_WORLD);
+void BcastAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, "action_bcast",
+      new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(),
+        -1.0, args.size, -1, Datatype::encode(args.datatype1), ""));
 
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  Colls::bcast(send_buffer(args.size * args.datatype1->size()), args.size, args.datatype1, args.root, MPI_COMM_WORLD);
 
-class ReduceAction : public ReplayAction<ReduceArgParser> {
-public:
-  ReduceAction() : ReplayAction("reduce") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, "action_reduce",
-                       new simgrid::instr::CollTIData("reduce", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(),
-                                                      args.comp_size, args.comm_size, -1,
-                                                      Datatype::encode(args.datatype1), ""));
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    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);
+void ReduceAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, "action_reduce",
+      new simgrid::instr::CollTIData("reduce", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(),
+        args.comp_size, args.comm_size, -1,
+        Datatype::encode(args.datatype1), ""));
 
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  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);
 
-class AllReduceAction : public ReplayAction<AllReduceArgParser> {
-public:
-  AllReduceAction() : ReplayAction("allReduce") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    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), ""));
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    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);
+void AllReduceAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  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), ""));
 
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  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);
 
-class AllToAllAction : public ReplayAction<AllToAllArgParser> {
-public:
-  AllToAllAction() : ReplayAction("allToAll") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, "action_allToAll",
-                     new simgrid::instr::CollTIData("allToAll", -1, -1.0, args.send_size, args.recv_size,
-                                                    Datatype::encode(args.datatype1),
-                                                    Datatype::encode(args.datatype2)));
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    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);
+void AllToAllAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, "action_allToAll",
+      new simgrid::instr::CollTIData("allToAll", -1, -1.0, args.send_size, args.recv_size,
+        Datatype::encode(args.datatype1),
+        Datatype::encode(args.datatype2)));
 
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  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);
 
-class GatherAction : public ReplayAction<GatherArgParser> {
-public:
-  explicit GatherAction(std::string name) : ReplayAction(name) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, name.c_str(), new simgrid::instr::CollTIData(name, (name == "gather") ? args.root : -1, -1.0, args.send_size, args.recv_size,
-                                                                          Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    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);
-    }
-    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);
+void GatherAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, name.c_str(), new simgrid::instr::CollTIData(name, (name == "gather") ? args.root : -1, -1.0, args.send_size, args.recv_size,
+        Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
 
-    TRACE_smpi_comm_out(my_proc_id);
+  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);
   }
-};
+  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);
 
-class GatherVAction : public ReplayAction<GatherVArgParser> {
-public:
-  explicit GatherVAction(std::string name) : ReplayAction(name) {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    int rank = MPI_COMM_WORLD->rank();
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    TRACE_smpi_comm_in(my_proc_id, name.c_str(), new simgrid::instr::VarCollTIData(
-                                               name, (name == "gatherV") ? args.root : -1, args.send_size, nullptr, -1, args.recvcounts,
-                                               Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
+void GatherVAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  int rank = MPI_COMM_WORLD->rank();
 
-    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);
-    }
-    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);
-    }
+  TRACE_smpi_comm_in(my_proc_id, name.c_str(), new simgrid::instr::VarCollTIData(
+        name, (name == "gatherV") ? args.root : -1, args.send_size, nullptr, -1, args.recvcounts,
+        Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
 
-    TRACE_smpi_comm_out(my_proc_id);
+  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);
+  }
+  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);
   }
-};
 
-class ScatterAction : public ReplayAction<ScatterArgParser> {
-public:
-  ScatterAction() : ReplayAction("scatter") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    int rank = MPI_COMM_WORLD->rank();
-    TRACE_smpi_comm_in(my_proc_id, "action_scatter", new simgrid::instr::CollTIData(name, args.root, -1.0, args.send_size, args.recv_size,
-                                                                          Datatype::encode(args.datatype1),
-                                                                          Datatype::encode(args.datatype2)));
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-    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);
+void ScatterAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  int rank = MPI_COMM_WORLD->rank();
+  TRACE_smpi_comm_in(my_proc_id, "action_scatter", new simgrid::instr::CollTIData(name, args.root, -1.0, args.send_size, args.recv_size,
+        Datatype::encode(args.datatype1),
+        Datatype::encode(args.datatype2)));
 
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  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);
+}
 
-class ScatterVAction : public ReplayAction<ScatterVArgParser> {
-public:
-  ScatterVAction() : ReplayAction("scatterV") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    int rank = MPI_COMM_WORLD->rank();
-    TRACE_smpi_comm_in(my_proc_id, "action_scatterv", new simgrid::instr::VarCollTIData(name, args.root, -1, args.sendcounts, args.recv_size,
-          nullptr, Datatype::encode(args.datatype1),
-          Datatype::encode(args.datatype2)));
+void ScatterVAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  int rank = MPI_COMM_WORLD->rank();
+  TRACE_smpi_comm_in(my_proc_id, "action_scatterv", new simgrid::instr::VarCollTIData(name, args.root, -1, args.sendcounts, args.recv_size,
+        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);
-  }
-};
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-class ReduceScatterAction : public ReplayAction<ReduceScatterArgParser> {
-public:
-  ReduceScatterAction() : ReplayAction("reduceScatter") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, "action_reducescatter",
-                       new simgrid::instr::VarCollTIData("reduceScatter", -1, 0, nullptr, -1, args.recvcounts,
-                                                         std::to_string(args.comp_size), /* ugly hack to print comp_size */
-                                                         Datatype::encode(args.datatype1)));
+void ReduceScatterAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, "action_reducescatter",
+      new simgrid::instr::VarCollTIData("reducescatter", -1, 0, nullptr, -1, args.recvcounts,
+        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);
-    TRACE_smpi_comm_out(my_proc_id);
-  }
-};
+  smpi_execute_flops(args.comp_size);
+  TRACE_smpi_comm_out(my_proc_id);
+}
 
-class AllToAllVAction : public ReplayAction<AllToAllVArgParser> {
-public:
-  AllToAllVAction() : ReplayAction("allToAllV") {}
-  void kernel(simgrid::xbt::ReplayAction& action) override
-  {
-    TRACE_smpi_comm_in(my_proc_id, __func__,
-                       new simgrid::instr::VarCollTIData(
-                           "allToAllV", -1, args.send_size_sum, args.sendcounts, args.recv_size_sum, args.recvcounts,
-                           Datatype::encode(args.datatype1), Datatype::encode(args.datatype2)));
+void AllToAllVAction::kernel(simgrid::xbt::ReplayAction& action)
+{
+  TRACE_smpi_comm_in(my_proc_id, __func__,
+      new simgrid::instr::VarCollTIData(
+        "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);
-  }
-};
+  TRACE_smpi_comm_out(my_proc_id);
+}
 } // Replay Namespace
 }} // namespace simgrid::smpi
 
-std::vector<simgrid::smpi::replay::RequestStorage> storage;
+static std::vector<simgrid::smpi::replay::RequestStorage> storage;
 /** @brief Only initialize the replay, don't do it for real */
 void smpi_replay_init(int* argc, char*** argv)
 {
@@ -962,20 +723,20 @@ void smpi_replay_init(int* argc, char*** argv)
   xbt_replay_action_register("Irecv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::RecvAction("Irecv", storage[simgrid::s4u::this_actor::get_pid()-1]).execute(action); });
   xbt_replay_action_register("test",  [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::TestAction(storage[simgrid::s4u::this_actor::get_pid()-1]).execute(action); });
   xbt_replay_action_register("wait",  [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::WaitAction(storage[simgrid::s4u::this_actor::get_pid()-1]).execute(action); });
-  xbt_replay_action_register("waitAll", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::WaitAllAction(storage[simgrid::s4u::this_actor::get_pid()-1]).execute(action); });
+  xbt_replay_action_register("waitall", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::WaitAllAction(storage[simgrid::s4u::this_actor::get_pid()-1]).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::xbt::ReplayAction& action) { simgrid::smpi::replay::ReduceAction().execute(action); });
-  xbt_replay_action_register("allReduce", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::AllReduceAction().execute(action); });
+  xbt_replay_action_register("allreduce", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::AllReduceAction().execute(action); });
   xbt_replay_action_register("allToAll", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::AllToAllAction().execute(action); });
   xbt_replay_action_register("allToAllV", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::AllToAllVAction().execute(action); });
   xbt_replay_action_register("gather",   [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::GatherAction("gather").execute(action); });
   xbt_replay_action_register("scatter",  [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::ScatterAction().execute(action); });
   xbt_replay_action_register("gatherV",  [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::GatherVAction("gatherV").execute(action); });
-  xbt_replay_action_register("scatterV", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::ScatterVAction().execute(action); });
+  xbt_replay_action_register("scatterv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::ScatterVAction().execute(action); });
   xbt_replay_action_register("allGather", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::GatherAction("allGather").execute(action); });
-  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("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); });
 
   //if we have a delayed start, sleep here.