X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6ca0df6f5bb17b5708c11a19846c0e90e25b7889..4634214e18b847f6346048fa12179d3d99ae82c9:/include/simgrid/kernel/resource/Action.hpp diff --git a/include/simgrid/kernel/resource/Action.hpp b/include/simgrid/kernel/resource/Action.hpp index 47efce3305..c8e20eb4bd 100644 --- a/include/simgrid/kernel/resource/Action.hpp +++ b/include/simgrid/kernel/resource/Action.hpp @@ -13,7 +13,7 @@ #include #include -const int NO_MAX_DURATION = -1.0; +static constexpr int NO_MAX_DURATION = -1.0; namespace simgrid { namespace kernel { @@ -24,12 +24,38 @@ typedef boost::heap::pairing_heap>> heap_type; -/** @details An action is a consumption on a resource (e.g.: a communication for the network) */ +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 */ + 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 + }; + + double top_date() const; + void insert(Action* action, double date, ActionHeap::Type type); + void update(Action* action, double date, ActionHeap::Type type); + void remove(Action* action); + Action* pop(); + bool empty() const { return heap_type::empty(); } +}; + +/** @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. + */ class XBT_PUBLIC Action { + friend ActionHeap; + public: /* Lazy update needs this Set hook to maintain a list of the tracked actions */ boost::intrusive::list_member_hook<> modified_set_hook_; - bool isLinkedModifiedSet() const { return modified_set_hook_.is_linked(); } + 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; @@ -40,12 +66,11 @@ public: StateSet; enum class State { - ready = 0, /**< Ready */ - running, /**< Running */ - failed, /**< Task Failure */ - done, /**< Completed */ - to_free, /**< Action to free in next cleanup */ - not_in_the_system /**< Not in the system anymore. Why did you ask ? */ + inited, /**< Created, but not started yet */ + running, /**< Started, currently running */ + failed, /**< Completed (unsuccessfully: either the resource failed, or the action was canceled) */ + done, /**< Completed (successfully) */ + ignored /**< e.g. failure detectors, these infinite sleep actions that are put on resources which failure should be notified */ }; enum class SuspendStates { @@ -54,8 +79,6 @@ public: sleeping }; - enum class Type { LATENCY = 100, MAX_DURATION, NORMAL, NOTSET }; - /** * @brief Action constructor * @@ -97,7 +120,7 @@ public: /** @brief Get the start time of the current action */ double get_start_time() const { return start_time_; } /** @brief Get the finish time of the current action */ - double getFinishTime() const { return finish_time_; } + double get_finish_time() const { return finish_time_; } /** @brief Get the user data associated to the current action */ void* get_data() const { return data_; } @@ -105,34 +128,36 @@ public: void set_data(void* data) { data_ = data; } /** @brief Get the cost of the current action */ - double getCost() const { return cost_; } + double get_cost() const { return cost_; } /** @brief Set the cost of the current action */ - void setCost(double cost) { cost_ = cost; } + void set_cost(double cost) { cost_ = cost; } /** @brief Update the maximum duration of the current action * @param delta Amount to remove from the MaxDuration */ - void updateMaxDuration(double delta); + void update_max_duration(double delta); /** @brief Update the remaining time of the current action * @param delta Amount to remove from the remaining time */ - void updateRemains(double delta); + void update_remains(double delta); + + virtual void update_remains_lazy(double now) = 0; /** @brief Set the remaining time of the current action */ - void setRemains(double value) { remains_ = value; } + void set_remains(double value) { remains_ = value; } + /** @brief Get the remaining time of the current action after updating the resource */ - virtual double getRemains(); + virtual double get_remains(); /** @brief Get the remaining time of the current action without updating the resource */ - double getRemainsNoUpdate() const { return remains_; } + double get_remains_no_update() const { return remains_; } /** @brief Set the finish time of the current action */ - void setFinishTime(double value) { finish_time_ = value; } + void set_finish_time(double value) { finish_time_ = value; } /**@brief Add a reference to the current action (refcounting) */ void ref(); /** @brief Unref that action (and destroy it if refcount reaches 0) - * @return true if the action was destroyed and false if someone still has references on it - */ - virtual int unref(); + * @return true if the action was destroyed and false if someone still has references on it */ + int unref(); /** @brief Cancel the current Action if running */ virtual void cancel(); @@ -144,66 +169,64 @@ public: virtual void resume(); /** @brief Returns true if the current action is running */ - virtual bool isSuspended(); + bool is_suspended(); /** @brief Get the maximum duration of the current action */ - double getMaxDuration() const { return max_duration_; } + double get_max_duration() const { return max_duration_; } /** @brief Set the maximum duration of the current Action */ - virtual void setMaxDuration(double duration); + virtual void set_max_duration(double duration); /** @brief Get the tracing category associated to the current action */ - char* getCategory() const { return category_; } + char* get_category() const { return category_; } /** @brief Set the tracing category of the current Action */ - void setCategory(const char* category); + void set_category(const char* category); /** @brief Get the priority of the current Action */ - double getPriority() const { return sharing_weight_; }; + double get_priority() const { return sharing_priority_; }; /** @brief Set the priority of the current Action */ - virtual void setSharingWeight(double priority); - void setSharingWeightNoUpdate(double weight) { sharing_weight_ = weight; } + virtual void set_priority(double priority); + void set_priority_no_update(double priority) { sharing_priority_ = priority; } /** @brief Get the state set in which the action is */ - StateSet* getStateSet() const { return state_set_; }; + StateSet* get_state_set() const { return state_set_; }; - simgrid::kernel::resource::Model* getModel() const { return model_; } + simgrid::kernel::resource::Model* get_model() const { return model_; } protected: StateSet* state_set_; - int refcount_ = 1; private: - double sharing_weight_ = 1.0; /**< priority (1.0 by default) */ + 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 */ - char* category_ = nullptr; /**< tracing category for categorized resource utilization monitoring */ - double finish_time_ = - -1; /**< finish time : this is modified during the run and fluctuates until the task is completed */ + double finish_time_ = -1; /**< finish time (may fluctuate until the task is completed) */ + char* category_ = nullptr; /**< tracing category for categorized resource utilization monitoring */ double cost_; simgrid::kernel::resource::Model* model_; void* data_ = nullptr; /**< for your convenience */ /* LMM */ - double last_update_ = 0; - double last_value_ = 0; - kernel::lmm::Variable* variable_ = nullptr; - Action::Type type_ = Action::Type::NOTSET; - boost::optional heap_handle_ = boost::none; + 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: - virtual void updateRemainingLazy(double now) = 0; - void heapInsert(heap_type& heap, double key, Action::Type hat); - void heapRemove(heap_type& heap); - void heapUpdate(heap_type& heap, double key, Action::Type hat); - void clearHeapHandle() { heap_handle_ = boost::none; } - kernel::lmm::Variable* getVariable() const { return variable_; } - void setVariable(kernel::lmm::Variable* var) { variable_ = var; } - double getLastUpdate() const { return last_update_; } - void refreshLastUpdate(); - double getLastValue() const { return last_value_; } - void setLastValue(double val) { last_value_ = val; } - Action::Type getType() const { return type_; } + ActionHeap::Type get_type() const { return type_; } + + lmm::Variable* get_variable() const { return variable_; } + void set_variable(lmm::Variable* var) { variable_ = var; } + + double get_last_update() const { return last_update_; } + void set_last_update(); + + 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;