X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4141cd9660259caa66e2e9af10873e53402b4812..4d02714ee138a3bd9b02e0064b7a2aa26407e9e8:/include/simgrid/Exception.hpp

diff --git a/include/simgrid/Exception.hpp b/include/simgrid/Exception.hpp
index a0786a9df8..0f3a5e3a6d 100644
--- a/include/simgrid/Exception.hpp
+++ b/include/simgrid/Exception.hpp
@@ -15,6 +15,7 @@
 #include <xbt/ex.h>
 
 #include <atomic>
+#include <functional>
 #include <stdexcept>
 #include <string>
 
@@ -33,7 +34,8 @@ namespace xbt {
 class ThrowPoint {
 public:
   ThrowPoint() = default;
-  explicit ThrowPoint(const char* file, int line, const char* function, Backtrace bt, std::string actor_name, int pid)
+  explicit ThrowPoint(const char* file, int line, const char* function, Backtrace&& bt, std::string&& actor_name,
+                      int pid)
       : file_(file)
       , line_(line)
       , function_(function)
@@ -53,14 +55,13 @@ public:
 
 /** Create a ThrowPoint with (__FILE__, __LINE__, __func__) */
 #define XBT_THROW_POINT                                                                                                \
-  ::simgrid::xbt::ThrowPoint(__FILE__, __LINE__, __func__, std::move(simgrid::xbt::Backtrace()), xbt_procname(),       \
-                             xbt_getpid())
+  ::simgrid::xbt::ThrowPoint(__FILE__, __LINE__, __func__, simgrid::xbt::Backtrace(), xbt_procname(), xbt_getpid())
 } // namespace xbt
 
 /** Ancestor class of all SimGrid exception */
 class Exception : public std::runtime_error {
 public:
-  Exception(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  Exception(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : std::runtime_error(std::move(message)), throwpoint_(std::move(throwpoint))
   {
   }
@@ -96,7 +97,7 @@ public:
    * @param throwpoint Throw point (use XBT_THROW_POINT)
    * @param message    Exception message
    */
-  xbt_ex(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  xbt_ex(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : simgrid::Exception(std::move(throwpoint), std::move(message))
   {
   }
@@ -117,7 +118,7 @@ namespace simgrid {
 /** Exception raised when a timeout elapsed */
 class TimeoutError : public xbt_ex {
 public:
-  TimeoutError(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  TimeoutError(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : xbt_ex(std::move(throwpoint), std::move(message))
   {
     category = timeout_error;
@@ -127,17 +128,17 @@ public:
 /** Exception raised when a host fails */
 class HostFailureException : public xbt_ex {
 public:
-  HostFailureException(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  HostFailureException(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : xbt_ex(std::move(throwpoint), std::move(message))
   {
     category = host_error;
   }
 };
 
-/** Exception raised when a communication fails because of the network */
+/** Exception raised when a communication fails because of the network or because of the remote host */
 class NetworkFailureException : public xbt_ex {
 public:
-  NetworkFailureException(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  NetworkFailureException(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : xbt_ex(std::move(throwpoint), std::move(message))
   {
     category = network_error;
@@ -147,7 +148,7 @@ public:
 /** Exception raised when a storage fails */
 class StorageFailureException : public xbt_ex {
 public:
-  StorageFailureException(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  StorageFailureException(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : xbt_ex(std::move(throwpoint), std::move(message))
   {
     category = io_error;
@@ -157,13 +158,51 @@ public:
 /** Exception raised when something got canceled before completion */
 class CancelException : public xbt_ex {
 public:
-  CancelException(simgrid::xbt::ThrowPoint throwpoint, std::string message)
+  CancelException(simgrid::xbt::ThrowPoint&& throwpoint, std::string&& message)
       : xbt_ex(std::move(throwpoint), std::move(message))
   {
     category = cancel_error;
   }
 };
 
+class XBT_PUBLIC ForcefulKillException {
+  /** @brief Exception launched to kill an actor; DO NOT BLOCK IT!
+   *
+   * This exception is thrown whenever the actor's host is turned off. The actor stack is properly unwinded to release
+   * all objects allocated on the stack (RAII powa).
+   *
+   * You may want to catch this exception to perform some extra cleanups in your simulation, but YOUR ACTORS MUST NEVER
+   * SURVIVE a ForcefulKillException, or your simulation will segfault.
+   *
+   * @verbatim
+   * void* payload = malloc(512);
+   *
+   * try {
+   *   simgrid::s4u::this_actor::execute(100000);
+   * } catch (simgrid::kernel::context::ForcefulKillException& e) { // oops, my host just turned off
+   *   free(malloc);
+   *   throw; // I shall never survive on an host that was switched off
+   * }
+   * @endverbatim
+   */
+  /* Nope, Sonar, this should not inherit of std::exception nor of simgrid::Exception.
+   * Otherwise, users may accidentally catch it with a try {} catch (std::exception)
+   */
+public:
+  ForcefulKillException() = default;
+  explicit ForcefulKillException(const std::string& msg) : msg_(std::string("Actor killed (") + msg + std::string(")."))
+  {
+  }
+  ~ForcefulKillException();
+  const char* what() const noexcept { return msg_.c_str(); }
+
+  static void do_throw();
+  static bool try_n_catch(std::function<void(void)> try_block);
+
+private:
+  std::string msg_ = std::string("Actor killed.");
+};
+
 } // namespace simgrid
 
 #endif