ActorPtr Actor::create(std::string name, s4u::Host* host, std::function<void()> code)
{
- simgrid::kernel::actor::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr);
+ simgrid::kernel::actor::ActorImpl* actor =
+ simcall_process_create(std::move(name), std::move(code), nullptr, host, nullptr);
return actor->iface();
}
-ActorPtr Actor::create(std::string name, s4u::Host* host, std::string function, std::vector<std::string> args)
+ActorPtr Actor::create(std::string name, s4u::Host* host, const std::string& function, std::vector<std::string> args)
{
simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function);
- return create(name, host, factory(std::move(args)));
+ return create(std::move(name), host, factory(std::move(args)));
}
void intrusive_ptr_add_ref(Actor* actor)
void Actor::set_auto_restart(bool autorestart)
{
simgrid::simix::simcall([this, autorestart]() {
- xbt_assert(autorestart && not pimpl_->auto_restart_); // FIXME: handle all cases
+ 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_->host_, pimpl_);
+ simgrid::kernel::actor::ProcessArg* arg = new simgrid::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_->host_->pimpl_->actors_at_boot_.emplace_back(arg);
+ pimpl_->get_host()->pimpl_->actors_at_boot_.emplace_back(arg);
});
}
xbt_assert(exec.get() != nullptr, "We can only migrate blocked actors when they are blocked on executions.");
exec->migrate(new_host);
}
- this->pimpl_->change_host(new_host);
+ this->pimpl_->set_host(new_host);
});
s4u::Actor::on_migration_end(this);
s4u::Host* Actor::get_host()
{
- return this->pimpl_->host_;
+ return this->pimpl_->get_host();
}
void Actor::daemonize()
aid_t Actor::get_pid() const
{
- return this->pimpl_->pid_;
+ return this->pimpl_->get_pid();
}
aid_t Actor::get_ppid() const
{
- return this->pimpl_->ppid_;
+ return this->pimpl_->get_ppid();
}
void Actor::suspend()
bool Actor::is_suspended()
{
- return simgrid::simix::simcall([this] { return pimpl_->suspended_; });
+ return simgrid::simix::simcall([this] { return pimpl_->is_suspended(); });
}
void Actor::set_kill_time(double kill_time)
/** @brief Get the kill time of an actor(or 0 if unset). */
double Actor::get_kill_time()
{
- return SIMIX_timer_get_date(pimpl_->kill_timer);
+ return pimpl_->get_kill_time();
}
void Actor::kill(aid_t pid) // deprecated
{
smx_actor_t killer = SIMIX_process_self();
- smx_actor_t process = SIMIX_process_from_PID(pid);
- if (process != nullptr) {
- simgrid::simix::simcall([killer, process] { SIMIX_process_kill(process, killer); });
+ smx_actor_t victim = SIMIX_process_from_PID(pid);
+ if (victim != nullptr) {
+ simgrid::simix::simcall([killer, victim] { killer->kill(victim); });
} else {
std::ostringstream oss;
oss << "kill: (" << pid << ") - No such actor" << std::endl;
void Actor::kill()
{
smx_actor_t process = SIMIX_process_self();
- simgrid::simix::simcall(
- [this, process] { SIMIX_process_kill(pimpl_, (pimpl_ == simix_global->maestro_process) ? pimpl_ : process); });
+ simgrid::simix::simcall([this, process] {
+ if (pimpl_ == simix_global->maestro_process)
+ pimpl_->exit();
+ else
+ process->kill(pimpl_);
+ });
}
smx_actor_t Actor::get_impl()
void Actor::kill_all()
{
smx_actor_t self = SIMIX_process_self();
- simgrid::simix::simcall([&self] { SIMIX_process_killall(self); });
+ simgrid::simix::simcall([self] { self->kill_all(); });
}
std::unordered_map<std::string, std::string>* Actor::get_properties()
}
/** Retrieve the property value (or nullptr if not set) */
-const char* Actor::get_property(std::string key)
+const char* Actor::get_property(const std::string& key)
{
return simgrid::simix::simcall([this, key] { return pimpl_->get_property(key); });
}
-void Actor::set_property(std::string key, std::string value)
+void Actor::set_property(const std::string& key, std::string value)
{
- simgrid::simix::simcall([this, key, value] { pimpl_->set_property(key, value); });
+ simgrid::simix::simcall([this, key, value] { pimpl_->set_property(key, std::move(value)); });
}
Actor* Actor::restart()
exec_init(flops)->set_priority(priority)->start()->wait();
}
-void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
- std::vector<double> bytes_amounts)
+void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+ const std::vector<double>& bytes_amounts)
{
parallel_execute(hosts, flops_amounts, bytes_amounts, -1);
}
-void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
- std::vector<double> bytes_amounts, double timeout)
+void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+ const std::vector<double>& bytes_amounts, double timeout)
{
xbt_assert(hosts.size() > 0, "Your parallel executions must span over at least one host.");
xbt_assert(hosts.size() == flops_amounts.size() || flops_amounts.empty(),
}
// deprecated
-void parallel_execute(int host_nb, s4u::Host** host_list, double* flops_amount, double* bytes_amount, double timeout)
+void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount, const double* bytes_amount,
+ double timeout)
{
smx_activity_t s =
simcall_execution_parallel_start("", host_nb, host_list, flops_amount, bytes_amount, /* rate */ -1, timeout);
}
// deprecated
-void parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount)
+void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount, const double* bytes_amount)
{
smx_activity_t s = simcall_execution_parallel_start("", host_nb, host_list, flops_amount, bytes_amount,
/* rate */ -1, /*timeout*/ -1);
aid_t get_pid()
{
- return SIMIX_process_self()->pid_;
+ return SIMIX_process_self()->get_pid();
}
aid_t get_ppid()
{
- return SIMIX_process_self()->ppid_;
+ return SIMIX_process_self()->get_ppid();
}
std::string get_name()
Host* get_host()
{
- return SIMIX_process_self()->host_;
+ return SIMIX_process_self()->get_host();
}
void suspend()
void exit()
{
- smx_actor_t process = SIMIX_process_self();
- simgrid::simix::simcall([process] { SIMIX_process_kill(process, process); });
+ smx_actor_t actor = SIMIX_process_self();
+ simgrid::simix::simcall([actor] { actor->exit(); });
}
void on_exit(std::function<void(int, void*)> fun, void* data)
{
simgrid::s4u::this_actor::yield();
}
+
+void sg_actor_sleep_for(double duration)
+{
+ simgrid::s4u::this_actor::sleep_for(duration);
+}
