src/surf/network_interface.cpp

   1 /* Copyright (c) 2013-2014. 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 "network_interface.hpp"
   8 #include "simgrid/sg_config.h"
   9
  10 #ifndef NETWORK_INTERFACE_CPP_
  11 #define NETWORK_INTERFACE_CPP_
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network, surf,
  14                                 "Logging specific to the SURF network module");
  15
  16 /*********
  17  * C API *
  18  *********/
  19 SG_BEGIN_DECL()
  20 int surf_network_link_is_shared(Link *link){
  21   return link->isShared();
  22 }
  23
  24 double surf_network_link_get_bandwidth(Link *link){
  25   return link->getBandwidth();
  26 }
  27
  28 double surf_network_link_get_latency(Link *link){
  29   return link->getLatency();
  30 }
  31 SG_END_DECL()
  32
  33 /*************
  34  * Callbacks *
  35  *************/
  36
  37 surf_callback(void, Link*) networkLinkCreatedCallbacks;
  38 surf_callback(void, Link*) networkLinkDestructedCallbacks;
  39 surf_callback(void, Link*, e_surf_resource_state_t, e_surf_resource_state_t) networkLinkStateChangedCallbacks;
  40 surf_callback(void, NetworkActionPtr, e_surf_action_state_t, e_surf_action_state_t) networkActionStateChangedCallbacks;
  41 surf_callback(void, NetworkActionPtr, RoutingEdgePtr src, RoutingEdgePtr dst, double size, double rate) networkCommunicateCallbacks;
  42
  43 void netlink_parse_init(sg_platf_link_cbarg_t link){
  44   if (link->policy == SURF_LINK_FULLDUPLEX) {
  45     char *link_id;
  46     link_id = bprintf("%s_UP", link->id);
  47     surf_network_model->createLink(link_id,
  48                       link->bandwidth,
  49                       link->bandwidth_trace,
  50                       link->latency,
  51                       link->latency_trace,
  52                       link->state,
  53                       link->state_trace, link->policy, link->properties);
  54     xbt_free(link_id);
  55     link_id = bprintf("%s_DOWN", link->id);
  56     surf_network_model->createLink(link_id,
  57                       link->bandwidth,
  58                       link->bandwidth_trace,
  59                       link->latency,
  60                       link->latency_trace,
  61                       link->state,
  62                       link->state_trace, link->policy, link->properties);
  63     xbt_free(link_id);
  64   } else {
  65           surf_network_model->createLink(link->id,
  66                           link->bandwidth,
  67                           link->bandwidth_trace,
  68                           link->latency,
  69                           link->latency_trace,
  70                           link->state,
  71                           link->state_trace, link->policy, link->properties);
  72   }
  73 }
  74
  75 void net_add_traces(){
  76   surf_network_model->addTraces();
  77 }
  78
  79 /*********
  80  * Model *
  81  *********/
  82
  83 NetworkModelPtr surf_network_model = NULL;
  84
  85 double NetworkModel::latencyFactor(double /*size*/) {
  86   return sg_latency_factor;
  87 }
  88
  89 double NetworkModel::bandwidthFactor(double /*size*/) {
  90   return sg_bandwidth_factor;
  91 }
  92
  93 double NetworkModel::bandwidthConstraint(double rate, double /*bound*/, double /*size*/) {
  94   return rate;
  95 }
  96
  97 double NetworkModel::shareResourcesFull(double now)
  98 {
  99   NetworkActionPtr action = NULL;
 100   ActionListPtr runningActions = surf_network_model->getRunningActionSet();
 101   double minRes;
 102
 103   minRes = shareResourcesMaxMin(runningActions, surf_network_model->p_maxminSystem, surf_network_model->f_networkSolve);
 104
 105   for(ActionList::iterator it(runningActions->begin()), itend(runningActions->end())
 106        ; it != itend ; ++it) {
 107       action = static_cast<NetworkActionPtr>(&*it);
 108 #ifdef HAVE_LATENCY_BOUND_TRACKING
 109     if (lmm_is_variable_limited_by_latency(action->getVariable())) {
 110       action->m_latencyLimited = 1;
 111     } else {
 112       action->m_latencyLimited = 0;
 113     }
 114 #endif
 115     if (action->m_latency > 0) {
 116       minRes = (minRes < 0) ? action->m_latency : min(minRes, action->m_latency);
 117     }
 118   }
 119
 120   XBT_DEBUG("Min of share resources %f", minRes);
 121
 122   return minRes;
 123 }
 124
 125 /************
 126  * Resource *
 127  ************/
 128
 129 Link::Link(NetworkModelPtr model, const char *name, xbt_dict_t props)
 130 : Resource(model, name, props)
 131 , p_latEvent(NULL)
 132 {
 133   surf_callback_emit(networkLinkCreatedCallbacks, this);
 134 }
 135
 136 Link::Link(NetworkModelPtr model, const char *name, xbt_dict_t props,
 137                                  lmm_constraint_t constraint,
 138                              tmgr_history_t history,
 139                              tmgr_trace_t state_trace)
 140 : Resource(model, name, props, constraint),
 141   p_latEvent(NULL)
 142 {
 143   surf_callback_emit(networkLinkCreatedCallbacks, this);
 144   if (state_trace)
 145     p_stateEvent = tmgr_history_add_trace(history, state_trace, 0.0, 0, this);
 146 }
 147
 148 Link::~Link()
 149 {
 150   surf_callback_emit(networkLinkDestructedCallbacks, this);
 151 }
 152
 153 bool Link::isUsed()
 154 {
 155   return lmm_constraint_used(getModel()->getMaxminSystem(), getConstraint());
 156 }
 157
 158 double Link::getLatency()
 159 {
 160   return m_latCurrent;
 161 }
 162
 163 double Link::getBandwidth()
 164 {
 165   return p_power.peak * p_power.scale;
 166 }
 167
 168 bool Link::isShared()
 169 {
 170   return lmm_constraint_is_shared(getConstraint());
 171 }
 172
 173 void Link::setState(e_surf_resource_state_t state){
 174   e_surf_resource_state_t old = Resource::getState();
 175   Resource::setState(state);
 176   surf_callback_emit(networkLinkStateChangedCallbacks, this, old, state);
 177 }
 178
 179 /**********
 180  * Action *
 181  **********/
 182
 183 void NetworkAction::setState(e_surf_action_state_t state){
 184   e_surf_action_state_t old = getState();
 185   Action::setState(state);
 186   surf_callback_emit(networkActionStateChangedCallbacks, this, old, state);
 187 }
 188
 189 #endif /* NETWORK_INTERFACE_CPP_ */