X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c7895d72bc8dfe43a87706f08f8ec5ea46664de9..3ae6123aa28d3dd81f94623705f692d0cde6de57:/src/s4u/s4u_Actor.cpp diff --git a/src/s4u/s4u_Actor.cpp b/src/s4u/s4u_Actor.cpp index d4ecc67bea..b44df1471f 100644 --- a/src/s4u/s4u_Actor.cpp +++ b/src/s4u/s4u_Actor.cpp @@ -21,50 +21,51 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor, "S4U actors"); namespace simgrid { namespace s4u { -simgrid::xbt::signal s4u::Actor::on_creation; -simgrid::xbt::signal s4u::Actor::on_suspend; -simgrid::xbt::signal s4u::Actor::on_resume; -simgrid::xbt::signal s4u::Actor::on_sleep; -simgrid::xbt::signal s4u::Actor::on_wake_up; -simgrid::xbt::signal s4u::Actor::on_migration_start; -simgrid::xbt::signal s4u::Actor::on_migration_end; -simgrid::xbt::signal s4u::Actor::on_destruction; +xbt::signal s4u::Actor::on_creation; +xbt::signal s4u::Actor::on_suspend; +xbt::signal s4u::Actor::on_resume; +xbt::signal s4u::Actor::on_sleep; +xbt::signal s4u::Actor::on_wake_up; +xbt::signal s4u::Actor::on_migration_start; +xbt::signal s4u::Actor::on_migration_end; +xbt::signal s4u::Actor::on_destruction; // ***** Actor creation ***** ActorPtr Actor::self() { - smx_context_t self_context = simgrid::kernel::context::Context::self(); + kernel::context::Context* self_context = kernel::context::Context::self(); if (self_context == nullptr) - return simgrid::s4u::ActorPtr(); + return ActorPtr(); return self_context->get_actor()->iface(); } -ActorPtr Actor::init(std::string name, s4u::Host* host) +ActorPtr Actor::init(const std::string& name, s4u::Host* host) { smx_actor_t self = SIMIX_process_self(); - simgrid::kernel::actor::ActorImpl* actor = - simgrid::simix::simcall([self, name, host] { return self->init(std::move(name), host).get(); }); + kernel::actor::ActorImpl* actor = simix::simcall([self, &name, host] { return self->init(name, host).get(); }); return actor->ciface(); } -ActorPtr Actor::start(std::function code) +ActorPtr Actor::start(const std::function& code) { - simgrid::simix::simcall([this, code] { pimpl_->start(code); }); + simgrid::simix::simcall([this, &code] { pimpl_->start(code); }); return this; } -ActorPtr Actor::create(std::string name, s4u::Host* host, std::function code) +ActorPtr Actor::create(const std::string& name, s4u::Host* host, const std::function& code) { - simgrid::kernel::actor::ActorImpl* actor = - simcall_process_create(std::move(name), std::move(code), nullptr, host, nullptr); + smx_actor_t self = SIMIX_process_self(); + kernel::actor::ActorImpl* actor = + simix::simcall([self, &name, host, &code] { return self->init(name, host)->start(code); }); return actor->iface(); } -ActorPtr Actor::create(std::string name, s4u::Host* host, const std::string& function, std::vector args) +ActorPtr Actor::create(const std::string& name, s4u::Host* host, const std::string& function, + std::vector args) { - simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function); - return create(std::move(name), host, factory(std::move(args))); + simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function); + return create(name, host, factory(std::move(args))); } void intrusive_ptr_add_ref(Actor* actor) @@ -90,11 +91,11 @@ void Actor::join(double timeout) void Actor::set_auto_restart(bool autorestart) { - simgrid::simix::simcall([this, autorestart]() { + simix::simcall([this, autorestart]() { xbt_assert(autorestart && not pimpl_->has_to_auto_restart()); // FIXME: handle all cases pimpl_->set_auto_restart(autorestart); - simgrid::kernel::actor::ProcessArg* arg = new simgrid::kernel::actor::ProcessArg(pimpl_->get_host(), pimpl_); + kernel::actor::ProcessArg* arg = new kernel::actor::ProcessArg(pimpl_->get_host(), pimpl_); XBT_DEBUG("Adding Process %s to the actors_at_boot_ list of Host %s", arg->name.c_str(), arg->host->get_cname()); pimpl_->get_host()->pimpl_->actors_at_boot_.emplace_back(arg); }); @@ -104,12 +105,17 @@ void Actor::on_exit(int_f_pvoid_pvoid_t fun, void* data) /* deprecated: cleanup SIMIX_process_on_exit: change prototype of second parameter and remove the last one */ { - simgrid::simix::simcall([this, fun, data] { SIMIX_process_on_exit(pimpl_, fun, data); }); + simix::simcall([this, fun, data] { SIMIX_process_on_exit(pimpl_, fun, data); }); +} + +void Actor::on_exit(const std::function& fun, void* data) /* deprecated */ +{ + on_exit([fun, data](bool exit) { fun(exit, data); }); } -void Actor::on_exit(std::function const fun) +void Actor::on_exit(const std::function& fun) { - simgrid::simix::simcall( + simix::simcall( [this, fun] { SIMIX_process_on_exit(pimpl_, [fun](int a, void* /*data*/) { fun(a != 0); }, nullptr); }); } @@ -117,12 +123,12 @@ void Actor::migrate(Host* new_host) { s4u::Actor::on_migration_start(this); - simgrid::simix::simcall([this, new_host]() { + simix::simcall([this, new_host]() { if (pimpl_->waiting_synchro != nullptr) { // The actor is blocked on an activity. If it's an exec, migrate it too. // FIXME: implement the migration of other kind of activities - simgrid::kernel::activity::ExecImplPtr exec = - boost::dynamic_pointer_cast(pimpl_->waiting_synchro); + kernel::activity::ExecImplPtr exec = + boost::dynamic_pointer_cast(pimpl_->waiting_synchro); xbt_assert(exec.get() != nullptr, "We can only migrate blocked actors when they are blocked on executions."); exec->migrate(new_host); } @@ -139,7 +145,7 @@ s4u::Host* Actor::get_host() void Actor::daemonize() { - simgrid::simix::simcall([this]() { pimpl_->daemonize(); }); + simix::simcall([this]() { pimpl_->daemonize(); }); } bool Actor::is_daemon() const @@ -175,18 +181,18 @@ void Actor::suspend() void Actor::resume() { - simgrid::simix::simcall([this] { pimpl_->resume(); }); + simix::simcall([this] { pimpl_->resume(); }); s4u::Actor::on_resume(this); } bool Actor::is_suspended() { - return simgrid::simix::simcall([this] { return pimpl_->is_suspended(); }); + return simix::simcall([this] { return pimpl_->is_suspended(); }); } void Actor::set_kill_time(double kill_time) { - simgrid::simix::simcall([this, kill_time] { pimpl_->set_kill_time(kill_time); }); + simix::simcall([this, kill_time] { pimpl_->set_kill_time(kill_time); }); } /** @brief Get the kill time of an actor(or 0 if unset). */ @@ -197,10 +203,10 @@ double Actor::get_kill_time() void Actor::kill(aid_t pid) // deprecated { - smx_actor_t killer = SIMIX_process_self(); - smx_actor_t victim = SIMIX_process_from_PID(pid); + kernel::actor::ActorImpl* killer = SIMIX_process_self(); + kernel::actor::ActorImpl* victim = SIMIX_process_from_PID(pid); if (victim != nullptr) { - simgrid::simix::simcall([killer, victim] { killer->kill(victim); }); + simix::simcall([killer, victim] { killer->kill(victim); }); } else { std::ostringstream oss; oss << "kill: (" << pid << ") - No such actor" << std::endl; @@ -210,16 +216,14 @@ void Actor::kill(aid_t pid) // deprecated void Actor::kill() { - smx_actor_t process = SIMIX_process_self(); - simgrid::simix::simcall([this, process] { - if (pimpl_ == simix_global->maestro_process) - pimpl_->exit(); - else - process->kill(pimpl_); + kernel::actor::ActorImpl* process = SIMIX_process_self(); + simix::simcall([this, process] { + xbt_assert(pimpl_ != simix_global->maestro_process, "Killing maestro is a rather bad idea"); + process->kill(pimpl_); }); } -smx_actor_t Actor::get_impl() +kernel::actor::ActorImpl* Actor::get_impl() { return pimpl_; } @@ -228,7 +232,7 @@ smx_actor_t Actor::get_impl() ActorPtr Actor::by_pid(aid_t pid) { - smx_actor_t process = SIMIX_process_from_PID(pid); + kernel::actor::ActorImpl* process = SIMIX_process_from_PID(pid); if (process != nullptr) return process->iface(); else @@ -237,29 +241,29 @@ ActorPtr Actor::by_pid(aid_t pid) void Actor::kill_all() { - smx_actor_t self = SIMIX_process_self(); - simgrid::simix::simcall([self] { self->kill_all(); }); + kernel::actor::ActorImpl* self = SIMIX_process_self(); + simix::simcall([self] { self->kill_all(); }); } std::unordered_map* Actor::get_properties() { - return simgrid::simix::simcall([this] { return this->pimpl_->get_properties(); }); + return simix::simcall([this] { return this->pimpl_->get_properties(); }); } /** Retrieve the property value (or nullptr if not set) */ const char* Actor::get_property(const std::string& key) { - return simgrid::simix::simcall([this, key] { return pimpl_->get_property(key); }); + return simix::simcall([this, &key] { return pimpl_->get_property(key); }); } -void Actor::set_property(const std::string& key, std::string value) +void Actor::set_property(const std::string& key, const std::string& value) { - simgrid::simix::simcall([this, key, value] { pimpl_->set_property(key, std::move(value)); }); + simix::simcall([this, &key, &value] { pimpl_->set_property(key, value); }); } Actor* Actor::restart() { - return simgrid::simix::simcall([this]() { return pimpl_->restart(); }); + return simix::simcall([this]() { return pimpl_->restart(); }); } // ***** this_actor ***** @@ -277,25 +281,25 @@ namespace this_actor { */ bool is_maestro() { - smx_actor_t process = SIMIX_process_self(); + kernel::actor::ActorImpl* process = SIMIX_process_self(); return process == nullptr || process == simix_global->maestro_process; } void sleep_for(double duration) { if (duration > 0) { - smx_actor_t actor = SIMIX_process_self(); - simgrid::s4u::Actor::on_sleep(actor->iface()); + kernel::actor::ActorImpl* actor = SIMIX_process_self(); + Actor::on_sleep(actor->iface()); simcall_process_sleep(duration); - simgrid::s4u::Actor::on_wake_up(actor->iface()); + Actor::on_wake_up(actor->iface()); } } void yield() { - simgrid::simix::simcall([] { /* do nothing*/ }); + simix::simcall([] { /* do nothing*/ }); } XBT_PUBLIC void sleep_until(double timeout) @@ -331,10 +335,10 @@ void parallel_execute(const std::vector& hosts, const std::vector(hosts.front())); + bool is_a_vm = (nullptr != dynamic_cast(hosts.front())); xbt_assert(std::all_of(hosts.begin(), hosts.end(), [is_a_vm](s4u::Host* elm) { - bool tmp_is_a_vm = (nullptr != dynamic_cast(elm)); + bool tmp_is_a_vm = (nullptr != dynamic_cast(elm)); return is_a_vm == tmp_is_a_vm; }), "parallel_execute: mixing VMs and PMs is not supported (yet)."); @@ -413,31 +417,31 @@ Host* get_host() void suspend() { - smx_actor_t actor = SIMIX_process_self(); - simgrid::s4u::Actor::on_suspend(actor->iface()); + kernel::actor::ActorImpl* actor = SIMIX_process_self(); + Actor::on_suspend(actor->iface()); simcall_process_suspend(actor); } void resume() { - smx_actor_t process = SIMIX_process_self(); - simgrid::simix::simcall([process] { process->resume(); }); - simgrid::s4u::Actor::on_resume(process->iface()); + kernel::actor::ActorImpl* self = SIMIX_process_self(); + simix::simcall([self] { self->resume(); }); + Actor::on_resume(self->iface()); } void exit() { - smx_actor_t actor = SIMIX_process_self(); - simgrid::simix::simcall([actor] { actor->exit(); }); + kernel::actor::ActorImpl* self = SIMIX_process_self(); + simgrid::simix::simcall([self] { self->exit(); }); } -void on_exit(std::function const fun) +void on_exit(const std::function& fun) { SIMIX_process_self()->iface()->on_exit(fun); } -void on_exit(std::function const fun, void* data) /* deprecated */ +void on_exit(const std::function& fun, void* data) /* deprecated */ { SIMIX_process_self()->iface()->on_exit([fun, data](bool exit) { fun(exit, data); }); }