-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
namespace s4u {
simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Actor::onCreation;
+simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Actor::onDestruction;
// ***** Actor creation *****
ActorPtr Actor::self()
simgrid::simix::kernelImmediate([this]() { pimpl_->daemonize(); });
}
+bool Actor::isDaemon()
+{
+ return this->pimpl_->isDaemon();
+}
+
const simgrid::xbt::string& Actor::getName() const
{
return this->pimpl_->getName();
void Actor::kill(aid_t pid)
{
+ smx_actor_t killer = SIMIX_process_self();
smx_actor_t process = SIMIX_process_from_PID(pid);
if(process != nullptr) {
- simgrid::simix::kernelImmediate([process] { SIMIX_process_kill(process, process); });
+ simgrid::simix::kernelImmediate([killer, process] { SIMIX_process_kill(process, killer); });
} else {
std::ostringstream oss;
- oss << "kill: ("<< pid <<") - No such process" << std::endl;
+ oss << "kill: (" << pid << ") - No such actor" << std::endl;
throw std::runtime_error(oss.str());
}
}
-smx_actor_t Actor::getImpl() {
- return pimpl_;
-}
-
void Actor::kill() {
smx_actor_t process = SIMIX_process_self();
simgrid::simix::kernelImmediate(
[this, process] { SIMIX_process_kill(pimpl_, (pimpl_ == simix_global->maestro_process) ? pimpl_ : process); });
}
+smx_actor_t Actor::getImpl()
+{
+ return pimpl_;
+}
+
// ***** Static functions *****
ActorPtr Actor::byPid(aid_t pid)
void Actor::killAll()
{
- simcall_process_killall(1);
-}
-
-void Actor::killAll(int resetPid)
-{
- simcall_process_killall(resetPid);
+ simcall_process_killall();
}
std::map<std::string, std::string>* Actor::getProperties()
simgrid::simix::kernelImmediate([] { /* do nothing*/ });
}
-XBT_PUBLIC(void) sleep_until(double timeout)
+XBT_PUBLIC void sleep_until(double timeout)
{
double now = SIMIX_get_clock();
if (timeout > now)
{
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.
+ *
+ * This function checks whether \a actor is a valid pointer and return its PID (or 0 in case of problem).
+ */
+int sg_actor_get_PID(sg_actor_t actor)
+{
+ /* Do not raise an exception here: this function is called by the logs
+ * and the exceptions, so it would be called back again and again */
+ if (actor == nullptr || actor->getImpl() == nullptr)
+ return 0;
+ return actor->getPid();
}
+
+/** \ingroup m_actor_management
+ * \brief Returns the process ID of the parent of \a actor.
+ *
+ * This function checks whether \a actor is a valid pointer and return its parent's PID.
+ * Returns -1 if the actor has not been created by any other actor.
+ */
+int sg_actor_get_PPID(sg_actor_t actor)
+{
+ return actor->getPpid();
}
+
+/** \ingroup m_actor_management
+ * \brief Return the name of an actor.
+ */
+const char* sg_actor_get_name(sg_actor_t actor)
+{
+ return actor->getCname();
}
+
+sg_host_t sg_actor_get_host(sg_actor_t actor)
+{
+ return actor->getHost();
+}
+
+/** \ingroup m_actor_management
+ * \brief Returns the value of a given actor property
+ *
+ * \param actor an actor
+ * \param name a property name
+ * \return value of a property (or nullptr if the property is not set)
+ */
+const char* sg_actor_get_property_value(sg_actor_t actor, const char* name)
+{
+ return actor->getProperty(name);
+}
+
+/** \ingroup m_actor_management
+ * \brief Return the list of properties
+ *
+ * This function returns all the parameters associated with an actor
+ */
+xbt_dict_t sg_actor_get_properties(sg_actor_t actor)
+{
+ xbt_assert(actor != nullptr, "Invalid parameter: First argument must not be nullptr");
+ xbt_dict_t as_dict = xbt_dict_new_homogeneous(xbt_free_f);
+ std::map<std::string, std::string>* props = actor->getProperties();
+ if (props == nullptr)
+ return nullptr;
+ for (auto const& elm : *props) {
+ xbt_dict_set(as_dict, elm.first.c_str(), xbt_strdup(elm.second.c_str()), nullptr);
+ }
+ return as_dict;
+}
+
+/** \ingroup m_actor_management
+ * \brief Suspend the actor.
+ *
+ * This function suspends the actor by suspending the task on which it was waiting for the completion.
+ */
+void sg_actor_suspend(sg_actor_t actor)
+{
+ xbt_assert(actor != nullptr, "Invalid parameter: First argument must not be nullptr");
+ actor->suspend();
+}
+
+/** \ingroup m_actor_management
+ * \brief Resume a suspended actor.
+ *
+ * This function resumes a suspended actor by resuming the task on which it was waiting for the completion.
+ */
+void sg_actor_resume(sg_actor_t actor)
+{
+ xbt_assert(actor != nullptr, "Invalid parameter: First argument must not be nullptr");
+ actor->resume();
+}
+
+/** \ingroup m_actor_management
+ * \brief Returns true if the actor is suspended .
+ *
+ * This checks whether an actor is suspended or not by inspecting the task on which it was waiting for the completion.
+ */
+int sg_actor_is_suspended(sg_actor_t actor)
+{
+ return actor->isSuspended();
+}
+
+/**
+ * \ingroup m_actor_management
+ * \brief Restarts an actor from the beginning.
+ */
+sg_actor_t sg_actor_restart(sg_actor_t actor)
+{
+ return actor->restart();
+}
+
+/** @ingroup m_actor_management
+ * @brief This actor will be terminated automatically when the last non-daemon actor finishes
+ */
+void sg_actor_daemonize(sg_actor_t actor)
+{
+ actor->daemonize();
+}
+
+SG_END_DECL()
