X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4634214e18b847f6346048fa12179d3d99ae82c9..5fda94ac3d246037758dab959b3dfc9a071ccc26:/include/simgrid/kernel/resource/Action.hpp diff --git a/include/simgrid/kernel/resource/Action.hpp b/include/simgrid/kernel/resource/Action.hpp index c8e20eb4bd..a74f944faf 100644 --- a/include/simgrid/kernel/resource/Action.hpp +++ b/include/simgrid/kernel/resource/Action.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2004-2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2020. 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. */ @@ -12,6 +12,7 @@ #include #include +#include static constexpr int NO_MAX_DURATION = -1.0; @@ -19,18 +20,18 @@ namespace simgrid { namespace kernel { namespace resource { -typedef std::pair heap_element_type; +typedef std::pair heap_element_type; typedef boost::heap::pairing_heap, boost::heap::stable, boost::heap::compare>> heap_type; -typedef std::pair heap_element_type; +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 @@ -41,13 +42,19 @@ public: 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. + * + * - 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; @@ -66,17 +73,18 @@ public: StateSet; enum class State { - 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 */ + INITED, /**< Created, but not started yet */ + STARTED, /**< Currently running */ + FAILED, /**< either the resource failed, or the action was canceled */ + FINISHED, /**< Successfully completed */ + IGNORED /**< e.g. failure detectors: infinite sleep actions that are put on resources which failure should get + noticed */ }; enum class SuspendStates { - not_suspended = 0, /**< Action currently not suspended **/ - suspended, - sleeping + RUNNING = 0, /**< Action currently not suspended **/ + SUSPENDED, + SLEEPING }; /** @@ -97,19 +105,21 @@ public: * @param var The lmm variable associated to this Action if it is part of a LMM component */ Action(Model* model, double cost, bool failed, lmm::Variable* var); + Action(const Action&) = delete; + Action& operator=(const Action&) = delete; virtual ~Action(); /** * @brief Mark that the action is now finished * - * @param state the new [state](\ref simgrid::kernel::resource::Action::State) of the current Action + * @param state the new [state](@ref simgrid::kernel::resource::Action::State) of the current Action */ void finish(Action::State state); - /** @brief Get the [state](\ref simgrid::kernel::resource::Action::State) of the current Action */ + /** @brief Get the [state](@ref simgrid::kernel::resource::Action::State) of the current Action */ Action::State get_state() const; /**< get the state*/ - /** @brief Set the [state](\ref simgrid::kernel::resource::Action::State) of the current Action */ + /** @brief Set the [state](@ref simgrid::kernel::resource::Action::State) of the current Action */ virtual void set_state(Action::State state); /** @brief Get the bound of the current Action */ @@ -127,6 +137,11 @@ public: /** @brief Set the user data associated to the current action */ void set_data(void* data) { data_ = data; } + /** @brief Get the user data associated to the current action */ + activity::ActivityImpl* get_activity() const { return activity_; } + /** @brief Set the user data associated to the current action */ + void set_activity(activity::ActivityImpl* activity) { activity_ = activity; } + /** @brief Get the cost of the current action */ double get_cost() const { return cost_; } /** @brief Set the cost of the current action */ @@ -157,7 +172,7 @@ public: 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 */ - int unref(); + bool unref(); /** @brief Cancel the current Action if running */ virtual void cancel(); @@ -168,8 +183,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_; } @@ -177,41 +194,41 @@ public: virtual void set_max_duration(double duration); /** @brief Get the tracing category associated to the current action */ - char* get_category() const { return category_; } + const std::string& get_category() const { return category_; } /** @brief Set the tracing category of the current Action */ - void set_category(const char* category); + void set_category(const std::string& 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_; + Model* get_model() const { return model_; } private: + StateSet* state_set_; + Action::SuspendStates suspended_ = Action::SuspendStates::RUNNING; int refcount_ = 1; - double sharing_priority_ = 1.0; /**< priority (1.0 by default) */ + 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) */ - char* category_ = nullptr; /**< tracing category for categorized resource utilization monitoring */ + std::string category_; /**< tracing category for categorized resource utilization monitoring */ double cost_; - simgrid::kernel::resource::Model* model_; - void* data_ = nullptr; /**< for your convenience */ + Model* model_; + void* data_ = nullptr; /**< for your convenience */ + activity::ActivityImpl* activity_ = nullptr; /* LMM */ - double last_update_ = 0; - double last_value_ = 0; - kernel::lmm::Variable* variable_ = nullptr; + double last_update_ = 0; + double last_value_ = 0; + lmm::Variable* variable_ = nullptr; ActionHeap::Type type_ = ActionHeap::Type::unset; boost::optional heap_hook_ = boost::none; @@ -227,9 +244,7 @@ public: 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