Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
let lmm_system_free(nullptr) be a noop
[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 #include "src/surf/PropertyHolder.hpp"
19
20 #include "simgrid/link.h"
21
22 /***********
23  * Classes *
24  ***********/
25
26 namespace simgrid {
27   namespace surf {
28
29     class NetworkModel;
30     class NetworkAction;
31
32     /*************
33      * Callbacks *
34      *************/
35
36
37     /** @brief Callback signal fired when the state of a NetworkAction changes
38      *  Signature: `void(NetworkAction *action, simgrid::surf::Action::State old, simgrid::surf::Action::State current)` */
39     XBT_PUBLIC_DATA(simgrid::xbt::signal<void(simgrid::surf::NetworkAction*, simgrid::surf::Action::State, simgrid::surf::Action::State)>) networkActionStateChangedCallbacks;
40
41       }
42 }
43
44 /*********
45  * Tools *
46  *********/
47 XBT_PUBLIC(void) netlink_parse_init(sg_platf_link_cbarg_t link);
48
49 /*********
50  * Model *
51  *********/
52
53 namespace simgrid {
54   namespace surf {
55
56     /** @ingroup SURF_network_interface
57      * @brief SURF network model interface class
58      * @details A model is an object which handles the interactions between its Resources and its Actions
59      */
60     class NetworkModel : public Model {
61     public:
62       /** @brief Constructor */
63       NetworkModel() : Model() { }
64
65       /** @brief Destructor */
66       ~NetworkModel() {
67         lmm_system_free(maxminSystem_);
68         xbt_heap_free(actionHeap_);
69         delete modifiedSet_;
70       }
71
72       /**
73        * @brief Create a Link
74        *
75        * @param name The name of the Link
76        * @param bandwidth The initial bandwidth of the Link in bytes per second
77        * @param latency The initial latency of the Link in seconds
78        * @param policy The sharing policy of the Link
79        * @param properties Dictionary of properties associated to this Resource
80        * @return The created Link
81        */
82       virtual Link* createLink(const char *name, double bandwidth, double latency,
83           e_surf_link_sharing_policy_t policy, xbt_dict_t properties)=0;
84
85       /**
86        * @brief Create a communication between two hosts.
87        * @details It makes calls to the routing part, and execute the communication
88        * between the two end points.
89        *
90        * @param src The source of the communication
91        * @param dst The destination of the communication
92        * @param size The size of the communication in bytes
93        * @param rate Allows to limit the transfer rate. Negative value means
94        * unlimited.
95        * @return The action representing the communication
96        */
97       virtual Action *communicate(NetCard *src, NetCard *dst, double size, double rate)=0;
98
99       /** @brief Function pointer to the function to use to solve the lmm_system_t
100        *
101        * @param system The lmm_system_t to solve
102        */
103       void (*f_networkSolve)(lmm_system_t) = lmm_solve;
104
105       /**
106        * @brief Get the right multiplicative factor for the latency.
107        * @details Depending on the model, the effective latency when sending
108        * a message might be different from the theoretical latency of the link,
109        * in function of the message size. In order to account for this, this
110        * function gets this factor.
111        *
112        * @param size The size of the message.
113        * @return The latency factor.
114        */
115       virtual double latencyFactor(double size);
116
117       /**
118        * @brief Get the right multiplicative factor for the bandwidth.
119        * @details Depending on the model, the effective bandwidth when sending
120        * a message might be different from the theoretical bandwidth of the link,
121        * in function of the message size. In order to account for this, this
122        * function gets this factor.
123        *
124        * @param size The size of the message.
125        * @return The bandwidth factor.
126        */
127       virtual double bandwidthFactor(double size);
128
129       /**
130        * @brief Get definitive bandwidth.
131        * @details It gives the minimum bandwidth between the one that would
132        * occur if no limitation was enforced, and the one arbitrary limited.
133        * @param rate The desired maximum bandwidth.
134        * @param bound The bandwidth with only the network taken into account.
135        * @param size The size of the message.
136        * @return The new bandwidth.
137        */
138       virtual double bandwidthConstraint(double rate, double bound, double size);
139       double next_occuring_event_full(double now) override;
140     };
141
142     /************
143      * Resource *
144      ************/
145     /** @ingroup SURF_network_interface
146      * @brief SURF network link interface class
147      * @details A Link represents the link between two [hosts](\ref Host)
148      */
149     class Link :
150         public simgrid::surf::Resource,
151         public simgrid::surf::PropertyHolder {
152         public:
153       /**
154        * @brief Link constructor
155        *
156        * @param model The NetworkModel associated to this Link
157        * @param name The name of the Link
158        * @param props Dictionary of properties associated to this Link
159        */
160       Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props);
161
162       /**
163        * @brief Link constructor
164        *
165        * @param model The NetworkModel associated to this Link
166        * @param name The name of the Link
167        * @param props Dictionary of properties associated to this Link
168        * @param constraint The lmm constraint associated to this Cpu if it is part of a LMM component
169        */
170       Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint);
171
172       /* Link destruction logic */
173       /**************************/
174         protected:
175       ~Link();
176         public:
177       void destroy(); // Must be called instead of the destructor
178         private:
179       bool currentlyDestroying_ = false;
180
181         public:
182       /** @brief Callback signal fired when a new Link is created.
183        *  Signature: void(Link*) */
184       static simgrid::xbt::signal<void(simgrid::surf::Link*)> onCreation;
185
186       /** @brief Callback signal fired when a Link is destroyed.
187        *  Signature: void(Link*) */
188       static simgrid::xbt::signal<void(simgrid::surf::Link*)> onDestruction;
189
190       /** @brief Callback signal fired when the state of a Link changes (when it is turned on or off)
191        *  Signature: `void(Link*)` */
192       static simgrid::xbt::signal<void(simgrid::surf::Link*)> onStateChange;
193
194       /** @brief Callback signal fired when a communication starts
195        *  Signature: `void(NetworkAction *action, RoutingEdge *src, RoutingEdge *dst)` */
196       static simgrid::xbt::signal<void(simgrid::surf::NetworkAction*, simgrid::surf::NetCard *src, simgrid::surf::NetCard *dst)> onCommunicate;
197
198
199
200       /** @brief Get the bandwidth in bytes per second of current Link */
201       virtual double getBandwidth();
202
203       /** @brief Update the bandwidth in bytes per second of current Link */
204       virtual void updateBandwidth(double value)=0;
205
206       /** @brief Get the latency in seconds of current Link */
207       virtual double getLatency();
208
209       /** @brief Update the latency in seconds of current Link */
210       virtual void updateLatency(double value)=0;
211
212       /** @brief The sharing policy is a @{link e_surf_link_sharing_policy_t::EType} (0: FATPIPE, 1: SHARED, 2: FULLDUPLEX) */
213       virtual int sharingPolicy();
214
215       /** @brief Check if the Link is used */
216       bool isUsed() override;
217
218       void turnOn() override;
219       void turnOff() override;
220
221       virtual void setStateTrace(tmgr_trace_t trace); /*< setup the trace file with states events (ON or OFF). Trace must contain boolean values. */
222       virtual void setBandwidthTrace(tmgr_trace_t trace); /*< setup the trace file with bandwidth events (peak speed changes due to external load). Trace must contain percentages (value between 0 and 1). */
223       virtual void setLatencyTrace(tmgr_trace_t trace); /*< setup the trace file with latency events (peak latency changes due to external load). Trace must contain absolute values */
224
225       tmgr_trace_iterator_t m_stateEvent = NULL;
226       s_surf_metric_t m_latency = {1.0,0,NULL};
227       s_surf_metric_t m_bandwidth = {1.0,0,NULL};
228
229       /* User data */
230         public:
231       void *getData()        { return userData;}
232       void  setData(void *d) { userData=d;}
233         private:
234       void *userData = NULL;
235
236       /* List of all links */
237         private:
238       static boost::unordered_map<std::string, Link *> *links;
239         public:
240       static Link *byName(const char* name);
241       static int linksCount();
242       static Link **linksList();
243       static void linksExit();
244     };
245
246     /**********
247      * Action *
248      **********/
249     /** @ingroup SURF_network_interface
250      * @brief SURF network action interface class
251      * @details A NetworkAction represents a communication between two [hosts](\ref Host)
252      */
253     class NetworkAction : public simgrid::surf::Action {
254     public:
255       /** @brief Constructor
256        *
257        * @param model The NetworkModel associated to this NetworkAction
258        * @param cost The cost of this  NetworkAction in [TODO]
259        * @param failed [description]
260        */
261       NetworkAction(simgrid::surf::Model *model, double cost, bool failed)
262     : simgrid::surf::Action(model, cost, failed) {}
263
264       /**
265        * @brief NetworkAction constructor
266        *
267        * @param model The NetworkModel associated to this NetworkAction
268        * @param cost The cost of this  NetworkAction in [TODO]
269        * @param failed [description]
270        * @param var The lmm variable associated to this Action if it is part of a
271        * LMM component
272        */
273       NetworkAction(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var)
274       : simgrid::surf::Action(model, cost, failed, var) {};
275
276       void setState(simgrid::surf::Action::State state) override;
277
278       double latency_;
279       double latCurrent_;
280       double weight_;
281       double rate_;
282       const char* senderLinkName_;
283       double senderSize_;
284       xbt_fifo_item_t senderFifoItem_;
285     };
286   }
287 }
288
289 #endif /* SURF_NETWORK_INTERFACE_HPP_ */
290
291