X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9ceaa7392dd84bd6b76a143addd7db5871225c5b..6847a26d9973030337f6ef9f18464b1f04ce7452:/include/simgrid/s4u/Actor.hpp diff --git a/include/simgrid/s4u/Actor.hpp b/include/simgrid/s4u/Actor.hpp index 8d3a99f636..25f2ede6ec 100644 --- a/include/simgrid/s4u/Actor.hpp +++ b/include/simgrid/s4u/Actor.hpp @@ -132,9 +132,9 @@ namespace s4u { class XBT_PUBLIC Actor : public simgrid::xbt::Extendable { friend Exec; friend Mailbox; - friend simgrid::simix::ActorImpl; + friend simgrid::kernel::actor::ActorImpl; friend simgrid::kernel::activity::MailboxImpl; - simix::ActorImpl* pimpl_ = nullptr; + kernel::actor::ActorImpl* pimpl_ = nullptr; /** Wrap a (possibly non-copyable) single-use task into a `std::function` */ template @@ -163,20 +163,20 @@ public: static ActorPtr self(); /** Signal to others that a new actor has been created **/ - static simgrid::xbt::signal onCreation; + static simgrid::xbt::signal on_creation; /** Signal indicating that the given actor is about to disappear */ - static simgrid::xbt::signal onDestruction; + static simgrid::xbt::signal on_destruction; /** Create an actor using a function * * If the actor is restarted, the actor has a fresh copy of the function. */ - static ActorPtr createActor(const char* name, s4u::Host* host, std::function code); + static ActorPtr create(const char* name, s4u::Host* host, std::function code); - static ActorPtr createActor(const char* name, s4u::Host* host, std::function*)> code, - std::vector* args) + static ActorPtr create(const char* name, s4u::Host* host, std::function*)> code, + std::vector* args) { - return createActor(name, host, [code](std::vector* args) { code(args); }, args); + return create(name, host, [code](std::vector* args) { code(args); }, args); } /** Create an actor using code @@ -186,64 +186,62 @@ public: * state. In order to use auto-restart, an explicit `function` must be passed * instead. */ - template::type - > - static ActorPtr createActor(const char* name, s4u::Host *host, F code, Args... args) + template ::type> + static ActorPtr create(const char* name, s4u::Host* host, F code, Args... args) { - return createActor(name, host, wrap_task(std::move(code), std::move(args)...)); + return create(name, host, wrap_task(std::move(code), std::move(args)...)); } // Create actor from function name: - - static ActorPtr createActor(const char* name, s4u::Host* host, const char* function, std::vector args); + static ActorPtr create(const char* name, s4u::Host* host, const char* function, std::vector args); // ***** Methods ***** /** This actor will be automatically terminated when the last non-daemon actor finishes **/ void daemonize(); /** Returns whether or not this actor has been daemonized or not **/ - bool isDaemon(); + bool is_daemon() const; /** Retrieves the name of that actor as a C++ string */ - const simgrid::xbt::string& getName() const; + const simgrid::xbt::string& get_name() const; /** Retrieves the name of that actor as a C string */ - const char* getCname() const; + const char* get_cname() const; /** Retrieves the host on which that actor is running */ - s4u::Host* getHost(); + s4u::Host* get_host(); /** Retrieves the PID of that actor * * aid_t is an alias for long */ - aid_t getPid(); + aid_t get_pid() const; /** Retrieves the PPID of that actor * * aid_t is an alias for long */ - aid_t getPpid(); + aid_t get_ppid() const; /** Suspend an actor by suspending the task on which it was waiting for the completion. */ void suspend(); /** Resume a suspended actor by resuming the task on which it was waiting for the completion. */ void resume(); - + void yield(); - + /** Returns true if the actor is suspended. */ - int isSuspended(); + int is_suspended(); /** If set to true, the actor will automatically restart when its host reboots */ - void setAutoRestart(bool autorestart); + void set_auto_restart(bool autorestart); /** Add a function to the list of "on_exit" functions for the current actor. The on_exit functions are the functions * executed when your actor is killed. You should use them to free the data used by your actor. */ - void onExit(int_f_pvoid_pvoid_t fun, void* data); + void on_exit(int_f_pvoid_pvoid_t fun, void* data); /** Sets the time at which that actor should be killed */ - void setKillTime(double time); + void set_kill_time(double time); /** Retrieves the time at which that actor will be killed (or -1 if not set) */ - double getKillTime(); + double get_kill_time(); void migrate(Host * new_host); @@ -260,7 +258,7 @@ public: static void kill(aid_t pid); /** Retrieves the actor that have the given PID (or nullptr if not existing) */ - static ActorPtr byPid(aid_t pid); + static ActorPtr by_pid(aid_t pid); /** @brief Wait for the actor to finish. * @@ -268,28 +266,87 @@ public: */ void join(); void join(double timeout); - - // Static methods on all actors: + Actor* restart(); /** Ask kindly to all actors to die. Only the issuer will survive. */ - static void killAll(); - static void killAll(int resetPid); + static void kill_all(); /** Returns the internal implementation of this actor */ - simix::ActorImpl* getImpl(); + kernel::actor::ActorImpl* get_impl(); /** Retrieve the property value (or nullptr if not set) */ - std::map* getProperties(); - const char* getProperty(const char* key); - void setProperty(const char* key, const char* value); - Actor* restart(); + std::map* get_properties(); // FIXME: do not export the map, but only the keys or something + const char* get_property(const char* key); + void set_property(const char* key, const char* value); + + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::create()") static ActorPtr + createActor(const char* name, s4u::Host* host, std::function code) + { + return create(name, host, code); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::create()") static ActorPtr + createActor(const char* name, s4u::Host* host, std::function*)> code, + std::vector* args) + { + return create(name, host, code, args); + } + template ::type> + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::create()") static ActorPtr + createActor(const char* name, s4u::Host* host, F code, Args... args) + { + return create(name, host, code, std::move(args)...); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::create()") static ActorPtr + createActor(const char* name, s4u::Host* host, const char* function, std::vector args) + { + return create(name, host, function, args); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::is_daemon()") bool isDaemon() const; + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_name()") const simgrid::xbt::string& getName() const + { + return get_name(); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_cname()") const char* getCname() const { return get_cname(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_host()") Host* getHost() { return get_host(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_pid()") aid_t getPid() { return get_pid(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_ppid()") aid_t getPpid() { return get_ppid(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::is_suspended()") int isSuspended() { return is_suspended(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::set_auto_restart()") void setAutoRestart(bool a) + { + set_auto_restart(a); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::on_exit()") void onExit(int_f_pvoid_pvoid_t fun, void* data) + { + on_exit(fun, data); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::set_kill_time()") void setKillTime(double time) { set_kill_time(time); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_kill_time()") double getKillTime() { return get_kill_time(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::by_pid()") static ActorPtr byPid(aid_t pid) { return by_pid(pid); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::kill_all()") static void killAll() { kill_all(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::kill_all() with no parameter") static void killAll(int resetPid) + { + kill_all(); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_impl()") kernel::actor::ActorImpl* getImpl() { return get_impl(); } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_property()") const char* getProperty(const char* key) + { + return get_property(key); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_properties()") std::map* getProperties() + { + return get_properties(); + } + XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_properties()") void setProperty(const char* key, const char* value) + { + set_property(key, value); + } }; /** @ingroup s4u_api * @brief Static methods working on the current actor (see @ref s4u::Actor) */ namespace this_actor { -XBT_PUBLIC bool isMaestro(); +XBT_PUBLIC bool is_maestro(); /** Block the actor sleeping for that amount of seconds (may throws hostFailure) */ XBT_PUBLIC void sleep_for(double duration); @@ -322,19 +379,18 @@ XBT_PUBLIC ExecPtr exec_init(double flops_amounts); XBT_PUBLIC ExecPtr exec_async(double flops_amounts); /** @brief Returns the actor ID of the current actor). */ -XBT_PUBLIC aid_t getPid(); +XBT_PUBLIC aid_t get_pid(); /** @brief Returns the ancestor's actor ID of the current actor. */ -XBT_PUBLIC aid_t getPpid(); +XBT_PUBLIC aid_t get_ppid(); /** @brief Returns the name of the current actor. */ -XBT_PUBLIC std::string getName(); - +XBT_PUBLIC std::string get_name(); /** @brief Returns the name of the current actor as a C string. */ -XBT_PUBLIC const char* getCname(); +XBT_PUBLIC const char* get_cname(); /** @brief Returns the name of the host on which the actor is running. */ -XBT_PUBLIC Host* getHost(); +XBT_PUBLIC Host* get_host(); /** @brief Suspend the actor. */ XBT_PUBLIC void suspend(); @@ -345,16 +401,26 @@ XBT_PUBLIC void yield(); /** @brief Resume the actor. */ XBT_PUBLIC void resume(); -XBT_PUBLIC bool isSuspended(); +XBT_PUBLIC bool is_suspended(); /** @brief kill the actor. */ XBT_PUBLIC void kill(); /** @brief Add a function to the list of "on_exit" functions. */ -XBT_PUBLIC void onExit(int_f_pvoid_pvoid_t fun, void* data); +XBT_PUBLIC void on_exit(int_f_pvoid_pvoid_t fun, void* data); /** @brief Migrate the actor to a new host. */ XBT_PUBLIC void migrate(Host* new_host); + +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_name()") XBT_PUBLIC std::string getName(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_cname()") XBT_PUBLIC const char* getCname(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::is_maestro()") XBT_PUBLIC bool isMaestro(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_pid()") XBT_PUBLIC aid_t getPid(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_ppid()") XBT_PUBLIC aid_t getPpid(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_host()") XBT_PUBLIC Host* getHost(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::is_suspended()") XBT_PUBLIC bool isSuspended(); +XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::on_exit()") XBT_PUBLIC + void onExit(int_f_pvoid_pvoid_t fun, void* data); } /** @} */