X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ed26e84f533a3dc510abdc384aee02506ab9798b..e96681fb89b328389ad0d4aecfe7addbda714da4:/src/surf/plugins/host_energy.cpp diff --git a/src/surf/plugins/host_energy.cpp b/src/surf/plugins/host_energy.cpp index d64ed6f12a..332f4a1e0c 100644 --- a/src/surf/plugins/host_energy.cpp +++ b/src/surf/plugins/host_energy.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2010, 2012-2016. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2017. 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. */ @@ -8,9 +8,10 @@ #include "src/plugins/vm/VirtualMachineImpl.hpp" #include "src/surf/cpu_interface.hpp" +#include "simgrid/s4u/Engine.hpp" + #include #include -#include #include #include #include @@ -112,43 +113,57 @@ void HostEnergy::update() double finish_time = surf_get_clock(); double cpu_load; double current_speed = host->speed(); - if (current_speed <= 0) - // 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 - cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / current_speed; - - /** Divide by the number of cores here **/ - cpu_load /= host->pimpl_cpu->coreCount(); - - if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more - cpu_load = 1; - - /* 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 - * - * X/(X+Y)*W_idle + Y/(X+Y)*W_burn - * - * where X is the amount of idling cores, and Y the amount of computing cores. - */ - double previous_energy = this->total_energy; + if (start_time < finish_time) { + // We may have start == finish if the past consumption was updated since the simcall was started + // for example if 2 actors requested to update the same host's consumption in a given scheduling round. + // + // Even in this case, we need to save the pstate for the next call (after this big if), + // which may have changed since that recent update. + + if (current_speed <= 0) + // 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 + cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / current_speed; + + /** Divide by the number of cores here **/ + cpu_load /= host->pimpl_cpu->coreCount(); + + if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more + cpu_load = 1; + + /* 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 + * + * X/(X+Y)*W_idle + Y/(X+Y)*W_burn + * + * where X is the amount of idling cores, and Y the amount of computing cores. + */ + + double previous_energy = this->total_energy; + + double instantaneous_consumption; + if (this->pstate == -1) // The host was off at the beginning of this time interval + instantaneous_consumption = this->watts_off; + else + instantaneous_consumption = this->getCurrentWattsValue(cpu_load); + + double energy_this_step = instantaneous_consumption * (finish_time - start_time); - double instantaneous_consumption; - if (host->isOff()) - instantaneous_consumption = this->watts_off; - else - instantaneous_consumption = this->getCurrentWattsValue(cpu_load); + // TODO Trace: Trace energy_this_step from start_time to finish_time in host->name() - double energy_this_step = instantaneous_consumption * (finish_time - start_time); + this->total_energy = previous_energy + energy_this_step; + this->last_updated = finish_time; - this->total_energy = previous_energy + energy_this_step; - this->last_updated = finish_time; - this->pstate = host->pstate(); - XBT_DEBUG( - "[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J", - host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step); + XBT_DEBUG("[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> " + "%.2f J", + host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step); + } + + /* Save data for the upcoming time interval: whether it's on/off and the pstate if it's on */ + this->pstate = host->isOn() ? host->pstate() : -1; } HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock()) @@ -168,20 +183,20 @@ HostEnergy::~HostEnergy() = default; double HostEnergy::getWattMinAt(int pstate) { - xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); + xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); return power_range_watts_list[pstate].min; } double HostEnergy::getWattMaxAt(int pstate) { - xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); + xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); return power_range_watts_list[pstate].max; } /** @brief Computes the power consumed by the host according to the current pstate and processor load */ double HostEnergy::getCurrentWattsValue(double cpu_load) { - xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); + xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname()); /* min_power corresponds to the power consumed when only one core is active */ /* max_power is the power consumed at 100% cpu load */ @@ -192,8 +207,8 @@ double HostEnergy::getCurrentWattsValue(double cpu_load) double power_slope = 0; if (cpu_load > 0) { /* Something is going on, the machine is not idle */ - double min_power = range.min; - double max_power = range.max; + min_power = range.min; + max_power = range.max; /** * The min_power states how much we consume when only one single @@ -205,15 +220,15 @@ double HostEnergy::getCurrentWattsValue(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->coreCount(); double coreReciprocal = static_cast(1) / static_cast(coreCount); - if (coreCount > 1) + if (coreCount > 1) { power_slope = (max_power - min_power) / (1 - coreReciprocal); - else - power_slope = 0; // Should be 0, since max_power == min_power (in this case) + current_power = min_power + (cpu_load - coreReciprocal) * power_slope; + } else { + current_power = max_power; + } - current_power = min_power + (cpu_load - coreReciprocal) * power_slope; } else { /* Our machine is idle, take the dedicated value! */ current_power = range.idle; } @@ -275,6 +290,9 @@ static void onCreation(simgrid::s4u::Host& host) { if (dynamic_cast(&host)) // Ignore virtual machines return; + + //TODO Trace: set to zero the energy variable associated to host->name() + host.extension_set(new HostEnergy(&host)); } @@ -363,7 +381,26 @@ void sg_host_energy_plugin_init() simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange); } +/** @brief updates the consumption of all hosts + * + * After this call, sg_host_get_consumed_energy() will not interrupt your process + * (until after the next clock update). + */ +void sg_host_energy_update_all() +{ + simgrid::simix::kernelImmediate([]() { + std::vector list; + simgrid::s4u::Engine::instance()->hostList(&list); + for (auto host : list) + host->extension()->update(); + }); +} + /** @brief Returns the total energy consumed by the host 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. * * See also @ref SURF_plugin_energy. */