X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a96adb51dabc0c759af11e60c770355f22a54ef3..b63adff37a6c05384b40d5c5bd5be49b246cf9fc:/src/surf/plugins/host_load.cpp diff --git a/src/surf/plugins/host_load.cpp b/src/surf/plugins/host_load.cpp index f1e039a858..039f23cda7 100644 --- a/src/surf/plugins/host_load.cpp +++ b/src/surf/plugins/host_load.cpp @@ -1,20 +1,10 @@ -/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2018. 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/load.h" -#include "simgrid/simix.hpp" #include "src/plugins/vm/VirtualMachineImpl.hpp" -#include "src/surf/cpu_interface.hpp" - -#include "simgrid/s4u/Engine.hpp" - -#include -#include -#include -#include -#include /** @addtogroup plugin_load @@ -37,6 +27,7 @@ public: double getCurrentLoad(); double getComputedFlops(); double getAverageLoad(); + double getIdleTime(); void update(); void reset(); @@ -44,8 +35,12 @@ private: simgrid::s4u::Host* host = nullptr; double last_updated = 0; double last_reset = 0; + double current_speed = 0; double current_flops = 0; double computed_flops = 0; + double idle_time = 0; + double theor_max_flops = 0; + bool was_prev_idle = true; /* A host is idle at the beginning */ }; simgrid::xbt::Extension HostLoad::EXTENSION_ID; @@ -54,7 +49,10 @@ HostLoad::HostLoad(simgrid::s4u::Host* ptr) : host(ptr) , last_updated(surf_get_clock()) , last_reset(surf_get_clock()) - , current_flops(lmm_constraint_get_usage(host->pimpl_cpu->constraint())) + , current_speed(host->getSpeed()) + , current_flops(host->pimpl_cpu->get_constraint()->get_usage()) + , theor_max_flops(0) + , was_prev_idle(current_flops == 0) { } @@ -63,31 +61,59 @@ HostLoad::~HostLoad() = default; void HostLoad::update() { double now = surf_get_clock(); - if (last_updated < now) { - /* Current flop per second computed by the cpu; current_flops = k * pstate_speed_in_flops, k \in {0, 1, ..., cores} - * number of active cores */ - current_flops = lmm_constraint_get_usage(host->pimpl_cpu->constraint()); - - /* flops == pstate_speed * cores_being_currently_used */ - computed_flops += (now - last_updated) * current_flops; - last_updated = now; + + /* Current flop per second computed by the cpu; current_flops = k * pstate_speed_in_flops, k \in {0, 1, ..., cores} + * number of active cores */ + current_flops = host->pimpl_cpu->get_constraint()->get_usage(); + + /* flops == pstate_speed * cores_being_currently_used */ + computed_flops += (now - last_updated) * current_flops; + + if (was_prev_idle) { + idle_time += (now - last_updated); } + + theor_max_flops += current_speed * host->getCoreCount() * (now - last_updated); + current_speed = host->getSpeed(); + last_updated = now; + was_prev_idle = (current_flops == 0); } +/** + * WARNING: This function does not guarantee that you have the real load at any time + * imagine all actions on your CPU terminate at time t. Your load is then 0. Then + * you query the load (still 0) and then another action starts (still at time t!). + * This means that the load was never really 0 (because the time didn't advance) but + * it will still be reported as 0. + * + * So, use at your own risk. + */ double HostLoad::getCurrentLoad() { - return current_flops / (host->getSpeed() * host->getCoreCount()); + // We don't need to call update() here because it is called everytime an + // action terminates or starts + // FIXME: Can this happen at the same time? stop -> call to getCurrentLoad, load = 0 -> next action starts? + return current_flops / static_cast(host->getSpeed() * host->getCoreCount()); +} + +/** + * Return idle time since last reset + */ +double HostLoad::getIdleTime() { + return idle_time; } double HostLoad::getAverageLoad() { - return getComputedFlops() / (host->getSpeed() * host->getCoreCount() * (surf_get_clock() - last_reset)); + if (theor_max_flops == 0) { // Avoid division by 0 + return 0; + } + + return computed_flops / theor_max_flops; } double HostLoad::getComputedFlops() { - update(); - return computed_flops; } @@ -96,9 +122,14 @@ double HostLoad::getComputedFlops() */ void HostLoad::reset() { - last_updated = surf_get_clock(); - last_reset = surf_get_clock(); - computed_flops = 0; + last_updated = surf_get_clock(); + last_reset = surf_get_clock(); + idle_time = 0; + computed_flops = 0; + theor_max_flops = 0; + current_flops = host->pimpl_cpu->get_constraint()->get_usage(); + current_speed = host->getSpeed(); + was_prev_idle = (current_flops == 0); } } } @@ -106,13 +137,6 @@ void HostLoad::reset() using simgrid::plugin::HostLoad; /* **************************** events callback *************************** */ -static void on_host_added(simgrid::s4u::Host& host) -{ - if (dynamic_cast(&host)) // Ignore virtual machines - return; - host.extension_set(new HostLoad(&host)); -} - /* This callback is fired either when the host changes its state (on/off) or its speed * (because the user changed the pstate, or because of external trace events) */ static void onHostChange(simgrid::s4u::Host& host) @@ -120,26 +144,25 @@ static void onHostChange(simgrid::s4u::Host& host) if (dynamic_cast(&host)) // Ignore virtual machines return; - HostLoad* host_load = host.extension(); - host_load->update(); + host.extension()->update(); } /* This callback is called when an action (computation, idle, ...) terminates */ -static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous) +static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::kernel::resource::Action::State /*previous*/) { for (simgrid::surf::Cpu* const& cpu : action->cpus()) { simgrid::s4u::Host* host = cpu->getHost(); + if (dynamic_cast(host)) // Ignore virtual machines + return; + if (host != nullptr) { - // Get the host_load extension for the relevant host - HostLoad* host_load = host->extension(); - host_load->update(); + host->extension()->update(); } } } /* **************************** Public interface *************************** */ -extern "C" { /** \ingroup plugin_load * \brief Initializes the HostLoad plugin @@ -152,7 +175,14 @@ void sg_host_load_plugin_init() HostLoad::EXTENSION_ID = simgrid::s4u::Host::extension_create(); - simgrid::s4u::Host::onCreation.connect(&on_host_added); + /* When attaching a callback into a signal, you can use a lambda as follows, or a regular function as done below */ + + simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) { + if (dynamic_cast(&host)) // Ignore virtual machines + return; + host.extension_set(new HostLoad(&host)); + }); + simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange); simgrid::s4u::Host::onStateChange.connect(&onHostChange); simgrid::s4u::Host::onSpeedChange.connect(&onHostChange); @@ -170,6 +200,30 @@ double sg_host_get_current_load(sg_host_t host) return host->extension()->getCurrentLoad(); } +/** @brief Returns the current load of the host passed as argument + * + * See also @ref plugin_load + */ +double sg_host_get_avg_load(sg_host_t host) +{ + xbt_assert(HostLoad::EXTENSION_ID.valid(), + "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization."); + + return host->extension()->getAverageLoad(); +} + +/** @brief Returns the time this host was idle since the last reset + * + * See also @ref plugin_load + */ +double sg_host_get_idle_time(sg_host_t host) +{ + xbt_assert(HostLoad::EXTENSION_ID.valid(), + "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization."); + + return host->extension()->getIdleTime(); +} + double sg_host_get_computed_flops(sg_host_t host) { xbt_assert(HostLoad::EXTENSION_ID.valid(), @@ -185,4 +239,3 @@ void sg_host_load_reset(sg_host_t host) host->extension()->reset(); } -}