#include "src/surf/cpu_interface.hpp"
#include <boost/range/algorithm.hpp>
+#include <utility>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix, "Logging specific to SIMIX (process)");
return (self_context != nullptr) ? self_context->get_actor() : nullptr;
}
-/**
- * @brief Returns whether a process has pending asynchronous communications.
- * @return true if there are asynchronous communications in this process
- * @deprecated
- */
-int SIMIX_process_has_pending_comms(smx_actor_t process)
-{
-
- return process->comms.size() > 0;
-}
-
namespace simgrid {
namespace kernel {
namespace actor {
return maxpid;
}
-ActorImpl::ActorImpl(const simgrid::xbt::string& name, s4u::Host* host) : host_(host), name_(name), piface_(this)
+ActorImpl::ActorImpl(simgrid::xbt::string name, s4u::Host* host) : host_(host), name_(std::move(name)), piface_(this)
{
pid_ = maxpid++;
simcall.issuer_ = this;
actor->set_properties(*properties);
/* Add the process to it's host process list */
- host->pimpl_->process_list_.push_back(*actor);
+ host->pimpl_->add_actor(actor);
/* Now insert it in the global process list and in the process to run list */
simix_global->process_list[actor->get_pid()] = actor;
simix_global->mutex.lock();
simix_global->process_list.erase(pid_);
- if (host_ && host_process_list_hook.is_linked())
- simgrid::xbt::intrusive_erase(host_->pimpl_->process_list_, *this);
+ if (host_ && host_actor_list_hook.is_linked())
+ host_->pimpl_->remove_actor(this);
if (not smx_destroy_list_hook.is_linked()) {
#if SIMGRID_HAVE_MC
xbt_dynar_push_as(simix_global->dead_actors_vector, ActorImpl*, this);
void ActorImpl::kill(ActorImpl* actor)
{
+ xbt_assert(actor != simix_global->maestro_process, "Killing maestro is a rather bad idea");
if (actor->finished_) {
XBT_DEBUG("Ignoring request to kill actor %s@%s that is already dead", actor->get_cname(),
actor->host_->get_cname());
if (context_->iwannadie) {
XBT_DEBUG("Actor %s@%s is dead", get_cname(), host_->get_cname());
- // throw simgrid::kernel::context::ForcefulKillException(); Does not seem to properly kill the actor
context_->stop();
THROW_IMPOSSIBLE;
}
xbt_assert(exception_ == nullptr, "Gasp! This exception may be lost by subsequent calls.");
suspended_ = false;
- suspend(this);
+ suspend();
}
if (exception_ != nullptr) {
return actor->ciface();
}
-void ActorImpl::suspend(ActorImpl* issuer)
+void ActorImpl::suspend()
{
if (suspended_) {
XBT_DEBUG("Actor '%s' is already suspended", get_cname());
/* If the suspended actor is waiting on a sync, suspend its synchronization. */
if (waiting_synchro == nullptr) {
- activity::ExecImpl* exec = new activity::ExecImpl();
+ auto exec = new activity::ExecImpl();
exec->set_name("suspend").set_host(host_).set_flops_amount(0.0).start();
waiting_synchro = activity::ExecImplPtr(exec);
throw_exception(std::make_exception_ptr(simgrid::HostFailureException(
XBT_THROW_POINT, std::string("Host ") + host_->get_cname() + " failed, you cannot sleep there.")));
- activity::SleepImpl* sleep = new activity::SleepImpl();
- (*sleep).set_name("sleep").set_host(host_).set_duration(duration).start();
+ auto sleep = new activity::SleepImpl();
+ sleep->set_name("sleep").set_host(host_).set_duration(duration).start();
return activity::SleepImplPtr(sleep);
}
void ActorImpl::set_host(s4u::Host* dest)
{
- xbt::intrusive_erase(host_->pimpl_->process_list_, *this);
+ host_->pimpl_->remove_actor(this);
host_ = dest;
- dest->pimpl_->process_list_.push_back(*this);
+ dest->pimpl_->add_actor(this);
}
ActorImplPtr ActorImpl::init(const std::string& name, s4u::Host* host)
XBT_DEBUG("Start context '%s'", get_cname());
/* Add the actor to its host's actor list */
- host_->pimpl_->process_list_.push_back(*this);
+ host_->pimpl_->add_actor(this);
simix_global->process_list[pid_] = this;
/* Now insert it in the global actor list and in the actor to run list */
} // namespace kernel
} // namespace simgrid
-void SIMIX_process_detach() // deprecated v3.25
-{
- simgrid::kernel::actor::ActorImpl::detach();
-}
-
-smx_actor_t SIMIX_process_attach(const char* name, void* data, const char* hostname,
- std::unordered_map<std::string, std::string>* properties,
- smx_actor_t /*parent_process*/) // deprecated 3.25
-{
- return simgrid::kernel::actor::ActorImpl::attach(name, data, sg_host_by_name(hostname), properties).get();
-}
-
int SIMIX_process_count()
{
return simix_global->process_list.size();
}
-void* SIMIX_process_self_get_data() // deprecated
+void* SIMIX_process_self_get_data()
{
smx_actor_t self = SIMIX_process_self();
return self->get_user_data();
}
-void SIMIX_process_self_set_data(void* data) // deprecated
+void SIMIX_process_self_set_data(void* data)
{
SIMIX_process_self()->set_user_data(data);
}
by exceptions and logging events */
const char* SIMIX_process_self_get_name()
{
-
- smx_actor_t process = SIMIX_process_self();
- if (process == nullptr || process == simix_global->maestro_process)
- return "maestro";
-
- return process->get_cname();
+ return SIMIX_is_maestro() ? "maestro" : SIMIX_process_self()->get_cname();
}
/**
* @param self the current process
*/
-/** @brief Returns the list of processes to run.
- * @deprecated
- */
-const std::vector<smx_actor_t>& simgrid::simix::process_get_runnable()
-{
- return simix_global->actors_to_run;
-}
-
/** @brief Returns the process from PID. */
smx_actor_t SIMIX_process_from_PID(aid_t PID)
{
return item->second;
}
-void SIMIX_process_on_exit(smx_actor_t actor, int_f_pvoid_pvoid_t fun, void* data)
-{
- SIMIX_process_on_exit(actor, [fun, data](bool failed) {
- intptr_t status = failed ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS;
- fun(reinterpret_cast<void*>(status), data);
- });
-}
-
-void SIMIX_process_on_exit(smx_actor_t actor, const std::function<void(int, void*)>& fun, void* data)
-{
- SIMIX_process_on_exit(actor, [fun, data](bool failed) { fun(failed ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS, data); });
-}
-
void SIMIX_process_on_exit(smx_actor_t actor, const std::function<void(bool /*failed*/)>& fun)
{
xbt_assert(actor, "current process not found: are you in maestro context ?");
