X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/cb150044a0e9683b33f936309746f56f39fb35a9..4bd1f48f0bf1ad1703be680ec2a38d626c6a2668:/src/surf/surf_interface.hpp diff --git a/src/surf/surf_interface.hpp b/src/surf/surf_interface.hpp index fd87a11604..0c39619c5b 100644 --- a/src/surf/surf_interface.hpp +++ b/src/surf/surf_interface.hpp @@ -1,74 +1,58 @@ -//using namespace generic; +/* Copyright (c) 2004-2017. 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. */ #ifndef SURF_MODEL_H_ #define SURF_MODEL_H_ -#include -#include -#include -#include -#include -#include -#include "surf/trace_mgr.h" -#include "xbt/lib.h" -#include "surf/surf_routing.h" -#include "simgrid/platf_interface.h" -#include "surf/surf.h" -#include "surf/surf_private.h" +#include "xbt/signal.hpp" -extern tmgr_history_t history; -#define NO_MAX_DURATION -1.0 +#include "src/surf/surf_private.h" +#include "surf/surf.h" +#include "xbt/str.h" -using namespace std; +#include +#include +#include +#include -/** \ingroup SURF_simulation - * \brief Return the current time - * - * Return the current time in millisecond. - */ +#define NO_MAX_DURATION -1.0 /********* * Utils * *********/ /* user-visible parameters */ -extern double sg_tcp_gamma; -extern double sg_sender_gap; -extern double sg_latency_factor; -extern double sg_bandwidth_factor; -extern double sg_weight_S_parameter; -extern int sg_network_crosstraffic; -#ifdef HAVE_GTNETS -extern double sg_gtnets_jitter; -extern int sg_gtnets_jitter_seed; -#endif -extern xbt_dynar_t surf_path; +extern XBT_PRIVATE double sg_tcp_gamma; +extern XBT_PRIVATE double sg_latency_factor; +extern XBT_PRIVATE double sg_bandwidth_factor; +extern XBT_PRIVATE double sg_weight_S_parameter; +extern XBT_PRIVATE int sg_network_crosstraffic; +extern XBT_PRIVATE std::vector surf_path; +extern XBT_PRIVATE std::unordered_map traces_set_list; +extern XBT_PRIVATE std::set watched_hosts; extern "C" { -XBT_PUBLIC(double) surf_get_clock(void); +XBT_PUBLIC(double) surf_get_clock(); } +/** \ingroup SURF_simulation + * \brief List of hosts that have just restarted and whose autorestart process should be restarted. + */ +XBT_PUBLIC_DATA(std::vector) host_that_restart; -extern double sg_sender_gap; -XBT_PUBLIC(int) SURF_CPU_LEVEL; //Surf cpu level +namespace simgrid { +namespace surf { + +extern XBT_PRIVATE simgrid::xbt::signal surfExitCallbacks; +} +} -int __surf_is_absolute_file_path(const char *file_path); +int XBT_PRIVATE __surf_is_absolute_file_path(const char *file_path); /*********** * Classes * ***********/ -//class Model; -typedef Model* ModelPtr; - -//class Resource; -typedef Resource* ResourcePtr; -typedef boost::function ResourceCallback; - -//class Action; -typedef Action* ActionPtr; -typedef boost::function ActionCallback; - -//class ActionLmm; -typedef ActionLmm* ActionLmmPtr; enum heap_action_type{ LATENCY = 100, @@ -77,280 +61,361 @@ enum heap_action_type{ NOTSET }; -/********* - * Trace * - *********/ -/* For the trace and trace:connect tag (store their content till the end of the parsing) */ -XBT_PUBLIC_DATA(xbt_dict_t) traces_set_list; -XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_host_avail; -XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_power; -XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_link_avail; -XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_bandwidth; -XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_latency; +/********** + * Action * + **********/ +XBT_PRIVATE void surf_action_lmm_update_index_heap(void *action, int i); -/********* - * Model * - *********/ -XBT_PUBLIC_DATA(xbt_dynar_t) model_list; +/** \ingroup SURF_models + * \brief List of initialized models + */ +XBT_PUBLIC_DATA(std::vector*) all_existing_models; -class Model { - const char *p_name; +namespace simgrid { +namespace surf { - xbt_swag_t p_readyActionSet; /**< Actions in state SURF_ACTION_READY */ - xbt_swag_t p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */ - xbt_swag_t p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */ - xbt_swag_t p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */ +/** @ingroup SURF_interface + * @brief SURF action interface class + * @details An action is an event generated by a resource (e.g.: a communication for the network) + */ +XBT_PUBLIC_CLASS Action { +public: + boost::intrusive::list_member_hook<> action_hook; + boost::intrusive::list_member_hook<> action_lmm_hook; + typedef boost::intrusive::member_hook< + Action, boost::intrusive::list_member_hook<>, &Action::action_hook> ActionOptions; + typedef boost::intrusive::list ActionList; + + 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 ? */ + }; - ResourceCallback m_resOnCB, m_resOffCB; - ActionCallback m_actCancelCB, m_actSuspendCB, m_actResumeCB; + /** + * @brief Action constructor + * + * @param model The Model associated to this Action + * @param cost The cost of the Action + * @param failed If the action is impossible (e.g.: execute something on a switched off host) + */ + Action(simgrid::surf::Model *model, double cost, bool failed); + + /** + * @brief Action constructor + * + * @param model The Model associated to this Action + * @param cost The cost of the Action + * @param failed If the action is impossible (e.g.: execute something on a switched off host) + * @param var The lmm variable associated to this Action if it is part of a LMM component + */ + Action(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var); + + /** @brief Destructor */ + virtual ~Action(); -protected: - xbt_swag_t p_modifiedSet; + /** @brief Mark that the action is now finished */ + void finish(); - lmm_system_t p_maxminSystem; - e_UM_t p_updateMechanism; - int m_selectiveUpdate; - xbt_heap_t p_actionHeap; + /** @brief Get the [state](\ref simgrid::surf::Action::State) of the current Action */ + Action::State getState(); /**< get the state*/ + /** @brief Set the [state](\ref simgrid::surf::Action::State) of the current Action */ + virtual void setState(Action::State state); -public: - Model(const char *name); - virtual ~Model(); + /** @brief Get the bound of the current Action */ + double getBound(); + /** @brief Set the bound of the current Action */ + void setBound(double bound); - const char *getName() {return p_name;} - xbt_swag_t getReadyActionSet() {return p_readyActionSet;} - xbt_swag_t getRunningActionSet() {return p_runningActionSet;} - xbt_swag_t getFailedActionSet() {return p_failedActionSet;} - xbt_swag_t getDoneActionSet() {return p_doneActionSet;} - xbt_swag_t getModifiedSet() {return p_modifiedSet;} - lmm_system_t getMaxminSystem() {return p_maxminSystem;} - e_UM_t getUpdateMechanism() {return p_updateMechanism;} - xbt_heap_t getActionHeap() {return p_actionHeap;} - - ActionPtr createAction(double _cost, bool _failed); - virtual double shareResources(double now); - virtual double shareResourcesLazy(double now); - virtual double shareResourcesFull(double now); - double shareResourcesMaxMin(xbt_swag_t running_actions, - lmm_system_t sys, - void (*solve) (lmm_system_t)); - virtual void updateActionsState(double now, double delta); - virtual void updateActionsStateLazy(double now, double delta); - virtual void updateActionsStateFull(double now, double delta); + /** @brief Get the start time of the current action */ + double getStartTime(); + /** @brief Get the finish time of the current action */ + double getFinishTime(); - void addTurnedOnCallback(ResourceCallback rc); - void notifyResourceTurnedOn(ResourcePtr r); + /** @brief Get the user data associated to the current action */ + void *getData() {return data_;} + /** @brief Set the user data associated to the current action */ + void setData(void* data); - void addTurnedOffCallback(ResourceCallback rc); - void notifyResourceTurnedOff(ResourcePtr r); + /** @brief Get the cost of the current action */ + double getCost() {return cost_;} + /** @brief Set the cost of the current action */ + void setCost(double cost) {cost_ = cost;} - void addActionCancelCallback(ActionCallback ac); - void notifyActionCancel(ActionPtr a); - void addActionResumeCallback(ActionCallback ac); - void notifyActionResume(ActionPtr a); - void addActionSuspendCallback(ActionCallback ac); - void notifyActionSuspend(ActionPtr a); -}; + /** @brief Update the maximum duration of the current action + * @param delta Amount to remove from the MaxDuration */ + void updateMaxDuration(double delta) {double_update(&maxDuration_, delta,sg_surf_precision);} -/************ - * Resource * - ************/ + /** @brief Update the remaining time of the current action + * @param delta Amount to remove from the remaining time */ + void updateRemains(double delta) {double_update(&remains_, delta, sg_maxmin_precision*sg_surf_precision);} -/** - * Resource which have a metric handled by a maxmin system - */ -typedef struct { - double scale; - double peak; - tmgr_trace_event_t event; -} s_surf_metric_t; + /** @brief Set the remaining time of the current action */ + void setRemains(double value) {remains_ = value;} + /** @brief Get the remaining time of the current action after updating the resource */ + virtual double getRemains(); + /** @brief Get the remaining time of the current action without updating the resource */ + double getRemainsNoUpdate(); -class Resource { - void *p_resource; - const char *p_name; - ModelPtr p_model; - xbt_dict_t p_properties; - bool m_running; + /** @brief Set the finish time of the current action */ + void setFinishTime(double value) {finishTime_ = value;} -protected: - e_surf_resource_state_t m_stateCurrent; + /**@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(); -public: - Resource(); - Resource(ModelPtr model, const char *name, xbt_dict_t properties); - Resource(surf_model_t model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit); - virtual ~Resource() { - xbt_free((void*)p_name); - xbt_dict_free(&p_properties); - }; + /** @brief Cancel the current Action if running */ + virtual void cancel(); - ModelPtr getModel() {return p_model;}; - const char *getName() {return p_name;}; - virtual xbt_dict_t getProperties() {return p_properties;}; + /** @brief Suspend the current Action */ + virtual void suspend(); - virtual void updateState(tmgr_trace_event_t event_type, double value, double date)=0; - virtual bool isUsed()=0; - bool isOn(); - void turnOn(); - void turnOff(); - void setName(string name); + /** @brief Resume the current Action */ + virtual void resume(); - virtual e_surf_resource_state_t getState(); - virtual void setState(e_surf_resource_state_t state); -}; + /** @brief Returns true if the current action is running */ + virtual bool isSuspended(); -class ResourceLmm: virtual public Resource { - lmm_constraint_t p_constraint; + /** @brief Get the maximum duration of the current action */ + double getMaxDuration() {return maxDuration_;} + /** @brief Set the maximum duration of the current Action */ + virtual void setMaxDuration(double duration); -public: - ResourceLmm(); - ResourceLmm(lmm_constraint_t constraint); - ~ResourceLmm() { - }; + /** @brief Get the tracing category associated to the current action */ + char *getCategory() {return category_;} + /** @brief Set the tracing category of the current Action */ + void setCategory(const char *category); - lmm_constraint_t constraint() {return p_constraint;}; -}; + /** @brief Get the priority of the current Action */ + double getPriority() { return sharingWeight_; }; + /** @brief Set the priority of the current Action */ + virtual void setSharingWeight(double priority); -/********** - * Action * - **********/ + /** @brief Get the state set in which the action is */ + ActionList* getStateSet() {return stateSet_;}; + + s_xbt_swag_hookup_t stateHookup_ = {nullptr,nullptr}; -class Action { - xbt_swag_t p_modifiedSet; - xbt_heap_t p_actionHeap; - int m_selectiveUpdate; - ModelPtr p_model; - double m_bound; /**< the capping of the CPU use */ - bool m_failed; - double m_start; /**< start time */ - char *p_category; /**< tracing category for categorized resource utilization monitoring */ - - #ifdef HAVE_LATENCY_BOUND_TRACKING - int m_latencyLimited; /**< Set to 1 if is limited by latency, 0 otherwise */ - #endif - int m_cost; - void *p_data; /**< for your convenience */ + simgrid::surf::Model* getModel() { return model_; } protected: - xbt_swag_t p_stateSet; - double m_priority; /**< priority (1.0 by default) */ - int m_refcount; - double m_remains; /**< How much of that cost remains to be done in the currently running task */ - double m_maxDuration; /*< max_duration (may fluctuate until the task is completed) */ - double m_finish; /**< finish time : this is modified during the run and fluctuates until the task is completed */ + ActionList* stateSet_; + double sharingWeight_ = 1.0; /**< priority (1.0 by default) */ + int refcount_ = 1; + double remains_; /**< How much of that cost remains to be done in the currently running task */ + double maxDuration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */ + double finishTime_ = -1; /**< finish time : this is modified during the run and fluctuates until the task is completed */ + +private: + double start_; /**< start time */ + char *category_ = nullptr; /**< tracing category for categorized resource utilization monitoring */ - ModelPtr getModel() {return p_model;} + double cost_; + simgrid::surf::Model *model_; + void *data_ = nullptr; /**< for your convenience */ + /* LMM */ public: + virtual void updateRemainingLazy(double now); + void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat); + void heapRemove(xbt_heap_t heap); + void heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat); + virtual void updateIndexHeap(int i); + lmm_variable_t getVariable() {return variable_;} + double getLastUpdate() {return lastUpdate_;} + void refreshLastUpdate() {lastUpdate_ = surf_get_clock();} + enum heap_action_type getHat() {return hat_;} + bool is_linked() {return action_lmm_hook.is_linked();} - Action(); - Action(ModelPtr model, double cost, bool failed); - virtual ~Action(); - - void finish(); - s_xbt_swag_hookup_t p_stateHookup; - - e_surf_action_state_t getState(); /**< get the state*/ - virtual void setState(e_surf_action_state_t state); /**< Change state*/ - double getBound() {return m_bound;} - double getStartTime(); /**< Return the start time of an action */ - double getFinishTime(); /**< Return the finish time of an action */ - void *getData() {return p_data;} - void setData(void* data); - double getMaxDuration() {return m_maxDuration;} - char *getCategory() {return p_category;} - double getCost() {return m_cost;} - void setCost(double cost) {m_cost = cost;} +protected: + lmm_variable_t variable_ = nullptr; + double lastValue_ = 0; + double lastUpdate_ = 0; + int suspended_ = 0; + int indexHeap_; + enum heap_action_type hat_ = NOTSET; +}; - void updateMaxDuration(double delta) {double_update(&m_maxDuration, delta);} - void updateRemains(double delta) {double_update(&m_remains, delta);} - void setRemains(double value) {m_remains = value;} - void setFinishTime(double value) {m_finish = value;} +typedef Action::ActionList ActionList; +typedef boost::intrusive::member_hook< + Action, boost::intrusive::list_member_hook<>, &Action::action_lmm_hook> ActionLmmOptions; +typedef boost::intrusive::list ActionLmmList; +typedef ActionLmmList* ActionLmmListPtr; - void ref(); - virtual int unref(); /**< Specify that we don't use that action anymore. Returns true if the action was destroyed and false if someone still has references on it. */ - virtual void cancel(); /**< Cancel a running action */ - virtual void recycle(); /**< Recycle an action */ - - virtual void suspend()=0; /**< Suspend an action */ - virtual void resume()=0; /**< Resume a suspended action */ - virtual bool isSuspended()=0; /**< Return whether an action is suspended */ - virtual void setMaxDuration(double duration)=0; /**< Set the max duration of an action*/ - virtual void setPriority(double priority)=0; /**< Set the priority of an action */ -#ifdef HAVE_TRACING - void setCategory(const char *category); /**< Set the category of an action */ -#endif - virtual double getRemains(); /**< Get the remains of an action */ -#ifdef HAVE_LATENCY_BOUND_TRACKING - int getLatencyLimited(); /**< Return 1 if action is limited by latency, 0 otherwise */ -#endif - - - double getPriority() {return m_priority;}; - xbt_swag_t getStateSet() {return p_stateSet;}; +/********* + * Model * + *********/ -private: - int resourceUsed(void *resource_id); - /* Share the resources to the actions and return in how much time - the next action may terminate */ - double shareResources(double now); - /* Update the actions' state */ - void updateActionsState(double now, double delta); - void updateResourceState(void *id, tmgr_trace_event_t event_type, - double value, double time); +/** @ingroup SURF_interface + * @brief SURF model interface class + * @details A model is an object which handle the interactions between its Resources and its Actions + */ +XBT_PUBLIC_CLASS Model { +public: + Model(); + virtual ~Model(); + + /** @brief Get the set of [actions](@ref Action) in *ready* state */ + virtual ActionList* getReadyActionSet() {return readyActionSet_;} + + /** @brief Get the set of [actions](@ref Action) in *running* state */ + virtual ActionList* getRunningActionSet() {return runningActionSet_;} + + /** @brief Get the set of [actions](@ref Action) in *failed* state */ + virtual ActionList* getFailedActionSet() {return failedActionSet_;} + + /** @brief Get the set of [actions](@ref Action) in *done* state */ + virtual ActionList* getDoneActionSet() {return doneActionSet_;} + + /** @brief Get the set of modified [actions](@ref Action) */ + virtual ActionLmmListPtr getModifiedSet() {return modifiedSet_;} + + /** @brief Get the maxmin system of the current Model */ + lmm_system_t getMaxminSystem() {return maxminSystem_;} + + /** + * @brief Get the update mechanism of the current Model + * @see e_UM_t + */ + e_UM_t getUpdateMechanism() {return updateMechanism_;} + + /** @brief Get Action heap */ + xbt_heap_t getActionHeap() {return actionHeap_;} + + /** + * @brief Share the resources between the actions + * + * @param now The current time of the simulation + * @return The delta of time till the next action will finish + */ + virtual double nextOccuringEvent(double now); + virtual double nextOccuringEventLazy(double now); + virtual double nextOccuringEventFull(double now); + + /** + * @brief Update action to the current time + * + * @param now The current time of the simulation + * @param delta The delta of time since the last update + */ + virtual void updateActionsState(double now, double delta); + virtual void updateActionsStateLazy(double now, double delta); + virtual void updateActionsStateFull(double now, double delta); + /** @brief Returns whether this model have an idempotent shareResource() + * + * The only model that is not is NS3: computing the next timestamp moves the model up to that point, + * so we need to call it only when the next timestamp of other sources is computed. + */ + virtual bool nextOccuringEventIsIdempotent() { return true;} +protected: + ActionLmmListPtr modifiedSet_; + lmm_system_t maxminSystem_ = nullptr; + e_UM_t updateMechanism_ = UM_UNDEFINED; + bool selectiveUpdate_; + xbt_heap_t actionHeap_; + +private: + ActionList* readyActionSet_; /**< Actions in state SURF_ACTION_READY */ + ActionList* runningActionSet_; /**< Actions in state SURF_ACTION_RUNNING */ + ActionList* failedActionSet_; /**< Actions in state SURF_ACTION_FAILED */ + ActionList* doneActionSet_; /**< Actions in state SURF_ACTION_DONE */ }; -//FIXME:REMOVE -void surf_action_lmm_update_index_heap(void *action, int i); +} +} -class ActionLmm: virtual public Action { +/************ + * Resource * + ************/ -protected: - lmm_variable_t p_variable; - double m_lastUpdate; - double m_lastValue; - int m_suspended; - int m_indexHeap; - enum heap_action_type m_hat; +/** @ingroup SURF_interface + * @brief Resource which have a metric handled by a maxmin system + */ +typedef struct { + double peak; /**< The peak of the metric, ie its max value */ + double scale; /**< Current availability of the metric according to the traces, in [0,1] */ + tmgr_trace_event_t event; /**< The associated trace event associated to the metric */ +} s_surf_metric_t; + +namespace simgrid { +namespace surf { +/** @ingroup SURF_interface + * @brief SURF resource interface class + * @details This is the ancestor class of every resources in SimGrid, such as links, CPU or storage + */ +XBT_PUBLIC_CLASS Resource { public: - ActionLmm() : m_suspended(false) { - p_actionListHookup.prev = 0; - p_actionListHookup.next = 0; - m_lastUpdate = 0; - m_lastValue = 0; - }; - ActionLmm(lmm_variable_t var) : m_suspended(false) { - p_actionListHookup.prev = 0; - p_actionListHookup.next = 0; - m_lastUpdate = 0; - m_lastValue = 0; - p_variable = var; - }; + /** + * @brief Constructor of LMM Resources + * + * @param model Model associated to this Resource + * @param name The name of the Resource + * @param constraint The lmm constraint associated to this Resource if it is part of a LMM component + */ + Resource(Model *model, const char *name, lmm_constraint_t constraint); + + virtual ~Resource(); + + /** @brief Get the Model of the current Resource */ + Model* model() const; + + /** @brief Get the name of the current Resource */ + const char* cname() const; + + bool operator==(const Resource &other) const; + + /** + * @brief Apply an event of external load event to that resource + * + * @param event What happened + * @param value [TODO] + */ + virtual void apply_event(tmgr_trace_event_t event, double value) = 0; + + /** @brief Check if the current Resource is used (if it currently serves an action) */ + virtual bool isUsed()=0; - virtual void updateRemainingLazy(double now); - void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat); - void heapRemove(xbt_heap_t heap); - double getRemains(); /**< Get the remains of an action */ - void updateIndexHeap(int i); - lmm_variable_t getVariable() {return p_variable;} - double getLastUpdate() {return m_lastUpdate;} - void refreshLastUpdate() {m_lastUpdate = surf_get_clock();} - enum heap_action_type getHat() {return m_hat;} + /** @brief Check if the current Resource is active */ + virtual bool isOn() const; + /** @brief Check if the current Resource is shut down */ + virtual bool isOff() const; + /** @brief Turn on the current Resource */ + virtual void turnOn(); + /** @brief Turn off the current Resource */ + virtual void turnOff(); - virtual int unref(); - void cancel(); - void suspend(); - void resume(); - bool isSuspended(); - void setMaxDuration(double duration); - void setPriority(double priority); - void gapRemove(); - s_xbt_swag_hookup_t p_actionListHookup; +private: + std::string name_; + Model *model_; + bool isOn_ = true; +public: /* LMM */ + /** @brief Get the lmm constraint associated to this Resource if it is part of a LMM component (or null if none) */ + lmm_constraint_t constraint() const; + +protected: + const lmm_constraint_t constraint_ = nullptr; }; +} +} + +namespace std { +template <> class hash { +public: + std::size_t operator()(const simgrid::surf::Resource& r) const { return (std::size_t)xbt_str_hash(r.cname()); } + }; +} + #endif /* SURF_MODEL_H_ */