provide a backtrace implementation that uses boost.stacktrace

[simgrid.git] / src / simix / ActorImpl.cpp

diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index 4ee0c20..5842df4 100644 (file)
--- a/src/simix/ActorImpl.cpp
+++ b/src/simix/ActorImpl.cpp
@@ -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);
@@ -498,10 +499,35 @@ void SIMIX_process_kill(smx_actor_t process, smx_actor_t issuer) {
   process->suspended_          = false;
   process->exception = nullptr;
 
+  // Forcefully kill the actor if its host is turned off. Not an HostFailureException because you should not survive that
+  if (process->host_->is_off()) {
+    /* HORRIBLE HACK: Don't throw an StopRequest exception in Java, because it breaks sometimes.
+     *
+     * It seems to break for the actors started from the Java world, with new Process()
+     * while it works for the ones started from the C world, with the deployment file.
+     * When it happens, the simulation stops brutally with a message "untrapped exception StopRequest".
+     *
+     * From what I understand, it works for the native actors because they have a nice try/catch block around their main
+     * but I fail to have something like that for pure Java actors. That's probably a story of C->Java vs Java->C
+     * calling conventions. The right solution may be to have try/catch(StopRequest) blocks around each native call in
+     * JNI. ie, protect every Java->C++ call from C++ exceptions. But this sounds long and painful to do before we
+     * switch to an automatic generator such as SWIG. For now, we don't throw here that exception that we sometimes fail
+     * to catch.
+     *
+     * One of the unfortunate outcome is that the threads started from the deployment file are not stopped anymore.
+     * Or maybe this is the actors stopping gracefully as opposed to the killed ones? Or maybe this is absolutely all
+     * actors of the Java simulation? I'm not sure. Anyway. Because of them, the simulation hangs at the end, waiting
+     * for them to stop but they won't. The current answer to that is very brutal:
+     * we do a "exit(0)" to kill the JVM from the C code after the call to MSG_run(). Definitely unpleasant.
+     */
+
+    if (simgrid::kernel::context::factory_initializer == nullptr) // Only Java sets a factory_initializer, for now
+      process->throw_exception(std::make_exception_ptr(simgrid::kernel::context::Context::StopRequest("Host failed")));
+  }
+
   /* destroy the blocking synchro if any */
   if (process->waiting_synchro != nullptr) {
-    if (process->host_->is_off())
-      process->throw_exception(std::make_exception_ptr(simgrid::HostFailureException(XBT_THROW_POINT, "Host failed")));
+
     simgrid::kernel::activity::ExecImplPtr exec =
         boost::dynamic_pointer_cast<simgrid::kernel::activity::ExecImpl>(process->waiting_synchro);
     simgrid::kernel::activity::CommImplPtr comm =
@@ -536,7 +562,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;
@@ -754,6 +782,8 @@ void SIMIX_process_yield(smx_actor_t self)
 
     XBT_DEBUG("Process %s@%s is dead", self->get_cname(), self->host_->get_cname());
     self->context_->stop();
+    xbt_backtrace_display_current();
+    xbt_die("I should be dead by now.");
   }
 
   if (self->suspended_) {