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 b901e96..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)
@@ -165,6 +165,19 @@ void ComputeParser::parse(simgrid::xbt::ReplayAction& action, const std::string&
   flops = parse_double(action[2]);
 }
 
+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)
@@ -260,13 +273,12 @@ void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::stri
     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, const std::stri
                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]);
     }
@@ -477,7 +489,23 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
 
 void ComputeAction::kernel(simgrid::xbt::ReplayAction&)
 {
-  smpi_execute_flops(args.flops);
+  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&)
@@ -535,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) {
@@ -549,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);
 }
 
@@ -559,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);
 }
@@ -571,8 +598,9 @@ 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);
+  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);
@@ -583,8 +611,9 @@ 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);
+  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);
@@ -597,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);
 }
@@ -611,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);
 }
@@ -630,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);
@@ -650,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);
 }
@@ -663,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);
 }
@@ -678,9 +710,9 @@ 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);
 
   private_execute_flops(args.comp_size);
   TRACE_smpi_comm_out(my_proc_id);
@@ -693,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);
 }
@@ -746,6 +779,8 @@ 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) {
@@ -771,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--;