/* 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. */
-#include "xbt/log.h"
-
#include "simgrid/s4u/Actor.hpp"
-#include "simgrid/s4u/Comm.hpp"
#include "simgrid/s4u/Exec.hpp"
#include "simgrid/s4u/Host.hpp"
-#include "simgrid/s4u/Mailbox.hpp"
-
-#include "src/kernel/context/Context.hpp"
+#include "src/instr/instr_private.hpp"
#include "src/simix/smx_private.hpp"
-#include <sstream>
-
XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor, "S4U actors");
namespace simgrid {
ActorPtr Actor::createActor(const char* name, s4u::Host* host, std::function<void()> code)
{
- simgrid::simix::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr);
+ simgrid::kernel::actor::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr);
return actor->iface();
}
{
simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(function);
simgrid::simix::ActorCode code = factory(std::move(args));
- simgrid::simix::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr);
+ simgrid::kernel::actor::ActorImpl* actor = simcall_process_create(name, std::move(code), nullptr, host, nullptr);
return actor->iface();
}
*/
void Actor::migrate(Host* new_host)
{
+ std::string key;
+ simgrid::instr::LinkType* link = nullptr;
+ if (TRACE_actor_is_enabled()) {
+ static long long int counter = 0;
+
+ key = std::to_string(counter);
+ counter++;
+
+ // start link
+ container_t actor_container = simgrid::instr::Container::byName(instr_pid(this));
+ link = simgrid::instr::Container::getRoot()->getLink("ACTOR_LINK");
+ link->startEvent(actor_container, "M", key);
+
+ // destroy existing container of this process
+ actor_container->removeFromParent();
+ }
+
simgrid::simix::kernelImmediate([this, new_host]() {
if (pimpl_->waiting_synchro != nullptr) {
// The actor is blocked on an activity. If it's an exec, migrate it too.
}
SIMIX_process_change_host(this->pimpl_, new_host);
});
+
+ if (TRACE_actor_is_enabled()) {
+ // create new container on the new_host location
+ simgrid::instr::Container::byName(new_host->get_name())->createChild(instr_pid(this), "ACTOR");
+ // end link
+ link->endEvent(simgrid::instr::Container::byName(instr_pid(this)), "M", key);
+ }
}
s4u::Host* Actor::getHost()
return this->pimpl_->isDaemon();
}
-const simgrid::xbt::string& Actor::getName() const
+const simgrid::xbt::string& Actor::get_name() const
{
- return this->pimpl_->getName();
+ return this->pimpl_->get_name();
}
-const char* Actor::getCname() const
+const char* Actor::get_cname() const
{
- return this->pimpl_->getCname();
+ return this->pimpl_->get_cname();
}
aid_t Actor::getPid()
void Actor::suspend()
{
if (TRACE_actor_is_enabled())
- simgrid::instr::Container::byName(instr_pid(this))->getState("MSG_PROCESS_STATE")->pushEvent("suspend");
+ simgrid::instr::Container::byName(instr_pid(this))->getState("ACTOR_STATE")->pushEvent("suspend");
simcall_process_suspend(pimpl_);
}
{
simgrid::simix::kernelImmediate([this] { pimpl_->resume(); });
if (TRACE_actor_is_enabled())
- simgrid::instr::Container::byName(instr_pid(this))->getState("MSG_PROCESS_STATE")->popEvent();
+ simgrid::instr::Container::byName(instr_pid(this))->getState("ACTOR_STATE")->popEvent();
}
int Actor::isSuspended()
return res;
}
-void* recv(MailboxPtr chan) // deprecated
-{
- return chan->get();
-}
-
-void* recv(MailboxPtr chan, double timeout) // deprecated
-{
- return chan->get(timeout);
-}
-
-void send(MailboxPtr chan, void* payload, double simulatedSize) // deprecated
-{
- chan->put(payload, simulatedSize);
-}
-
-void send(MailboxPtr chan, void* payload, double simulatedSize, double timeout) // deprecated
-{
- chan->put(payload, simulatedSize, timeout);
-}
-
-CommPtr isend(MailboxPtr chan, void* payload, double simulatedSize) // deprecated
-{
- return chan->put_async(payload, simulatedSize);
-}
-
-CommPtr irecv(MailboxPtr chan, void** data) // deprecated
-{
- return chan->get_async(data);
-}
-
aid_t getPid()
{
return SIMIX_process_self()->pid;
return SIMIX_process_self()->ppid;
}
-std::string getName()
+std::string get_name()
{
- return SIMIX_process_self()->getName();
+ return SIMIX_process_self()->get_name();
}
-const char* getCname()
+const char* get_cname()
{
- return SIMIX_process_self()->getCname();
+ return SIMIX_process_self()->get_cname();
}
Host* getHost()
void suspend()
{
if (TRACE_actor_is_enabled())
- instr::Container::byName(getName() + "-" + std::to_string(getPid()))
- ->getState("MSG_PROCESS_STATE")
+ instr::Container::byName(get_name() + "-" + std::to_string(getPid()))
+ ->getState("ACTOR_STATE")
->pushEvent("suspend");
simcall_process_suspend(SIMIX_process_self());
}
simgrid::simix::kernelImmediate([process] { process->resume(); });
if (TRACE_actor_is_enabled())
- instr::Container::byName(getName() + "-" + std::to_string(getPid()))->getState("MSG_PROCESS_STATE")->popEvent();
+ instr::Container::byName(get_name() + "-" + std::to_string(getPid()))->getState("ACTOR_STATE")->popEvent();
}
bool isSuspended()
{
SIMIX_process_self()->iface()->migrate(new_host);
}
+
} // namespace this_actor
} // namespace s4u
} // namespace simgrid
/* **************************** Public C interface *************************** */
-SG_BEGIN_DECL()
+
/** \ingroup m_actor_management
* \brief Returns the process ID of \a actor.
*
*/
const char* sg_actor_get_name(sg_actor_t actor)
{
- return actor->getCname();
+ return actor->get_cname();
}
sg_host_t sg_actor_get_host(sg_actor_t actor)
actor->daemonize();
}
-SG_END_DECL()
+/** \ingroup m_actor_management
+ * \brief Migrates an actor to another location.
+ *
+ * This function changes the value of the #sg_host_t on which \a actor is running.
+ */
+void sg_actor_migrate(sg_actor_t process, sg_host_t host)
+{
+ process->migrate(host);
+}
+
+/** \ingroup m_actor_management
+* \brief Wait for the completion of a #sg_actor_t.
+*
+* \param actor the actor to wait for
+* \param timeout wait until the actor is over, or the timeout expires
+*/
+void sg_actor_join(sg_actor_t actor, double timeout)
+{
+ actor->join(timeout);
+}
+
+void sg_actor_kill(sg_actor_t actor)
+{
+ actor->kill();
+}
+
+/** \ingroup m_actor_management
+ * \brief Set the kill time of an actor.
+ *
+ * \param actor an actor
+ * \param kill_time the time when the actor is killed.
+ */
+void sg_actor_set_kill_time(sg_actor_t actor, double kill_time)
+{
+ actor->setKillTime(kill_time);
+}
