X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/92cd12d0b61dd5a17500ef7d38f7b95a80301037..f16ce13525c4b4e00ef8e1f578dc92794fa10506:/src/plugins/link_energy.cpp diff --git a/src/plugins/link_energy.cpp b/src/plugins/link_energy.cpp index bdf842b688..e16379978b 100644 --- a/src/plugins/link_energy.cpp +++ b/src/plugins/link_energy.cpp @@ -1,21 +1,23 @@ -/* Copyright (c) 2017-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2017-2023. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ +#include "simgrid/Exception.hpp" +#include "simgrid/host.h" #include "simgrid/plugins/energy.h" +#include "simgrid/s4u/Comm.hpp" #include "simgrid/s4u/Engine.hpp" -#include "src/surf/network_interface.hpp" -#include "src/surf/surf_interface.hpp" -#include "surf/surf.hpp" +#include "simgrid/s4u/Link.hpp" +#include "src/kernel/activity/CommImpl.hpp" +#include "src/simgrid/module.hpp" #include #include SIMGRID_REGISTER_PLUGIN(link_energy, "Link energy consumption.", &sg_link_energy_plugin_init) -/** @addtogroup SURF_plugin_energy - +/** @defgroup plugin_link_energy Plugin Link Energy This is the link energy plugin, accounting for the dissipated energy in the simulated platform. @@ -24,8 +26,8 @@ SIMGRID_REGISTER_PLUGIN(link_energy, "Link energy consumption.", &sg_link_energy @verbatim - - + + @endverbatim @@ -34,31 +36,16 @@ SIMGRID_REGISTER_PLUGIN(link_energy, "Link energy consumption.", &sg_link_energy The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these values are arbitrary). - To simulate the energy-related elements, first call the simgrid#energy#sg_link_energy_plugin_init() before your - #MSG_init(), + To simulate the energy-related elements, first call the sg_link_energy_plugin_init() before loading the platform and then use the following function to retrieve the consumption of a given link: sg_link_get_consumed_energy(). */ -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(link_energy, surf, "Logging specific to the SURF LinkEnergy plugin"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(link_energy, kernel, "Logging specific to the LinkEnergy plugin"); -namespace simgrid { -namespace plugin { +namespace simgrid::plugin { class LinkEnergy { -public: - static simgrid::xbt::Extension EXTENSION_ID; - - explicit LinkEnergy(simgrid::s4u::Link* ptr) : link_(ptr), last_updated_(surf_get_clock()) {} - ~LinkEnergy() = default; - - void init_watts_range_list(); - double get_consumed_energy(); - void update(); - -private: - double get_power(); - - simgrid::s4u::Link* link_{}; + s4u::Link* link_{}; bool inited_{false}; double idle_{0.0}; @@ -66,17 +53,28 @@ private: double total_energy_{0.0}; double last_updated_{0.0}; /*< Timestamp of the last energy update event*/ + + double get_power() const; + +public: + static xbt::Extension EXTENSION_ID; + + explicit LinkEnergy(s4u::Link* ptr) : link_(ptr), last_updated_(simgrid::s4u::Engine::get_clock()) {} + + void init_watts_range_list(); + double get_consumed_energy(); + void update(); }; -simgrid::xbt::Extension LinkEnergy::EXTENSION_ID; +xbt::Extension LinkEnergy::EXTENSION_ID; void LinkEnergy::update() { - if (!inited_) + if (not inited_) init_watts_range_list(); double power = get_power(); - double now = surf_get_clock(); + double now = simgrid::s4u::Engine::get_clock(); total_energy_ += power * (now - last_updated_); last_updated_ = now; } @@ -87,7 +85,12 @@ void LinkEnergy::init_watts_range_list() return; inited_ = true; - const char* all_power_values_str = this->link_->get_property("watt_range"); + const char* all_power_values_str = this->link_->get_property("wattage_range"); + if (all_power_values_str == nullptr) { + all_power_values_str = this->link_->get_property("watt_range"); + if (all_power_values_str != nullptr) + XBT_WARN("Please rename the 'watt_range' property of link %s into 'wattage_range'.", link_->get_cname()); + } if (all_power_values_str == nullptr) return; @@ -108,26 +111,25 @@ void LinkEnergy::init_watts_range_list() try { idle_ = std::stod(current_power_values.front()); } catch (const std::invalid_argument&) { - throw std::invalid_argument(std::string("Invalid idle power value for link ") + this->link_->get_cname()); + throw std::invalid_argument("Invalid idle power value for link " + this->link_->get_name()); } try { busy_ = std::stod(current_power_values.back()); } catch (const std::invalid_argument&) { - throw std::invalid_argument(std::string("Invalid busy power value for link ") + this->link_->get_cname()); + throw std::invalid_argument("Invalid busy power value for link " + this->link_->get_name()); } } } -double LinkEnergy::get_power() +double LinkEnergy::get_power() const { - - if (!inited_) + if (not inited_) return 0.0; double power_slope = busy_ - idle_; - double normalized_link_usage = link_->get_usage() / link_->get_bandwidth(); + double normalized_link_usage = link_->get_load() / link_->get_bandwidth(); double dynamic_power = power_slope * normalized_link_usage; return idle_ + dynamic_power; @@ -135,95 +137,98 @@ double LinkEnergy::get_power() double LinkEnergy::get_consumed_energy() { - if (last_updated_ < surf_get_clock()) // We need to simcall this as it modifies the environment - simgrid::kernel::actor::simcall(std::bind(&LinkEnergy::update, this)); + if (last_updated_ < simgrid::s4u::Engine::get_clock()) // We need to simcall this as it modifies the environment + kernel::actor::simcall_answered(std::bind(&LinkEnergy::update, this)); return this->total_energy_; } -} // namespace plugin -} // namespace simgrid +} // namespace simgrid::plugin using simgrid::plugin::LinkEnergy; /* **************************** events callback *************************** */ -static void on_communicate(simgrid::kernel::resource::NetworkAction const& action, simgrid::s4u::Host*, - simgrid::s4u::Host*) -{ - XBT_DEBUG("onCommunicate is called"); - for (simgrid::kernel::resource::LinkImpl* link : action.links()) { - - if (link == nullptr) - continue; - - XBT_DEBUG("Update link %s", link->get_cname()); - LinkEnergy* link_energy = link->piface_.extension(); - link_energy->init_watts_range_list(); - link_energy->update(); - } -} - static void on_simulation_end() { std::vector links = simgrid::s4u::Engine::get_instance()->get_all_links(); double total_energy = 0.0; // Total dissipated energy (whole platform) - for (const auto link : links) { + for (auto const* link : links) { + if (link == nullptr || link->get_sharing_policy() == simgrid::s4u::Link::SharingPolicy::WIFI) + continue; + double link_energy = link->extension()->get_consumed_energy(); total_energy += link_energy; } XBT_INFO("Total energy over all links: %f", total_energy); } + +static void on_communication(const simgrid::s4u::Comm& comm) +{ + const auto* pimpl = static_cast(comm.get_impl()); + for (auto const* link : pimpl->get_traversed_links()) { + if (link != nullptr && link->get_sharing_policy() != simgrid::s4u::Link::SharingPolicy::WIFI) { + XBT_DEBUG("Update %s on Comm Start/End", link->get_cname()); + link->extension()->update(); + } + } +} + /* **************************** Public interface *************************** */ int sg_link_energy_is_inited() { return LinkEnergy::EXTENSION_ID.valid(); } -/** @ingroup SURF_plugin_energy +/** @ingroup plugin_link_energy * @brief Enable energy plugin * @details Enable energy plugin to get joules consumption of each cpu. You should call this function before - * #MSG_init(). + * loading your platform. */ void sg_link_energy_plugin_init() { - if (LinkEnergy::EXTENSION_ID.valid()) return; LinkEnergy::EXTENSION_ID = simgrid::s4u::Link::extension_create(); xbt_assert(sg_host_count() == 0, "Please call sg_link_energy_plugin_init() before initializing the platform."); - simgrid::s4u::Link::on_creation.connect([](simgrid::s4u::Link& link) { link.extension_set(new LinkEnergy(&link)); }); + simgrid::s4u::Link::on_creation_cb([](simgrid::s4u::Link& link) { + if (link.get_sharing_policy() != simgrid::s4u::Link::SharingPolicy::WIFI) { + XBT_DEBUG("Wired Link created: %s", link.get_cname()); + link.extension_set(new LinkEnergy(&link)); + } else { + XBT_DEBUG("Not Wired link: %s", link.get_cname()); + } + }); - simgrid::s4u::Link::on_state_change.connect( - [](simgrid::s4u::Link const& link) { link.extension()->update(); }); + simgrid::s4u::Link::on_onoff_cb([](simgrid::s4u::Link const& link) { + if (link.get_sharing_policy() != simgrid::s4u::Link::SharingPolicy::WIFI) + link.extension()->update(); + }); - simgrid::s4u::Link::on_destruction.connect([](simgrid::s4u::Link const& link) { - if (link.get_name() != "__loopback__") + simgrid::s4u::Link::on_destruction_cb([](simgrid::s4u::Link const& link) { + if (link.get_name() != "__loopback__" && link.get_sharing_policy() != simgrid::s4u::Link::SharingPolicy::WIFI) XBT_INFO("Energy consumption of link '%s': %f Joules", link.get_cname(), link.extension()->get_consumed_energy()); }); - simgrid::s4u::Link::on_communication_state_change.connect([]( - simgrid::kernel::resource::NetworkAction const& action, simgrid::kernel::resource::Action::State /* previous */) { - for (simgrid::kernel::resource::LinkImpl* link : action.links()) { - if (link != nullptr) - link->piface_.extension()->update(); - } - }); + simgrid::s4u::Comm::on_start_cb(&on_communication); + simgrid::s4u::Comm::on_completion_cb(&on_communication); - simgrid::s4u::Link::on_communicate.connect(&on_communicate); - simgrid::s4u::on_simulation_end.connect(&on_simulation_end); + simgrid::s4u::Engine::on_simulation_end_cb(&on_simulation_end); } -/** @ingroup plugin_energy +/** @ingroup plugin_link_energy * @brief Returns the total energy consumed by the link so far (in Joules) * * Please note that since the consumption is lazily updated, it may require a simcall to update it. * The result is that the actor requesting this value will be interrupted, * the value will be updated in kernel mode before returning the control to the requesting actor. */ -double sg_link_get_consumed_energy(sg_link_t link) +double sg_link_get_consumed_energy(const_sg_link_t link) { + if (not LinkEnergy::EXTENSION_ID.valid()) + throw simgrid::xbt::InitializationError("The Energy plugin is not active. Please call sg_link_energy_plugin_init() " + "before calling sg_link_get_consumed_energy()."); return link->extension()->get_consumed_energy(); }