use consistent namespaces

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

diff --git a/src/simix/ActorImpl.cpp b/src/simix/ActorImpl.cpp
index 2e604a9..e0ec997 100644 (file)
--- a/src/simix/ActorImpl.cpp
+++ b/src/simix/ActorImpl.cpp
@@ -52,16 +52,14 @@ namespace simgrid {
 namespace kernel {
 namespace actor {
 
-ActorImpl::ActorImpl(simgrid::xbt::string name, s4u::Host* host) : host_(host), name_(name), piface_(this)
+ActorImpl::ActorImpl(const simgrid::xbt::string& name, s4u::Host* host) : host_(host), name_(name), piface_(this)
 {
   pid_ = simix_process_maxpid++;
   simcall.issuer = this;
 }
 
-ActorImpl::~ActorImpl()
-{
-  delete this->context_;
-}
+ActorImpl::~ActorImpl() = default;
+
 /* Become an actor in the simulation
  *
  * Currently this can only be called by the main thread (once) and only work with some thread factories
@@ -70,7 +68,7 @@ ActorImpl::~ActorImpl()
  * In the future, it might be extended in order to attach other threads created by a third party library.
  */
 
-ActorImplPtr ActorImpl::attach(std::string name, void* data, s4u::Host* host,
+ActorImplPtr ActorImpl::attach(const std::string& name, void* data, s4u::Host* host,
                                std::unordered_map<std::string, std::string>* properties)
 {
   // This is mostly a copy/paste from create(), it'd be nice to share some code between those two functions.
@@ -90,7 +88,7 @@ ActorImplPtr ActorImpl::attach(std::string name, void* data, s4u::Host* host,
 
   XBT_VERB("Create context %s", actor->get_cname());
   xbt_assert(simix_global != nullptr, "simix is not initialized, please call MSG_init first");
-  actor->context_ = simix_global->context_factory->attach(actor);
+  actor->context_.reset(simix_global->context_factory->attach(actor));
 
   /* Add properties */
   if (properties != nullptr)
@@ -106,7 +104,7 @@ ActorImplPtr ActorImpl::attach(std::string name, void* data, s4u::Host* host,
   simix_global->actors_to_run.push_back(actor);
   intrusive_ptr_add_ref(actor);
 
-  auto* context = dynamic_cast<simgrid::kernel::context::AttachContext*>(actor->context_);
+  auto* context = dynamic_cast<simgrid::kernel::context::AttachContext*>(actor->context_.get());
   xbt_assert(nullptr != context, "Not a suitable context");
   context->attach_start();
 
@@ -444,7 +442,7 @@ void ActorImpl::set_host(s4u::Host* dest)
   dest->pimpl_->process_list_.push_back(*this);
 }
 
-ActorImplPtr ActorImpl::init(std::string name, s4u::Host* host)
+ActorImplPtr ActorImpl::init(const std::string& name, s4u::Host* host)
 {
   ActorImpl* actor = new ActorImpl(simgrid::xbt::string(name), host);
   actor->set_ppid(this->pid_);
@@ -456,19 +454,20 @@ ActorImplPtr ActorImpl::init(std::string name, s4u::Host* host)
   return ActorImplPtr(actor);
 }
 
-ActorImpl* ActorImpl::start(simix::ActorCode code)
+ActorImpl* ActorImpl::start(const simix::ActorCode& code)
 {
   xbt_assert(code && host_ != nullptr, "Invalid parameters");
 
   if (not host_->is_on()) {
     XBT_WARN("Cannot launch actor '%s' on failed host '%s'", name_.c_str(), host_->get_cname());
+    intrusive_ptr_release(this);
     std::rethrow_exception(
         std::make_exception_ptr(simgrid::HostFailureException(XBT_THROW_POINT, "Cannot start actor on failed host.")));
   }
 
   this->code = code;
   XBT_VERB("Create context %s", get_cname());
-  context_ = simix_global->context_factory->create_context(std::move(code), this);
+  context_.reset(simix_global->context_factory->create_context(simix::ActorCode(code), this));
 
   XBT_DEBUG("Start context '%s'", get_cname());
 
@@ -483,7 +482,7 @@ ActorImpl* ActorImpl::start(simix::ActorCode code)
   return this;
 }
 
-ActorImplPtr ActorImpl::create(std::string name, simix::ActorCode code, void* data, s4u::Host* host,
+ActorImplPtr ActorImpl::create(const std::string& name, const simix::ActorCode& code, void* data, s4u::Host* host,
                                std::unordered_map<std::string, std::string>* properties, ActorImpl* parent_actor)
 {
   XBT_DEBUG("Start actor %s@'%s'", name.c_str(), host->get_cname());
@@ -502,20 +501,20 @@ ActorImplPtr ActorImpl::create(std::string name, simix::ActorCode code, void* da
     for (auto const& kv : *properties)
       actor->set_property(kv.first, kv.second);
 
-  actor->start(std::move(code));
+  actor->start(code);
 
   return actor;
 }
 
-void create_maestro(simix::ActorCode code)
+void create_maestro(const std::function<void()>& code)
 {
   /* Create maestro actor and initialize it */
   ActorImpl* maestro = new ActorImpl(xbt::string(""), /*host*/ nullptr);
 
   if (not code) {
-    maestro->context_ = simix_global->context_factory->create_context(simix::ActorCode(), maestro);
+    maestro->context_.reset(simix_global->context_factory->create_context(simix::ActorCode(), maestro));
   } else {
-    maestro->context_ = simix_global->context_factory->create_maestro(code, maestro);
+    maestro->context_.reset(simix_global->context_factory->create_maestro(simix::ActorCode(code), maestro));
   }
 
   maestro->simcall.issuer       = maestro;
@@ -705,7 +704,7 @@ void SIMIX_process_on_exit(smx_actor_t actor, int_f_pvoid_pvoid_t fun, void* dat
   SIMIX_process_on_exit(actor, [fun](int a, void* b) { fun((void*)(intptr_t)a, b); }, data);
 }
 
-void SIMIX_process_on_exit(smx_actor_t actor, std::function<void(bool, void*)> fun, void* data)
+void SIMIX_process_on_exit(smx_actor_t actor, const std::function<void(bool, void*)>& fun, void* data)
 {
   xbt_assert(actor, "current process not found: are you in maestro context ?");
 
@@ -727,13 +726,12 @@ void SIMIX_process_on_exit(smx_actor_t actor, std::function<void(bool, void*)> f
  * @param host where the new agent is executed.
  * @param properties the properties of the process
  */
-smx_actor_t simcall_process_create(std::string name, simgrid::simix::ActorCode code, void* data, sg_host_t host,
-                                   std::unordered_map<std::string, std::string>* properties)
+smx_actor_t simcall_process_create(const std::string& name, const simgrid::simix::ActorCode& code, void* data,
+                                   sg_host_t host, std::unordered_map<std::string, std::string>* properties)
 {
   smx_actor_t self = SIMIX_process_self();
-  return simgrid::simix::simcall([name, code, data, host, properties, self] {
-    return simgrid::kernel::actor::ActorImpl::create(std::move(name), std::move(code), data, host, properties, self)
-        .get();
+  return simgrid::simix::simcall([&name, &code, data, host, properties, self] {
+    return simgrid::kernel::actor::ActorImpl::create(name, code, data, host, properties, self).get();
   });
 }