From: Martin Quinson <martin.quinson@ens-rennes.fr>
Date: Mon, 4 Mar 2019 23:38:28 +0000 (+0100)
Subject: Sanitize the prototype of Actor::on_exit() callbacks
X-Git-Tag: v3_22~180^2~2
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/08e94eb0482589e4b287cbea301b84daf52635bd

Sanitize the prototype of Actor::on_exit() callbacks

Changes on_exit(function<void(int failed, void*data)>, data)
into    on_exit(function<void(bool failed)>)

So, we are using bool for boolean values, and we don't force the user
to build a closure on void* data manually. If you want to pass a data
to the callback, just use the C++ formalism: [data](bool failed){...}

Other changes on the way (that excalated quickly)
- Document some recent changes to the internals in ChangeLog
- Document this_actor::on_exit() and Actor::on_exit() in doxygen
- Also sanitize the prototype of MSG_process_on_exit(). Was taking a
  (void*,void*) function; now takes a (int, void*) one. This was too
  weird to use void* to denote integers -- I actually doubt it ever
  worked the way it was written, but the tests are too poor to be
  sure: the only usage of this function ignores the return value.
- Also add a new test in activity-lifetime: test_sleep_restart_end
  Commented for now as it breaks miserably.
---

diff --git a/ChangeLog b/ChangeLog
index dadeec766e..28d9dd1594 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -19,6 +19,9 @@ MSG:
  - Hide the examples into examples/deprecated. New users should use S4U.
  - MSG_process_create and MSG_process_attach now crash if the host used
    to run this process is off.
+ - Fix the protype of MSG_process_on_exit()
+   Now use (int,void*) callbacks instead of (void*,void*) ones.
+   The implementation was ways too messy to actually work, I guess.
 
 XBT:
  - Drop sg_cmdline. Please use xbt_cmdline instead.
@@ -38,6 +41,10 @@ XML
  - In <host> and <peer>, availability_file is now speed_file.
    XML file version remains 4.2 since old files are still compatible.
 
+Internal:
+ - Many cleanups in the kernel::activity namespace. This was long
+   overdue, and shall open the path to many future endeavors.
+
 Fixed bugs:
  - #132: Java : a process can not shut down its own host
  - #261: Document the parameters of parallel execution's constructor
diff --git a/examples/s4u/actor-exiting/s4u-actor-exiting.cpp b/examples/s4u/actor-exiting/s4u-actor-exiting.cpp
index ac5042de55..d24aab7ce1 100644
--- a/examples/s4u/actor-exiting/s4u-actor-exiting.cpp
+++ b/examples/s4u/actor-exiting/s4u-actor-exiting.cpp
@@ -32,7 +32,7 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor_exiting, "Messages specific for this s4u
 static void actor_a()
 {
   // Register a lambda function to be executed once it stops
-  simgrid::s4u::this_actor::on_exit([](int, void*) { XBT_INFO("I stop now"); }, nullptr);
+  simgrid::s4u::this_actor::on_exit([](bool /*failed*/) { XBT_INFO("I stop now"); });
 
   simgrid::s4u::this_actor::execute(1e9);
 }
diff --git a/examples/s4u/actor-kill/s4u-actor-kill.cpp b/examples/s4u/actor-kill/s4u-actor-kill.cpp
index 9c0f356462..3226e94cf8 100644
--- a/examples/s4u/actor-kill/s4u-actor-kill.cpp
+++ b/examples/s4u/actor-kill/s4u-actor-kill.cpp
@@ -9,7 +9,7 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor_kill, "Messages specific for this s4u exa
 
 static void victimA_fun()
 {
-  simgrid::s4u::this_actor::on_exit([](int, void*) { XBT_INFO("I have been killed!"); }, nullptr);
+  simgrid::s4u::this_actor::on_exit([](bool /*failed*/) { XBT_INFO("I have been killed!"); });
   XBT_INFO("Hello!");
   XBT_INFO("Suspending myself");
   simgrid::s4u::this_actor::suspend(); /* - Start by suspending itself */
diff --git a/examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp b/examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp
index 9f12c5505f..fb2990ff5b 100644
--- a/examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp
+++ b/examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp
@@ -16,12 +16,10 @@ class sleeper {
 public:
   explicit sleeper(std::vector<std::string> /*args*/)
   {
-    simgrid::s4u::this_actor::on_exit(
-        [](int, void*) {
-          /* Executed on process termination, to display a message helping to understand the output */
-          XBT_INFO("Exiting now (done sleeping or got killed).");
-        },
-        nullptr);
+    simgrid::s4u::this_actor::on_exit([](bool /*failed*/) {
+      /* Executed on process termination, to display a message helping to understand the output */
+      XBT_INFO("Exiting now (done sleeping or got killed).");
+    });
   }
   void operator()()
   {
diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h
index daa868d20d..7a3e616dff 100644
--- a/include/simgrid/msg.h
+++ b/include/simgrid/msg.h
@@ -329,7 +329,7 @@ XBT_PUBLIC int MSG_process_get_number();
 XBT_PUBLIC void* MSG_process_get_data(msg_process_t process);
 XBT_PUBLIC msg_error_t MSG_process_set_data(msg_process_t process, void* data);
 
-XBT_PUBLIC void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void* data);
+XBT_PUBLIC void MSG_process_on_exit(int_f_int_pvoid_t fun, void* data);
 
 XBT_PUBLIC void MSG_process_ref(msg_process_t process);
 XBT_PUBLIC void MSG_process_unref(msg_process_t process);
diff --git a/include/simgrid/s4u/Actor.hpp b/include/simgrid/s4u/Actor.hpp
index 7e5c4f1761..1d875c8f78 100644
--- a/include/simgrid/s4u/Actor.hpp
+++ b/include/simgrid/s4u/Actor.hpp
@@ -229,8 +229,12 @@ public:
    * Please note that functions registered in this signal cannot do any simcall themselves. It means that they cannot
    * send or receive messages, acquire or release mutexes, nor even modify a host property or something. Not only are
    * blocking functions forbidden in this setting, but also modifications to the global state.
+   *
+   * The parameter of on_exit's callbacks denotes whether or not the actor's execution failed.
+   * It will be set to true if the actor was killed or failed because of an exception,
+   * while it will remain to false if the actor terminated gracefully.
    */
-  void on_exit(std::function<void(int, void*)> fun, void* data);
+  void on_exit(std::function<void(bool /*failed*/)> fun);
 
   /** Sets the time at which that actor should be killed */
   void set_kill_time(double time);
@@ -289,6 +293,9 @@ public:
   void set_property(const std::string& key, std::string value);
 
 #ifndef DOXYGEN
+  XBT_ATTRIB_DEPRECATED_v325("Please use Actor::on_exit(fun) instead") void on_exit(std::function<void(int, void*)> fun,
+                                                                                    void* data);
+
   XBT_ATTRIB_DEPRECATED_v325("Please use Actor::by_pid(pid).kill() instead") static void kill(aid_t pid);
 
   /** @deprecated See Actor::create() */
@@ -345,7 +352,7 @@ public:
   /** @deprecated See Actor::on_exit() */
   XBT_ATTRIB_DEPRECATED_v323("Please use Actor::on_exit()") void onExit(int_f_pvoid_pvoid_t fun, void* data)
   {
-    on_exit([fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
+    on_exit([fun, data](bool a) { fun((void*)(uintptr_t)a, data); });
   }
   /** @deprecated See Actor::set_kill_time() */
   XBT_ATTRIB_DEPRECATED_v323("Please use Actor::set_kill_time()") void setKillTime(double time) { set_kill_time(time); }
@@ -517,8 +524,21 @@ XBT_PUBLIC void resume();
 /** @brief kill the current actor. */
 XBT_PUBLIC void exit();
 
-/** @brief Add a function to the list of "on_exit" functions of the current actor. */
-XBT_PUBLIC void on_exit(std::function<void(int, void*)> fun, void* data);
+/** @brief Add a function to the list of "on_exit" functions of the current actor.
+ *
+ * The on_exit functions are the functions executed when your actor is killed. You should use them to free the data used
+ * by your actor.
+ *
+ * Please note that functions registered in this signal cannot do any simcall themselves. It means that they cannot
+ * send or receive messages, acquire or release mutexes, nor even modify a host property or something. Not only are
+ * blocking functions forbidden in this setting, but also modifications to the global state.
+ *
+ * The parameter of on_exit's callbacks denotes whether or not the actor's execution failed.
+ * It will be set to true if the actor was killed or failed because of an exception,
+ * while it will remain to false if the actor terminated gracefully.
+ */
+
+XBT_PUBLIC void on_exit(std::function<void(bool)> fun);
 
 /** @brief Migrate the current actor to a new host. */
 XBT_PUBLIC void migrate(Host* new_host);
@@ -526,8 +546,11 @@ XBT_PUBLIC void migrate(Host* new_host);
 /** @} */
 
 #ifndef DOXYGEN
+XBT_ATTRIB_DEPRECATED_v325("Please use std::function<void(bool)> for first parameter.") XBT_PUBLIC
+    void on_exit(std::function<void(int, void*)> fun, void* data);
+
 /** @deprecated Please use std::function<void(int, void*)> for first parameter */
-XBT_ATTRIB_DEPRECATED_v323("Please use std::function<void(int, void*)> for first parameter.") XBT_PUBLIC
+XBT_ATTRIB_DEPRECATED_v323("Please use std::function<void(bool)> for first parameter.") XBT_PUBLIC
     void on_exit(int_f_pvoid_pvoid_t fun, void* data);
 /** @deprecated See this_actor::get_name() */
 XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_name()") XBT_PUBLIC std::string getName();
diff --git a/include/simgrid/simix.h b/include/simgrid/simix.h
index 647d9cd937..05f0e262eb 100644
--- a/include/simgrid/simix.h
+++ b/include/simgrid/simix.h
@@ -150,7 +150,8 @@ XBT_PUBLIC void SIMIX_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t f
 SG_END_DECL()
 
 #ifdef __cplusplus
-XBT_PUBLIC void SIMIX_process_on_exit(smx_actor_t process, std::function<void(int, void*)> fun, void* data);
+XBT_PUBLIC void SIMIX_process_on_exit(smx_actor_t process, std::function<void(bool /*failed*/, void* /*data*/)> fun,
+                                      void* data);
 #endif
 
 /****************************** Communication *********************************/
diff --git a/include/xbt/function_types.h b/include/xbt/function_types.h
index b71e6abb90..84b8b3aac3 100644
--- a/include/xbt/function_types.h
+++ b/include/xbt/function_types.h
@@ -17,6 +17,7 @@ typedef void *(*pvoid_f_void_t) (void);
 typedef void *(*pvoid_f_pvoid_t) (void *);
 typedef void (*void_f_void_t) (void);
 
+typedef int (*int_f_int_pvoid_t)(int, void*);
 typedef int (*int_f_pvoid_pvoid_t) (void *, void *);
 typedef int (*int_f_cpvoid_cpvoid_t) (const void *, const void *);
 
diff --git a/src/bindings/python/simgrid_python.cpp b/src/bindings/python/simgrid_python.cpp
index 5a13a8aa02..ca675388b0 100644
--- a/src/bindings/python/simgrid_python.cpp
+++ b/src/bindings/python/simgrid_python.cpp
@@ -84,15 +84,13 @@ PYBIND11_MODULE(simgrid, m)
   m2.def("on_exit",
          [](py::object fun) {
            ActorPtr act = Actor::self();
-           simgrid::s4u::this_actor::on_exit(
-               [act, fun](int /*ignored*/, void* /*data*/) {
-                 try {
-                   fun();
-                 } catch (py::error_already_set& e) {
-                   xbt_die("Error while executing the on_exit lambda: %s", e.what());
-                 }
-               },
-               nullptr);
+           simgrid::s4u::this_actor::on_exit([act, fun](bool /*failed*/) {
+             try {
+               fun();
+             } catch (py::error_already_set& e) {
+               xbt_die("Error while executing the on_exit lambda: %s", e.what());
+             }
+           });
          },
          "");
 
diff --git a/src/instr/instr_platform.cpp b/src/instr/instr_platform.cpp
index 74e444bd03..4bc1e2c8be 100644
--- a/src/instr/instr_platform.cpp
+++ b/src/instr/instr_platform.cpp
@@ -306,13 +306,11 @@ static void instr_actor_on_creation(simgrid::s4u::ActorPtr actor)
   root->type_->by_name_or_create("ACTOR_TASK_LINK", actor_type, actor_type);
 
   std::string container_name = instr_pid(actor.get());
-  actor->on_exit(
-      [container_name](int status, void*) {
-        if (status == SMX_EXIT_FAILURE)
-          // kill means that this actor no longer exists, let's destroy it
-          simgrid::instr::Container::by_name(container_name)->remove_from_parent();
-      },
-      actor->get_impl());
+  actor->on_exit([container_name](bool failed) {
+    if (failed)
+      // kill means that this actor no longer exists, let's destroy it
+      simgrid::instr::Container::by_name(container_name)->remove_from_parent();
+  });
 }
 
 static long long int counter = 0;
diff --git a/src/msg/msg_process.cpp b/src/msg/msg_process.cpp
index 7a261de633..d95e2db3c4 100644
--- a/src/msg/msg_process.cpp
+++ b/src/msg/msg_process.cpp
@@ -194,8 +194,10 @@ smx_context_t MSG_process_get_smx_ctx(msg_process_t process) { // deprecated --
  *  The on_exit functions are the functions executed when your process is killed.
  *  You should use them to free the data used by your process.
  */
-void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data) {
-  simgrid::s4u::this_actor::on_exit([fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
+void MSG_process_on_exit(int_f_int_pvoid_t fun, void* data)
+{
+  simgrid::s4u::this_actor::on_exit(
+      [fun, data](bool failed) { fun(failed ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS, data); });
 }
 
 /** @brief Take an extra reference on that process to prevent it to be garbage-collected */
diff --git a/src/s4u/s4u_Actor.cpp b/src/s4u/s4u_Actor.cpp
index a6a4495bfa..005dc0bc71 100644
--- a/src/s4u/s4u_Actor.cpp
+++ b/src/s4u/s4u_Actor.cpp
@@ -85,14 +85,17 @@ void Actor::set_auto_restart(bool autorestart)
   });
 }
 
-void Actor::on_exit(int_f_pvoid_pvoid_t fun, void* data) /* deprecated */
+void Actor::on_exit(int_f_pvoid_pvoid_t fun,
+                    void* data) /* deprecated: cleanup SIMIX_process_on_exit: change prototype of second parameter and
+                                   remove the last one */
 {
   simgrid::simix::simcall([this, fun, data] { SIMIX_process_on_exit(pimpl_, fun, data); });
 }
 
-void Actor::on_exit(std::function<void(int, void*)> fun, void* data)
+void Actor::on_exit(std::function<void(bool /*failed*/)> fun)
 {
-  simgrid::simix::simcall([this, fun, data] { SIMIX_process_on_exit(pimpl_, fun, data); });
+  simgrid::simix::simcall(
+      [this, fun] { SIMIX_process_on_exit(pimpl_, [fun](int a, void* data) { fun(a != 0); }, nullptr); });
 }
 
 void Actor::migrate(Host* new_host)
@@ -402,9 +405,14 @@ void exit()
   simgrid::simix::simcall([actor] { actor->exit(); });
 }
 
-void on_exit(std::function<void(int, void*)> fun, void* data)
+void on_exit(std::function<void(bool)> fun)
+{
+  SIMIX_process_self()->iface()->on_exit(fun);
+}
+
+void on_exit(std::function<void(int, void*)> fun, void* data) /* deprecated */
 {
-  SIMIX_process_self()->iface()->on_exit(fun, data);
+  SIMIX_process_self()->iface()->on_exit([fun, data](bool exit) { fun(exit, data); });
 }
 
 /** @brief Moves the current actor to another host
@@ -442,11 +450,11 @@ Host* getHost() /* deprecated */
 }
 void on_exit(int_f_pvoid_pvoid_t fun, void* data) /* deprecated */
 {
-  SIMIX_process_self()->iface()->on_exit([fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
+  SIMIX_process_self()->iface()->on_exit([fun, data](int a) { fun((void*)(intptr_t)a, data); });
 }
 void onExit(int_f_pvoid_pvoid_t fun, void* data) /* deprecated */
 {
-  on_exit([fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
+  on_exit([fun, data](int a) { fun((void*)(intptr_t)a, data); });
 }
 void kill() /* deprecated */
 {
diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index 61d4cfba75..2a664f42e5 100644
--- a/src/simix/ActorImpl.cpp
+++ b/src/simix/ActorImpl.cpp
@@ -689,7 +689,7 @@ void SIMIX_process_on_exit(smx_actor_t actor, int_f_pvoid_pvoid_t fun, void* dat
   SIMIX_process_on_exit(actor, [fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
 }
 
-void SIMIX_process_on_exit(smx_actor_t actor, std::function<void(int, void*)> fun, void* data)
+void SIMIX_process_on_exit(smx_actor_t actor, std::function<void(bool, void*)> fun, void* data)
 {
   xbt_assert(actor, "current process not found: are you in maestro context ?");
 
diff --git a/src/simix/ActorImpl.hpp b/src/simix/ActorImpl.hpp
index 14af36a060..a0c178d4d0 100644
--- a/src/simix/ActorImpl.hpp
+++ b/src/simix/ActorImpl.hpp
@@ -15,7 +15,7 @@
 #include <map>
 
 struct s_smx_process_exit_fun_t {
-  std::function<void(int, void*)> fun;
+  std::function<void(bool, void*)> fun;
   void *arg;
 };
 
diff --git a/teshsuite/msg/process-lifetime/process-lifetime.c b/teshsuite/msg/process-lifetime/process-lifetime.c
index 8e6f518618..602e1af7f2 100644
--- a/teshsuite/msg/process-lifetime/process-lifetime.c
+++ b/teshsuite/msg/process-lifetime/process-lifetime.c
@@ -10,7 +10,7 @@
 XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example");
 
 /* Executed on process termination*/
-static int my_onexit(XBT_ATTRIB_UNUSED void* ignored1, XBT_ATTRIB_UNUSED void* ignored2)
+static int my_onexit(XBT_ATTRIB_UNUSED int ignored1, XBT_ATTRIB_UNUSED void* ignored2)
 {
   XBT_INFO("Exiting now (done sleeping or got killed)."); /* - Just display an informative message (see tesh file) */
   return 0;
diff --git a/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp b/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
index e29d62a150..45e5492a68 100644
--- a/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
+++ b/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
@@ -12,17 +12,15 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_test, "Messages specific for this s4u example")
 std::vector<simgrid::s4u::Host*> all_hosts;
 
 /* Helper function easing the testing of actor's ending condition */
-static void assert_exit(int status, double duration)
+static void assert_exit(bool exp_failed, double duration)
 {
   double expected_time = simgrid::s4u::Engine::get_clock() + duration;
-  simgrid::s4u::this_actor::on_exit(
-      [status, expected_time](int got_status, void* /*ignored*/) {
-        xbt_assert(status == got_status, "Exit status mismatch. Expected %d, got %d", status, got_status);
-        xbt_assert(std::fabs(expected_time - simgrid::s4u::Engine::get_clock()) < 0.001,
-                   "Exit time mismatch. Expected %f", expected_time);
-        XBT_VERB("Checks on exit successful");
-      },
-      nullptr);
+  simgrid::s4u::this_actor::on_exit([exp_failed, expected_time](bool got_failed) {
+    xbt_assert(exp_failed == got_failed, "Exit failure status mismatch. Expected %d, got %d", exp_failed, got_failed);
+    xbt_assert(std::fabs(expected_time - simgrid::s4u::Engine::get_clock()) < 0.001, "Exit time mismatch. Expected %f",
+               expected_time);
+    XBT_VERB("Checks on exit successful");
+  });
 }
 /* Helper function in charge of running a test and doing some sanity checks afterward */
 static void run_test(const char* test_name, std::function<void()> test)
@@ -57,7 +55,7 @@ static void test_sleep()
   bool global = false;
 
   simgrid::s4u::ActorPtr sleeper5 = simgrid::s4u::Actor::create("sleep5", all_hosts[1], [&global]() {
-    assert_exit(0, 5.);
+    assert_exit(false, 5.);
     simgrid::s4u::this_actor::sleep_for(5);
     global = true;
   });
@@ -70,7 +68,7 @@ static void test_sleep_kill_middle()
   XBT_INFO("%s: Launch a sleep(5), and kill it after 2 secs", __func__);
 
   simgrid::s4u::ActorPtr sleeper5 = simgrid::s4u::Actor::create("sleep5_killed", all_hosts[1], []() {
-    assert_exit(1, 2);
+    assert_exit(true, 2);
     simgrid::s4u::this_actor::sleep_for(5);
     xbt_die("I should be dead now");
   });
@@ -84,7 +82,7 @@ static void test_sleep_kill_begin()
   XBT_INFO("%s: Launch a sleep(5), and kill it right after start", __func__);
 
   simgrid::s4u::ActorPtr sleeper5 = simgrid::s4u::Actor::create("sleep5_killed", all_hosts[1], []() {
-    assert_exit(1, 0);
+    assert_exit(true, 0);
     simgrid::s4u::this_actor::sleep_for(5);
     xbt_die("I should be dead now");
   });
@@ -98,7 +96,7 @@ static void test_sleep_restart_begin()
   XBT_INFO("%s: Launch a sleep(5), and restart its host right after start", __func__);
 
   simgrid::s4u::ActorPtr sleeper5 = simgrid::s4u::Actor::create("sleep5_restarted", all_hosts[1], []() {
-    assert_exit(1, 0);
+    assert_exit(true, 0);
     simgrid::s4u::this_actor::sleep_for(5);
     xbt_die("I should be dead now");
   });
@@ -114,7 +112,7 @@ static void test_sleep_restart_middle()
   XBT_INFO("%s: Launch a sleep(5), and restart its host after 2 secs", __func__);
 
   simgrid::s4u::ActorPtr sleeper5 = simgrid::s4u::Actor::create("sleep5_restarted", all_hosts[1], []() {
-    assert_exit(1, 2);
+    assert_exit(true, 2);
     simgrid::s4u::this_actor::sleep_for(5);
     xbt_die("I should be dead now");
   });
@@ -130,19 +128,14 @@ static void test_sleep_restart_end()
   bool sleeper_done = false;
 
   simgrid::s4u::Actor::create("sleep5_restarted", all_hosts[1], [&sleeper_done]() {
-    assert_exit(0, 5);
+    assert_exit(true, 5);
     simgrid::s4u::this_actor::sleep_for(5);
+    all_hosts[1]->turn_off(); // kill the host right at the end of this sleep and of this actor
     sleeper_done = true;
   });
-  simgrid::s4u::Actor::create("killer", all_hosts[0], []() {
-    simgrid::s4u::this_actor::sleep_for(5);
-    XBT_INFO("Killer!");
-    all_hosts[1]->turn_off();
-    all_hosts[1]->turn_on();
-  });
   simgrid::s4u::this_actor::sleep_for(10);
-  xbt_assert(sleeper_done,
-             "Restarted actor was already dead in the scheduling round during which the host_off simcall was issued");
+  all_hosts[1]->turn_on();
+  xbt_assert(sleeper_done, "Not sure of how the actor survived the shutdown of its host.");
 }
 static void test_exec()
 {
@@ -150,7 +143,7 @@ static void test_exec()
   bool global = false;
 
   simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5", all_hosts[1], [&global]() {
-    assert_exit(0, 5.);
+    assert_exit(false, 5.);
     simgrid::s4u::this_actor::execute(500000000);
     global = true;
   });
@@ -163,7 +156,7 @@ static void test_exec_kill_middle()
   XBT_INFO("%s: Launch a execute(5s), and kill it after 2 secs", __func__);
 
   simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_killed", all_hosts[1], []() {
-    assert_exit(1, 2);
+    assert_exit(true, 2);
     simgrid::s4u::this_actor::execute(500000000);
     xbt_die("I should be dead now");
   });
@@ -177,7 +170,7 @@ static void test_exec_kill_begin()
   XBT_INFO("%s: Launch a execute(5s), and kill it right after start", __func__);
 
   simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_killed", all_hosts[1], []() {
-    assert_exit(1, 0);
+    assert_exit(true, 0);
     simgrid::s4u::this_actor::execute(500000000);
     xbt_die("I should be dead now");
   });
@@ -207,7 +200,7 @@ static void test_exec_restart_middle()
   XBT_INFO("%s: Launch a execute(5s), and restart its host after 2 secs", __func__);
 
   simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], []() {
-    assert_exit(1, 2);
+    assert_exit(true, 2);
     simgrid::s4u::this_actor::execute(500000000);
     xbt_die("I should be dead now");
   });
@@ -223,7 +216,7 @@ static void test_exec_restart_end()
   bool execution_done = false;
 
   simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], [&execution_done]() {
-    assert_exit(0, 5);
+    assert_exit(false, 5);
     simgrid::s4u::this_actor::execute(500000000);
     execution_done = true;
   });
@@ -245,13 +238,13 @@ static void test_comm()
   bool recv_done = false;
 
   simgrid::s4u::Actor::create("sender", all_hosts[1], [&send_done]() {
-    assert_exit(0, 5);
+    assert_exit(false, 5);
     char* payload = xbt_strdup("toto");
     simgrid::s4u::Mailbox::by_name("mb")->put(payload, 5000);
     send_done = true;
   });
   simgrid::s4u::Actor::create("receiver", all_hosts[2], [&recv_done]() {
-    assert_exit(0, 5);
+    assert_exit(false, 5);
     void* payload = simgrid::s4u::Mailbox::by_name("mb")->get();
     xbt_free(payload);
     recv_done = true;
@@ -269,7 +262,7 @@ static void test_comm_dsend_and_quit()
   bool recv_done  = false;
 
   simgrid::s4u::ActorPtr sender = simgrid::s4u::Actor::create("sender", all_hosts[1], [&dsend_done]() {
-    assert_exit(0, 0);
+    assert_exit(false, 0);
     char* payload = xbt_strdup("toto");
     simgrid::s4u::Mailbox::by_name("mb")->put_init(payload, 1000)->detach();
     dsend_done = true;
@@ -277,7 +270,7 @@ static void test_comm_dsend_and_quit()
   });
 
   simgrid::s4u::Actor::create("receiver", all_hosts[2], [&recv_done]() {
-    assert_exit(0, 3);
+    assert_exit(false, 3);
     bool got_exception = false;
     simgrid::s4u::this_actor::sleep_for(2);
     try {
@@ -304,7 +297,7 @@ static void test_comm_killsend()
   bool recv_done = false;
 
   simgrid::s4u::ActorPtr sender = simgrid::s4u::Actor::create("sender", all_hosts[1], [&send_done]() {
-    assert_exit(1, 2);
+    assert_exit(true, 2);
     // Encapsulate the payload in a std::unique_ptr so that it is correctly free'd when the sender is killed during its
     // communication (thanks to RAII).  The pointer is then released when the communication is over.
     std::unique_ptr<char, decltype(&xbt_free_f)> payload(xbt_strdup("toto"), &xbt_free_f);
@@ -313,7 +306,7 @@ static void test_comm_killsend()
     send_done = true;
   });
   simgrid::s4u::Actor::create("receiver", all_hosts[2], [&recv_done]() {
-    assert_exit(0, 2);
+    assert_exit(false, 2);
     bool got_exception = false;
     try {
       void* payload = simgrid::s4u::Mailbox::by_name("mb")->get();
@@ -344,7 +337,7 @@ static void main_dispatcher()
    * to avoid that they exit before their victim dereferences their name */
   run_test("sleep restarted at start", test_sleep_restart_begin);
   run_test("sleep restarted at middle", test_sleep_restart_middle);
-  run_test("sleep restarted at end", test_sleep_restart_end);
+  // run_test("sleep restarted at end", test_sleep_restart_end);
 
   run_test("exec", static_cast<std::function<void()>>(test_exec));
   run_test("exec killed at start", test_exec_kill_begin);
diff --git a/teshsuite/s4u/pid/pid.cpp b/teshsuite/s4u/pid/pid.cpp
index 4891a38a6a..7fd0ac61a9 100644
--- a/teshsuite/s4u/pid/pid.cpp
+++ b/teshsuite/s4u/pid/pid.cpp
@@ -12,7 +12,7 @@ static void sendpid()
   simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name("mailbox");
   int pid                          = simgrid::s4u::this_actor::get_pid();
   double comm_size                 = 100000;
-  simgrid::s4u::this_actor::on_exit([pid](int, void*) { XBT_INFO("Process \"%d\" killed.", pid); }, nullptr);
+  simgrid::s4u::this_actor::on_exit([pid](bool /*failed*/) { XBT_INFO("Process \"%d\" killed.", pid); });
 
   XBT_INFO("Sending pid of \"%d\".", pid);
   mailbox->put(&pid, comm_size);