+}
+
+static int dying_daemon(void* exit_status, void* data)
+{
+ std::vector<ActorImpl*>* vect = &simix_global->daemons;
+
+ auto it = std::find(vect->begin(), vect->end(), static_cast<ActorImpl*>(data));
+ xbt_assert(it != vect->end(), "The dying daemon is not a daemon after all. Please report that bug.");
+
+ /* Don't move the whole content since we don't really care about the order */
+ std::swap(*it, vect->back());
+ vect->pop_back();
+
+ return 0;
+}
+/** This process will be terminated automatically when the last non-daemon process finishes */
+void ActorImpl::daemonize()
+{
+ if (not daemon) {
+ daemon = true;
+ simix_global->daemons.push_back(this);
+ SIMIX_process_on_exit(this, dying_daemon, this);
+ }
+}
+
+simgrid::s4u::Actor* ActorImpl::restart()
+{
+ XBT_DEBUG("Restarting process %s on %s", cname(), host->getCname());
+
+ // retrieve the arguments of the old process
+ // FIXME: Factorize this with SIMIX_host_add_auto_restart_process ?
+ simgrid::simix::ProcessArg arg;
+ arg.name = name;
+ arg.code = code;
+ arg.host = host;
+ arg.kill_time = SIMIX_timer_get_date(kill_timer);
+ arg.data = userdata;
+ arg.properties = nullptr;
+ arg.auto_restart = auto_restart;
+
+ // kill the old process
+ 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);
+ if (arg.kill_time >= 0)
+ simcall_process_set_kill_time(actor, arg.kill_time);
+ if (arg.auto_restart)
+ actor->auto_restart = arg.auto_restart;
+
+ return actor->ciface();
+}
+
+smx_activity_t ActorImpl::suspend(ActorImpl* issuer)
+{
+ if (suspended) {
+ XBT_DEBUG("Actor '%s' is already suspended", name.c_str());
+ return nullptr;
+ }
+
+ suspended = 1;
+
+ /* If we are suspending another actor that is waiting on a sync, suspend its synchronization. */
+ if (this != issuer) {
+ if (waiting_synchro)
+ waiting_synchro->suspend();
+ /* If the other actor is not waiting, its suspension is delayed to when the actor is rescheduled. */
+
+ return nullptr;
+ } else {
+ return SIMIX_execution_start(this, "suspend", 0.0, 1.0, 0.0);
+ }
+}
+
+void ActorImpl::resume()
+{
+ XBT_IN("process = %p", this);
+
+ if (context->iwannadie) {
+ XBT_VERB("Ignoring request to suspend an actor that is currently dying.");
+ return;
+ }
+
+ if (not suspended)
+ return;
+ suspended = 0;
+
+ /* resume the synchronization that was blocking the resumed actor. */
+ if (waiting_synchro)
+ waiting_synchro->resume();
+
+ XBT_OUT();
+}
+
+smx_activity_t ActorImpl::sleep(double duration)
+{
+ if (host->isOff())
+ THROWF(host_error, 0, "Host %s failed, you cannot sleep there.", host->getCname());
+
+ simgrid::kernel::activity::SleepImpl* synchro = new simgrid::kernel::activity::SleepImpl();
+ synchro->host = host;
+ synchro->surf_sleep = host->pimpl_cpu->sleep(duration);
+ synchro->surf_sleep->setData(synchro);
+ XBT_DEBUG("Create sleep synchronization %p", synchro);
+
+ return synchro;