X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fc45b14055d16a944771ccf34cd94f5511e6fb24..e99ac4319ea4bab13a821b840b58a443918d5c28:/src/plugins/host_energy.cpp diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp index 340c283b50..82417f7f46 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" @@ -108,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 { @@ -121,6 +124,7 @@ public: }; class HostEnergy { + friend void ::on_simulation_end(); // For access to host_was_used_ public: static simgrid::xbt::Extension EXTENSION_ID; @@ -130,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(); @@ -146,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 */ @@ -204,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", @@ -243,6 +260,8 @@ double HostEnergy::get_current_watts_value() 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 @@ -341,13 +360,13 @@ void HostEnergy::init_watts_range_list() // In this case, 1core == AllCores current_power_values.push_back(current_power_values.at(1)); } else { // size == 3 - current_power_values[2] = current_power_values.at(1); - static thread_local bool displayed_warning = false; + 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." - " Since this is a single-core machine, AllCores and OneCore are identical." - " Here, only the value for 'OneCore' is used.", host_->get_cname(), current_power_values_str.c_str()); + " Here, only the value for 'AllCores' is used.", host_->get_cname(), current_power_values_str.c_str()); displayed_warning = true; } } @@ -440,10 +459,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; } } @@ -462,8 +480,6 @@ 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); @@ -472,6 +488,21 @@ void sg_host_energy_plugin_init() 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); + // 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::ExecImplPtr activity){ + if (activity->host_ != nullptr) { // We only run on one host + simgrid::s4u::Host* host = activity->host_; + if (dynamic_cast(activity->host_)) + host = dynamic_cast(activity->host_)->get_pm(); + + host->extension()->update(); + } + }); } /** @ingroup plugin_energy @@ -504,6 +535,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 */