X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e18a7b043d161b29d0bf3f5743cb7a570241576a..67bdf5427542ebb33da6978c6ae422a763ea0ab3:/src/surf/plugins/host_energy.cpp diff --git a/src/surf/plugins/host_energy.cpp b/src/surf/plugins/host_energy.cpp index 6e102e470e..7074846e53 100644 --- a/src/surf/plugins/host_energy.cpp +++ b/src/surf/plugins/host_energy.cpp @@ -110,7 +110,7 @@ before you can get accurate energy predictions. XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin"); namespace simgrid { -namespace energy { +namespace plugin { class PowerRange { public: @@ -128,6 +128,7 @@ public: explicit HostEnergy(simgrid::s4u::Host* ptr); ~HostEnergy(); + double getCurrentWattsValue(); double getCurrentWattsValue(double cpu_load); double getConsumedEnergy(); double getWattMinAt(int pstate); @@ -159,48 +160,15 @@ void HostEnergy::update() { double start_time = this->last_updated; double finish_time = surf_get_clock(); - double current_speed = host->getSpeed(); if (start_time < finish_time) { - double cpu_load; - // 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 == pstate_off) // The host was off at the beginning of this time interval - instantaneous_consumption = this->watts_off; - else - instantaneous_consumption = this->getCurrentWattsValue(cpu_load); + double instantaneous_consumption = this->getCurrentWattsValue(); double energy_this_step = instantaneous_consumption * (finish_time - start_time); - // TODO Trace: Trace energy_this_step from start_time to finish_time in host->name() + // TODO Trace: Trace energy_this_step from start_time to finish_time in host->getName() this->total_energy = previous_energy + energy_this_step; this->last_updated = finish_time; @@ -245,11 +213,63 @@ double HostEnergy::getWattMaxAt(int pstate) return power_range_watts_list[pstate].max; } -/** @brief Computes the power consumed by the host according to the current pstate and processor load */ +/** @brief Computes the power consumed by the host according to the current situation + * + * - If the host is off, that's the watts_off value + * - if it's on, take the current pstate and the current processor load into account */ +double HostEnergy::getCurrentWattsValue() +{ + 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->getSpeed(); + + double cpu_load; + // 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 = host->pimpl_cpu->constraint()->get_usage() / 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. + */ + return getCurrentWattsValue(cpu_load); +} + +/** @brief Computes the power that the host would consume at the provided processor load + * + * Whether the host is ON or OFF is not taken into account. + */ double HostEnergy::getCurrentWattsValue(double cpu_load) { xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->getCname()); + /* + * * Return watts_off if pstate == pstate_off + * * this happens when host is off + */ + if (this->pstate == pstate_off) { + return watts_off; + } + /* 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); @@ -355,7 +375,7 @@ void HostEnergy::initWattsRangeList() } } -using simgrid::energy::HostEnergy; +using simgrid::plugin::HostEnergy; /* **************************** events callback *************************** */ static void onCreation(simgrid::s4u::Host& host) @@ -363,7 +383,7 @@ 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() + // TODO Trace: set to zero the energy variable associated to host->getName() host.extension_set(new HostEnergy(&host)); } @@ -377,7 +397,7 @@ static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf: // If it's a VM, take the corresponding PM simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); if (vm) // If it's a VM, take the corresponding PM - host = vm->pimpl_vm_->getPm(); + host = vm->getPm(); // Get the host_energy extension for the relevant host HostEnergy* host_energy = host->extension(); @@ -405,9 +425,8 @@ static void onHostDestruction(simgrid::s4u::Host& host) if (dynamic_cast(&host)) // Ignore virtual machines return; - HostEnergy* host_energy = host.extension(); - host_energy->update(); - XBT_INFO("Energy consumption of host %s: %f Joules", host.getCname(), host_energy->getConsumedEnergy()); + XBT_INFO("Energy consumption of host %s: %f Joules", host.getCname(), + host.extension()->getConsumedEnergy()); } static void onSimulationEnd() @@ -432,7 +451,7 @@ static void onSimulationEnd() } /* **************************** Public interface *************************** */ -SG_BEGIN_DECL() +extern "C" { /** \ingroup plugin_energy * \brief Enable host energy plugin @@ -510,8 +529,6 @@ double sg_host_get_current_consumption(sg_host_t host) { xbt_assert(HostEnergy::EXTENSION_ID.valid(), "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization."); - double cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->getSpeed(); - return host->extension()->getCurrentWattsValue(cpu_load); + return host->extension()->getCurrentWattsValue(); +} } - -SG_END_DECL()