X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3502bf1993d45e8fd54892262565aef8b1914b3d..38f7ddbf61f574a934f191ef2d8358d9f8be1f96:/src/s4u/s4u_actor.cpp diff --git a/src/s4u/s4u_actor.cpp b/src/s4u/s4u_actor.cpp index 3f1c2b84ed..6b036dd349 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,21 +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) { - smx_actor_t actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); - return ActorPtr(&actor->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 actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); - return ActorPtr(&actor->getIface()); + simgrid::simix::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr); + return actor->iface(); } // ***** Actor methods ***** @@ -52,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); } @@ -81,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 { @@ -102,19 +133,37 @@ 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 { @@ -139,30 +188,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(); +} + +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); } -int pid() +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); +} } } }