X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/81ee7d3fca29758a511b651d520e7b35aafbf018..08e94eb0482589e4b287cbea301b84daf52635bd:/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp

diff --git a/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp b/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
index 41637c18a5..45e5492a68 100644
--- a/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
+++ b/teshsuite/s4u/activity-lifecycle/activity-lifecycle.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2018. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2010-2019. 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. */
@@ -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)
@@ -35,7 +33,7 @@ static void run_test(const char* test_name, std::function<void()> test)
     std::vector<simgrid::s4u::ActorPtr> all_actors = all_hosts[i]->get_all_actors();
     unsigned int expected_count = (i == 0) ? 1 : 0; // host[0] contains main_dispatcher, all other are empty
     if (all_actors.size() != expected_count) {
-      XBT_CRITICAL("Host %s contains %lu actors but %u are expected (i=%u). Existing actors: ",
+      XBT_CRITICAL("Host %s contains %zu actors but %u are expected (i=%u). Existing actors: ",
                    all_hosts[i]->get_cname(), all_actors.size(), expected_count, i);
       for (auto act : all_actors)
         XBT_CRITICAL(" - %s", act->get_cname());
@@ -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,10 +128,98 @@ 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::this_actor::sleep_for(10);
+  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()
+{
+  XBT_INFO("%s: Launch a execute(5s), and let it proceed", __func__);
+  bool global = false;
+
+  simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5", all_hosts[1], [&global]() {
+    assert_exit(false, 5.);
+    simgrid::s4u::this_actor::execute(500000000);
+    global = true;
+  });
+  simgrid::s4u::this_actor::sleep_for(10);
+  xbt_assert(global, "The forked actor did not modify the global after executing. Was it killed before?");
+}
+
+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(true, 2);
+    simgrid::s4u::this_actor::execute(500000000);
+    xbt_die("I should be dead now");
+  });
+
+  simgrid::s4u::this_actor::sleep_for(2);
+  exec5->kill();
+}
+
+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(true, 0);
+    simgrid::s4u::this_actor::execute(500000000);
+    xbt_die("I should be dead now");
+  });
+
+  simgrid::s4u::this_actor::yield();
+  exec5->kill();
+}
+
+static void test_exec_restart_begin()
+{
+  XBT_INFO("%s: Launch a execute(5s), and restart its host right after start", __func__);
+
+  simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], []() {
+    assert_exit(1, 0);
+    simgrid::s4u::this_actor::execute(500000000);
+    xbt_die("I should be dead now");
+  });
+
+  simgrid::s4u::this_actor::yield();
+  exec5->get_host()->turn_off();
+  exec5->get_host()->turn_on();
+  XBT_INFO("Test %s is ending", __func__);
+}
+
+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(true, 2);
+    simgrid::s4u::this_actor::execute(500000000);
+    xbt_die("I should be dead now");
+  });
+
+  simgrid::s4u::this_actor::sleep_for(2);
+  exec5->get_host()->turn_off();
+  exec5->get_host()->turn_on();
+  XBT_INFO("Test %s is ending", __func__);
+}
+static void test_exec_restart_end()
+{
+  XBT_INFO("%s: Launch a execute(5s), and restart its host right when it stops", __func__);
+  bool execution_done = false;
+
+  simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], [&execution_done]() {
+    assert_exit(false, 5);
+    simgrid::s4u::this_actor::execute(500000000);
+    execution_done = true;
+  });
   simgrid::s4u::Actor::create("killer", all_hosts[0], []() {
     simgrid::s4u::this_actor::sleep_for(5);
     XBT_INFO("Killer!");
@@ -141,7 +227,7 @@ static void test_sleep_restart_end()
     all_hosts[1]->turn_on();
   });
   simgrid::s4u::this_actor::sleep_for(10);
-  xbt_assert(sleeper_done,
+  xbt_assert(execution_done,
              "Restarted actor was already dead in the scheduling round during which the host_off simcall was issued");
 }
 
@@ -152,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;
@@ -169,6 +255,41 @@ static void test_comm()
   xbt_assert(recv_done, "Receiver killed somehow. It shouldn't");
 }
 
+static void test_comm_dsend_and_quit()
+{
+  XBT_INFO("%s: Launch a detached communication and end right after", __func__);
+  bool dsend_done = false;
+  bool recv_done  = false;
+
+  simgrid::s4u::ActorPtr sender = simgrid::s4u::Actor::create("sender", all_hosts[1], [&dsend_done]() {
+    assert_exit(false, 0);
+    char* payload = xbt_strdup("toto");
+    simgrid::s4u::Mailbox::by_name("mb")->put_init(payload, 1000)->detach();
+    dsend_done = true;
+    return;
+  });
+
+  simgrid::s4u::Actor::create("receiver", all_hosts[2], [&recv_done]() {
+    assert_exit(false, 3);
+    bool got_exception = false;
+    simgrid::s4u::this_actor::sleep_for(2);
+    try {
+      void* payload = simgrid::s4u::Mailbox::by_name("mb")->get();
+      xbt_free(payload);
+    } catch (xbt_ex const& e) {
+      got_exception = true;
+    }
+    recv_done = true;
+    xbt_assert(not got_exception);
+    return;
+  });
+
+  // Sleep long enough to let the test ends by itself. 3 + surf_precision should be enough.
+  simgrid::s4u::this_actor::sleep_for(4);
+  xbt_assert(dsend_done, "Sender killed somehow. It shouldn't");
+  xbt_assert(recv_done, "Receiver killed somehow. It shouldn't");
+}
+
 static void test_comm_killsend()
 {
   XBT_INFO("%s: Launch a communication and kill the sender", __func__);
@@ -176,13 +297,16 @@ 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);
-    char* payload = xbt_strdup("toto");
-    simgrid::s4u::Mailbox::by_name("mb")->put(payload, 5000);
+    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);
+    simgrid::s4u::Mailbox::by_name("mb")->put(payload.get(), 5000);
+    payload.release();
     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();
@@ -196,32 +320,47 @@ static void test_comm_killsend()
 
   simgrid::s4u::this_actor::sleep_for(2);
   sender->kill();
+  // let the test ends by itself. waiting for surf_precision should be enough.
+  simgrid::s4u::this_actor::sleep_for(0.00001);
 
   xbt_assert(not send_done, "Sender was not killed properly");
-  // xbt_assert(recv_done, "Receiver killed somehow. It shouldn't");
+  xbt_assert(recv_done, "Receiver killed somehow. It shouldn't");
 }
 
 /* We need an extra actor here, so that it can sleep until the end of each test */
 static void main_dispatcher()
 {
-  run_test("sleep", test_sleep);
+  run_test("sleep", static_cast<std::function<void()>>(test_sleep));
   run_test("sleep killed at start", test_sleep_kill_begin);
   run_test("sleep killed in middle", test_sleep_kill_middle);
   /* We cannot kill right at the end of the action because killer actors are always rescheduled to the end of the round
    * 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);
+  run_test("exec killed in middle", test_exec_kill_middle);
+  run_test("exec restarted at start", test_exec_restart_begin);
+  run_test("exec restarted at middle", test_exec_restart_middle);
+  run_test("exec restarted at end", test_exec_restart_end);
 
   run_test("comm", test_comm);
-  // run_test("comm kill sender", test_comm_killsend);
+  run_test("comm dsend and quit", test_comm_dsend_and_quit);
+  run_test("comm kill sender", test_comm_killsend);
 }
 
 int main(int argc, char* argv[])
 {
   simgrid::s4u::Engine e(&argc, argv);
-  xbt_assert(argc > 1);
-  e.load_platform(argv[1]);
+
+  const char* platf = argv[1];
+  if (argc <= 1) {
+    XBT_WARN("No platform file provided. Using './testing_platform.xml'");
+    platf = "./testing_platform.xml";
+  }
+  e.load_platform(platf);
 
   all_hosts = e.get_all_hosts();
   simgrid::s4u::Actor::create("main_dispatcher", all_hosts[0], main_dispatcher);