src/plugins/link_energy.cpp

   1 /* Copyright (c) 2017-2018. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "simgrid/plugins/energy.h"
   7 #include "simgrid/s4u/Engine.hpp"
   8 #include "src/surf/network_interface.hpp"
   9 #include "surf/surf.hpp"
  10
  11 #include <boost/algorithm/string/classification.hpp>
  12 #include <boost/algorithm/string/split.hpp>
  13
  14 /** @addtogroup SURF_plugin_energy
  15
  16
  17  This is the link energy plugin, accounting for the dissipated energy in the simulated platform.
  18
  19  The energy consumption of a link depends directly on its current traffic load. Specify that consumption in your
  20  platform file as follows:
  21
  22  \verbatim
  23  <link id="SWITCH1" bandwidth="125Mbps" latency="5us" sharing_policy="SHARED" >
  24  <prop id="watt_range" value="100.0:200.0" />
  25  <prop id="watt_off" value="10" />
  26  </link>
  27  \endverbatim
  28
  29  The first property means that when your link is switched on, but without anything to do, it will dissipate 100 Watts.
  30  If it's fully loaded, it will dissipate 200 Watts. If its load is at 50%, then it will dissipate 150 Watts.
  31  The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these
  32  values are arbitrary).
  33
  34  To simulate the energy-related elements, first call the simgrid#energy#sg_link_energy_plugin_init() before your
  35  #MSG_init(),
  36  and then use the following function to retrieve the consumption of a given link: sg_link_get_consumed_energy().
  37  */
  38
  39 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(link_energy, surf, "Logging specific to the SURF LinkEnergy plugin");
  40
  41 namespace simgrid {
  42 namespace plugin {
  43
  44 class LinkEnergy {
  45 public:
  46   static simgrid::xbt::Extension<simgrid::s4u::Link, LinkEnergy> EXTENSION_ID;
  47
  48   explicit LinkEnergy(simgrid::s4u::Link* ptr);
  49   ~LinkEnergy();
  50
  51   void initWattsRangeList();
  52   double getConsumedEnergy();
  53   void update();
  54
  55 private:
  56   double getPower();
  57
  58   simgrid::s4u::Link* link_{};
  59
  60   bool inited_{false};
  61   double idle_{0.0};
  62   double busy_{0.0};
  63
  64   double totalEnergy_{0.0};
  65   double lastUpdated_{0.0}; /*< Timestamp of the last energy update event*/
  66 };
  67
  68 simgrid::xbt::Extension<simgrid::s4u::Link, LinkEnergy> LinkEnergy::EXTENSION_ID;
  69
  70 LinkEnergy::LinkEnergy(simgrid::s4u::Link* ptr) : link_(ptr), lastUpdated_(surf_get_clock()) {}
  71
  72 LinkEnergy::~LinkEnergy() = default;
  73
  74 void LinkEnergy::update()
  75 {
  76   double power = getPower();
  77   double now   = surf_get_clock();
  78   totalEnergy_ += power * (now - lastUpdated_);
  79   lastUpdated_ = now;
  80 }
  81
  82 void LinkEnergy::initWattsRangeList()
  83 {
  84
  85   if (inited_)
  86     return;
  87   inited_ = true;
  88
  89   const char* all_power_values_str = this->link_->get_property("watt_range");
  90
  91   if (all_power_values_str == nullptr)
  92     return;
  93
  94   std::vector<std::string> all_power_values;
  95   boost::split(all_power_values, all_power_values_str, boost::is_any_of(","));
  96
  97   for (auto current_power_values_str : all_power_values) {
  98     /* retrieve the power values associated */
  99     std::vector<std::string> current_power_values;
 100     boost::split(current_power_values, current_power_values_str, boost::is_any_of(":"));
 101     xbt_assert(current_power_values.size() == 2,
 102                "Power properties incorrectly defined - could not retrieve idle and busy power values for link %s",
 103                this->link_->get_cname());
 104
 105     /* min_power corresponds to the idle power (link load = 0) */
 106     /* max_power is the power consumed at 100% link load       */
 107     char* idleMsg = bprintf("Invalid idle power value for link%s", this->link_->get_cname());
 108     char* busyMsg = bprintf("Invalid busy power value for %s", this->link_->get_cname());
 109
 110     idle_ = xbt_str_parse_double((current_power_values.at(0)).c_str(), idleMsg);
 111     busy_ = xbt_str_parse_double((current_power_values.at(1)).c_str(), busyMsg);
 112
 113     xbt_free(idleMsg);
 114     xbt_free(busyMsg);
 115     update();
 116   }
 117 }
 118
 119 double LinkEnergy::getPower()
 120 {
 121
 122   if (!inited_)
 123     return 0.0;
 124
 125   double power_slope = busy_ - idle_;
 126
 127   double normalized_link_usage = link_->get_usage() / link_->get_bandwidth();
 128   double dynamic_power         = power_slope * normalized_link_usage;
 129
 130   return idle_ + dynamic_power;
 131 }
 132
 133 double LinkEnergy::getConsumedEnergy()
 134 {
 135   if (lastUpdated_ < surf_get_clock()) // We need to simcall this as it modifies the environment
 136     simgrid::simix::simcall(std::bind(&LinkEnergy::update, this));
 137   return this->totalEnergy_;
 138 }
 139 } // namespace plugin
 140 } // namespace simgrid
 141
 142 using simgrid::plugin::LinkEnergy;
 143
 144 /* **************************** events  callback *************************** */
 145 static void onCommunicate(simgrid::kernel::resource::NetworkAction* action, simgrid::s4u::Host* src,
 146                           simgrid::s4u::Host* dst)
 147 {
 148   XBT_DEBUG("onCommunicate is called");
 149   for (simgrid::kernel::resource::LinkImpl* link : action->links()) {
 150
 151     if (link == nullptr)
 152       continue;
 153
 154     XBT_DEBUG("Update link %s", link->get_cname());
 155     LinkEnergy* link_energy = link->piface_.extension<LinkEnergy>();
 156     link_energy->initWattsRangeList();
 157     link_energy->update();
 158   }
 159 }
 160
 161 static void onSimulationEnd()
 162 {
 163   std::vector<simgrid::s4u::Link*> links = simgrid::s4u::Engine::get_instance()->get_all_links();
 164
 165   double total_energy = 0.0; // Total dissipated energy (whole platform)
 166   for (const auto link : links) {
 167     double link_energy = link->extension<LinkEnergy>()->getConsumedEnergy();
 168     total_energy += link_energy;
 169   }
 170
 171   XBT_INFO("Total energy over all links: %f", total_energy);
 172 }
 173 /* **************************** Public interface *************************** */
 174
 175 int sg_link_energy_is_inited()
 176 {
 177   return LinkEnergy::EXTENSION_ID.valid();
 178 }
 179 /** \ingroup SURF_plugin_energy
 180  * \brief Enable energy plugin
 181  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before
 182  * #MSG_init().
 183  */
 184 void sg_link_energy_plugin_init()
 185 {
 186
 187   if (LinkEnergy::EXTENSION_ID.valid())
 188     return;
 189   LinkEnergy::EXTENSION_ID = simgrid::s4u::Link::extension_create<LinkEnergy>();
 190
 191   xbt_assert(sg_host_count() == 0, "Please call sg_link_energy_plugin_init() before initializing the platform.");
 192
 193   simgrid::s4u::Link::on_creation.connect([](simgrid::s4u::Link& link) { link.extension_set(new LinkEnergy(&link)); });
 194
 195   simgrid::s4u::Link::on_state_change.connect([](simgrid::s4u::Link& link) { link.extension<LinkEnergy>()->update(); });
 196
 197   simgrid::s4u::Link::on_destruction.connect([](simgrid::s4u::Link& link) {
 198     if (strcmp(link.get_cname(), "__loopback__"))
 199       XBT_INFO("Energy consumption of link '%s': %f Joules", link.get_cname(),
 200                link.extension<LinkEnergy>()->getConsumedEnergy());
 201   });
 202
 203   simgrid::s4u::Link::on_communication_state_change.connect([](simgrid::kernel::resource::NetworkAction* action) {
 204     for (simgrid::kernel::resource::LinkImpl* link : action->links()) {
 205       if (link != nullptr)
 206         link->piface_.extension<LinkEnergy>()->update();
 207     }
 208   });
 209
 210   simgrid::s4u::Link::on_communicate.connect(&onCommunicate);
 211   simgrid::s4u::on_simulation_end.connect(&onSimulationEnd);
 212 }
 213
 214 /** @ingroup plugin_energy
 215  *  @brief Returns the total energy consumed by the link so far (in Joules)
 216  *
 217  *  Please note that since the consumption is lazily updated, it may require a simcall to update it.
 218  *  The result is that the actor requesting this value will be interrupted,
 219  *  the value will be updated in kernel mode before returning the control to the requesting actor.
 220  */
 221 double sg_link_get_consumed_energy(sg_link_t link)
 222 {
 223   return link->extension<LinkEnergy>()->getConsumedEnergy();
 224 }