Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
f175f4c5349d8557dca1b8986eedf46a2809a3ed
[simgrid.git] / src / surf / surf_interface.hpp
1 /* Copyright (c) 2004-2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef SURF_MODEL_H_
8 #define SURF_MODEL_H_
9
10 #include <xbt.h>
11 #include <string>
12 #include <vector>
13 #include <memory>
14 #include <utility>
15
16 #include <boost/function.hpp>
17 #include <boost/intrusive/list.hpp>
18 #include "surf/trace_mgr.h"
19 #include "xbt/lib.h"
20 #include "surf/surf_routing.h"
21 #include "simgrid/platf_interface.h"
22 #include "surf/surf.h"
23 #include "src/surf/surf_private.h"
24 #include "src/internal_config.h"
25
26 #ifdef LIBSIGC
27 #include <sigc++/sigc++.h>
28 namespace simgrid {
29 namespace surf {
30   // Wraps sigc++ signals with the interface of boost::signals2:
31   template<class T> class signal;
32   template<class R, class... P>
33   class signal<R(P...)> {
34   private:
35     sigc::signal<R, P...> sig_;
36   public:
37     template<class T> XBT_ALWAYS_INLINE
38     void connect(T&& slot)
39     {
40       sig_.connect(std::forward<T>(slot));
41     }
42     template<class Res, class... Args> XBT_ALWAYS_INLINE
43     void connect(Res(*slot)(Args...))
44     {
45       sig_.connect(sigc::ptr_fun(slot));
46     }
47     template<class... Args>
48     R operator()(Args&&... args) const
49     {
50       return sig_.emit(std::forward<Args>(args)...);
51     }
52   };
53 }
54 }
55 #else
56 #include <boost/signals2.hpp>
57 namespace simgrid {
58 namespace surf {
59   template<class T>
60   using signal = ::boost::signals2::signal<T>;
61 }
62 }
63 #endif
64
65 extern XBT_PRIVATE tmgr_history_t history;
66 #define NO_MAX_DURATION -1.0
67
68 /*********
69  * Utils *
70  *********/
71
72 /* user-visible parameters */
73 extern XBT_PRIVATE double sg_tcp_gamma;
74 extern XBT_PRIVATE double sg_sender_gap;
75 extern XBT_PRIVATE double sg_latency_factor;
76 extern XBT_PRIVATE double sg_bandwidth_factor;
77 extern XBT_PRIVATE double sg_weight_S_parameter;
78 extern XBT_PRIVATE int sg_network_crosstraffic;
79 extern XBT_PRIVATE xbt_dynar_t surf_path;
80
81 extern "C" {
82 XBT_PUBLIC(double) surf_get_clock(void);
83 }
84
85 extern XBT_PRIVATE double sg_sender_gap;
86
87 namespace simgrid {
88 namespace surf {
89
90 extern XBT_PRIVATE simgrid::surf::signal<void(void)> surfExitCallbacks;
91
92 }
93 }
94
95 int XBT_PRIVATE __surf_is_absolute_file_path(const char *file_path);
96
97 /***********
98  * Classes *
99  ***********/
100
101 enum heap_action_type{
102   LATENCY = 100,
103   MAX_DURATION,
104   NORMAL,
105   NOTSET
106 };
107
108 /*********
109  * Trace *
110  *********/
111 /* For the trace and trace:connect tag (store their content till the end of the parsing) */
112 XBT_PUBLIC_DATA(xbt_dict_t) traces_set_list;
113 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_host_avail;
114 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_power;
115 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_link_avail;
116 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_bandwidth;
117 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_latency;
118
119 /**********
120  * Action *
121  **********/
122
123 XBT_PRIVATE void surf_action_lmm_update_index_heap(void *action, int i);
124
125 XBT_PUBLIC_DATA(xbt_dynar_t) all_existing_models;
126
127 namespace simgrid {
128 namespace surf {
129
130 /** @ingroup SURF_interface
131  * @brief SURF action interface class
132  * @details An action is an event generated by a resource (e.g.: a communication for the network)
133  */
134 XBT_PUBLIC_CLASS Action {
135 public:
136   boost::intrusive::list_member_hook<> action_hook;
137   boost::intrusive::list_member_hook<> action_lmm_hook;
138   typedef boost::intrusive::member_hook<
139     Action, boost::intrusive::list_member_hook<>, &Action::action_hook> ActionOptions;
140   typedef boost::intrusive::list<Action, ActionOptions> ActionList;
141 private:
142   /**
143    * @brief Common initializations for the constructors
144    */
145   void initialize(simgrid::surf::Model *model, double cost, bool failed,
146                   lmm_variable_t var = NULL);
147
148 public:
149   /**
150    * @brief Action constructor
151    *
152    * @param model The Model associated to this Action
153    * @param cost The cost of the Action
154    * @param failed If the action is impossible (e.g.: execute something on a switched off host)
155    */
156   Action(simgrid::surf::Model *model, double cost, bool failed);
157
158   /**
159    * @brief Action constructor
160    *
161    * @param model The Model associated to this Action
162    * @param cost The cost of the Action
163    * @param failed If the action is impossible (e.g.: execute something on a switched off host)
164    * @param var The lmm variable associated to this Action if it is part of a LMM component
165    */
166   Action(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var);
167
168   /** @brief Destructor */
169   virtual ~Action();
170
171   /** @brief Mark that the action is now finished */
172   void finish();
173
174   /** @brief Get the [state](\ref e_surf_action_state_t) of the current Action */
175   e_surf_action_state_t getState(); /**< get the state*/
176   /** @brief Set the [state](\ref e_surf_action_state_t) of the current Action */
177   virtual void setState(e_surf_action_state_t state);
178
179   /** @brief Get the bound of the current Action */
180   double getBound();
181   /** @brief Set the bound of the current Action */
182   void setBound(double bound);
183
184   /** @brief Get the start time of the current action */
185   double getStartTime();
186   /** @brief Get the finish time of the current action */
187   double getFinishTime();
188
189   /** @brief Get the user data associated to the current action */
190   void *getData() {return p_data;}
191   /** @brief Set the user data associated to the current action */
192   void setData(void* data);
193
194   /** @brief Get the cost of the current action */
195   double getCost() {return m_cost;}
196   /** @brief Set the cost of the current action */
197   void setCost(double cost) {m_cost = cost;}
198
199   /** @brief Update the maximum duration of the current action
200    *  @param delta Amount to remove from the MaxDuration */
201   void updateMaxDuration(double delta) {double_update(&m_maxDuration, delta,sg_surf_precision);}
202
203   /** @brief Update the remaining time of the current action
204    *  @param delta Amount to remove from the remaining time */
205   void updateRemains(double delta) {double_update(&m_remains, delta, sg_maxmin_precision*sg_surf_precision);}
206
207   /** @brief Set the remaining time of the current action */
208   void setRemains(double value) {m_remains = value;}
209   /** @brief Get the remaining time of the current action after updating the resource */
210   virtual double getRemains();
211   /** @brief Get the remaining time of the current action without updating the resource */
212   double getRemainsNoUpdate();
213
214   /** @brief Set the finish time of the current action */
215   void setFinishTime(double value) {m_finish = value;}
216
217   /**@brief Add a reference to the current action (refcounting) */
218   void ref();
219   /** @brief Unref that action (and destroy it if refcount reaches 0)
220    *  @return true if the action was destroyed and false if someone still has references on it
221    */
222   virtual int unref();
223
224   /** @brief Cancel the current Action if running */
225   virtual void cancel();
226
227   /** @brief Suspend the current Action */
228   virtual void suspend();
229
230   /** @brief Resume the current Action */
231   virtual void resume();
232
233   /** @brief Returns true if the current action is running */
234   virtual bool isSuspended();
235
236   /** @brief Get the maximum duration of the current action */
237   double getMaxDuration() {return m_maxDuration;}
238   /** @brief Set the maximum duration of the current Action */
239   virtual void setMaxDuration(double duration);
240
241   /** @brief Get the tracing category associated to the current action */
242   char *getCategory() {return p_category;}
243   /** @brief Set the tracing category of the current Action */
244   void setCategory(const char *category);
245
246   /** @brief Get the priority of the current Action */
247   double getPriority() {return m_priority;};
248   /** @brief Set the priority of the current Action */
249   virtual void setPriority(double priority);
250
251   /** @brief Get the state set in which the action is */
252   ActionList* getStateSet() {return p_stateSet;};
253
254   s_xbt_swag_hookup_t p_stateHookup = {NULL,NULL};
255
256   simgrid::surf::Model *getModel() {return p_model;}
257
258 protected:
259   ActionList* p_stateSet;
260   double m_priority = 1.0; /**< priority (1.0 by default) */
261   int    m_refcount = 1;
262   double m_remains; /**< How much of that cost remains to be done in the currently running task */
263   double m_maxDuration = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */
264   double m_finish = -1; /**< finish time : this is modified during the run and fluctuates until the task is completed */
265
266 private:
267   double m_start; /**< start time  */
268   char *p_category = NULL;            /**< tracing category for categorized resource utilization monitoring */
269
270   #ifdef HAVE_LATENCY_BOUND_TRACKING
271   int m_latencyLimited;               /**< Set to 1 if is limited by latency, 0 otherwise */
272   #endif
273   double    m_cost;
274   simgrid::surf::Model *p_model;
275   void *p_data = NULL; /**< for your convenience */
276
277   /* LMM */
278 public:
279   virtual void updateRemainingLazy(double now);
280   void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat);
281   void heapRemove(xbt_heap_t heap);
282   void heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat);
283   void updateIndexHeap(int i);
284   lmm_variable_t getVariable() {return p_variable;}
285   double getLastUpdate() {return m_lastUpdate;}
286   void refreshLastUpdate() {m_lastUpdate = surf_get_clock();}
287   enum heap_action_type getHat() {return m_hat;}
288   bool is_linked() {return action_lmm_hook.is_linked();}
289   void gapRemove();
290
291 protected:
292   lmm_variable_t p_variable;
293   double m_lastValue = 0;
294   double m_lastUpdate = 0;
295   int m_suspended = 0;
296   int m_indexHeap;
297   enum heap_action_type m_hat = NOTSET;
298 };
299
300 typedef Action::ActionList ActionList;
301
302 typedef boost::intrusive::member_hook<
303   Action, boost::intrusive::list_member_hook<>, &Action::action_lmm_hook> ActionLmmOptions;
304 typedef boost::intrusive::list<Action, ActionLmmOptions> ActionLmmList;
305 typedef ActionLmmList* ActionLmmListPtr;
306
307 /*********
308  * Model *
309  *********/
310
311 /** @ingroup SURF_interface
312  * @brief SURF model interface class
313  * @details A model is an object which handle the interactions between its Resources and its Actions
314  */
315 XBT_PUBLIC_CLASS Model {
316 public:
317   Model();
318   virtual ~Model();
319
320   virtual void addTraces() =0;
321
322   /** @brief Get the set of [actions](@ref Action) in *ready* state */
323   virtual ActionList* getReadyActionSet() {return p_readyActionSet;}
324
325   /** @brief Get the set of [actions](@ref Action) in *running* state */
326   virtual ActionList* getRunningActionSet() {return p_runningActionSet;}
327
328   /** @brief Get the set of [actions](@ref Action) in *failed* state */
329   virtual ActionList* getFailedActionSet() {return p_failedActionSet;}
330
331   /** @brief Get the set of [actions](@ref Action) in *done* state */
332   virtual ActionList* getDoneActionSet() {return p_doneActionSet;}
333
334   /** @brief Get the set of modified [actions](@ref Action) */
335   virtual ActionLmmListPtr getModifiedSet() {return p_modifiedSet;}
336
337   /** @brief Get the maxmin system of the current Model */
338   lmm_system_t getMaxminSystem() {return p_maxminSystem;}
339
340   /**
341    * @brief Get the update mechanism of the current Model
342    * @see e_UM_t
343    */
344   e_UM_t getUpdateMechanism() {return p_updateMechanism;}
345
346   /** @brief Get Action heap */
347   xbt_heap_t getActionHeap() {return p_actionHeap;}
348
349   /**
350    * @brief Share the resources between the actions
351    *
352    * @param now The current time of the simulation
353    * @return The delta of time till the next action will finish
354    */
355   virtual double shareResources(double now);
356   virtual double shareResourcesLazy(double now);
357   virtual double shareResourcesFull(double now);
358   double shareResourcesMaxMin(ActionList* running_actions,
359                                       lmm_system_t sys,
360                                       void (*solve) (lmm_system_t));
361
362   /**
363    * @brief Update action to the current time
364    *
365    * @param now The current time of the simulation
366    * @param delta The delta of time since the last update
367    */
368   virtual void updateActionsState(double now, double delta);
369   virtual void updateActionsStateLazy(double now, double delta);
370   virtual void updateActionsStateFull(double now, double delta);
371
372   /** @brief Returns whether this model have an idempotent shareResource()
373    *
374    * The only model that is not is NS3: computing the next timestamp moves the model up to that point,
375    * so we need to call it only when the next timestamp of other sources is computed.
376    */
377   virtual bool shareResourcesIsIdempotent()=0;
378
379 protected:
380   ActionLmmListPtr p_modifiedSet;
381   lmm_system_t p_maxminSystem;
382   e_UM_t p_updateMechanism = UM_UNDEFINED;
383   int m_selectiveUpdate;
384   xbt_heap_t p_actionHeap;
385
386 private:
387   ActionList* p_readyActionSet; /**< Actions in state SURF_ACTION_READY */
388   ActionList* p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */
389   ActionList* p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */
390   ActionList* p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */
391 };
392
393 }
394 }
395
396 /************
397  * Resource *
398  ************/
399
400 /** @ingroup SURF_interface
401  * @brief Resource which have a metric handled by a maxmin system
402  */
403 typedef struct {
404   double peak;              /**< The peak of the metric, ie its max value */
405   double scale;             /**< Current availability of the metric according to the traces, in [0,1] */
406   tmgr_trace_event_t event; /**< The associated trace event associated to the metric */
407 } s_surf_metric_t;
408
409 namespace simgrid {
410 namespace surf {
411
412 /** @ingroup SURF_interface
413  * @brief SURF resource interface class
414  * @details A resource represent an element of a component (e.g.: a link for the network)
415  */
416 XBT_PUBLIC_CLASS Resource {
417 public:
418   Resource();
419
420   /**
421    * @brief Constructor of non-LMM Resources
422    *
423    * @param model Model associated to this Resource
424    * @param name The name of the Resource
425    */
426   Resource(Model *model, const char *name);
427
428   /**
429    * @brief Constructor of LMM Resources
430    *
431    * @param model Model associated to this Resource
432    * @param name The name of the Resource
433    * @param constraint The lmm constraint associated to this Resource if it is part of a LMM component
434    */
435   Resource(Model *model, const char *name, lmm_constraint_t constraint);
436
437   Resource(Model *model, const char *name, lmm_constraint_t constraint, e_surf_resource_state_t stateInit);
438
439   /**
440    * @brief Resource constructor
441    *
442    * @param model Model associated to this Resource
443    * @param name The name of the Resource
444    * @param stateInit the initial state of the Resource
445    */
446   Resource(Model *model, const char *name, e_surf_resource_state_t stateInit);
447
448   virtual ~Resource();
449
450   /** @brief Get the Model of the current Resource */
451   Model *getModel();
452
453   /** @brief Get the name of the current Resource */
454   const char *getName();
455
456   /**
457    * @brief Update the state of the current Resource
458    * @details [TODO]
459    *
460    * @param event_type [TODO]
461    * @param value [TODO]
462    * @param date [TODO]
463    */
464   virtual void updateState(tmgr_trace_event_t event_type, double value, double date)=0;
465
466   /** @brief Check if the current Resource is used (if it currently serves an action) */
467   virtual bool isUsed()=0;
468
469   /** @brief Check if the current Resource is active */
470   bool isOn();
471   /** @brief Turn on the current Resource */
472   void turnOn();
473   /** @brief Turn off the current Resource */
474   void turnOff();
475
476   /** @brief Get the [state](\ref e_surf_resource_state_t) of the current Resource */
477   virtual e_surf_resource_state_t getState();
478   /** @brief Set the [state](\ref e_surf_resource_state_t) of the current Resource */
479   virtual void setState(e_surf_resource_state_t state);
480
481 private:
482   const char *p_name;
483   Model *p_model;
484   bool m_running;
485   e_surf_resource_state_t m_stateCurrent;
486
487
488 public: /* LMM */
489   /** @brief Get the lmm constraint associated to this Resource if it is part of a LMM component */
490   lmm_constraint_t getConstraint();
491 protected:
492   lmm_constraint_t p_constraint;
493 };
494
495 }
496 }
497
498 #endif /* SURF_MODEL_H_ */