Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
reimplement energy plugin using Host callbacks (not Cpu ones)
[simgrid.git] / src / surf / network_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_NETWORK_INTERFACE_HPP_
8 #define SURF_NETWORK_INTERFACE_HPP_
9
10 #include <xbt/base.h>
11
12 #include <boost/unordered_map.hpp>
13
14 #include "xbt/fifo.h"
15 #include "xbt/dict.h"
16 #include "surf_interface.hpp"
17 #include "surf_routing.hpp"
18
19 #include "simgrid/link.h"
20
21 /***********
22  * Classes *
23  ***********/
24 class NetworkModel;
25 class NetworkAction;
26
27 /*************
28  * Callbacks *
29  *************/
30
31 /** @ingroup SURF_callbacks
32  * @brief Callbacks handler which emits the callbacks after Link creation
33  * @details Callback functions have the following signature: `void(Link*)`
34  */
35 XBT_PUBLIC_DATA( surf_callback(void, Link*)) networkLinkCreatedCallbacks;
36
37 /** @ingroup SURF_callbacks
38  * @brief Callbacks handler which emits the callbacks after Link destruction
39  * @details Callback functions have the following signature: `void(Link*)`
40  */
41 XBT_PUBLIC_DATA( surf_callback(void, Link*)) networkLinkDestructedCallbacks;
42
43 /** @ingroup SURF_callbacks
44  * @brief Callbacks handler which emits the callbacks after Link State changed
45  * @details Callback functions have the following signature: `void(LinkAction *action, e_surf_resource_state_t old, e_surf_resource_state_t current)`
46  */
47 XBT_PUBLIC_DATA( surf_callback(void, Link*, e_surf_resource_state_t, e_surf_resource_state_t)) networkLinkStateChangedCallbacks;
48
49 /** @ingroup SURF_callbacks
50  * @brief Callbacks handler which emits the callbacks after NetworkAction State changed
51  * @details Callback functions have the following signature: `void(NetworkAction *action, e_surf_action_state_t old, e_surf_action_state_t current)`
52  */
53 XBT_PUBLIC_DATA( surf_callback(void, NetworkAction*, e_surf_action_state_t, e_surf_action_state_t)) networkActionStateChangedCallbacks;
54
55 /** @ingroup SURF_callbacks
56  * @brief Callbacks handler which emits the callbacks after communication created
57  * @details Callback functions have the following signature: `void(NetworkAction *action, RoutingEdge *src, RoutingEdge *dst, double size, double rate)`
58  */
59 XBT_PUBLIC_DATA( surf_callback(void, NetworkAction*, RoutingEdge *src, RoutingEdge *dst, double size, double rate)) networkCommunicateCallbacks;
60
61 /*********
62  * Tools *
63  *********/
64 XBT_PUBLIC(void) netlink_parse_init(sg_platf_link_cbarg_t link);
65
66 XBT_PUBLIC(void) net_add_traces();
67
68 /*********
69  * Model *
70  *********/
71 /** @ingroup SURF_network_interface
72  * @brief SURF network model interface class
73  * @details A model is an object which handles the interactions between its Resources and its Actions
74  */
75 class NetworkModel : public Model {
76 public:
77   /** @brief Constructor */
78   NetworkModel() : Model() { }
79
80   /** @brief Destructor */
81   ~NetworkModel() {
82         if (p_maxminSystem)
83           lmm_system_free(p_maxminSystem);
84         if (p_actionHeap)
85           xbt_heap_free(p_actionHeap);
86         if (p_modifiedSet)
87           delete p_modifiedSet;
88   }
89
90   /**
91    * @brief Create a Link
92    *
93    * @param name The name of the Link
94    * @param bw_initial The initial bandwidth of the Link in bytes per second
95    * @param bw_trace The trace associated to the Link bandwidth
96    * @param lat_initial The initial latency of the Link in seconds
97    * @param lat_trace The trace associated to the Link latency
98    * @param state_initial The initial Link (state)[e_surf_resource_state_t]
99    * @param state_trace The trace associated to the Link (state)[e_surf_resource_state_t]
100    * @param policy The sharing policy of the Link
101    * @param properties Dictionary of properties associated to this Resource
102    * @return The created Link
103    */
104   virtual Link* createLink(const char *name,
105                                    double bw_initial,
106                                    tmgr_trace_t bw_trace,
107                                    double lat_initial,
108                                    tmgr_trace_t lat_trace,
109                                    e_surf_resource_state_t state_initial,
110                                    tmgr_trace_t state_trace,
111                                    e_surf_link_sharing_policy_t policy,
112                                    xbt_dict_t properties)=0;
113
114   /**
115    * @brief Create a communication between two hosts.
116    * @details It makes calls to the routing part, and execute the communication
117    * between the two end points.
118    *
119    * @param src The source of the communication
120    * @param dst The destination of the communication
121    * @param size The size of the communication in bytes
122    * @param rate Allows to limit the transfer rate. Negative value means
123    * unlimited.
124    * @return The action representing the communication
125    */
126   virtual Action *communicate(RoutingEdge *src, RoutingEdge *dst,
127                                            double size, double rate)=0;
128
129   /** @brief Function pointer to the function to use to solve the lmm_system_t
130    *
131    * @param system The lmm_system_t to solve
132    */
133   void (*f_networkSolve)(lmm_system_t) = lmm_solve;
134
135   /**
136    * @brief Get the right multiplicative factor for the latency.
137    * @details Depending on the model, the effective latency when sending
138    * a message might be different from the theoretical latency of the link,
139    * in function of the message size. In order to account for this, this
140    * function gets this factor.
141    *
142    * @param size The size of the message.
143    * @return The latency factor.
144    */
145   virtual double latencyFactor(double size);
146
147   /**
148    * @brief Get the right multiplicative factor for the bandwidth.
149    * @details Depending on the model, the effective bandwidth when sending
150    * a message might be different from the theoretical bandwidth of the link,
151    * in function of the message size. In order to account for this, this
152    * function gets this factor.
153    *
154    * @param size The size of the message.
155    * @return The bandwidth factor.
156    */
157   virtual double bandwidthFactor(double size);
158
159   /**
160    * @brief Get definitive bandwidth.
161    * @details It gives the minimum bandwidth between the one that would
162    * occur if no limitation was enforced, and the one arbitrary limited.
163    * @param rate The desired maximum bandwidth.
164    * @param bound The bandwidth with only the network taken into account.
165    * @param size The size of the message.
166    * @return The new bandwidth.
167    */
168   virtual double bandwidthConstraint(double rate, double bound, double size);
169   double shareResourcesFull(double now);
170 };
171
172 /************
173  * Resource *
174  ************/
175  /** @ingroup SURF_network_interface
176   * @brief SURF network link interface class
177   * @details A Link represents the link between two [hosts](\ref Host)
178   */
179 class Link : public Resource {
180 public:
181   /**
182    * @brief Link constructor
183    *
184    * @param model The NetworkModel associated to this Link
185    * @param name The name of the Link
186    * @param props Dictionary of properties associated to this Link
187    */
188   Link(NetworkModel *model, const char *name, xbt_dict_t props);
189
190   /**
191    * @brief Link constructor
192    *
193    * @param model The NetworkModel associated to this Link
194    * @param name The name of the Link
195    * @param props Dictionary of properties associated to this Link
196    * @param constraint The lmm constraint associated to this Cpu if it is part of a LMM component
197    * @param history [TODO]
198    * @param state_trace [TODO]
199    */
200   Link(NetworkModel *model, const char *name, xbt_dict_t props,
201               lmm_constraint_t constraint,
202               tmgr_history_t history,
203               tmgr_trace_t state_trace);
204
205   /** @brief Link destructor */
206   ~Link();
207
208   /** @brief Get the bandwidth in bytes per second of current Link */
209   virtual double getBandwidth();
210
211   /** @brief Update the bandwidth in bytes per second of current Link */
212   virtual void updateBandwidth(double value, double date=surf_get_clock())=0;
213
214   /** @brief Get the latency in seconds of current Link */
215   virtual double getLatency();
216
217   /** @brief Update the latency in seconds of current Link */
218   virtual void updateLatency(double value, double date=surf_get_clock())=0;
219
220   /**
221    * @brief Check if the Link is shared
222    *
223    * @return true if the current NetwokrLink is shared, false otherwise
224    */
225   virtual bool isShared();
226
227   /** @brief Check if the Link is used */
228   bool isUsed();
229
230   void setState(e_surf_resource_state_t state);
231
232   /* Using this object with the public part of
233     model does not make sense */
234   double m_latCurrent;
235   tmgr_trace_event_t p_latEvent;
236
237   /* LMM */
238   tmgr_trace_event_t p_stateEvent = NULL;
239   s_surf_metric_t p_power;
240
241   /* User data */
242 public:
243   void *getData()        { return userData;}
244   void  setData(void *d) { userData=d;}
245 private:
246   void *userData = NULL;
247
248   /* List of all links */
249 private:
250   static boost::unordered_map<std::string, Link *> *links;
251 public:
252   static Link *byName(const char* name);
253   static int linksAmount();
254   static Link **linksList();
255   static void linksExit();
256 };
257
258 /**********
259  * Action *
260  **********/
261 /** @ingroup SURF_network_interface
262  * @brief SURF network action interface class
263  * @details A NetworkAction represents a communication between two [hosts](\ref Host)
264  */
265 class NetworkAction : public Action {
266 public:
267   /** @brief Constructor
268    *
269    * @param model The NetworkModel associated to this NetworkAction
270    * @param cost The cost of this  NetworkAction in [TODO]
271    * @param failed [description]
272    */
273   NetworkAction(Model *model, double cost, bool failed)
274   : Action(model, cost, failed) {}
275
276   /**
277    * @brief NetworkAction constructor
278    *
279    * @param model The NetworkModel associated to this NetworkAction
280    * @param cost The cost of this  NetworkAction in [TODO]
281    * @param failed [description]
282    * @param var The lmm variable associated to this Action if it is part of a
283    * LMM component
284    */
285   NetworkAction(Model *model, double cost, bool failed, lmm_variable_t var)
286   : Action(model, cost, failed, var) {};
287
288   void setState(e_surf_action_state_t state);
289
290 #ifdef HAVE_LATENCY_BOUND_TRACKING
291   /**
292    * @brief Check if the action is limited by latency.
293    *
294    * @return 1 if action is limited by latency, 0 otherwise
295    */
296   virtual int getLatencyLimited() {return m_latencyLimited;}
297 #endif
298
299   double m_latency;
300   double m_latCurrent;
301   double m_weight;
302   double m_rate;
303   const char* p_senderLinkName;
304   double m_senderSize;
305   xbt_fifo_item_t p_senderFifoItem;
306 #ifdef HAVE_LATENCY_BOUND_TRACKING
307   int m_latencyLimited;
308 #endif
309
310 };
311
312 #endif /* SURF_NETWORK_INTERFACE_HPP_ */
313
314