Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cleanup in the Link field names
[simgrid.git] / src / surf / network_interface.cpp
1 /* Copyright (c) 2013-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 #include <algorithm>
8
9 #include "network_interface.hpp"
10 #include "simgrid/sg_config.h"
11
12 #ifndef NETWORK_INTERFACE_CPP_
13 #define NETWORK_INTERFACE_CPP_
14
15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network, surf, "Logging specific to the SURF network module");
16
17 /*********
18  * C API *
19  *********/
20
21 extern "C" {
22
23   const char* sg_link_name(Link *link) {
24     return link->getName();
25   }
26   Link * sg_link_by_name(const char* name) {
27     return Link::byName(name);
28   }
29
30   int sg_link_is_shared(Link *link){
31     return link->sharingPolicy();
32   }
33   double sg_link_bandwidth(Link *link){
34     return link->bandwidth();
35   }
36   double sg_link_latency(Link *link){
37     return link->latency();
38   }
39   void* sg_link_data(Link *link) {
40     return link->getData();
41   }
42   void sg_link_data_set(Link *link,void *data) {
43     link->setData(data);
44   }
45   int sg_link_count() {
46     return Link::linksCount();
47   }
48   Link** sg_link_list() {
49     return Link::linksList();
50   }
51   void sg_link_exit() {
52     Link::linksExit();
53   }
54
55 }
56
57 /*****************
58  * List of links *
59  *****************/
60
61 namespace simgrid {
62   namespace surf {
63
64     std::unordered_map<std::string,Link *> *Link::links = new std::unordered_map<std::string,Link *>();
65     Link *Link::byName(const char* name) {
66       if (links->find(name) == links->end())
67         return nullptr;
68       return  links->at(name);
69     }
70     /** @brief Returns the amount of links in the platform */
71     int Link::linksCount() {
72       return links->size();
73     }
74     /** @brief Returns a list of all existing links */
75     Link **Link::linksList() {
76       Link **res = xbt_new(Link*, (int)links->size());
77       int i=0;
78       for (auto kv : *links) {
79         res[i++] = kv.second;
80       }
81       return res;
82     }
83     /** @brief destructor of the static data */
84     void Link::linksExit() {
85       for (auto kv : *links)
86         (kv.second)->destroy();
87       delete links;
88     }
89
90     /*************
91      * Callbacks *
92      *************/
93
94     simgrid::xbt::signal<void(Link*)> Link::onCreation;
95     simgrid::xbt::signal<void(Link*)> Link::onDestruction;
96     simgrid::xbt::signal<void(Link*)> Link::onStateChange;
97
98     simgrid::xbt::signal<void(NetworkAction*, Action::State, Action::State)> networkActionStateChangedCallbacks;
99     simgrid::xbt::signal<void(NetworkAction*, s4u::Host* src, s4u::Host* dst)> Link::onCommunicate;
100   }
101 }
102
103 /*********
104  * Model *
105  *********/
106
107 simgrid::surf::NetworkModel *surf_network_model = nullptr;
108
109 namespace simgrid {
110   namespace surf {
111
112     NetworkModel::~NetworkModel()
113     {
114       lmm_system_free(maxminSystem_);
115       xbt_heap_free(actionHeap_);
116       delete modifiedSet_;
117     }
118
119     double NetworkModel::latencyFactor(double /*size*/) {
120       return sg_latency_factor;
121     }
122
123     double NetworkModel::bandwidthFactor(double /*size*/) {
124       return sg_bandwidth_factor;
125     }
126
127     double NetworkModel::bandwidthConstraint(double rate, double /*bound*/, double /*size*/) {
128       return rate;
129     }
130
131     double NetworkModel::nextOccuringEventFull(double now)
132     {
133       double minRes = Model::nextOccuringEventFull(now);
134
135       for(auto it(getRunningActionSet()->begin()), itend(getRunningActionSet()->end()); it != itend ; it++) {
136         NetworkAction *action = static_cast<NetworkAction*>(&*it);
137         if (action->latency_ > 0)
138           minRes = (minRes < 0) ? action->latency_ : std::min(minRes, action->latency_);
139       }
140
141       XBT_DEBUG("Min of share resources %f", minRes);
142
143       return minRes;
144     }
145
146     /************
147      * Resource *
148      ************/
149
150     Link::Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props)
151     : Resource(model, name),
152       PropertyHolder(props)
153     {
154       links->insert({name, this});
155
156       latency_.scale   = 1;
157       bandwidth_.scale = 1;
158       XBT_DEBUG("Create link '%s'",name);
159     }
160
161     Link::Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint)
162     : Resource(model, name, constraint),
163       PropertyHolder(props)
164     {
165       if (strcmp(name,"__loopback__"))
166         xbt_assert(!Link::byName(name), "Link '%s' declared several times in the platform.", name);
167
168       latency_.scale   = 1;
169       bandwidth_.scale = 1;
170
171       links->insert({name, this});
172       XBT_DEBUG("Create link '%s'",name);
173
174     }
175
176     /** @brief use destroy() instead of this destructor */
177     Link::~Link() {
178       xbt_assert(currentlyDestroying_, "Don't delete Links directly. Call destroy() instead.");
179     }
180     /** @brief Fire the require callbacks and destroy the object
181      *
182      * Don't delete directly an Link, call l->destroy() instead.
183      */
184     void Link::destroy()
185     {
186       if (!currentlyDestroying_) {
187         currentlyDestroying_ = true;
188         onDestruction(this);
189         delete this;
190       }
191     }
192
193     bool Link::isUsed()
194     {
195       return lmm_constraint_used(getModel()->getMaxminSystem(), getConstraint());
196     }
197
198     double Link::latency()
199     {
200       return latency_.peak * latency_.scale;
201     }
202
203     double Link::bandwidth()
204     {
205       return bandwidth_.peak * bandwidth_.scale;
206     }
207
208     int Link::sharingPolicy()
209     {
210       return lmm_constraint_sharing_policy(getConstraint());
211     }
212
213     void Link::turnOn(){
214       if (isOff()) {
215         Resource::turnOn();
216         onStateChange(this);
217       }
218     }
219     void Link::turnOff(){
220       if (isOn()) {
221         Resource::turnOff();
222         onStateChange(this);
223       }
224     }
225     void Link::setStateTrace(tmgr_trace_t trace) {
226       xbt_assert(stateEvent_ == nullptr, "Cannot set a second state trace to Link %s", getName());
227       stateEvent_ = future_evt_set->add_trace(trace, 0.0, this);
228     }
229     void Link::setBandwidthTrace(tmgr_trace_t trace)
230     {
231       xbt_assert(bandwidth_.event == nullptr, "Cannot set a second bandwidth trace to Link %s", getName());
232       bandwidth_.event = future_evt_set->add_trace(trace, 0.0, this);
233     }
234     void Link::setLatencyTrace(tmgr_trace_t trace)
235     {
236       xbt_assert(latency_.event == nullptr, "Cannot set a second latency trace to Link %s", getName());
237       latency_.event = future_evt_set->add_trace(trace, 0.0, this);
238     }
239
240
241     /**********
242      * Action *
243      **********/
244
245     void NetworkAction::setState(Action::State state){
246       Action::State old = getState();
247       Action::setState(state);
248       networkActionStateChangedCallbacks(this, old, state);
249     }
250
251   }
252 }
253
254 #endif /* NETWORK_INTERFACE_CPP_ */