/* 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 "energy.hpp"
-#include "../cpu_cas01.hpp"
+#include <src/surf/plugins/energy.hpp>
+#include <src/surf/cpu_interface.hpp>
+#include <src/surf/virtual_machine.hpp>
/** @addtogroup SURF_plugin_energy
In this example, the idle consumption is 95 Watts, 93 Watts and 90 Watts in each pstate while the CPU burn consumption are at 200 Watts,
170 Watts and 150 Watts respectively.
-To change the pstate of a given CPU, use the following functions: #MSG_host_get_pstate_number, #MSG_host_set_pstate(), #MSG_host_get_power_peak_at().
+To change the pstate of a given CPU, use the following functions: #MSG_host_get_nb_pstates(), #MSG_host_set_pstate(), #MSG_host_get_power_peak_at().
To simulate the energy-related elements, first call the #sg_energy_plugin_init() before your #MSG_init(),
and then use the following function to retrieve the consumption of a given host: #MSG_host_get_consumed_energy().
*/
-XBT_LOG_EXTERNAL_CATEGORY(surf_kernel);
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf,
"Logging specific to the SURF energy plugin");
-std::map<CpuPtr, CpuEnergyPtr> *surf_energy=NULL;
+namespace simgrid {
+namespace energy {
-static void energyCpuCreatedCallback(CpuPtr cpu){
- (*surf_energy)[cpu] = new CpuEnergy(cpu);
-}
-
-static void update_consumption_running(CpuPtr cpu, CpuEnergyPtr cpu_energy) {
- double cpu_load = lmm_constraint_get_usage(cpu->getConstraint()) / cpu->m_powerPeak;
- double start_time = cpu_energy->last_updated;
- double finish_time = surf_get_clock();
-
- double previous_energy = cpu_energy->total_energy;
- double energy_this_step = cpu_energy->getCurrentWattsValue(cpu_load)*(finish_time-start_time);
-
- cpu_energy->total_energy = previous_energy + energy_this_step;
- cpu_energy->last_updated = finish_time;
+std::map<simgrid::surf::Host*, HostEnergy*> *surf_energy = NULL;
- XBT_DEBUG("[cpu_update_energy] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
- start_time, finish_time, cpu->m_powerPeak, previous_energy, energy_this_step);
}
-static void update_consumption_off(CpuPtr cpu, CpuEnergyPtr cpu_energy) {
- double start_time = cpu_energy->last_updated;
- double finish_time = surf_get_clock();
-
- double previous_energy = cpu_energy->total_energy;
- double energy_this_step = cpu_energy->watts_off*(finish_time-start_time);
-
- cpu_energy->total_energy = previous_energy + energy_this_step;
- cpu_energy->last_updated = finish_time;
-
- XBT_DEBUG("[cpu_update_energy] off period=[%.2f-%.2f]; consumption change: %.2f J -> %.2f J",
- start_time, finish_time, previous_energy, energy_this_step);
}
-static void energyCpuDestructedCallback(CpuPtr cpu){
- std::map<CpuPtr, CpuEnergyPtr>::iterator cpu_energy_it = surf_energy->find(cpu);
- xbt_assert(cpu_energy_it != surf_energy->end(), "The cpu is not in surf_energy.");
-
- CpuEnergyPtr cpu_energy = cpu_energy_it->second;
- if (cpu->getState() == SURF_RESOURCE_OFF)
- update_consumption_off(cpu, cpu_energy);
- else
- update_consumption_running(cpu, cpu_energy);
+using simgrid::energy::HostEnergy;
+using simgrid::energy::surf_energy;
- XBT_INFO("Total energy of host %s: %f Joules", cpu->getName(), cpu_energy->getConsumedEnergy());
- delete cpu_energy_it->second;
- surf_energy->erase(cpu_energy_it);
-}
+/* Computes the consumption so far. Called lazily on need. */
+static void update_consumption(simgrid::surf::Host *host, HostEnergy *host_energy) {
+ double cpu_load = lmm_constraint_get_usage(host->p_cpu->getConstraint()) / host->p_cpu->m_speedPeak;
+ double start_time = host_energy->last_updated;
+ double finish_time = surf_get_clock();
-static void energyCpuActionStateChangedCallback(CpuActionPtr action, e_surf_action_state_t old, e_surf_action_state_t cur){
- CpuPtr cpu = getActionCpu(action);
- CpuEnergyPtr cpu_energy = (*surf_energy)[cpu];
+ double previous_energy = host_energy->total_energy;
- if(cpu_energy->last_updated < surf_get_clock()) {
- update_consumption_running(cpu, cpu_energy);
- }
-}
+ double instantaneous_consumption;
+ if (host->getState() == SURF_RESOURCE_OFF)
+ instantaneous_consumption = host_energy->watts_off;
+ else
+ instantaneous_consumption = host_energy->getCurrentWattsValue(cpu_load);
-static void energyStateChangedCallback(CpuPtr cpu, e_surf_resource_state_t oldState, e_surf_resource_state_t newState){
- CpuEnergyPtr cpu_energy = (*surf_energy)[cpu];
+ double energy_this_step = instantaneous_consumption*(finish_time-start_time);
- if(cpu_energy->last_updated < surf_get_clock()) {
- if (oldState == SURF_RESOURCE_OFF)
- update_consumption_off(cpu, cpu_energy);
- else
- update_consumption_running(cpu, cpu_energy);
- }
-}
+ host_energy->total_energy = previous_energy + energy_this_step;
+ host_energy->last_updated = finish_time;
-static void sg_energy_plugin_exit()
-{
- delete surf_energy;
- surf_energy = NULL;
+ XBT_DEBUG("[cpu_update_energy] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
+ start_time, finish_time, host->p_cpu->m_speedPeak, previous_energy, energy_this_step);
}
/** \ingroup SURF_plugin_energy
* \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
*/
void sg_energy_plugin_init() {
- if (surf_energy == NULL) {
- surf_energy = new std::map<CpuPtr, CpuEnergyPtr>();
- surf_callback_connect(cpuCreatedCallbacks, energyCpuCreatedCallback);
- surf_callback_connect(cpuDestructedCallbacks, energyCpuDestructedCallback);
- surf_callback_connect(cpuActionStateChangedCallbacks, energyCpuActionStateChangedCallback);
- surf_callback_connect(surfExitCallbacks, sg_energy_plugin_exit);
- surf_callback_connect(cpuStateChangedCallbacks, energyStateChangedCallback);
+ if (simgrid::energy::surf_energy == NULL) {
+
+ simgrid::energy::surf_energy = new std::map<simgrid::surf::Host*, simgrid::energy::HostEnergy*>();
+
+ /* The following attaches an anonymous function to the Host::onCreation signal */
+ /* Search for "C++ lambda" for more information on the syntax used here */
+ simgrid::surf::Host::onCreation.connect([](simgrid::surf::Host *host) {
+ (*surf_energy)[host] = new HostEnergy(host);
+ });
+
+ simgrid::surf::VMCreatedCallbacks.connect([](simgrid::surf::VirtualMachine* vm) {
+ std::map<simgrid::surf::Host*, HostEnergy*>::iterator host_energy_it =
+ surf_energy->find(vm->p_hostPM->extension(simgrid::surf::Host::EXTENSION_ID));
+ xbt_assert(host_energy_it != surf_energy->end(), "The host is not in surf_energy.");
+ (*surf_energy)[vm] = host_energy_it->second;
+ host_energy_it->second->ref(); // protect the HostEnergy from getting deleted too early
+ });
+
+ simgrid::surf::Host::onDestruction.connect([](simgrid::surf::Host *host) {
+ std::map<simgrid::surf::Host*, HostEnergy*>::iterator host_energy_it = surf_energy->find(host);
+ xbt_assert(host_energy_it != surf_energy->end(), "The host is not in surf_energy.");
+
+ HostEnergy *host_energy = host_energy_it->second;
+ update_consumption(host, host_energy);
+
+ if (host_energy_it->second->refcount == 1) // Don't display anything for virtual CPUs
+ XBT_INFO("Total energy of host %s: %f Joules", host->getName(), host_energy->getConsumedEnergy());
+ host_energy_it->second->unref();
+ surf_energy->erase(host_energy_it);
+ });
+ simgrid::surf::CpuAction::onStateChange.connect([](simgrid::surf::CpuAction *action,
+ e_surf_action_state_t old,
+ e_surf_action_state_t cur) {
+ const char *name = getActionCpu(action)->getName();
+ simgrid::surf::Host *host = static_cast<simgrid::surf::Host*>(surf_host_resource_priv(sg_host_by_name(name)));
+
+ HostEnergy *host_energy = (*surf_energy)[host];
+
+ if(host_energy->last_updated < surf_get_clock())
+ update_consumption(host, host_energy);
+
+ });
+
+ simgrid::surf::Host::onStateChange.connect([]
+ (simgrid::surf::Host *host,
+ e_surf_resource_state_t oldState,
+ e_surf_resource_state_t newState) {
+ HostEnergy *host_energy = (*surf_energy)[host];
+
+ if(host_energy->last_updated < surf_get_clock())
+ update_consumption(host, host_energy);
+ });
+
+ simgrid::surf::surfExitCallbacks.connect([]() {
+ delete surf_energy;
+ surf_energy = NULL;
+ });
}
}
+namespace simgrid {
+namespace energy {
+
/**
*
*/
-CpuEnergy::CpuEnergy(CpuPtr ptr)
- : cpu(ptr)
+HostEnergy::HostEnergy(simgrid::surf::Host *ptr)
{
+ host = ptr;
total_energy = 0;
power_range_watts_list = getWattsRangeList();
last_updated = surf_get_clock();
- if (cpu->getProperties() != NULL) {
- char* off_power_str = (char*)xbt_dict_get_or_null(cpu->getProperties(), "watt_off");
+ if (host->getProperties() != NULL) {
+ char* off_power_str = (char*)xbt_dict_get_or_null(host->getProperties(), "watt_off");
if (off_power_str != NULL)
watts_off = atof(off_power_str);
else
}
-CpuEnergy::~CpuEnergy(){
+HostEnergy::~HostEnergy(){
unsigned int iter;
xbt_dynar_t power_tuple = NULL;
xbt_dynar_foreach(power_range_watts_list, iter, power_tuple)
xbt_dynar_free(&power_range_watts_list);
}
-/**
- * Computes the power consumed by the host according to the current pstate and processor load
- *
- */
-double CpuEnergy::getCurrentWattsValue(double cpu_load)
+
+double HostEnergy::getWattMinAt(int pstate) {
+ xbt_dynar_t power_range_list = power_range_watts_list;
+ xbt_assert(power_range_watts_list, "No power range properties specified for host %s", host->getName());
+ xbt_dynar_t current_power_values = xbt_dynar_get_as(power_range_list, host->p_cpu->getPState(), xbt_dynar_t);
+ double min_power = xbt_dynar_get_as(current_power_values, 0, double);
+ return min_power;
+}
+double HostEnergy::getWattMaxAt(int pstate) {
+ xbt_dynar_t power_range_list = power_range_watts_list;
+ xbt_assert(power_range_watts_list, "No power range properties specified for host %s", host->getName());
+ xbt_dynar_t current_power_values = xbt_dynar_get_as(power_range_list, host->p_cpu->getPState(), xbt_dynar_t);
+ double max_power = xbt_dynar_get_as(current_power_values, 1, double);
+ return max_power;
+}
+
+/** @brief Computes the power consumed by the host according to the current pstate and processor load */
+double HostEnergy::getCurrentWattsValue(double cpu_load)
{
xbt_dynar_t power_range_list = power_range_watts_list;
+ xbt_assert(power_range_watts_list, "No power range properties specified for host %s", host->getName());
- if (power_range_list == NULL)
- {
- XBT_DEBUG("No power range properties specified for host %s", cpu->getName());
- return 0;
- }
- /*xbt_assert(xbt_dynar_length(power_range_list) == xbt_dynar_length(cpu->p_powerPeakList),
- "The number of power ranges in the properties does not match the number of pstates for host %s",
- cpu->getName());*/
-
+ int pstate = host->p_cpu->getPState();
+ xbt_assert(pstate < (int)xbt_dynar_length(power_range_list),
+ "pstate %d >= power range amound %d",pstate,(int)xbt_dynar_length(power_range_list));
/* retrieve the power values associated with the current pstate */
- xbt_dynar_t current_power_values = xbt_dynar_get_as(power_range_list, static_cast<CpuCas01Ptr>(cpu)->getPState(), xbt_dynar_t);
+ xbt_dynar_t current_power_values = xbt_dynar_get_as( power_range_list, pstate, xbt_dynar_t);
/* min_power corresponds to the idle power (cpu load = 0) */
/* max_power is the power consumed at 100% cpu load */
return current_power;
}
-double CpuEnergy::getConsumedEnergy()
+double HostEnergy::getConsumedEnergy()
{
- if(last_updated < surf_get_clock()) {
- if (cpu->getState() == SURF_RESOURCE_OFF)
- update_consumption_off(cpu, this);
- else
- update_consumption_running(cpu, this);
- }
- return total_energy;
+ if(last_updated < surf_get_clock())
+ update_consumption(host, this);
+ return total_energy;
}
-xbt_dynar_t CpuEnergy::getWattsRangeList()
+xbt_dynar_t HostEnergy::getWattsRangeList()
{
xbt_dynar_t power_range_list;
xbt_dynar_t power_tuple;
xbt_dynar_t current_power_values;
double min_power, max_power;
- if (cpu->getProperties() == NULL)
+ if (host->getProperties() == NULL)
return NULL;
- char* all_power_values_str = (char*)xbt_dict_get_or_null(cpu->getProperties(), "watt_per_state");
+ char* all_power_values_str = (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
if (all_power_values_str == NULL)
return NULL;
current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
xbt_assert(xbt_dynar_length(current_power_values) > 1,
"Power properties incorrectly defined - could not retrieve min and max power values for host %s",
- cpu->getName());
+ host->getName());
/* min_power corresponds to the idle power (cpu load = 0) */
/* max_power is the power consumed at 100% cpu load */
xbt_dynar_free(&all_power_values);
return power_range_list;
}
+
+}
+}
