X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0a95c78251f3ecbf1dfcb3ebe7904e44acf1beef..a138d21077d565562a591d21260cc3937cacdba0:/src/s4u/s4u_actor.cpp diff --git a/src/s4u/s4u_actor.cpp b/src/s4u/s4u_actor.cpp index 4d082c1e0b..7b6e9687ab 100644 --- a/src/s4u/s4u_actor.cpp +++ b/src/s4u/s4u_actor.cpp @@ -1,5 +1,4 @@ -/* Copyright (c) 2006-2014. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -7,13 +6,14 @@ #include "xbt/log.h" #include "simgrid/s4u/Actor.hpp" -#include "simgrid/s4u/comm.hpp" -#include "simgrid/s4u/host.hpp" +#include "simgrid/s4u/Comm.hpp" +#include "simgrid/s4u/Host.hpp" #include "simgrid/s4u/Mailbox.hpp" #include "src/kernel/context/Context.hpp" +#include -XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor,"S4U actors"); +XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor, "S4U actors"); namespace simgrid { namespace s4u { @@ -25,23 +25,21 @@ 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, 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, nullptr, 0); - return ActorPtr(&process->getIface()); + simgrid::simix::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); + return actor->iface(); } 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, nullptr, 0); - return ActorPtr(&process->getIface()); + simgrid::simix::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); + return actor->iface(); } // ***** Actor methods ***** @@ -54,26 +52,56 @@ void Actor::setAutoRestart(bool autorestart) { simcall_process_auto_restart_set(pimpl_,autorestart); } +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() +aid_t Actor::pid() { return this->pimpl_->pid; } -int Actor::ppid() +aid_t Actor::ppid() { return this->pimpl_->ppid; } +void Actor::suspend() +{ + simcall_process_suspend(pimpl_); +} + +void Actor::resume() +{ + simcall_process_resume(pimpl_); +} + +int Actor::isSuspended() +{ + return simcall_process_is_suspended(pimpl_); +} + void Actor::setKillTime(double time) { simcall_process_set_kill_time(pimpl_,time); } @@ -83,8 +111,9 @@ double Actor::killTime() return simcall_process_get_kill_time(pimpl_); } -void Actor::kill(int pid) { - msg_process_t process = SIMIX_process_from_PID(pid); +void Actor::kill(aid_t pid) +{ + smx_actor_t process = SIMIX_process_from_PID(pid); if(process != nullptr) { simcall_process_kill(process); } else { @@ -104,23 +133,56 @@ void Actor::kill() { // ***** Static functions ***** -ActorPtr Actor::byPid(int pid) +ActorPtr Actor::byPid(aid_t 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); +} + +/** Retrieve the property value (or nullptr if not set) */ +const char* Actor::property(const char* key) +{ + return (char*)xbt_dict_get_or_null(simcall_process_get_properties(pimpl_), key); +} +void Actor::setProperty(const char* key, const char* value) +{ + simgrid::simix::kernelImmediate([this, key, value] { + xbt_dict_set(simcall_process_get_properties(pimpl_), key, (char*)value, (void_f_pvoid_t) nullptr); + }); +} + // ***** this_actor ***** namespace this_actor { +/** Returns true if run from the kernel mode, and false if run from a real actor + * + * Everything that is run out of any actor (simulation setup before the engine is run, + * computing the model evolutions as a result to the actors' action, etc) is run in + * kernel mode, just as in any operating systems. + * + * In SimGrid, the actor in charge of doing the stuff in kernel mode is called Maestro, + * because it is the one scheduling when the others should move or wait. + */ +bool isMaestro() +{ + smx_context_t self_context = SIMIX_context_self(); + return self_context == nullptr; +} + void sleep_for(double duration) { if (duration > 0) @@ -141,30 +203,94 @@ e_smx_state_t execute(double flops) { void* recv(MailboxPtr chan) { void *res = nullptr; - Comm& c = Comm::recv_init(chan); - c.setDstData(&res,sizeof(res)); - c.wait(); + CommPtr c = Comm::recv_init(chan); + c->setDstData(&res, sizeof(res)); + c->wait(); return res; } -void send(MailboxPtr chan, void *payload, size_t simulatedSize) { - Comm& c = Comm::send_init(chan); - c.setRemains(simulatedSize); - c.setSrcData(payload); - // c.start() is optional. - c.wait(); +void send(MailboxPtr chan, void* payload, double simulatedSize) +{ + CommPtr c = Comm::send_init(chan); + c->setRemains(simulatedSize); + c->setSrcData(payload); + // c->start() is optional. + c->wait(); } -int pid() +void send(MailboxPtr chan, void* payload, double simulatedSize, double timeout) +{ + CommPtr c = Comm::send_init(chan); + c->setRemains(simulatedSize); + c->setSrcData(payload); + // c->start() is optional. + c->wait(timeout); +} + +CommPtr isend(MailboxPtr chan, void* payload, double simulatedSize) +{ + return Comm::send_async(chan, payload, simulatedSize); +} + +void dsend(MailboxPtr chan, void* payload, double simulatedSize) +{ + Comm::send_detached(chan, payload, simulatedSize); +} + +CommPtr irecv(MailboxPtr chan, void** data) +{ + return Comm::recv_async(chan, data); +} + +aid_t pid() { return SIMIX_process_self()->pid; } -int ppid() +aid_t 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); +} } } }