these archaic callbacks are not used anymore, so kill them

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

diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index fd72b81..88734d6 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);
@@ -177,8 +178,8 @@ simgrid::s4u::Actor* ActorImpl::restart()
   SIMIX_process_kill(this, (this == simix_global->maestro_process) ? this : SIMIX_process_self());
 
   // start the new process
-  ActorImpl* actor = simix_global->create_process_function(arg.name.c_str(), std::move(arg.code), arg.data, arg.host,
-                                                           arg.properties.get(), nullptr);
+  ActorImpl* actor =
+      SIMIX_process_create(arg.name.c_str(), std::move(arg.code), arg.data, arg.host, arg.properties.get(), nullptr);
   simcall_process_set_kill_time(actor, arg.kill_time);
   actor->set_auto_restart(arg.auto_restart);
 
@@ -358,7 +359,7 @@ smx_actor_t SIMIX_process_create(std::string name, simgrid::simix::ActorCode cod
   process->code         = code;
 
   XBT_VERB("Create context %s", process->get_cname());
-  process->context_ = SIMIX_context_new(std::move(code), simix_global->cleanup_process_function, process);
+  process->context_ = SIMIX_context_new(std::move(code), &SIMIX_process_cleanup, process);
 
   /* Add properties */
   if (properties != nullptr)
@@ -415,7 +416,7 @@ smx_actor_t SIMIX_process_attach(const char* name, void* data, const char* hostn
   XBT_VERB("Create context %s", process->get_cname());
   if (not simix_global)
     xbt_die("simix is not initialized, please call MSG_init first");
-  process->context_ = simix_global->context_factory->attach(simix_global->cleanup_process_function, process);
+  process->context_ = simix_global->context_factory->attach(&SIMIX_process_cleanup, process);
 
   /* Add properties */
   if (properties != nullptr)
@@ -451,7 +452,7 @@ void SIMIX_process_detach()
     xbt_die("Not a suitable context");
 
   auto process = context->process();
-  simix_global->cleanup_process_function(process);
+  SIMIX_process_cleanup(process);
   context->attach_stop();
 }
 
@@ -498,8 +499,31 @@ 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")));
+  // 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) {
@@ -758,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_) {