X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/10ceac5fd14fb0426b5c93bda85676a79b02d0be..7bf5d20e2f3b137f0b08f437849834bc15984298:/src/s4u/s4u_actor.cpp diff --git a/src/s4u/s4u_actor.cpp b/src/s4u/s4u_actor.cpp index 1b46b96d40..570c181284 100644 --- a/src/s4u/s4u_actor.cpp +++ b/src/s4u/s4u_actor.cpp @@ -5,7 +5,6 @@ * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/log.h" -#include "src/msg/msg_private.h" #include "simgrid/s4u/Actor.hpp" #include "simgrid/s4u/comm.hpp" @@ -13,9 +12,8 @@ #include "simgrid/s4u/Mailbox.hpp" #include "src/kernel/context/Context.hpp" -#include "src/simix/smx_private.h" -XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor,"S4U actors"); +XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor, "S4U actors"); namespace simgrid { namespace s4u { @@ -27,67 +25,94 @@ ActorPtr Actor::self() if (self_context == nullptr) return simgrid::s4u::ActorPtr(); - return simgrid::s4u::ActorPtr(&self_context->process()->getIface()); + return self_context->process()->iface(); } - -ActorPtr Actor::createActor(const char* name, s4u::Host *host, double killTime, std::function code) +ActorPtr Actor::createActor(const char* name, s4u::Host* host, std::function code) { - // TODO, when autorestart is used, the std::function is copied so the new - // instance will get a fresh (reinitialized) state. Is this what we want? - smx_actor_t process = simcall_process_create( - name, std::move(code), nullptr, host->name().c_str(), - killTime, nullptr, 0); - return ActorPtr(&process->getIface()); + smx_actor_t actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); + return actor->iface(); } -ActorPtr Actor::createActor(const char* name, s4u::Host *host, double killTime, - const char* function, std::vector args) +ActorPtr Actor::createActor(const char* name, s4u::Host* host, const char* function, std::vector args) { simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function); simgrid::simix::ActorCode code = factory(std::move(args)); - smx_actor_t process = simcall_process_create( - name, std::move(code), nullptr, host->name().c_str(), - killTime, nullptr, 0); - return ActorPtr(&process->getIface()); + smx_actor_t actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); + return actor->iface(); } // ***** Actor methods ***** void Actor::join() { - simcall_process_join(pimpl_, -1); + simcall_process_join(this->pimpl_, -1); } void Actor::setAutoRestart(bool autorestart) { simcall_process_auto_restart_set(pimpl_,autorestart); } -s4u::Host *Actor::getHost() { - return pimpl_->host; +void Actor::onExit(int_f_pvoid_pvoid_t fun, void* data) +{ + simcall_process_on_exit(pimpl_, fun, data); +} + +void Actor::migrate(Host* new_host) +{ + simcall_process_set_host(pimpl_, new_host); +} + +s4u::Host* Actor::host() +{ + return this->pimpl_->host; +} + +const char* Actor::cname() +{ + return this->pimpl_->name.c_str(); +} + +simgrid::xbt::string Actor::name() +{ + return this->pimpl_->name; +} + +int Actor::pid() +{ + return this->pimpl_->pid; +} + +int Actor::ppid() +{ + return this->pimpl_->ppid; } -simgrid::xbt::string Actor::getName() { - return pimpl_->name; +void Actor::suspend() +{ + simcall_process_suspend(pimpl_); } -int Actor::getPid(){ - return pimpl_->pid; +void Actor::resume() +{ + simcall_process_resume(pimpl_); } -int Actor::getPpid() { - return pimpl_->ppid; +int Actor::isSuspended() +{ + return simcall_process_is_suspended(pimpl_); } void Actor::setKillTime(double time) { simcall_process_set_kill_time(pimpl_,time); } -double Actor::getKillTime() { +double Actor::killTime() +{ return simcall_process_get_kill_time(pimpl_); } void Actor::kill(int pid) { - msg_process_t process = SIMIX_process_from_PID(pid); + smx_actor_t process = SIMIX_process_from_PID(pid); if(process != nullptr) { simcall_process_kill(process); } else { @@ -107,19 +132,25 @@ void Actor::kill() { // ***** Static functions ***** -ActorPtr Actor::forPid(int pid) +ActorPtr Actor::byPid(int pid) { smx_actor_t process = SIMIX_process_from_PID(pid); if (process != nullptr) - return ActorPtr(&process->getIface()); + return process->iface(); else - return nullptr; + return ActorPtr(); } -void Actor::killAll() { +void Actor::killAll() +{ simcall_process_killall(1); } +void Actor::killAll(int resetPid) +{ + simcall_process_killall(resetPid); +} + // ***** this_actor ***** namespace this_actor { @@ -150,7 +181,8 @@ void* recv(MailboxPtr chan) { return res; } -void send(MailboxPtr chan, void *payload, size_t simulatedSize) { +void send(MailboxPtr chan, void* payload, double simulatedSize) +{ Comm& c = Comm::send_init(chan); c.setRemains(simulatedSize); c.setSrcData(payload); @@ -158,14 +190,74 @@ void send(MailboxPtr chan, void *payload, size_t simulatedSize) { c.wait(); } -int getPid() { +void send(MailboxPtr chan, void* payload, double simulatedSize, double timeout) +{ + Comm& c = Comm::send_init(chan); + c.setRemains(simulatedSize); + c.setSrcData(payload); + // c.start() is optional. + c.wait(timeout); +} + +Comm& isend(MailboxPtr chan, void* payload, double simulatedSize) +{ + return Comm::send_async(chan, payload, simulatedSize); +} + +Comm& isend(MailboxPtr chan, void** data) +{ + return Comm::recv_async(chan, data); +} + +int pid() +{ return SIMIX_process_self()->pid; } -int getPpid() { +int ppid() +{ return SIMIX_process_self()->ppid; } +std::string name() +{ + return SIMIX_process_self()->name; +} + +Host* host() +{ + return SIMIX_process_self()->host; +} + +void suspend() +{ + simcall_process_suspend(SIMIX_process_self()); +} + +void resume() +{ + simcall_process_resume(SIMIX_process_self()); +} + +int isSuspended() +{ + return simcall_process_is_suspended(SIMIX_process_self()); +} + +void kill() +{ + simcall_process_kill(SIMIX_process_self()); +} + +void onExit(int_f_pvoid_pvoid_t fun, void* data) +{ + simcall_process_on_exit(SIMIX_process_self(), fun, data); +} + +void migrate(Host* new_host) +{ + simcall_process_set_host(SIMIX_process_self(), new_host); +} } } }