X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1bd7cbc6f7c9069a69935f33ab7867de949babe7..6d004c352f7b26fba38486001f874e65466b5bee:/src/plugins/host_energy.cpp diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp index 1e7bdb7b46..2dd43f54f3 100644 --- a/src/plugins/host_energy.cpp +++ b/src/plugins/host_energy.cpp @@ -1,11 +1,11 @@ -/* Copyright (c) 2010-2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2019. 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/plugins/energy.h" -#include "simgrid/plugins/load.h" #include "simgrid/s4u/Engine.hpp" +#include "src/kernel/activity/ExecImpl.hpp" #include "src/include/surf/surf.hpp" #include "src/plugins/vm/VirtualMachineImpl.hpp" #include "src/surf/cpu_interface.hpp" @@ -13,6 +13,8 @@ #include #include +SIMGRID_REGISTER_PLUGIN(host_energy, "Cpu energy consumption.", &sg_host_energy_plugin_init) + /** @addtogroup plugin_energy This is the energy plugin, enabling to account not only for computation time, but also for the dissipated energy in the @@ -27,26 +29,26 @@ abnormality when all the cores are idle. The full details are in As a result, our energy model takes 4 parameters: - - \b Idle: instantaneous consumption (in Watt) when your host is up and running, but without anything to do. - - \b OneCore: instantaneous consumption (in Watt) when only one core is active, at 100%. - - \b AllCores: instantaneous consumption (in Watt) when all cores of the host are at 100%. - - \b Off: instantaneous consumption (in Watt) when the host is turned off. + - @b Idle: instantaneous consumption (in Watt) when your host is up and running, but without anything to do. + - @b OneCore: instantaneous consumption (in Watt) when only one core is active, at 100%. + - @b AllCores: instantaneous consumption (in Watt) when all cores of the host are at 100%. + - @b Off: instantaneous consumption (in Watt) when the host is turned off. Here is an example of XML declaration: -\code{.xml} +@code{.xml} -\endcode +@endcode -This example gives the following parameters: \b Off is 10 Watts; \b Idle is 100 Watts; \b OneCore is 120 Watts and \b +This example gives the following parameters: @b Off is 10 Watts; @b Idle is 100 Watts; @b OneCore is 120 Watts and @b AllCores is 200 Watts. This is enough to compute the consumption as a function of the amount of loaded cores: - + @@ -62,27 +64,27 @@ the time, and our model holds. ### What if the host has only one core? -In this case, the parameters \b OneCore and \b AllCores are obviously the same. +In this case, the parameters @b OneCore and @b AllCores are obviously the same. Actually, SimGrid expect an energetic profile formatted as 'Idle:Running' for mono-cores hosts. -If you insist on passing 3 parameters in this case, then you must have the same value for \b OneCore and \b AllCores. +If you insist on passing 3 parameters in this case, then you must have the same value for @b OneCore and @b AllCores. -\code{.xml} +@code{.xml} -\endcode +@endcode ### How does DVFS interact with the host energy model? If your host has several DVFS levels (several pstates), then you should give the energetic profile of each pstate level: -\code{.xml} +@code{.xml} -\endcode +@endcode This encodes the following values
\#Cores loadedConsumptionExplanation
@#Cores loadedConsumptionExplanation
0 100 WattsIdle value
1 120 WattsOneCore value
2 147 Wattslinear extrapolation between OneCore and AllCores
@@ -106,6 +108,9 @@ before you can get accurate energy predictions. XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin"); +// Forwards declaration needed to make this function a friend (because friends have external linkage by default) +static void on_simulation_end(); + namespace simgrid { namespace plugin { @@ -119,6 +124,7 @@ public: }; class HostEnergy { + friend void ::on_simulation_end(); // For access to host_was_used_ public: static simgrid::xbt::Extension EXTENSION_ID; @@ -128,6 +134,7 @@ public: double get_current_watts_value(); double get_current_watts_value(double cpu_load); double get_consumed_energy(); + double get_idle_consumption(); double get_watt_min_at(int pstate); double get_watt_max_at(int pstate); void update(); @@ -144,6 +151,10 @@ private: int pstate_ = 0; const int pstate_off_ = -1; + /* Only used to split total energy into unused/used hosts. + * If you want to get this info for something else, rather use the host_load plugin + */ + bool host_was_used_ = false; public: double watts_off_ = 0.0; /*< Consumption when the machine is turned off (shutdown) */ double total_energy_ = 0.0; /*< Total energy consumed by the host */ @@ -175,9 +186,8 @@ void HostEnergy::update() this->total_energy_ = previous_energy + energy_this_step; this->last_updated_ = finish_time; - XBT_DEBUG("[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> " - "%.2f J", - host_->get_cname(), start_time, finish_time, host_->pimpl_cpu->get_speed(1.0), previous_energy, + XBT_DEBUG("[update_energy of %s] period=[%.8f-%.8f]; current speed=%.2E flop/s (pstate %i); total consumption before: consumption change: %.8f J -> added now: %.8f J", + host_->get_cname(), start_time, finish_time, host_->pimpl_cpu->get_pstate_peak_speed(this->pstate_), this->pstate_, previous_energy, energy_this_step); } @@ -193,7 +203,7 @@ HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr), last_updated_(surf if (off_power_str != nullptr) { try { this->watts_off_ = std::stod(std::string(off_power_str)); - } catch (std::invalid_argument& ia) { + } catch (const std::invalid_argument&) { throw std::invalid_argument(std::string("Invalid value for property watt_off of host ") + host_->get_cname() + ": " + off_power_str); } @@ -203,6 +213,14 @@ HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr), last_updated_(surf HostEnergy::~HostEnergy() = default; +double HostEnergy::get_idle_consumption() +{ + xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", + host_->get_cname()); + + return power_range_watts_list_[0].idle_; +} + double HostEnergy::get_watt_min_at(int pstate) { xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", @@ -226,7 +244,7 @@ double HostEnergy::get_current_watts_value() if (this->pstate_ == pstate_off_) // The host is off (or was off at the beginning of this time interval) return this->watts_off_; - double current_speed = host_->get_speed(); + double current_speed = host_->get_pstate_speed(this->pstate_); double cpu_load; @@ -234,14 +252,17 @@ double HostEnergy::get_current_watts_value() // Some users declare a pstate of speed 0 flops (e.g., to model boot time). // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN cpu_load = 1; - else + else { cpu_load = host_->pimpl_cpu->get_constraint()->get_usage() / current_speed; - /** Divide by the number of cores here **/ - cpu_load /= host_->pimpl_cpu->get_core_count(); + /** Divide by the number of cores here **/ + cpu_load /= host_->pimpl_cpu->get_core_count(); - if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more - cpu_load = 1; + if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more + cpu_load = 1; + if (cpu_load > 0) + host_was_used_ = true; + } /* The problem with this model is that the load is always 0 or 1, never something less. * Another possibility could be to model the total energy as @@ -270,10 +291,10 @@ double HostEnergy::get_current_watts_value(double cpu_load) /* min_power corresponds to the power consumed when only one core is active */ /* max_power is the power consumed at 100% cpu load */ auto range = power_range_watts_list_.at(this->pstate_); - double current_power = 0; - double min_power = 0; - double max_power = 0; - double power_slope = 0; + double current_power; + double min_power; + double max_power; + double power_slope; if (cpu_load > 0) { /* Something is going on, the machine is not idle */ min_power = range.min_; @@ -289,9 +310,8 @@ double HostEnergy::get_current_watts_value(double cpu_load) * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power * (maxCpuLoad is by definition 1) */ - double power_slope; int coreCount = host_->get_core_count(); - double coreReciprocal = static_cast(1) / static_cast(coreCount); + double coreReciprocal = 1.0 / coreCount; if (coreCount > 1) power_slope = (max_power - min_power) / (1 - coreReciprocal); else @@ -299,10 +319,13 @@ double HostEnergy::get_current_watts_value(double cpu_load) current_power = min_power + (cpu_load - coreReciprocal) * power_slope; } else { /* Our machine is idle, take the dedicated value! */ + min_power = 0; + max_power = 0; + power_slope = 0; current_power = range.idle_; } - XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope); + XBT_DEBUG("[get_current_watts] pstate=%i, min_power=%f, max_power=%f, slope=%f", this->pstate_, min_power, max_power, power_slope); XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load); return current_power; @@ -311,7 +334,7 @@ double HostEnergy::get_current_watts_value(double cpu_load) double HostEnergy::get_consumed_energy() { if (last_updated_ < surf_get_clock()) // We need to simcall this as it modifies the environment - simgrid::simix::simcall(std::bind(&HostEnergy::update, this)); + simgrid::kernel::actor::simcall(std::bind(&HostEnergy::update, this)); return total_energy_; } @@ -340,12 +363,15 @@ void HostEnergy::init_watts_range_list() // In this case, 1core == AllCores current_power_values.push_back(current_power_values.at(1)); } else { // size == 3 - xbt_assert((current_power_values.at(1)) == (current_power_values.at(2)), - "Power properties incorrectly defined for host %s.\n" - "The energy profile of mono-cores should be formatted as 'Idle:FullSpeed' only.\n" - "If you go for a 'Idle:OneCore:AllCores' power profile on mono-cores, then OneCore and AllCores " - "must be equal.", - host_->get_cname()); + current_power_values[1] = current_power_values.at(2); + current_power_values[2] = current_power_values.at(2); + static bool displayed_warning = false; + if (not displayed_warning) { // Otherwise we get in the worst case no_pstate*no_hosts warnings + XBT_WARN("Host %s is a single-core machine and part of the power profile is '%s'" + ", which is in the 'Idle:OneCore:AllCores' format." + " Here, only the value for 'AllCores' is used.", host_->get_cname(), current_power_values_str.c_str()); + displayed_warning = true; + } } } else { xbt_assert(current_power_values.size() == 3, @@ -385,10 +411,10 @@ static void on_creation(simgrid::s4u::Host& host) host.extension_set(new HostEnergy(&host)); } -static void on_action_state_change(simgrid::surf::CpuAction* action, +static void on_action_state_change(simgrid::kernel::resource::CpuAction const& action, simgrid::kernel::resource::Action::State /*previous*/) { - for (simgrid::surf::Cpu* const& cpu : action->cpus()) { + for (simgrid::kernel::resource::Cpu* const& cpu : action.cpus()) { simgrid::s4u::Host* host = cpu->get_host(); if (host != nullptr) { @@ -408,9 +434,9 @@ static void on_action_state_change(simgrid::surf::CpuAction* action, /* This callback is fired either when the host changes its state (on/off) ("onStateChange") or its speed * (because the user changed the pstate, or because of external trace events) ("onSpeedChange") */ -static void on_host_change(simgrid::s4u::Host& host) +static void on_host_change(simgrid::s4u::Host const& host) { - if (dynamic_cast(&host)) // Ignore virtual machines + if (dynamic_cast(&host)) // Ignore virtual machines return; HostEnergy* host_energy = host.extension(); @@ -418,9 +444,9 @@ static void on_host_change(simgrid::s4u::Host& host) host_energy->update(); } -static void on_host_destruction(simgrid::s4u::Host& host) +static void on_host_destruction(simgrid::s4u::Host const& host) { - if (dynamic_cast(&host)) // Ignore virtual machines + if (dynamic_cast(&host)) // Ignore virtual machines return; XBT_INFO("Energy consumption of host %s: %f Joules", host.get_cname(), @@ -436,10 +462,9 @@ static void on_simulation_end() for (size_t i = 0; i < hosts.size(); i++) { if (dynamic_cast(hosts[i]) == nullptr) { // Ignore virtual machines - bool host_was_used = (sg_host_get_computed_flops(hosts[i]) != 0); double energy = hosts[i]->extension()->get_consumed_energy(); total_energy += energy; - if (host_was_used) + if (hosts[i]->extension()->host_was_used_) used_hosts_energy += energy; } } @@ -449,17 +474,15 @@ static void on_simulation_end() /* **************************** Public interface *************************** */ -/** \ingroup plugin_energy - * \brief Enable host energy plugin - * \details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init(). +/** @ingroup plugin_energy + * @brief Enable host energy plugin + * @details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init(). */ void sg_host_energy_plugin_init() { if (HostEnergy::EXTENSION_ID.valid()) return; - sg_host_load_plugin_init(); - HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create(); simgrid::s4u::Host::on_creation.connect(&on_creation); @@ -467,7 +490,23 @@ void sg_host_energy_plugin_init() simgrid::s4u::Host::on_speed_change.connect(&on_host_change); simgrid::s4u::Host::on_destruction.connect(&on_host_destruction); simgrid::s4u::on_simulation_end.connect(&on_simulation_end); - simgrid::surf::CpuAction::on_state_change.connect(&on_action_state_change); + simgrid::kernel::resource::CpuAction::on_state_change.connect(&on_action_state_change); + // We may only have one actor on a node. If that actor executes something like + // compute -> recv -> compute + // the recv operation will not trigger a "CpuAction::on_state_change". This means + // that the next trigger would be the 2nd compute, hence ignoring the idle time + // during the recv call. By updating at the beginning of a compute, we can + // fix that. (If the cpu is not idle, this is not required.) + simgrid::kernel::activity::ExecImpl::on_creation.connect([](simgrid::kernel::activity::ExecImpl const& activity) { + if (activity.get_host_number() == 1) { // We only run on one host + simgrid::s4u::Host* host = activity.get_host(); + simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); + if (vm != nullptr) + host = vm->get_pm(); + xbt_assert(host != nullptr); + host->extension()->update(); + } + }); } /** @ingroup plugin_energy @@ -478,11 +517,13 @@ void sg_host_energy_plugin_init() */ void sg_host_energy_update_all() { - simgrid::simix::simcall([]() { + simgrid::kernel::actor::simcall([]() { std::vector list = simgrid::s4u::Engine::get_instance()->get_all_hosts(); for (auto const& host : list) - if (dynamic_cast(host) == nullptr) // Ignore virtual machines + if (dynamic_cast(host) == nullptr) { // Ignore virtual machines + xbt_assert(host != nullptr); host->extension()->update(); + } }); } @@ -500,6 +541,16 @@ double sg_host_get_consumed_energy(sg_host_t host) return host->extension()->get_consumed_energy(); } +/** @ingroup plugin_energy + * @brief Get the amount of watt dissipated when the host is idling + */ +double sg_host_get_idle_consumption(sg_host_t host) +{ + xbt_assert(HostEnergy::EXTENSION_ID.valid(), + "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization."); + return host->extension()->get_idle_consumption(); +} + /** @ingroup plugin_energy * @brief Get the amount of watt dissipated at the given pstate when the host is idling */