Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Deobfuscation.
[simgrid.git] / src / kernel / actor / ActorImpl.cpp
1 /* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "mc/mc.h"
7 #include "simgrid/Exception.hpp"
8 #include "simgrid/s4u/Actor.hpp"
9 #include "simgrid/s4u/Exec.hpp"
10 #include "src/kernel/activity/CommImpl.hpp"
11 #include "src/kernel/activity/ExecImpl.hpp"
12 #include "src/kernel/activity/IoImpl.hpp"
13 #include "src/kernel/activity/SleepImpl.hpp"
14 #include "src/kernel/activity/SynchroRaw.hpp"
15 #include "src/mc/mc_replay.hpp"
16 #include "src/mc/remote/Client.hpp"
17 #include "src/simix/smx_private.hpp"
18 #include "src/surf/HostImpl.hpp"
19 #include "src/surf/cpu_interface.hpp"
20
21 #include <boost/range/algorithm.hpp>
22
23 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix, "Logging specific to SIMIX (process)");
24
25 static unsigned long simix_process_maxpid = 0;
26
27 /**
28  * @brief Returns the current agent.
29  *
30  * This functions returns the currently running SIMIX process.
31  *
32  * @return The SIMIX process
33  */
34 smx_actor_t SIMIX_process_self()
35 {
36   simgrid::kernel::context::Context* self_context = simgrid::kernel::context::Context::self();
37
38   return (self_context != nullptr) ? self_context->get_actor() : nullptr;
39 }
40
41 /**
42  * @brief Returns whether a process has pending asynchronous communications.
43  * @return true if there are asynchronous communications in this process
44  * @deprecated
45  */
46 int SIMIX_process_has_pending_comms(smx_actor_t process)
47 {
48
49   return process->comms.size() > 0;
50 }
51
52 namespace simgrid {
53 namespace kernel {
54 namespace actor {
55
56 ActorImpl::ActorImpl(const simgrid::xbt::string& name, s4u::Host* host) : host_(host), name_(name), piface_(this)
57 {
58   pid_           = simix_process_maxpid++;
59   simcall.issuer = this;
60 }
61
62 ActorImpl::~ActorImpl() = default;
63
64 /* Become an actor in the simulation
65  *
66  * Currently this can only be called by the main thread (once) and only work with some thread factories
67  * (currently ThreadContextFactory).
68  *
69  * In the future, it might be extended in order to attach other threads created by a third party library.
70  */
71
72 ActorImplPtr ActorImpl::attach(const std::string& name, void* data, s4u::Host* host,
73                                const std::unordered_map<std::string, std::string>* properties)
74 {
75   // This is mostly a copy/paste from create(), it'd be nice to share some code between those two functions.
76
77   XBT_DEBUG("Attach process %s on host '%s'", name.c_str(), host->get_cname());
78
79   if (not host->is_on()) {
80     XBT_WARN("Cannot launch process '%s' on failed host '%s'", name.c_str(), host->get_cname());
81     throw simgrid::HostFailureException(XBT_THROW_POINT, "Cannot attach actor on failed host.");
82   }
83
84   ActorImpl* actor = new ActorImpl(xbt::string(name), host);
85   /* Actor data */
86   actor->set_user_data(data);
87   actor->code_ = nullptr;
88
89   XBT_VERB("Create context %s", actor->get_cname());
90   xbt_assert(simix_global != nullptr, "simix is not initialized, please call MSG_init first");
91   actor->context_.reset(simix_global->context_factory->attach(actor));
92
93   /* Add properties */
94   if (properties != nullptr)
95     actor->set_properties(*properties);
96
97   /* Add the process to it's host process list */
98   host->pimpl_->process_list_.push_back(*actor);
99
100   /* Now insert it in the global process list and in the process to run list */
101   simix_global->process_list[actor->get_pid()] = actor;
102   XBT_DEBUG("Inserting [%p] %s(%s) in the to_run list", actor, actor->get_cname(), host->get_cname());
103   simix_global->actors_to_run.push_back(actor);
104   intrusive_ptr_add_ref(actor);
105
106   auto* context = dynamic_cast<simgrid::kernel::context::AttachContext*>(actor->context_.get());
107   xbt_assert(nullptr != context, "Not a suitable context");
108   context->attach_start();
109
110   /* The on_creation() signal must be delayed until there, where the pid and everything is set */
111   simgrid::s4u::Actor::on_creation(*actor->ciface());
112
113   return ActorImplPtr(actor);
114 }
115 /** @brief Detach an actor attached with `attach()`
116  *
117  *  This is called when the current actor has finished its job.
118  *  Used in the main thread, it waits for the simulation to finish before returning. When it returns, the other
119  *  simulated actors and the maestro are destroyed.
120  */
121 void ActorImpl::detach()
122 {
123   auto* context = dynamic_cast<context::AttachContext*>(context::Context::self());
124   if (context == nullptr)
125     xbt_die("Not a suitable context");
126
127   context->get_actor()->cleanup();
128   context->attach_stop();
129 }
130
131 void ActorImpl::cleanup()
132 {
133   finished_ = true;
134
135   if (has_to_auto_restart() && not get_host()->is_on()) {
136     XBT_DEBUG("Insert host %s to watched_hosts because it's off and %s needs to restart", get_host()->get_cname(),
137               get_cname());
138     watched_hosts.insert(get_host()->get_name());
139   }
140
141   if (on_exit) {
142     // Execute the termination callbacks
143     bool failed = context_->iwannadie;
144     for (auto exit_fun = on_exit->crbegin(); exit_fun != on_exit->crend(); ++exit_fun)
145       (*exit_fun)(failed);
146     on_exit.reset();
147   }
148   undaemonize();
149
150   /* cancel non-blocking activities */
151   for (auto activity : comms)
152     boost::static_pointer_cast<activity::CommImpl>(activity)->cancel();
153   comms.clear();
154
155   XBT_DEBUG("%s@%s(%ld) should not run anymore", get_cname(), get_host()->get_cname(), get_pid());
156
157   if (this == simix_global->maestro_process) /* Do not cleanup maestro */
158     return;
159
160   XBT_DEBUG("Cleanup actor %s (%p), waiting synchro %p", get_cname(), this, waiting_synchro.get());
161
162   /* Unregister from the kill timer if any */
163   if (kill_timer != nullptr) {
164     kill_timer->remove();
165     kill_timer = nullptr;
166   }
167
168   simix_global->mutex.lock();
169
170   simix_global->process_list.erase(pid_);
171   if (host_ && host_process_list_hook.is_linked())
172     simgrid::xbt::intrusive_erase(host_->pimpl_->process_list_, *this);
173   if (not smx_destroy_list_hook.is_linked()) {
174 #if SIMGRID_HAVE_MC
175     xbt_dynar_push_as(simix_global->dead_actors_vector, ActorImpl*, this);
176 #endif
177     simix_global->actors_to_destroy.push_back(*this);
178   }
179
180   simix_global->mutex.unlock();
181
182   context_->iwannadie = false; // don't let the simcall's yield() do a Context::stop(), to avoid infinite loops
183   simgrid::simix::simcall([this] { simgrid::s4u::Actor::on_destruction(*ciface()); });
184   context_->iwannadie = true;
185 }
186
187 void ActorImpl::exit()
188 {
189   context_->iwannadie = true;
190   suspended_          = false;
191   exception_          = nullptr;
192
193   // Forcefully kill the actor if its host is turned off. Not a HostFailureException because you should not survive that
194   if (not host_->is_on())
195     this->throw_exception(std::make_exception_ptr(ForcefulKillException("host failed")));
196
197   /* destroy the blocking synchro if any */
198   if (waiting_synchro != nullptr) {
199     waiting_synchro->cancel();
200     waiting_synchro->state_ = SIMIX_FAILED;
201
202     activity::ExecImplPtr exec   = boost::dynamic_pointer_cast<activity::ExecImpl>(waiting_synchro);
203     activity::CommImplPtr comm   = boost::dynamic_pointer_cast<activity::CommImpl>(waiting_synchro);
204
205     if (exec != nullptr) {
206       exec->clean_action();
207     } else if (comm != nullptr) {
208       comms.remove(waiting_synchro);
209       // Remove first occurrence of &actor->simcall:
210       auto i = boost::range::find(waiting_synchro->simcalls_, &simcall);
211       if (i != waiting_synchro->simcalls_.end())
212         waiting_synchro->simcalls_.remove(&simcall);
213     } else {
214       activity::ActivityImplPtr(waiting_synchro)->finish();
215     }
216
217     waiting_synchro = nullptr;
218   }
219 }
220
221 void ActorImpl::kill(ActorImpl* actor)
222 {
223   if (actor->finished_) {
224     XBT_DEBUG("Ignoring request to kill actor %s@%s that is already dead", actor->get_cname(),
225               actor->host_->get_cname());
226     return;
227   }
228
229   XBT_DEBUG("Actor '%s'@%s is killing actor '%s'@%s", get_cname(), host_ ? host_->get_cname() : "", actor->get_cname(),
230             actor->host_ ? actor->host_->get_cname() : "");
231
232   actor->exit();
233
234   if (std::find(begin(simix_global->actors_to_run), end(simix_global->actors_to_run), actor) ==
235           end(simix_global->actors_to_run) &&
236       actor != this) {
237     XBT_DEBUG("Inserting %s in the to_run list", actor->get_cname());
238     simix_global->actors_to_run.push_back(actor);
239   }
240 }
241
242 void ActorImpl::kill_all()
243 {
244   for (auto const& kv : simix_global->process_list)
245     if (kv.second != this)
246       this->kill(kv.second);
247 }
248
249 void ActorImpl::set_kill_time(double kill_time)
250 {
251   if (kill_time <= SIMIX_get_clock())
252     return;
253   XBT_DEBUG("Set kill time %f for actor %s@%s", kill_time, get_cname(), host_->get_cname());
254   kill_timer = simix::Timer::set(kill_time, [this] {
255     this->exit();
256     kill_timer = nullptr;
257   });
258 }
259
260 double ActorImpl::get_kill_time()
261 {
262   return kill_timer ? kill_timer->get_date() : 0;
263 }
264
265 void ActorImpl::yield()
266 {
267   XBT_DEBUG("Yield actor '%s'", get_cname());
268
269   /* Go into sleep and return control to maestro */
270   context_->suspend();
271
272   /* Ok, maestro returned control to us */
273   XBT_DEBUG("Control returned to me: '%s'", get_cname());
274
275   if (context_->iwannadie) {
276     XBT_DEBUG("Actor %s@%s is dead", get_cname(), host_->get_cname());
277     // throw simgrid::kernel::context::ForcefulKillException(); Does not seem to properly kill the actor
278     context_->stop();
279     THROW_IMPOSSIBLE;
280   }
281
282   if (suspended_) {
283     XBT_DEBUG("Hey! I'm suspended.");
284
285     xbt_assert(exception_ == nullptr, "Gasp! This exception may be lost by subsequent calls.");
286     suspended_ = false;
287     suspend(this);
288   }
289
290   if (exception_ != nullptr) {
291     XBT_DEBUG("Wait, maestro left me an exception");
292     std::exception_ptr exception = std::move(exception_);
293     exception_                   = nullptr;
294     std::rethrow_exception(std::move(exception));
295   }
296
297   if (SMPI_switch_data_segment && not finished_) {
298     SMPI_switch_data_segment(iface());
299   }
300 }
301
302 /** This actor will be terminated automatically when the last non-daemon actor finishes */
303 void ActorImpl::daemonize()
304 {
305   if (not daemon_) {
306     daemon_ = true;
307     simix_global->daemons.push_back(this);
308   }
309 }
310
311 void ActorImpl::undaemonize()
312 {
313   if (daemon_) {
314     auto& vect = simix_global->daemons;
315     auto it    = std::find(vect.begin(), vect.end(), this);
316     xbt_assert(it != vect.end(), "The dying daemon is not a daemon after all. Please report that bug.");
317     /* Don't move the whole content since we don't really care about the order */
318
319     std::swap(*it, vect.back());
320     vect.pop_back();
321     daemon_ = false;
322   }
323 }
324
325 s4u::Actor* ActorImpl::restart()
326 {
327   xbt_assert(this != simix_global->maestro_process, "Restarting maestro is not supported");
328
329   XBT_DEBUG("Restarting actor %s on %s", get_cname(), host_->get_cname());
330
331   // retrieve the arguments of the old actor
332   ProcessArg arg = ProcessArg(host_, this);
333
334   // kill the old actor
335   context::Context::self()->get_actor()->kill(this);
336
337   // start the new actor
338   ActorImplPtr actor =
339       ActorImpl::create(arg.name, std::move(arg.code), arg.data, arg.host, arg.properties.get(), nullptr);
340   *actor->on_exit = std::move(*arg.on_exit);
341   actor->set_kill_time(arg.kill_time);
342   actor->set_auto_restart(arg.auto_restart);
343
344   return actor->ciface();
345 }
346
347 activity::ActivityImplPtr ActorImpl::suspend(ActorImpl* issuer)
348 {
349   if (suspended_) {
350     XBT_DEBUG("Actor '%s' is already suspended", get_cname());
351     return nullptr;
352   }
353
354   suspended_ = true;
355
356   /* If we are suspending another actor that is waiting on a sync, suspend its synchronization. */
357   if (this != issuer) {
358     if (waiting_synchro)
359       waiting_synchro->suspend();
360     /* If the other actor is not waiting, its suspension is delayed to when the actor is rescheduled. */
361
362     return nullptr;
363   } else {
364     activity::ExecImpl* exec = new activity::ExecImpl();
365     (*exec).set_name("suspend").set_host(host_).set_flops_amount(0.0).start();
366     return activity::ExecImplPtr(exec);
367   }
368 }
369
370 void ActorImpl::resume()
371 {
372   XBT_IN("actor = %p", this);
373
374   if (context_->iwannadie) {
375     XBT_VERB("Ignoring request to suspend an actor that is currently dying.");
376     return;
377   }
378
379   if (not suspended_)
380     return;
381   suspended_ = false;
382
383   /* resume the synchronization that was blocking the resumed actor. */
384   if (waiting_synchro)
385     waiting_synchro->resume();
386
387   XBT_OUT();
388 }
389
390 activity::ActivityImplPtr ActorImpl::join(ActorImpl* actor, double timeout)
391 {
392   activity::ActivityImplPtr sleep = this->sleep(timeout);
393   SIMIX_process_on_exit(actor, [sleep](bool) {
394     if (sleep->surf_action_)
395       sleep->surf_action_->finish(resource::Action::State::FINISHED);
396   });
397   return sleep;
398 }
399
400 activity::ActivityImplPtr ActorImpl::sleep(double duration)
401 {
402   if (not host_->is_on())
403     throw_exception(std::make_exception_ptr(simgrid::HostFailureException(
404         XBT_THROW_POINT, std::string("Host ") + host_->get_cname() + " failed, you cannot sleep there.")));
405
406   activity::SleepImpl* sleep = new activity::SleepImpl();
407   (*sleep).set_name("sleep").set_host(host_).set_duration(duration).start();
408   return activity::SleepImplPtr(sleep);
409 }
410
411 void ActorImpl::throw_exception(std::exception_ptr e)
412 {
413   exception_ = e;
414
415   if (suspended_)
416     resume();
417
418   /* cancel the blocking synchro if any */
419   if (waiting_synchro) {
420     waiting_synchro->cancel();
421
422     activity::CommImplPtr comm = boost::dynamic_pointer_cast<activity::CommImpl>(waiting_synchro);
423
424     if (comm != nullptr)
425       comms.remove(comm);
426
427     waiting_synchro = nullptr;
428   }
429 }
430
431 void ActorImpl::set_host(s4u::Host* dest)
432 {
433   xbt::intrusive_erase(host_->pimpl_->process_list_, *this);
434   host_ = dest;
435   dest->pimpl_->process_list_.push_back(*this);
436 }
437
438 ActorImplPtr ActorImpl::init(const std::string& name, s4u::Host* host)
439 {
440   ActorImpl* actor = new ActorImpl(xbt::string(name), host);
441   actor->set_ppid(this->pid_);
442
443   intrusive_ptr_add_ref(actor);
444   /* The on_creation() signal must be delayed until there, where the pid and everything is set */
445   s4u::Actor::on_creation(*actor->ciface());
446
447   return ActorImplPtr(actor);
448 }
449
450 ActorImpl* ActorImpl::start(const simix::ActorCode& code)
451 {
452   xbt_assert(code && host_ != nullptr, "Invalid parameters");
453
454   if (not host_->is_on()) {
455     XBT_WARN("Cannot launch actor '%s' on failed host '%s'", name_.c_str(), host_->get_cname());
456     intrusive_ptr_release(this);
457     throw simgrid::HostFailureException(XBT_THROW_POINT, "Cannot start actor on failed host.");
458   }
459
460   this->code_ = code;
461   XBT_VERB("Create context %s", get_cname());
462   context_.reset(simix_global->context_factory->create_context(simix::ActorCode(code), this));
463
464   XBT_DEBUG("Start context '%s'", get_cname());
465
466   /* Add the actor to its host's actor list */
467   host_->pimpl_->process_list_.push_back(*this);
468   simix_global->process_list[pid_] = this;
469
470   /* Now insert it in the global actor list and in the actor to run list */
471   XBT_DEBUG("Inserting [%p] %s(%s) in the to_run list", this, get_cname(), host_->get_cname());
472   simix_global->actors_to_run.push_back(this);
473
474   return this;
475 }
476
477 ActorImplPtr ActorImpl::create(const std::string& name, const simix::ActorCode& code, void* data, s4u::Host* host,
478                                const std::unordered_map<std::string, std::string>* properties, ActorImpl* parent_actor)
479 {
480   XBT_DEBUG("Start actor %s@'%s'", name.c_str(), host->get_cname());
481
482   ActorImplPtr actor;
483   if (parent_actor != nullptr)
484     actor = parent_actor->init(xbt::string(name), host);
485   else
486     actor = SIMIX_process_self()->init(xbt::string(name), host);
487
488   /* actor data */
489   actor->set_user_data(data);
490
491   /* Add properties */
492   if (properties != nullptr)
493     actor->set_properties(*properties);
494
495   actor->start(code);
496
497   return actor;
498 }
499
500 void create_maestro(const std::function<void()>& code)
501 {
502   /* Create maestro actor and initialize it */
503   ActorImpl* maestro = new ActorImpl(xbt::string(""), /*host*/ nullptr);
504
505   if (not code) {
506     maestro->context_.reset(simix_global->context_factory->create_context(simix::ActorCode(), maestro));
507   } else {
508     maestro->context_.reset(simix_global->context_factory->create_maestro(simix::ActorCode(code), maestro));
509   }
510
511   maestro->simcall.issuer       = maestro;
512   simix_global->maestro_process = maestro;
513 }
514
515 } // namespace actor
516 } // namespace kernel
517 } // namespace simgrid
518
519 void SIMIX_process_detach()
520 {
521   simgrid::kernel::actor::ActorImpl::detach();
522 }
523
524 smx_actor_t SIMIX_process_attach(const char* name, void* data, const char* hostname,
525                                  std::unordered_map<std::string, std::string>* properties,
526                                  smx_actor_t /*parent_process*/)
527 {
528   return simgrid::kernel::actor::ActorImpl::attach(name, data, sg_host_by_name(hostname), properties).get();
529 }
530
531 /** @deprecated When this function gets removed, also remove the xbt_ex class, that is only there to help users to
532  * transition */
533 void SIMIX_process_throw(smx_actor_t actor, xbt_errcat_t cat, int value, const char* msg)
534 {
535   xbt_ex e(XBT_THROW_POINT, msg);
536   e.category = cat;
537   e.value    = value;
538   actor->throw_exception(std::make_exception_ptr(e));
539 }
540
541 void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t actor)
542 {
543   smx_activity_t sync_suspend = actor->suspend(simcall->issuer);
544
545   if (actor != simcall->issuer) {
546     SIMIX_simcall_answer(simcall);
547   } else {
548     sync_suspend->simcalls_.push_back(simcall);
549     actor->waiting_synchro = sync_suspend;
550     actor->waiting_synchro->suspend();
551   }
552   /* If we are suspending ourselves, then just do not finish the simcall now */
553 }
554
555 int SIMIX_process_get_maxpid()
556 {
557   return simix_process_maxpid;
558 }
559
560 int SIMIX_process_count()
561 {
562   return simix_global->process_list.size();
563 }
564
565 void* SIMIX_process_self_get_data() // deprecated
566 {
567   smx_actor_t self = SIMIX_process_self();
568
569   if (self == nullptr) {
570     return nullptr;
571   }
572   return self->get_user_data();
573 }
574
575 void SIMIX_process_self_set_data(void* data) // deprecated
576 {
577   SIMIX_process_self()->set_user_data(data);
578 }
579
580 /* needs to be public and without simcall because it is called
581    by exceptions and logging events */
582 const char* SIMIX_process_self_get_name()
583 {
584
585   smx_actor_t process = SIMIX_process_self();
586   if (process == nullptr || process == simix_global->maestro_process)
587     return "maestro";
588
589   return process->get_cname();
590 }
591
592 void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout)
593 {
594   if (process->finished_) {
595     // The joined process is already finished, just wake up the issuer process right away
596     simcall_process_sleep__set__result(simcall, SIMIX_DONE);
597     SIMIX_simcall_answer(simcall);
598     return;
599   }
600   smx_activity_t sync = simcall->issuer->join(process, timeout);
601   sync->simcalls_.push_back(simcall);
602   simcall->issuer->waiting_synchro = sync;
603 }
604
605 void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration)
606 {
607   if (MC_is_active() || MC_record_replay_is_active()) {
608     MC_process_clock_add(simcall->issuer, duration);
609     simcall_process_sleep__set__result(simcall, SIMIX_DONE);
610     SIMIX_simcall_answer(simcall);
611     return;
612   }
613   smx_activity_t sync = simcall->issuer->sleep(duration);
614   sync->simcalls_.push_back(simcall);
615   simcall->issuer->waiting_synchro = sync;
616 }
617
618 /**
619  * @brief Calling this function makes the process to yield.
620  *
621  * Only the current process can call this function, giving back the control to maestro.
622  *
623  * @param self the current process
624  */
625
626 /** @brief Returns the list of processes to run.
627  * @deprecated
628  */
629 const std::vector<smx_actor_t>& simgrid::simix::process_get_runnable()
630 {
631   return simix_global->actors_to_run;
632 }
633
634 /** @brief Returns the process from PID. */
635 smx_actor_t SIMIX_process_from_PID(aid_t PID)
636 {
637   auto actor = simix_global->process_list.find(PID);
638   return actor == simix_global->process_list.end() ? nullptr : actor->second;
639 }
640
641 void SIMIX_process_on_exit(smx_actor_t actor, int_f_pvoid_pvoid_t fun, void* data)
642 {
643   SIMIX_process_on_exit(actor, [fun, data](bool failed) {
644     intptr_t status = failed ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS;
645     fun(reinterpret_cast<void*>(status), data);
646   });
647 }
648
649 void SIMIX_process_on_exit(smx_actor_t actor, const std::function<void(int, void*)>& fun, void* data)
650 {
651   SIMIX_process_on_exit(actor, [fun, data](bool failed) { fun(failed ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS, data); });
652 }
653
654 void SIMIX_process_on_exit(smx_actor_t actor, const std::function<void(bool /*failed*/)>& fun)
655 {
656   xbt_assert(actor, "current process not found: are you in maestro context ?");
657   actor->on_exit->emplace_back(fun);
658 }
659
660 /** @brief Restart a process, starting it again from the beginning. */
661 /**
662  * @ingroup simix_process_management
663  * @brief Creates and runs a new SIMIX process.
664  *
665  * The structure and the corresponding thread are created and put in the list of ready processes.
666  *
667  * @param name a name for the process. It is for user-level information and can be nullptr.
668  * @param code the main function of the process
669  * @param data a pointer to any data one may want to attach to the new object. It is for user-level information and can
670  * be nullptr.
671  * It can be retrieved with the method ActorImpl::getUserData().
672  * @param host where the new agent is executed.
673  * @param properties the properties of the process
674  */
675 smx_actor_t simcall_process_create(const std::string& name, const simgrid::simix::ActorCode& code, void* data,
676                                    sg_host_t host, std::unordered_map<std::string, std::string>* properties)
677 {
678   smx_actor_t self = SIMIX_process_self();
679   return simgrid::simix::simcall([&name, &code, data, host, properties, self] {
680     return simgrid::kernel::actor::ActorImpl::create(name, code, data, host, properties, self).get();
681   });
682 }
683
684 void simcall_process_set_data(smx_actor_t process, void* data)
685 {
686   simgrid::simix::simcall([process, data] { process->set_user_data(data); });
687 }