X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f1137465cab98cdaa8b0364e533fc82d9b7b0cdc..5232905f5b6e218cd2378c59e407d40bfcb57b18:/src/surf/surf_interface.hpp diff --git a/src/surf/surf_interface.hpp b/src/surf/surf_interface.hpp index 3f5bde69b8..cd88f89f99 100644 --- a/src/surf/surf_interface.hpp +++ b/src/surf/surf_interface.hpp @@ -1,347 +1,254 @@ -//using namespace generic; +/* Copyright (c) 2004-2019. 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 "src/internal_config.h" +#include "src/surf/surf_private.hpp" + +#include +#include #include +#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 "internal_config.h" - -#define LIBSIGC ok -#ifdef LIBSIGC -#include -#define surf_callback(arg1, ...) sigc::signal -#define surf_callback_connect(callback, fun_ptr) callback.connect(sigc::ptr_fun(fun_ptr)) -#define surf_callback_emit(callback, ...) callback.emit(__VA_ARGS__) -#else -#include -#define surf_callback(arg1, ...) boost::signals2::signal -#define surf_callback_connect(callback, fun_ptr) callback.connect(fun_ptr) -#define surf_callback_emit(callback, ...) callback(__VA_ARGS__) -#endif - -extern tmgr_history_t history; -#define NO_MAX_DURATION -1.0 - -using namespace std; - -/** \ingroup SURF_simulation - * \brief Return the current time - * - * Return the current time in millisecond. - */ /********* * 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; +XBT_PUBLIC_DATA double sg_maxmin_precision; +XBT_PUBLIC_DATA double sg_surf_precision; +XBT_PUBLIC_DATA int sg_concurrency_limit; + +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 std::vector surf_path; +extern XBT_PRIVATE std::unordered_map traces_set_list; +extern XBT_PRIVATE std::set watched_hosts; + +static inline void double_update(double* variable, double value, double precision) +{ + // printf("Updating %g -= %g +- %g\n",*variable,value,precision); + // xbt_assert(value==0 || value>precision); + // Check that precision is higher than the machine-dependent size of the mantissa. If not, brutal rounding may + // happen, and the precision mechanism is not active... + // xbt_assert(*variable< (2< precision); } -extern double sg_sender_gap; -XBT_PUBLIC(int) SURF_CPU_LEVEL; //Surf cpu level +static inline int double_equals(double value1, double value2, double precision) +{ + return (fabs(value1 - value2) < precision); +} -int __surf_is_absolute_file_path(const char *file_path); +/** @ingroup SURF_models + * @brief Initializes the CPU model with the model Cas01 + * + * By default, this model uses the lazy optimization mechanism that relies on partial invalidation in LMM and a heap + * for lazy action update. + * You can change this behavior by setting the cpu/optim configuration variable to a different value. + * + * You shouldn't have to call it by yourself. + */ +XBT_PUBLIC void surf_cpu_model_init_Cas01(); -/*********** - * Classes * - ***********/ -//class Model; -typedef Model* ModelPtr; +/** @ingroup SURF_models + * @brief Same as network model 'LagrangeVelho', only with different correction factors. + * + * This model is proposed by Pierre-Nicolas Clauss and Martin Quinson and Stéphane Génaud based on the model 'LV08' and + * different correction factors depending on the communication size (< 1KiB, < 64KiB, >= 64KiB). + * See comments in the code for more information. + * + * @see surf_host_model_init_SMPI() + */ +#if !HAVE_SMPI +XBT_ATTRIB_NORETURN +#endif +XBT_PUBLIC void surf_network_model_init_SMPI(); -//class Resource; -typedef Resource* ResourcePtr; -typedef boost::function ResourceCallback; - -//class Action; -typedef Action* ActionPtr; -typedef boost::function ActionCallback; +/** @ingroup SURF_models + * @brief Same as network model 'LagrangeVelho', only with different correction factors. + * + * This model impelments a variant of the contention model on Infinband networks based on + * the works of Jérôme Vienne : http://mescal.imag.fr/membres/jean-marc.vincent/index.html/PhD/Vienne.pdf + * + * @see surf_host_model_init_IB() + */ +#if !HAVE_SMPI +XBT_ATTRIB_NORETURN +#endif +XBT_PUBLIC void surf_network_model_init_IB(); -typedef boost::intrusive::list ActionList; -typedef ActionList* ActionListPtr; -typedef boost::intrusive::list_base_hook<> actionHook; +/** @ingroup SURF_models + * @brief Initializes the platform with the network model 'LegrandVelho' + * + * This model is proposed by Arnaud Legrand and Pedro Velho based on the results obtained with the GTNets simulator for + * onelink and dogbone sharing scenarios. See comments in the code for more information. + * + * @see surf_host_model_init_LegrandVelho() + */ +XBT_PUBLIC void surf_network_model_init_LegrandVelho(); -struct lmmTag; -typedef boost::intrusive::list > > > ActionLmmList; -typedef ActionLmmList* ActionLmmListPtr; -typedef boost::intrusive::list_base_hook > actionLmmHook; +/** @ingroup SURF_models + * @brief Initializes the platform with the network model 'Constant' + * + * In this model, the communication time between two network cards is constant, hence no need for a routing table. + * This is particularly useful when simulating huge distributed algorithms where scalability is really an issue. This + * function is called in conjunction with surf_host_model_init_compound. + * + * @see surf_host_model_init_compound() + */ +XBT_PUBLIC void surf_network_model_init_Constant(); +/** @ingroup SURF_models + * @brief Initializes the platform with the network model CM02 + * + * You sould call this function by yourself only if you plan using surf_host_model_init_compound. + * See comments in the code for more information. + */ +XBT_PUBLIC void surf_network_model_init_CM02(); -enum heap_action_type{ - LATENCY = 100, - MAX_DURATION, - NORMAL, - NOTSET -}; +/** @ingroup SURF_models + * @brief Initializes the platform with the network model NS3 + * + * This function is called by surf_host_model_init_NS3 or by yourself only if you plan using + * surf_host_model_init_compound + * + * @see surf_host_model_init_NS3() + */ +#if !SIMGRID_HAVE_NS3 +XBT_ATTRIB_NORETURN +#endif +XBT_PUBLIC void surf_network_model_init_NS3(); -/********* - * 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; +/** @ingroup SURF_models + * @brief Initializes the platform with the network model Reno + * + * The problem is related to max( sum( arctan(C * Df * xi) ) ). + * + * Reference: + * [LOW03] S. H. Low. A duality model of TCP and queue management algorithms. + * IEEE/ACM Transaction on Networking, 11(4):525-536, 2003. + * + * Call this function only if you plan using surf_host_model_init_compound. + */ +XBT_PUBLIC void surf_network_model_init_Reno(); -/********* - * Model * - *********/ -XBT_PUBLIC_DATA(xbt_dynar_t) model_list; - -class Model { - const char *p_name; - - ActionListPtr p_readyActionSet; /**< Actions in state SURF_ACTION_READY */ - ActionListPtr p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */ - ActionListPtr p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */ - ActionListPtr p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */ - - ResourceCallback m_resOnCB, m_resOffCB; - ActionCallback m_actCancelCB, m_actSuspendCB, m_actResumeCB; - -protected: - ActionLmmListPtr p_modifiedSet; - - lmm_system_t p_maxminSystem; - e_UM_t p_updateMechanism; - int m_selectiveUpdate; - xbt_heap_t p_actionHeap; - -public: - Model(const char *name); - virtual ~Model(); - - const char *getName() {return p_name;} - virtual ActionListPtr getReadyActionSet() {return p_readyActionSet;} - virtual ActionListPtr getRunningActionSet() {return p_runningActionSet;} - virtual ActionListPtr getFailedActionSet() {return p_failedActionSet;} - virtual ActionListPtr getDoneActionSet() {return p_doneActionSet;} - virtual ActionLmmListPtr 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(ActionListPtr 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); - - void addTurnedOnCallback(ResourceCallback rc); - void notifyResourceTurnedOn(ResourcePtr r); - - void addTurnedOffCallback(ResourceCallback rc); - void notifyResourceTurnedOff(ResourcePtr r); - - void addActionCancelCallback(ActionCallback ac); - void notifyActionCancel(ActionPtr a); - void addActionResumeCallback(ActionCallback ac); - void notifyActionResume(ActionPtr a); - void addActionSuspendCallback(ActionCallback ac); - void notifyActionSuspend(ActionPtr a); -}; +/** @ingroup SURF_models + * @brief Initializes the platform with the network model Reno2 + * + * The problem is related to max( sum( arctan(C * Df * xi) ) ). + * + * Reference: + * [LOW01] S. H. Low. A duality model of TCP and queue management algorithms. + * IEEE/ACM Transaction on Networking, 11(4):525-536, 2003. + * + * Call this function only if you plan using surf_host_model_init_compound. + */ +XBT_PUBLIC void surf_network_model_init_Reno2(); + +/** @ingroup SURF_models + * @brief Initializes the platform with the network model Vegas + * + * This problem is related to max( sum( a * Df * ln(xi) ) ) which is equivalent to the proportional fairness. + * + * Reference: + * [LOW03] S. H. Low. A duality model of TCP and queue management algorithms. + * IEEE/ACM Transaction on Networking, 11(4):525-536, 2003. + * + * Call this function only if you plan using surf_host_model_init_compound. + */ +XBT_PUBLIC void surf_network_model_init_Vegas(); -/************ - * Resource * - ************/ +/** @ingroup SURF_models + * @brief Initializes the platform with the current best network and cpu models at hand + * + * This platform model seperates the host model and the network model. + * The host model will be initialized with the model compound, the network model with the model LV08 (with cross + * traffic support) and the CPU model with the model Cas01. + * Such model is subject to modification with warning in the ChangeLog so monitor it! + */ +XBT_PUBLIC void surf_vm_model_init_HL13(); -/** - * Resource which have a metric handled by a maxmin system +/** @ingroup SURF_models + * @brief Initializes the platform with a compound host model + * + * This function should be called after a cpu_model and a network_model have been set up. */ -typedef struct { - double scale; - double peak; - tmgr_trace_event_t event; -} s_surf_metric_t; - -class Resource { - void *p_resource; - const char *p_name; - ModelPtr p_model; - xbt_dict_t p_properties; - bool m_running; - -protected: - e_surf_resource_state_t m_stateCurrent; - -public: - Resource(); - Resource(ModelPtr model, const char *name, xbt_dict_t props); - Resource(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint); - Resource(ModelPtr model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit); - Resource(ModelPtr model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit, lmm_constraint_t constraint); - - virtual ~Resource() { - xbt_free((void*)p_name); - xbt_dict_free(&p_properties); - }; - - ModelPtr getModel() {return p_model;}; - const char *getName() {return p_name;}; - virtual xbt_dict_t getProperties() {return p_properties;}; - - 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); - - virtual e_surf_resource_state_t getState(); - virtual void setState(e_surf_resource_state_t state); - - /* LMM */ -private: - lmm_constraint_t p_constraint; -public: - lmm_constraint_t getConstraint() {return p_constraint;}; +XBT_PUBLIC void surf_host_model_init_compound(); +/** @ingroup SURF_models + * @brief Initializes the platform with the current best network and cpu models at hand + * + * This platform model separates the host model and the network model. + * The host model will be initialized with the model compound, the network model with the model LV08 (with cross + * traffic support) and the CPU model with the model Cas01. + * Such model is subject to modification with warning in the ChangeLog so monitor it! + */ +XBT_PUBLIC void surf_host_model_init_current_default(); + +/** @ingroup SURF_models + * @brief Initializes the platform with the model L07 + * + * With this model, only parallel tasks can be used. Resource sharing is done by identifying bottlenecks and giving an + * equal share of the model to each action. + */ +XBT_PUBLIC void surf_host_model_init_ptask_L07(); + +/** @ingroup SURF_models + * @brief The storage model + */ +XBT_PUBLIC void surf_storage_model_init_default(); + +/* -------------------- + * Model Descriptions + * -------------------- */ +/** @brief Resource model description */ +struct surf_model_description_t { + const char* name; + const char* description; + void_f_void_t model_init_preparse; }; +XBT_PUBLIC int find_model_description(const std::vector& table, const std::string& name); +XBT_PUBLIC void model_help(const char* category, const std::vector& table); + +#define SIMGRID_REGISTER_PLUGIN(id, desc, init) \ + static void XBT_ATTRIB_CONSTRUCTOR(800) simgrid_##id##_plugin_register() \ + { \ + simgrid_add_plugin_description(#id, desc, init); \ + } + +XBT_PUBLIC void simgrid_add_plugin_description(const char* name, const char* description, void_f_void_t init_fun); + +/** @brief The list of all available plugins */ +XBT_PUBLIC_DATA std::vector* surf_plugin_description; +/** @brief The list of all available optimization modes (both for cpu and networks). + * These optimization modes can be set using --cfg=cpu/optim:... and --cfg=network/optim:... */ +XBT_PUBLIC_DATA const std::vector surf_optimization_mode_description; +/** @brief The list of all cpu models (pick one with --cfg=cpu/model) */ +XBT_PUBLIC_DATA const std::vector surf_cpu_model_description; +/** @brief The list of all network models (pick one with --cfg=network/model) */ +XBT_PUBLIC_DATA const std::vector surf_network_model_description; +/** @brief The list of all storage models (pick one with --cfg=storage/model) */ +XBT_PUBLIC_DATA const std::vector surf_storage_model_description; +/** @brief The list of all host models (pick one with --cfg=host/model:) */ +XBT_PUBLIC_DATA const std::vector surf_host_model_description; + /********** * Action * **********/ -void surf_action_lmm_update_index_heap(void *action, int i); - -class Action : public actionHook, public actionLmmHook { - ActionLmmListPtr 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 */ - -protected: - ActionListPtr 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 */ - - ModelPtr getModel() {return p_model;} - -public: - - Action(); - Action(ModelPtr model, double cost, bool failed); - Action(ModelPtr model, double cost, bool failed, lmm_variable_t var); - 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;} - - 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;} - - - 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(); /**< Suspend an action */ - virtual void resume(); /**< Resume a suspended action */ - virtual bool isSuspended(); /**< Return whether an action is suspended */ - virtual void setMaxDuration(double duration); /**< Set the max duration of an action*/ - virtual void setPriority(double priority); /**< 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 */ - double getRemainsNoUpdate(); - -#ifdef HAVE_LATENCY_BOUND_TRACKING - int getLatencyLimited(); /**< Return 1 if action is limited by latency, 0 otherwise */ -#endif - - double getPriority() {return m_priority;}; - ActionListPtr getStateSet() {return p_stateSet;}; - -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); - - /* LMM */ -protected: - lmm_variable_t p_variable; - double m_lastUpdate; - double m_lastValue; - int m_suspended; - int m_indexHeap; - enum heap_action_type m_hat; - -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 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;} - bool is_linked() {return actionLmmHook::is_linked();} - void gapRemove(); -}; #endif /* SURF_MODEL_H_ */