X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0184f298bc4cc735d2cf2604e430d85d350d4b7c..47d0461ca727ac3e9790279e37f392cd039f040a:/include/simgrid/kernel/resource/Action.hpp diff --git a/include/simgrid/kernel/resource/Action.hpp b/include/simgrid/kernel/resource/Action.hpp index 92ca580c08..b75750e30b 100644 --- a/include/simgrid/kernel/resource/Action.hpp +++ b/include/simgrid/kernel/resource/Action.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2004-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2023. 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. */ @@ -13,25 +13,23 @@ #include #include #include +#include -static constexpr int NO_MAX_DURATION = -1.0; +static constexpr double NO_MAX_DURATION = -1.0; -namespace simgrid { -namespace kernel { -namespace resource { +namespace simgrid::kernel::resource { -typedef std::pair heap_element_type; -typedef boost::heap::pairing_heap, boost::heap::stable, - boost::heap::compare>> - heap_type; +using heap_element_type = std::pair; +using heap_type = + boost::heap::pairing_heap, boost::heap::stable, + boost::heap::compare>>; -typedef std::pair heap_element_type; class XBT_PUBLIC ActionHeap : public heap_type { friend Action; public: enum class Type { - latency = 100, /* this is a heap entry to warn us when the latency is payed */ + latency = 100, /* this is a heap entry to warn us when the latency is paid */ max_duration, /* this is a heap entry to warn us when the max_duration limit (timeout) is reached */ normal, /* this is a normal heap entry stating the date to finish transmitting */ unset @@ -47,23 +45,51 @@ public: /** @details An action is a consumption on a resource (e.g.: a communication for the network). * * It is related (but still different) from activities, that are the stuff on which an actor can be blocked. - * See simgrid::s4u::Activity for more details. + * + * - A sequential execution activity encompasses 2 actions: one for the exec itself, + * and a time-limited sleep used as timeout detector. + * - A point-to-point communication activity encompasses 3 actions: one for the comm itself + * (which spans on all links of the path), and one infinite sleep used as failure detector + * on both sender and receiver hosts. + * - Synchronization activities may possibly be connected to no action. + */ class XBT_PUBLIC Action { friend ActionHeap; + int refcount_ = 1; + double sharing_penalty_ = 1.0; /**< priority (1.0 by default) */ + double max_duration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */ + double remains_; /**< How much of that cost remains to be done in the currently running task */ + double start_time_; /**< start time */ + double finish_time_ = -1; /**< finish time (may fluctuate until the task is completed) */ + std::string category_; /**< tracing category for categorized resource utilization monitoring */ + + double cost_; + Model* model_; + void* data_ = nullptr; /**< for your convenience - XBT_ATTRIB_DEPRECATED_v334 */ + activity::ActivityImpl* activity_ = nullptr; + + /* LMM */ + double factor_ = 1.0; /**< Factor for effective rate = var->get_value() * factor_ */ + double last_update_ = 0; + double last_value_ = 0; + lmm::Variable* variable_ = nullptr; + double user_bound_ = -1; + + ActionHeap::Type type_ = ActionHeap::Type::unset; + boost::optional heap_hook_ = boost::none; + boost::intrusive::list_member_hook<> modified_set_hook_; + boost::intrusive::list_member_hook<> state_set_hook_; + public: /* Lazy update needs this Set hook to maintain a list of the tracked actions */ - boost::intrusive::list_member_hook<> modified_set_hook_; bool is_within_modified_set() const { return modified_set_hook_.is_linked(); } - typedef boost::intrusive::list< - Action, boost::intrusive::member_hook, &Action::modified_set_hook_>> - ModifiedSet; + using ModifiedSet = boost::intrusive::list< + Action, boost::intrusive::member_hook, &Action::modified_set_hook_>>; - boost::intrusive::list_member_hook<> state_set_hook_; - typedef boost::intrusive::list< - Action, boost::intrusive::member_hook, &Action::state_set_hook_>> - StateSet; + using StateSet = boost::intrusive::list< + Action, boost::intrusive::member_hook, &Action::state_set_hook_>>; enum class State { INITED, /**< Created, but not started yet */ @@ -75,11 +101,16 @@ public: }; enum class SuspendStates { - not_suspended = 0, /**< Action currently not suspended **/ - suspended, - sleeping + RUNNING = 0, /**< Action currently not suspended **/ + SUSPENDED, + SLEEPING }; +private: + StateSet* state_set_; + Action::SuspendStates suspended_ = Action::SuspendStates::RUNNING; + +public: /** * @brief Action constructor * @@ -126,9 +157,15 @@ public: double get_finish_time() const { return finish_time_; } /** @brief Get the user data associated to the current action */ - void* get_data() const { return data_; } + XBT_ATTRIB_DEPRECATED_v334("Please manifest if you actually need this function") void* get_data() const + { + return data_; + } /** @brief Set the user data associated to the current action */ - void set_data(void* data) { data_ = data; } + XBT_ATTRIB_DEPRECATED_v334("Please manifest if you actually need this function") void set_data(void* data) + { + data_ = data; + } /** @brief Get the user data associated to the current action */ activity::ActivityImpl* get_activity() const { return activity_; } @@ -176,8 +213,10 @@ public: /** @brief Resume the current Action */ virtual void resume(); + /** @brief Returns true if the current action is suspended */ + bool is_suspended() const { return suspended_ == SuspendStates::SUSPENDED; } /** @brief Returns true if the current action is running */ - bool is_suspended(); + bool is_running() const { return suspended_ == SuspendStates::RUNNING; } /** @brief Get the maximum duration of the current action */ double get_max_duration() const { return max_duration_; } @@ -187,61 +226,51 @@ public: /** @brief Get the tracing category associated to the current action */ const std::string& get_category() const { return category_; } /** @brief Set the tracing category of the current Action */ - void set_category(const std::string& category) { category_ = category; } + void set_category(std::string_view category) { category_ = category; } - /** @brief Get the priority of the current Action */ - double get_priority() const { return sharing_priority_; }; - /** @brief Set the priority of the current Action */ - virtual void set_priority(double priority); - void set_priority_no_update(double priority) { sharing_priority_ = priority; } + /** @brief Get the sharing_penalty (RTT or 1/thread_count) of the current Action */ + double get_sharing_penalty() const { return sharing_penalty_; }; + /** @brief Set the sharing_penalty (RTT or 1/thread_count) of the current Action */ + virtual void set_sharing_penalty(double sharing_penalty); + void set_sharing_penalty_no_update(double sharing_penalty) { sharing_penalty_ = sharing_penalty; } /** @brief Get the state set in which the action is */ StateSet* get_state_set() const { return state_set_; }; - simgrid::kernel::resource::Model* get_model() const { return model_; } - -protected: - StateSet* state_set_; - -private: - int refcount_ = 1; - double sharing_priority_ = 1.0; /**< priority (1.0 by default) */ - double max_duration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */ - double remains_; /**< How much of that cost remains to be done in the currently running task */ - double start_time_; /**< start time */ - double finish_time_ = -1; /**< finish time (may fluctuate until the task is completed) */ - std::string category_; /**< tracing category for categorized resource utilization monitoring */ - - double cost_; - simgrid::kernel::resource::Model* model_; - void* data_ = nullptr; /**< for your convenience */ - activity::ActivityImpl* activity_ = nullptr; + Model* get_model() const { return model_; } - /* LMM */ - double last_update_ = 0; - double last_value_ = 0; - kernel::lmm::Variable* variable_ = nullptr; - - ActionHeap::Type type_ = ActionHeap::Type::unset; - boost::optional heap_hook_ = boost::none; - -public: ActionHeap::Type get_type() const { return type_; } lmm::Variable* get_variable() const { return variable_; } void set_variable(lmm::Variable* var) { variable_ = var; } + double get_user_bound() const { return user_bound_; } + void set_user_bound(double bound) { user_bound_ = bound; } + double get_last_update() const { return last_update_; } void set_last_update(); + /** + * @brief Set a factor for this action + * + * Defines a multiplicative factor for the consumption of the underlying resource. + * + * @param factor Multiplicative factor for this action (e.g. 0.97) + */ + void set_rate_factor(double factor) { factor_ = factor; } + /** + * @brief Get the effective consumption rate of the resource + * + * The rate is based on the sharing given by the maxmin system underneath. + * However, it depends on the factor defined for this action. + * + * So, the effective rate is equal to var->get_value() * factor_ + */ + double get_rate() const; double get_last_value() const { return last_value_; } void set_last_value(double val) { last_value_ = val; } - -protected: - Action::SuspendStates suspended_ = Action::SuspendStates::not_suspended; + void set_suspend_state(Action::SuspendStates state) { suspended_ = state; } }; -} // namespace resource -} // namespace kernel -} // namespace simgrid +} // namespace simgrid::kernel::resource #endif