X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/56651d7c6d0cc1c2108ca0d8de7e34462acd0514..3df0b777791a70f16276ccecdb0ad5f2b524f65f:/src/instr/instr_platform.cpp

diff --git a/src/instr/instr_platform.cpp b/src/instr/instr_platform.cpp
index b2d214c92a..81e64bb7d9 100644
--- a/src/instr/instr_platform.cpp
+++ b/src/instr/instr_platform.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2020. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2010-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. */
@@ -29,34 +29,29 @@ std::string instr_pid(simgrid::s4u::Actor const& proc)
   return std::string(proc.get_name()) + "-" + std::to_string(proc.get_pid());
 }
 
-static container_t lowestCommonAncestor(const simgrid::instr::Container* a1, const simgrid::instr::Container* a2)
+static simgrid::instr::Container* lowestCommonAncestor(const simgrid::instr::Container* a1,
+                                                       const simgrid::instr::Container* a2)
 {
   // this is only an optimization (since most of a1 and a2 share the same parent)
-  if (a1->father_ == a2->father_)
-    return a1->father_;
+  if (a1->get_parent() == a2->get_parent())
+    return a1->get_parent();
 
   // create an array with all ancestors of a1
-  std::vector<container_t> ancestors_a1;
-  container_t p = a1->father_;
-  while (p) {
+  std::vector<simgrid::instr::Container*> ancestors_a1;
+  for (auto* p = a1->get_parent(); p != nullptr; p = p->get_parent())
     ancestors_a1.push_back(p);
-    p = p->father_;
-  }
 
   // create an array with all ancestors of a2
-  std::vector<container_t> ancestors_a2;
-  p = a2->father_;
-  while (p) {
+  std::vector<simgrid::instr::Container*> ancestors_a2;
+  for (auto* p = a2->get_parent(); p != nullptr; p = p->get_parent())
     ancestors_a2.push_back(p);
-    p = p->father_;
-  }
 
   // find the lowest ancestor
-  p     = nullptr;
-  int i = ancestors_a1.size() - 1;
-  int j = ancestors_a2.size() - 1;
+  simgrid::instr::Container* p = nullptr;
+  int i = static_cast<int>(ancestors_a1.size()) - 1;
+  int j = static_cast<int>(ancestors_a2.size()) - 1;
   while (i >= 0 && j >= 0) {
-    container_t a1p = ancestors_a1.at(i);
+    simgrid::instr::Container* a1p       = ancestors_a1.at(i);
     const simgrid::instr::Container* a2p = ancestors_a2.at(j);
     if (a1p == a2p) {
       p = a1p;
@@ -69,7 +64,8 @@ static container_t lowestCommonAncestor(const simgrid::instr::Container* a1, con
   return p;
 }
 
-static void linkContainers(container_t src, container_t dst, std::set<std::string>* filter)
+static void linkContainers(simgrid::instr::Container* src, simgrid::instr::Container* dst,
+                           std::set<std::string, std::less<>>* filter)
 {
   // ignore loopback
   if (src->get_name() == "__loopback__" || dst->get_name() == "__loopback__") {
@@ -77,11 +73,9 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
     return;
   }
 
-  // find common father
-  container_t father = lowestCommonAncestor(src, dst);
-  if (not father) {
-    xbt_die("common father unknown, this is a tracing problem");
-  }
+  // find common parent
+  simgrid::instr::Container* parent = lowestCommonAncestor(src, dst);
+  xbt_assert(parent, "common parent unknown, this is a tracing problem");
 
   // check if we already register this pair (we only need one direction)
   std::string aux1 = src->get_name() + dst->get_name();
@@ -100,11 +94,12 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
   filter->insert(aux2);
 
   // declare type
-  std::string link_typename = father->type_->get_name() + "-" + src->type_->get_name() +
-                              std::to_string(src->type_->get_id()) + "-" + dst->type_->get_name() +
-                              std::to_string(dst->type_->get_id());
-  simgrid::instr::LinkType* link = father->type_->by_name_or_create(link_typename, src->type_, dst->type_);
-  link->set_calling_container(father);
+  std::string link_typename = parent->get_type()->get_name() + "-" + src->get_type()->get_name() +
+                              std::to_string(src->get_type()->get_id()) + "-" + dst->get_type()->get_name() +
+                              std::to_string(dst->get_type()->get_id());
+  simgrid::instr::LinkType* link =
+      parent->get_type()->by_name_or_create(link_typename, src->get_type(), dst->get_type());
+  link->set_calling_container(parent);
 
   // create the link
   static long long counter = 0;
@@ -118,34 +113,31 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
   XBT_DEBUG("  linkContainers %s <-> %s", src->get_cname(), dst->get_cname());
 }
 
-static void recursiveGraphExtraction(const simgrid::s4u::NetZone* netzone, container_t container,
-                                     std::set<std::string>* filter)
+static void recursiveGraphExtraction(const simgrid::s4u::NetZone* netzone, const simgrid::instr::Container* container,
+                                     std::set<std::string, std::less<>>* filter)
 {
   if (not TRACE_platform_topology()) {
     XBT_DEBUG("Graph extraction disabled by user.");
     return;
   }
   XBT_DEBUG("Graph extraction for NetZone = %s", netzone->get_cname());
-  if (not netzone->get_children().empty()) {
-    // bottom-up recursion
-    for (auto const& nz_son : netzone->get_children()) {
-      container_t child_container = container->children_.at(nz_son->get_name());
-      recursiveGraphExtraction(nz_son, child_container, filter);
-    }
+
+  // bottom-up recursion
+  for (auto const& nz_son : netzone->get_children()) {
+    const simgrid::instr::Container* child_container = container->get_child_by_name(nz_son->get_name());
+    recursiveGraphExtraction(nz_son, child_container, filter);
   }
 
-  xbt_graph_t graph                        = xbt_graph_new_graph(0, nullptr);
-  std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>();
-  std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>();
+  auto* graph = xbt_graph_new_graph(0, nullptr);
+  std::map<std::string, xbt_node_t, std::less<>> nodes;
+  std::map<std::string, xbt_edge_t, std::less<>> edges;
 
-  netzone->get_impl()->get_graph(graph, nodes, edges);
-  for (auto elm : *edges) {
+  netzone->get_impl()->get_graph(graph, &nodes, &edges);
+  for (auto const& elm : edges) {
     const xbt_edge* edge = elm.second;
     linkContainers(simgrid::instr::Container::by_name(static_cast<const char*>(edge->src->data)),
                    simgrid::instr::Container::by_name(static_cast<const char*>(edge->dst->data)), filter);
   }
-  delete nodes;
-  delete edges;
   xbt_graph_free_graph(graph, xbt_free_f, xbt_free_f, nullptr);
 }
 
@@ -168,38 +160,38 @@ static void recursiveNewVariableType(const std::string& new_typename, const std:
 
 void instr_new_variable_type(const std::string& new_typename, const std::string& color)
 {
-  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::get_root()->type_);
+  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::get_root()->get_type());
 }
 
-static void recursiveNewUserVariableType(const std::string& father_type, const std::string& new_typename,
+static void recursiveNewUserVariableType(const std::string& parent_type, const std::string& new_typename,
                                          const std::string& color, simgrid::instr::Type* root)
 {
-  if (root->get_name() == father_type) {
+  if (root->get_name() == parent_type) {
     root->by_name_or_create(new_typename, color);
   }
   for (auto const& elm : root->get_children())
-    recursiveNewUserVariableType(father_type, new_typename, color, elm.second.get());
+    recursiveNewUserVariableType(parent_type, new_typename, color, elm.second.get());
 }
 
-void instr_new_user_variable_type(const std::string& father_type, const std::string& new_typename,
+void instr_new_user_variable_type(const std::string& parent_type, const std::string& new_typename,
                                   const std::string& color)
 {
-  recursiveNewUserVariableType(father_type, new_typename, color, simgrid::instr::Container::get_root()->type_);
+  recursiveNewUserVariableType(parent_type, new_typename, color, simgrid::instr::Container::get_root()->get_type());
 }
 
-static void recursiveNewUserStateType(const std::string& father_type, const std::string& new_typename,
+static void recursiveNewUserStateType(const std::string& parent_type, const std::string& new_typename,
                                       simgrid::instr::Type* root)
 {
-  if (root->get_name() == father_type)
+  if (root->get_name() == parent_type)
     root->by_name_or_create<simgrid::instr::StateType>(new_typename);
 
   for (auto const& elm : root->get_children())
-    recursiveNewUserStateType(father_type, new_typename, elm.second.get());
+    recursiveNewUserStateType(parent_type, new_typename, elm.second.get());
 }
 
-void instr_new_user_state_type(const std::string& father_type, const std::string& new_typename)
+void instr_new_user_state_type(const std::string& parent_type, const std::string& new_typename)
 {
-  recursiveNewUserStateType(father_type, new_typename, simgrid::instr::Container::get_root()->type_);
+  recursiveNewUserStateType(parent_type, new_typename, simgrid::instr::Container::get_root()->get_type());
 }
 
 static void recursiveNewValueForUserStateType(const std::string& type_name, const char* val, const std::string& color,
@@ -214,7 +206,7 @@ static void recursiveNewValueForUserStateType(const std::string& type_name, cons
 
 void instr_new_value_for_user_state_type(const std::string& type_name, const char* value, const std::string& color)
 {
-  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::get_root()->type_);
+  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::get_root()->get_type());
 }
 
 namespace simgrid {
@@ -222,10 +214,10 @@ namespace instr {
 
 void platform_graph_export_graphviz(const std::string& output_filename)
 {
-  xbt_graph_t g                            = xbt_graph_new_graph(0, nullptr);
-  std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>();
-  std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>();
-  s4u::Engine::get_instance()->get_netzone_root()->extract_xbt_graph(g, nodes, edges);
+  auto* g     = xbt_graph_new_graph(0, nullptr);
+  std::map<std::string, xbt_node_t, std::less<>> nodes;
+  std::map<std::string, xbt_edge_t, std::less<>> edges;
+  s4u::Engine::get_instance()->get_netzone_root()->extract_xbt_graph(g, &nodes, &edges);
 
   std::ofstream fs;
   fs.open(output_filename, std::ofstream::out);
@@ -241,10 +233,10 @@ void platform_graph_export_graphviz(const std::string& output_filename)
   fs << "  node [shape=box, style=filled]" << std::endl;
   fs << "  node [width=.3, height=.3, style=filled, color=skyblue]" << std::endl << std::endl;
 
-  for (auto const& elm : *nodes)
+  for (auto const& elm : nodes)
     fs << "  \"" << elm.first << "\";" << std::endl;
 
-  for (auto const& elm : *edges) {
+  for (auto const& elm : edges) {
     const char* src_s = static_cast<char*>(elm.second->src->data);
     const char* dst_s = static_cast<char*>(elm.second->dst->data);
     if (g->directed)
@@ -256,8 +248,6 @@ void platform_graph_export_graphviz(const std::string& output_filename)
   fs.close();
 
   xbt_graph_free_graph(g, xbt_free_f, xbt_free_f, nullptr);
-  delete nodes;
-  delete edges;
 }
 
 /* Callbacks */
@@ -266,16 +256,15 @@ static void on_netzone_creation(s4u::NetZone const& netzone)
 {
   std::string id = netzone.get_name();
   if (Container::get_root() == nullptr) {
-    NetZoneContainer* root = new NetZoneContainer(id, 0, nullptr);
+    auto* root = new NetZoneContainer(id, 0, nullptr);
     xbt_assert(Container::get_root() == root);
 
     if (TRACE_smpi_is_enabled()) {
-      ContainerType* mpi = root->type_->by_name_or_create<ContainerType>("MPI");
+      auto* mpi = root->get_type()->by_name_or_create<ContainerType>("MPI");
       if (not TRACE_smpi_is_grouped())
         mpi->by_name_or_create<StateType>("MPI_STATE");
-      root->type_->by_name_or_create("MPI_LINK", mpi, mpi);
-      // TODO See if we can move this to the LoadBalancer plugin
-      root->type_->by_name_or_create("MIGRATE_LINK", mpi, mpi);
+      root->get_type()->by_name_or_create("MPI_LINK", mpi, mpi);
+      root->get_type()->by_name_or_create("MIGRATE_LINK", mpi, mpi);
       mpi->by_name_or_create<StateType>("MIGRATE_STATE");
     }
 
@@ -286,7 +275,8 @@ static void on_netzone_creation(s4u::NetZone const& netzone)
   }
 
   if (TRACE_needs_platform()) {
-    NetZoneContainer* container = new NetZoneContainer(id, currentContainer.size(), currentContainer.back());
+    auto level      = static_cast<unsigned>(currentContainer.size());
+    auto* container = new NetZoneContainer(id, level, currentContainer.back());
     currentContainer.push_back(container);
   }
 }
@@ -296,45 +286,47 @@ static void on_link_creation(s4u::Link const& link)
   if (currentContainer.empty()) // No ongoing parsing. Are you creating the loopback?
     return;
 
-  Container* container = new Container(link.get_name(), "LINK", currentContainer.back());
+  auto* container = new Container(link.get_name(), "LINK", currentContainer.back());
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
-    VariableType* bandwidth = container->type_->by_name_or_create("bandwidth", "");
+    VariableType* bandwidth = container->get_type()->by_name_or_create("bandwidth", "");
     bandwidth->set_calling_container(container);
     bandwidth->set_event(0, link.get_bandwidth());
-    VariableType* latency = container->type_->by_name_or_create("latency", "");
+    VariableType* latency = container->get_type()->by_name_or_create("latency", "");
     latency->set_calling_container(container);
     latency->set_event(0, link.get_latency());
   }
 
   if (TRACE_uncategorized()) {
-    container->type_->by_name_or_create("bandwidth_used", "0.5 0.5 0.5");
+    container->get_type()->by_name_or_create("bandwidth_used", "0.5 0.5 0.5");
   }
 }
 
 static void on_host_creation(s4u::Host const& host)
 {
+  if (Container::by_name_or_null(host.get_name())) // This host already exists, do nothing
+    return;
+
   Container* container  = new HostContainer(host, currentContainer.back());
   const Container* root = Container::get_root();
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
-    VariableType* speed = container->type_->by_name_or_create("speed", "");
+    VariableType* speed = container->get_type()->by_name_or_create("speed", "");
     speed->set_calling_container(container);
     speed->set_event(0, host.get_speed());
 
-    VariableType* cores = container->type_->by_name_or_create("core_count", "");
+    VariableType* cores = container->get_type()->by_name_or_create("core_count", "");
     cores->set_calling_container(container);
     cores->set_event(0, host.get_core_count());
   }
 
   if (TRACE_uncategorized())
-    container->type_->by_name_or_create("speed_used", "0.5 0.5 0.5");
+    container->get_type()->by_name_or_create("speed_used", "0.5 0.5 0.5");
 
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()) {
-    ContainerType* mpi = container->type_->by_name_or_create<ContainerType>("MPI");
+    auto* mpi = container->get_type()->by_name_or_create<ContainerType>("MPI");
     mpi->by_name_or_create<StateType>("MPI_STATE");
-    // TODO See if we can move this to the LoadBalancer plugin
-    root->type_->by_name_or_create("MIGRATE_LINK", mpi, mpi);
+    root->get_type()->by_name_or_create("MIGRATE_LINK", mpi, mpi);
     mpi->by_name_or_create<StateType>("MIGRATE_STATE");
   }
 }
@@ -342,34 +334,33 @@ static void on_host_creation(s4u::Host const& host)
 static void on_action_state_change(kernel::resource::Action const& action,
                                    kernel::resource::Action::State /* previous */)
 {
-  int n = action.get_variable()->get_number_of_constraint();
+  auto n = static_cast<unsigned>(action.get_variable()->get_number_of_constraint());
 
-  for (int i = 0; i < n; i++) {
-    double value = action.get_variable()->get_value() * action.get_variable()->get_constraint_weight(i);
+  for (unsigned i = 0; i < n; i++) {
+    double value = action.get_rate() * action.get_variable()->get_constraint_weight(i);
     /* Beware of composite actions: ptasks put links and cpus together. Extra pb: we cannot dynamic_cast from void* */
     kernel::resource::Resource* resource = action.get_variable()->get_constraint(i)->get_id();
-    const kernel::resource::Cpu* cpu     = dynamic_cast<kernel::resource::Cpu*>(resource);
+    const kernel::resource::CpuImpl* cpu = dynamic_cast<kernel::resource::CpuImpl*>(resource);
 
     if (cpu != nullptr)
       resource_set_utilization("HOST", "speed_used", cpu->get_cname(), action.get_category(), value,
-                               action.get_last_update(), SIMIX_get_clock() - action.get_last_update());
+                               action.get_last_update(), simgrid_get_clock() - action.get_last_update());
 
     const kernel::resource::LinkImpl* link = dynamic_cast<kernel::resource::LinkImpl*>(resource);
 
     if (link != nullptr)
       resource_set_utilization("LINK", "bandwidth_used", link->get_cname(), action.get_category(), value,
-                               action.get_last_update(), SIMIX_get_clock() - action.get_last_update());
+                               action.get_last_update(), simgrid_get_clock() - action.get_last_update());
   }
 }
 
 static void on_platform_created()
 {
   currentContainer.clear();
-  std::set<std::string>* filter = new std::set<std::string>();
+  std::set<std::string, std::less<>> filter;
   XBT_DEBUG("Starting graph extraction.");
-  recursiveGraphExtraction(s4u::Engine::get_instance()->get_netzone_root(), Container::get_root(), filter);
+  recursiveGraphExtraction(s4u::Engine::get_instance()->get_netzone_root(), Container::get_root(), &filter);
   XBT_DEBUG("Graph extraction finished.");
-  delete filter;
   dump_buffer(true);
 }
 
@@ -380,14 +371,14 @@ static void on_actor_creation(s4u::Actor const& actor)
   std::string container_name = instr_pid(actor);
 
   container->create_child(container_name, "ACTOR");
-  ContainerType* actor_type = container->type_->by_name_or_create<ContainerType>("ACTOR");
-  StateType* state          = actor_type->by_name_or_create<StateType>("ACTOR_STATE");
+  auto* actor_type = container->get_type()->by_name_or_create<ContainerType>("ACTOR");
+  auto* state      = actor_type->by_name_or_create<StateType>("ACTOR_STATE");
   state->add_entity_value("suspend", "1 0 1");
   state->add_entity_value("sleep", "1 1 0");
   state->add_entity_value("receive", "1 0 0");
   state->add_entity_value("send", "0 0 1");
   state->add_entity_value("execute", "0 1 1");
-  root->type_->by_name_or_create("ACTOR_LINK", actor_type, actor_type);
+  root->get_type()->by_name_or_create("ACTOR_LINK", actor_type, actor_type);
 
   actor.on_exit([container_name](bool failed) {
     if (failed)
@@ -399,7 +390,7 @@ static void on_actor_creation(s4u::Actor const& actor)
 static void on_actor_host_change(s4u::Actor const& actor, s4u::Host const& /*previous_location*/)
 {
   static long long int counter = 0;
-  container_t container        = Container::by_name(instr_pid(actor));
+  Container* container         = Container::by_name(instr_pid(actor));
   LinkType* link               = Container::get_root()->get_link("ACTOR_LINK");
 
   // start link
@@ -417,15 +408,15 @@ static void on_vm_creation(s4u::Host const& host)
 {
   const Container* container = new HostContainer(host, currentContainer.back());
   const Container* root      = Container::get_root();
-  ContainerType* vm          = container->type_->by_name_or_create<ContainerType>("VM");
-  StateType* state           = vm->by_name_or_create<StateType>("VM_STATE");
+  auto* vm                   = container->get_type()->by_name_or_create<ContainerType>("VM");
+  auto* state                = vm->by_name_or_create<StateType>("VM_STATE");
   state->add_entity_value("suspend", "1 0 1");
   state->add_entity_value("sleep", "1 1 0");
   state->add_entity_value("receive", "1 0 0");
   state->add_entity_value("send", "0 0 1");
   state->add_entity_value("execute", "0 1 1");
-  root->type_->by_name_or_create("VM_LINK", vm, vm);
-  root->type_->by_name_or_create("VM_ACTOR_LINK", vm, vm);
+  root->get_type()->by_name_or_create("VM_LINK", vm, vm);
+  root->get_type()->by_name_or_create("VM_ACTOR_LINK", vm, vm);
 }
 
 void define_callbacks()
@@ -475,31 +466,33 @@ void define_callbacks()
     });
     s4u::Actor::on_wake_up.connect(
         [](s4u::Actor const& actor) { Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event(); });
-    s4u::Exec::on_start.connect([](simgrid::s4u::Actor const& actor, s4u::Exec const&) {
-      Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("execute");
+    s4u::Exec::on_start.connect([](s4u::Exec const&) {
+      Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->push_event("execute");
     });
-    s4u::Exec::on_completion.connect([](s4u::Actor const& actor, s4u::Exec const&) {
-      Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
+    s4u::Exec::on_completion.connect([](s4u::Exec const&) {
+      Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->pop_event();
     });
-    s4u::Comm::on_sender_start.connect([](s4u::Actor const& actor) {
-      Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("send");
+    s4u::Comm::on_start.connect([](s4u::Comm const&, bool is_sender) {
+      Container::by_name(instr_pid(*s4u::Actor::self()))
+          ->get_state("ACTOR_STATE")
+          ->push_event(is_sender ? "send" : "receive");
     });
-    s4u::Comm::on_receiver_start.connect([](s4u::Actor const& actor) {
-      Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("receive");
+    s4u::Comm::on_completion.connect([](s4u::Comm const&) {
+      Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->pop_event();
     });
-    s4u::Comm::on_completion.connect(
-        [](s4u::Actor const& actor) { Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event(); });
     s4u::Actor::on_host_change.connect(on_actor_host_change);
   }
 
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing()) {
-    s4u::Exec::on_start.connect([](simgrid::s4u::Actor const& actor, s4u::Exec const& exec) {
-      Container::by_name(std::string("rank-") + std::to_string(actor.get_pid()))
+    s4u::Exec::on_start.connect([](s4u::Exec const& exec) {
+      Container::by_name(std::string("rank-") + std::to_string(s4u::Actor::self()->get_pid()))
           ->get_state("MPI_STATE")
           ->push_event("computing", new CpuTIData("compute", exec.get_cost()));
     });
-    s4u::Exec::on_completion.connect([](s4u::Actor const& actor, s4u::Exec const&) {
-      Container::by_name(std::string("rank-") + std::to_string(actor.get_pid()))->get_state("MPI_STATE")->pop_event();
+    s4u::Exec::on_completion.connect([](s4u::Exec const&) {
+      Container::by_name(std::string("rank-") + std::to_string(s4u::Actor::self()->get_pid()))
+          ->get_state("MPI_STATE")
+          ->pop_event();
     });
   }