-/** @ingroup s4u_api
- * @brief Static methods working on the current actor (see @ref s4u::Actor) */
-namespace this_actor {
-
-XBT_PUBLIC bool is_maestro();
-
-/** Block the current actor sleeping for that amount of seconds */
-XBT_PUBLIC void sleep_for(double duration);
-/** Block the current actor sleeping until the specified timestamp */
-XBT_PUBLIC void sleep_until(double wakeup_time);
-
-template <class Rep, class Period> inline void sleep_for(std::chrono::duration<Rep, Period> duration)
-{
- auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
- this_actor::sleep_for(seconds.count());
-}
-
-template <class Duration> inline void sleep_until(const SimulationTimePoint<Duration>& wakeup_time)
-{
- auto timeout_native = std::chrono::time_point_cast<SimulationClockDuration>(wakeup_time);
- this_actor::sleep_until(timeout_native.time_since_epoch().count());
-}
-
-/** Block the current actor, computing the given amount of flops */
-XBT_PUBLIC void execute(double flop);
-
-/** Block the current actor, computing the given amount of flops at the given priority.
- * An execution of priority 2 computes twice as fast as an execution at priority 1. */
-XBT_PUBLIC void execute(double flop, double priority);
-
-/**
- * @example examples/s4u/exec-ptask/s4u-exec-ptask.cpp
- */
-
-/** Block the current actor until the built parallel execution terminates
- *
- * \rst
- * .. _API_s4u_parallel_execute:
- *
- * **Example of use:** `examples/s4u/exec-ptask/s4u-exec-ptask.cpp
- * <https://framagit.org/simgrid/simgrid/tree/master/examples/s4u/exec-ptask/s4u-exec-ptask.cpp>`_
- *
- * Parallel executions convenient abstractions of parallel computational kernels that span over several machines,
- * such as a PDGEM and the other ScaLAPACK routines. If you are interested in the effects of such parallel kernel
- * on the platform (e.g. to schedule them wisely), there is no need to model them in all details of their internal
- * execution and communications. It is much more convenient to model them as a single execution activity that spans
- * over several hosts. This is exactly what s4u's Parallel Executions are.
- *
- * To build such an object, you need to provide a list of hosts that are involved in the parallel kernel (the
- * actor's own host may or may not be in this list) and specify the amount of computations that should be done by
- * each host, using a vector of flops amount. Then, you should specify the amount of data exchanged between each
- * hosts during the parallel kernel. For that, a matrix of values is expected.
- *
- * It is OK to build a parallel execution without any computation and/or without any communication.
- * Just pass an empty vector to the corresponding parameter.
- *
- * For example, if your list of hosts is ``[host0, host1]``, passing a vector ``[1000, 2000]`` as a `flops_amount`
- * vector means that `host0` should compute 1000 flops while `host1` will compute 2000 flops. A matrix of
- * communications' sizes of ``[0, 1, 2, 3]`` specifies the following data exchanges:
- *
- * +-----------+-------+------+
- * |from \\ to | host0 | host1|
- * +===========+=======+======+
- * |host0 | 0 | 1 |
- * +-----------+-------+------+
- * |host1 | 2 | 3 |
- * +-----------+-------+------+
- *
- * - From host0 to host0: 0 bytes are exchanged
- * - From host0 to host1: 1 byte is exchanged
- * - From host1 to host0: 2 bytes are exchanged
- * - From host1 to host1: 3 bytes are exchanged
- *
- * In a parallel execution, all parts (all executions on each hosts, all communications) progress exactly at the
- * same pace, so they all terminate at the exact same pace. If one part is slow because of a slow resource or
- * because of contention, this slows down the parallel execution as a whole.
- *
- * These objects are somewhat surprising from a modeling point of view. For example, the unit of their speed is
- * somewhere between flop/sec and byte/sec. Arbitrary parallel executions will simply not work with the usual platform
- * models, and you must :ref:`use the ptask_L07 host model <options_model_select>` for that. Note that you can mix
- * regular executions and communications with parallel executions, provided that the host model is ptask_L07.
- *
- * \endrst
- */
-XBT_PUBLIC void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
- const std::vector<double>& bytes_amounts);
-
-/** Block the current actor until the built parallel execution completes, or until the timeout. */
-XBT_PUBLIC void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
- const std::vector<double>& bytes_amounts, double timeout);
-
-/** Initialize a sequential execution that must then be started manually */
-XBT_PUBLIC ExecPtr exec_init(double flops_amounts);
-/** Initialize a parallel execution that must then be started manually */
-XBT_PUBLIC ExecPtr exec_init(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
- const std::vector<double>& bytes_amounts);
-
-XBT_PUBLIC ExecPtr exec_async(double flops_amounts);
-
-/** @brief Returns the actor ID of the current actor. */
-XBT_PUBLIC aid_t get_pid();
-
-/** @brief Returns the ancestor's actor ID of the current actor. */
-XBT_PUBLIC aid_t get_ppid();
-
-/** @brief Returns the name of the current actor. */
-XBT_PUBLIC std::string get_name();
-/** @brief Returns the name of the current actor as a C string. */
-XBT_PUBLIC const char* get_cname();
-
-/** @brief Returns the name of the host on which the current actor is running. */
-XBT_PUBLIC Host* get_host();
-
-/** @brief Suspend the current actor, that is blocked until resume()ed by another actor. */
-XBT_PUBLIC void suspend();
-
-/** @brief Yield the current actor. */
-XBT_PUBLIC void yield();
-
-/** @brief Resume the current actor, that was suspend()ed previously. */
-XBT_PUBLIC void resume();
-
-/** @brief kill the current actor. */
-XBT_PUBLIC void exit();
-
-/** @brief Add a function to the list of "on_exit" functions of 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.
- *
- * Please note that functions registered in this signal cannot do any simcall themselves. It means that they cannot
- * send or receive messages, acquire or release mutexes, nor even modify a host property or something. Not only are
- * blocking functions forbidden in this setting, but also modifications to the global state.
- *
- * The parameter of on_exit's callbacks denotes whether or not the actor's execution failed.
- * It will be set to true if the actor was killed or failed because of an exception,
- * while it will remain to false if the actor terminated gracefully.
- */
-
-XBT_PUBLIC void on_exit(const std::function<void(bool)>& fun);
-
-/** @brief Migrate the current actor to a new host. */
-XBT_PUBLIC void migrate(Host* new_host);
-
-/** @} */
-}
-
-