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

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index 10bb834385..dfec134f00 100644
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2020. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2009-2021. The SimGrid Team. All rights reserved.          */
 
 /* 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. */
@@ -9,7 +9,7 @@
 #include "smpi_group.hpp"
 #include "smpi_request.hpp"
 #include "xbt/replay.hpp"
-#include <simgrid/smpi/replay.hpp>
+#include <simgrid/smpi/smpi_replay.hpp>
 #include <src/smpi/include/private.hpp>
 
 #include <memory>
@@ -61,8 +61,8 @@ public:
 };
 }
 
-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;
+using req_key_t     = std::tuple</*sender*/ int, /* receiver */ int, /* tag */ int>;
+using req_storage_t = std::unordered_map<req_key_t, MPI_Request, hash_tuple::hash<std::tuple<int, int, int>>>;
 
 void log_timed_action(const simgrid::xbt::ReplayAction& action, double clock)
 {
@@ -89,29 +89,26 @@ private:
     req_storage_t store;
 
 public:
-    RequestStorage() {}
-    int size() const { return store.size(); }
+  RequestStorage() = default;
+  int size() const { return store.size(); }
 
-    req_storage_t& get_store()
-    {
-      return store;
-    }
+  req_storage_t& get_store() { return store; }
 
-    void get_requests(std::vector<MPI_Request>& vec) const
-    {
-      for (auto const& pair : store) {
-        auto& req = pair.second;
-        auto my_proc_id = simgrid::s4u::this_actor::get_pid();
-        if (req != MPI_REQUEST_NULL && (req->src() == my_proc_id || req->dst() == my_proc_id)) {
-          vec.push_back(pair.second);
-          pair.second->print_request("MM");
-        }
+  void get_requests(std::vector<MPI_Request>& vec) const
+  {
+    for (auto const& pair : store) {
+      auto& req       = pair.second;
+      auto my_proc_id = simgrid::s4u::this_actor::get_pid();
+      if (req != MPI_REQUEST_NULL && (req->src() == my_proc_id || req->dst() == my_proc_id)) {
+        vec.push_back(pair.second);
+        pair.second->print_request("MM");
       }
     }
+  }
 
     MPI_Request find(int src, int dst, int tag)
     {
-      req_storage_t::iterator it = store.find(req_key_t(src, dst, tag));
+      auto it = store.find(req_key_t(src, dst, tag));
       return (it == store.end()) ? MPI_REQUEST_NULL : it->second;
     }
 
@@ -131,10 +128,9 @@ public:
     /* Sometimes we need to re-insert MPI_REQUEST_NULL but we still need src,dst and tag */
     void addNullRequest(int src, int dst, int tag)
     {
-      store.insert({req_key_t(
-            MPI_COMM_WORLD->group()->actor(src)->get_pid()-1,
-            MPI_COMM_WORLD->group()->actor(dst)->get_pid()-1,
-            tag), MPI_REQUEST_NULL});
+      store.insert(
+          {req_key_t(MPI_COMM_WORLD->group()->actor_pid(src) - 1, MPI_COMM_WORLD->group()->actor_pid(dst) - 1, tag),
+           MPI_REQUEST_NULL});
     }
 };
 
@@ -413,7 +409,7 @@ void WaitAction::kernel(simgrid::xbt::ReplayAction& action)
   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
+    /* Assume that the trace is well formed, meaning the comm might have been caught by an MPI_test. Then just
      * return.*/
     return;
   }
@@ -437,7 +433,7 @@ void WaitAction::kernel(simgrid::xbt::ReplayAction& action)
 void SendAction::kernel(simgrid::xbt::ReplayAction&)
 {
   const SendRecvParser& args = get_args();
-  int dst_traced = MPI_COMM_WORLD->group()->actor(args.partner)->get_pid();
+  int dst_traced             = MPI_COMM_WORLD->group()->actor_pid(args.partner);
 
   TRACE_smpi_comm_in(
       get_pid(), __func__,
@@ -485,7 +481,7 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
 
   TRACE_smpi_comm_out(get_pid());
   if (is_recv && not TRACE_smpi_view_internals()) {
-    int src_traced = MPI_COMM_WORLD->group()->actor(status.MPI_SOURCE)->get_pid();
+    int src_traced = MPI_COMM_WORLD->group()->actor_pid(status.MPI_SOURCE);
     TRACE_smpi_recv(src_traced, get_pid(), args.tag);
   }
 }
@@ -567,7 +563,7 @@ void WaitAllAction::kernel(simgrid::xbt::ReplayAction&)
     req_storage.get_requests(reqs);
     for (auto const& req : reqs) {
       if (req && (req->flags() & MPI_REQ_RECV)) {
-        sender_receiver.push_back({req->src(), req->dst()});
+        sender_receiver.emplace_back(req->src(), req->dst());
       }
     }
     Request::waitall(count_requests, &(reqs.data())[0], MPI_STATUSES_IGNORE);
@@ -591,7 +587,7 @@ void BcastAction::kernel(simgrid::xbt::ReplayAction&)
 {
   const BcastArgParser& args = get_args();
   TRACE_smpi_comm_in(get_pid(), "action_bcast",
-                     new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(), -1.0,
+                     new simgrid::instr::CollTIData("bcast", MPI_COMM_WORLD->group()->actor_pid(args.root), -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);
@@ -603,7 +599,7 @@ void ReduceAction::kernel(simgrid::xbt::ReplayAction&)
 {
   const ReduceArgParser& args = get_args();
   TRACE_smpi_comm_in(get_pid(), "action_reduce",
-                     new simgrid::instr::CollTIData("reduce", MPI_COMM_WORLD->group()->actor(args.root)->get_pid(),
+                     new simgrid::instr::CollTIData("reduce", MPI_COMM_WORLD->group()->actor_pid(args.root),
                                                     args.comp_size, args.comm_size, -1,
                                                     Datatype::encode(args.datatype1), ""));
 
@@ -811,28 +807,27 @@ void smpi_replay_init(const char* instance_id, int rank, double start_delay_flop
 }
 
 /** @brief actually run the replay after initialization */
-void smpi_replay_main(int rank, const char* trace_filename)
+void smpi_replay_main(int rank, const char* private_trace_filename)
 {
   static int active_processes = 0;
   active_processes++;
   storage[simgrid::s4u::this_actor::get_pid()] = simgrid::smpi::replay::RequestStorage();
   std::string rank_string                      = std::to_string(rank);
-  simgrid::xbt::replay_runner(rank_string.c_str(), trace_filename);
+  simgrid::xbt::replay_runner(rank_string.c_str(), private_trace_filename);
 
   /* and now, finalize everything */
   /* One active process will stop. Decrease the counter*/
   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) {
-    auto* requests = new MPI_Request[count_requests];
+    std::vector<MPI_Request> requests(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, MPI_STATUSES_IGNORE);
-    delete[] requests;
+    simgrid::smpi::Request::waitall(count_requests, requests.data(), MPI_STATUSES_IGNORE);
   }
   active_processes--;
 
@@ -851,8 +846,8 @@ void smpi_replay_main(int rank, const char* trace_filename)
 }
 
 /** @brief chain a replay initialization and a replay start */
-void smpi_replay_run(const char* instance_id, int rank, double start_delay_flops, const char* trace_filename)
+void smpi_replay_run(const char* instance_id, int rank, double start_delay_flops, const char* private_trace_filename)
 {
   smpi_replay_init(instance_id, rank, start_delay_flops);
-  smpi_replay_main(rank, trace_filename);
+  smpi_replay_main(rank, private_trace_filename);
 }