X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/50ddfe2f5b5035e0ed9556b334d6977ee81ff83a..8265fae7843fa515935916b005f15daa93ff2f26:/src/simix/ActorImpl.cpp

diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index c27e6d0386..8c9e22a3c5 100644
--- a/src/simix/ActorImpl.cpp
+++ b/src/simix/ActorImpl.cpp
@@ -4,6 +4,7 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "mc/mc.h"
+#include "simgrid/Exception.hpp"
 #include "smx_private.hpp"
 #include "src/kernel/activity/CommImpl.hpp"
 #include "src/kernel/activity/ExecImpl.hpp"
@@ -17,7 +18,6 @@
 #include "src/simix/smx_synchro_private.hpp"
 #include "src/surf/HostImpl.hpp"
 #include "src/surf/cpu_interface.hpp"
-#include "xbt/ex.hpp"
 
 #ifdef HAVE_SMPI
 #include "src/smpi/include/private.hpp"
@@ -101,7 +101,8 @@ void SIMIX_process_cleanup(smx_actor_t process)
     comm->cancel();
   }
 
-  XBT_DEBUG("%p should not be run anymore",process);
+  XBT_DEBUG("%s@%s(%ld) should not run anymore", process->get_cname(), process->iface()->get_host()->get_cname(),
+            process->pid_);
   simix_global->process_list.erase(process->pid_);
   if (process->host_ && process->host_process_list_hook.is_linked())
     simgrid::xbt::intrusive_erase(process->host_->pimpl_->process_list_, *process);
@@ -229,7 +230,8 @@ void ActorImpl::resume()
 smx_activity_t ActorImpl::sleep(double duration)
 {
   if (host_->is_off())
-    THROWF(host_error, 0, "Host %s failed, you cannot sleep there.", host_->get_cname());
+    throw_exception(std::make_exception_ptr(simgrid::HostFailureException(
+        XBT_THROW_POINT, std::string("Host ") + std::string(host_->get_cname()) + " failed, you cannot sleep there.")));
 
   simgrid::kernel::activity::SleepImpl* synchro = new simgrid::kernel::activity::SleepImpl();
   synchro->host                                 = host_;
@@ -240,6 +242,55 @@ smx_activity_t ActorImpl::sleep(double duration)
   return synchro;
 }
 
+void ActorImpl::throw_exception(std::exception_ptr e)
+{
+  exception = e;
+
+  if (suspended_)
+    resume();
+
+  /* cancel the blocking synchro if any */
+  if (waiting_synchro) {
+
+    simgrid::kernel::activity::ExecImplPtr exec =
+        boost::dynamic_pointer_cast<simgrid::kernel::activity::ExecImpl>(waiting_synchro);
+    if (exec != nullptr && exec->surf_action_)
+      exec->surf_action_->cancel();
+
+    simgrid::kernel::activity::CommImplPtr comm =
+        boost::dynamic_pointer_cast<simgrid::kernel::activity::CommImpl>(waiting_synchro);
+    if (comm != nullptr) {
+      comms.remove(comm);
+      comm->cancel();
+    }
+
+    simgrid::kernel::activity::SleepImplPtr sleep =
+        boost::dynamic_pointer_cast<simgrid::kernel::activity::SleepImpl>(waiting_synchro);
+    if (sleep != nullptr) {
+      SIMIX_process_sleep_destroy(waiting_synchro);
+      if (std::find(begin(simix_global->process_to_run), end(simix_global->process_to_run), this) ==
+              end(simix_global->process_to_run) &&
+          this != SIMIX_process_self()) {
+        XBT_DEBUG("Inserting %s in the to_run list", get_cname());
+        simix_global->process_to_run.push_back(this);
+      }
+    }
+
+    simgrid::kernel::activity::RawImplPtr raw =
+        boost::dynamic_pointer_cast<simgrid::kernel::activity::RawImpl>(waiting_synchro);
+    if (raw != nullptr) {
+      SIMIX_synchro_stop_waiting(this, &simcall);
+    }
+
+    simgrid::kernel::activity::IoImplPtr io =
+        boost::dynamic_pointer_cast<simgrid::kernel::activity::IoImpl>(waiting_synchro);
+    if (io != nullptr) {
+      delete io.get();
+    }
+  }
+  waiting_synchro = nullptr;
+}
+
 void create_maestro(simgrid::simix::ActorCode code)
 {
   smx_actor_t maestro = nullptr;
@@ -448,6 +499,9 @@ void SIMIX_process_kill(smx_actor_t process, smx_actor_t issuer) {
   process->suspended_          = false;
   process->exception = nullptr;
 
+  if (process->host_->is_off())
+    process->throw_exception(std::make_exception_ptr(simgrid::HostFailureException(XBT_THROW_POINT, "Host failed")));
+
   /* destroy the blocking synchro if any */
   if (process->waiting_synchro != nullptr) {
 
@@ -485,7 +539,9 @@ void SIMIX_process_kill(smx_actor_t process, smx_actor_t issuer) {
     } else if (io != nullptr) {
       delete io.get();
     } else {
-      xbt_die("Unknown type of activity");
+      simgrid::kernel::activity::ActivityImplPtr activity = process->waiting_synchro;
+      xbt_die("Activity %s is of unknown type %s", activity->name_.c_str(),
+              simgrid::xbt::demangle(typeid(activity).name()).get());
     }
 
     process->waiting_synchro = nullptr;
@@ -498,13 +554,8 @@ void SIMIX_process_kill(smx_actor_t process, smx_actor_t issuer) {
   }
 }
 
-/** @brief Ask another process to raise the given exception
- *
- * @param process The process that should raise that exception
- * @param cat category of exception
- * @param value value associated to the exception
- * @param msg string information associated to the exception
- */
+/** @deprecated When this function gets removed, also remove the xbt_ex class, that is only there to help users to
+ * transition */
 void SIMIX_process_throw(smx_actor_t process, xbt_errcat_t cat, int value, const char *msg) {
   SMX_EXCEPTION(process, cat, value, msg);
 
@@ -698,12 +749,17 @@ void SIMIX_process_yield(smx_actor_t self)
     self->finished_ = true;
     /* execute the on_exit functions */
     SIMIX_process_on_exit_runall(self);
-    /* Add the process to the list of process to restart, only if the host is down */
-    if (self->auto_restart_ && self->host_->is_off()) {
-      SIMIX_host_add_auto_restart_process(self->host_, self);
+
+    if (self->auto_restart_ && self->host_->is_off() &&
+        watched_hosts.find(self->host_->get_cname()) == watched_hosts.end()) {
+      XBT_DEBUG("Push host %s to watched_hosts because it's off and %s needs to restart", self->host_->get_cname(),
+                self->get_cname());
+      watched_hosts.insert(self->host_->get_cname());
     }
+
     XBT_DEBUG("Process %s@%s is dead", self->get_cname(), self->host_->get_cname());
     self->context_->stop();
+    xbt_die("I should be dead by now.");
   }
 
   if (self->suspended_) {