X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/44594d451daa767330a63962c7ad367212b222ae..635743ad3b947c1b55642cb708fbf1626fe0b36f:/src/surf/plugins/host_energy.cpp diff --git a/src/surf/plugins/host_energy.cpp b/src/surf/plugins/host_energy.cpp index e09e5e9241..2b88fb032c 100644 --- a/src/surf/plugins/host_energy.cpp +++ b/src/surf/plugins/host_energy.cpp @@ -16,47 +16,102 @@ #include #include -/** @addtogroup SURF_plugin_energy +/** @addtogroup plugin_energy This is the energy plugin, enabling to account not only for computation time, but also for the dissipated energy in the simulated platform. +To activate this plugin, first call sg_host_energy_plugin_init() before your #MSG_init(), +and then use MSG_host_get_consumed_energy() to retrieve the consumption of a given host. -The energy consumption of a CPU depends directly of its current load. Specify that consumption in your platform file as -follows: +When the host is on, this energy consumption naturally depends on both the +current CPU load and the host energy profile. According to our measurements, +the consumption is somehow linear in the amount of cores at full speed, +with an abnormality when all the cores are idle. The full details are in +our scientific paper on that topic. -\verbatim - +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. + +Here is an example of XML declaration: + +\code{.xml} + -\endverbatim +\endcode + +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: + + + + + + + + +
#Cores loadedConsumptionExplanation
0 100 WattsIdle value
1 120 WattsOneCore value
2 147 Wattslinear extrapolation between OneCore and AllCores
3 173 Wattslinear extrapolation between OneCore and AllCores
4 200 WattsAllCores value
-The first property means that when your host is up and running, but without anything to do, it will dissipate 100 Watts. -If only one care is active, it will dissipate 120 Watts. If it's fully loaded, it will dissipate 200 Watts. If its load is at 50%, then it will dissipate 153.33 Watts. -The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these -values are arbitrary). +### What if a given core is only at load 50%? -If your CPU is using pstates, then you can provide one consumption interval per pstate. +This is impossible in SimGrid because we recompute everything each time +that the CPU starts or stops doing something. So if a core is at load 50% over +a period, it means that it is at load 100% half of the time and at load 0% the +rest of 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. +Actually, SimGrid expect an energetic profile formated 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. + +\code{.xml} + + + + +\endcode -\verbatim - +### 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} + -\endverbatim +\endcode -That host has 3 levels of performance with the following performance: 100 Mflop/s, 50 Mflop/s or 20 Mflop/s. -It starts at pstate 0 (ie, at 100 Mflop/s). In this case, you have to specify one interval per pstate in the -watt_per_state property. -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. If only one core is active, this machine consumes 120 / 115 / 110 watts. +This encodes the following values + + + + + +
pstatePerformanceIdleOneCoreAllCores
0100 Mflop/s95 Watts120 Watts200 Watts
150 Mflop/s93 Watts115 Watts170 Watts
220 Mflop/s90 Watts110 Watts150 Watts
To change the pstate of a given CPU, use the following functions: #MSG_host_get_nb_pstates(), simgrid#s4u#Host#setPstate(), #MSG_host_get_power_peak_at(). -To simulate the energy-related elements, first call the simgrid#energy#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(). +### How accurate are these models? + +This model cannot be more accurate than your instantiation: +with the default values, your result will not be accurate at all. You can still get +accurate energy prediction, provided that you carefully instantiate the model. +The first step is to ensure that your timing prediction match perfectly. But this +is only the first step of the path, and you really want to read +this paper to see all what you need +to do before you can get accurate energy predictions. + */ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin"); @@ -111,10 +166,10 @@ void HostEnergy::update() { double start_time = this->last_updated; double finish_time = surf_get_clock(); - double cpu_load; double current_speed = host->speed(); 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. // @@ -255,21 +310,41 @@ void HostEnergy::initWattsRangeList() std::vector all_power_values; boost::split(all_power_values, all_power_values_str, boost::is_any_of(",")); + XBT_DEBUG("%s: profile: %s, cores: %d", host->cname(), all_power_values_str, host->coreCount()); int i = 0; for (auto current_power_values_str : all_power_values) { /* retrieve the power values associated with the current pstate */ std::vector current_power_values; boost::split(current_power_values, current_power_values_str, boost::is_any_of(":")); - xbt_assert(current_power_values.size() == 3, "Power properties incorrectly defined - " - "could not retrieve idle, min and max power values for host %s", - host->cname()); + if (host->coreCount() == 1) { + xbt_assert(current_power_values.size() == 2 || current_power_values.size() == 3, + "Power properties incorrectly defined for host %s." + "It should be 'Idle:FullSpeed' power values because you have one core only.", + host->cname()); + if (current_power_values.size() == 2) { + // 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 formated 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->cname()); + } + } else { + xbt_assert(current_power_values.size() == 3, + "Power properties incorrectly defined for host %s." + "It should be 'Idle:OneCore:AllCores' power values because you have more than one core.", + host->cname()); + } /* min_power corresponds to the idle power (cpu load = 0) */ /* max_power is the power consumed at 100% cpu load */ char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname()); - char* msg_min = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->cname()); - char* msg_max = bprintf("Invalid max value for pstate %d on host %s: %%s", i, host->cname()); + char* msg_min = bprintf("Invalid OneCore value for pstate %d on host %s: %%s", i, host->cname()); + char* msg_max = bprintf("Invalid AllCores value for pstate %d on host %s: %%s", i, host->cname()); PowerRange range(xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle), xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_min), xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max)); @@ -362,7 +437,7 @@ static void onSimulationEnd() /* **************************** Public interface *************************** */ SG_BEGIN_DECL() -/** \ingroup SURF_plugin_energy +/** \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(). */ @@ -381,7 +456,8 @@ void sg_host_energy_plugin_init() simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange); } -/** @brief updates the consumption of all hosts +/** @ingroup plugin_energy + * @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). @@ -392,17 +468,17 @@ void sg_host_energy_update_all() std::vector list; simgrid::s4u::Engine::instance()->hostList(&list); for (auto host : list) - host->extension()->update(); + if (dynamic_cast(host) == nullptr) // Ignore virtual machines + host->extension()->update(); }); } -/** @brief Returns the total energy consumed by the host so far (in Joules) +/** @ingroup plugin_energy + * @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. */ double sg_host_get_consumed_energy(sg_host_t host) { @@ -411,14 +487,18 @@ double sg_host_get_consumed_energy(sg_host_t host) return host->extension()->getConsumedEnergy(); } -/** @brief Get the amount of watt dissipated at the given pstate when the host is idling */ +/** @ingroup plugin_energy + * @brief Get the amount of watt dissipated at the given pstate when the host is idling + */ double sg_host_get_wattmin_at(sg_host_t host, int pstate) { xbt_assert(HostEnergy::EXTENSION_ID.valid(), "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization."); return host->extension()->getWattMinAt(pstate); } -/** @brief Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */ +/** @ingroup plugin_energy + * @brief Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% + */ double sg_host_get_wattmax_at(sg_host_t host, int pstate) { xbt_assert(HostEnergy::EXTENSION_ID.valid(), @@ -426,7 +506,9 @@ double sg_host_get_wattmax_at(sg_host_t host, int pstate) return host->extension()->getWattMaxAt(pstate); } -/** @brief Returns the current consumption of the host */ +/** @ingroup plugin_energy + * @brief Returns the current consumption of the host + */ double sg_host_get_current_consumption(sg_host_t host) { xbt_assert(HostEnergy::EXTENSION_ID.valid(),