X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4af3b3329ad57dcfe30cf363b3f79f209c32a4ac..a3f5e3d6901fbcd1857fb8cc07ad3a54bf244bde:/src/surf/plugins/host_dvfs.cpp diff --git a/src/surf/plugins/host_dvfs.cpp b/src/surf/plugins/host_dvfs.cpp index 589dfede01..1d7336a30a 100644 --- a/src/surf/plugins/host_dvfs.cpp +++ b/src/surf/plugins/host_dvfs.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2010, 2012-2016. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010, 2012-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. */ @@ -9,6 +9,7 @@ #include "src/plugins/vm/VirtualMachineImpl.hpp" #include "src/surf/cpu_interface.hpp" +#include #include #include #include @@ -16,6 +17,7 @@ #include #include #include +#include /** @addtogroup SURF_plugin_load @@ -37,7 +39,8 @@ protected: public: double sampling_rate; - Governor(simgrid::s4u::Host* ptr) : host(ptr) { init(); } + explicit Governor(simgrid::s4u::Host* ptr) : host(ptr) { init(); } + virtual ~Governor() = default; void init() { @@ -50,20 +53,20 @@ public: } } - virtual void update() = 0; + virtual void update() {} double samplingRate() { return sampling_rate; } }; class Performance : public Governor { public: - Performance(simgrid::s4u::Host* ptr) : Governor(ptr) {} + explicit Performance(simgrid::s4u::Host* ptr) : Governor(ptr) {} void update() { host->setPstate(0); } }; class Powersave : public Governor { public: - Powersave(simgrid::s4u::Host* ptr) : Governor(ptr) {} + explicit Powersave(simgrid::s4u::Host* ptr) : Governor(ptr) {} void update() { host->setPstate(host->getPstatesCount() - 1); } }; @@ -72,22 +75,23 @@ class OnDemand : public Governor { double freq_up_threshold = 0.95; public: - OnDemand(simgrid::s4u::Host* ptr) : Governor(ptr) {} + explicit OnDemand(simgrid::s4u::Host* ptr) : Governor(ptr) {} void update() { double load = sg_host_get_current_load(host); - if (load > freq_up_threshold) { + // FIXME I don't like that we multiply with the getCoreCount() just here... + if (load*host->getCoreCount() > freq_up_threshold) { host->setPstate(0); /* Run at max. performance! */ XBT_INFO("Changed to pstate %f", 0.0); } else { /* The actual implementation uses a formula here: (See Kernel file cpufreq_ondemand.c:158) * - * freq_next = min_f + load * (max_f - min_f) / 100; + * freq_next = min_f + load * (max_f - min_f) / 100 * * So they assume that frequency increases by 100 MHz. We will just use - * lowest_pstate - load*pstatesCount(); + * lowest_pstate - load*pstatesCount() */ int max_pstate = host->getPstatesCount() - 1; @@ -102,17 +106,20 @@ class Conservative : public Governor { double freq_down_threshold = .2; public: - Conservative(simgrid::s4u::Host* ptr) : Governor(ptr) {} + explicit Conservative(simgrid::s4u::Host* ptr) : Governor(ptr) {} void update() { - double load = sg_host_get_current_load(host); + double load = sg_host_get_current_load(host)*host->getCoreCount(); int pstate = host->getPstate(); if (load > freq_up_threshold) { if (pstate != 0) { host->setPstate(pstate - 1); - XBT_INFO("Reducing pstate to %d", pstate - 1); + XBT_INFO("Increasing performance to pstate %d", pstate - 1); + } + else { + XBT_DEBUG("Cannot speed up even more, already in slowest pstate %d", pstate); } } @@ -120,7 +127,10 @@ public: int max_pstate = host->getPstatesCount() - 1; if (pstate != max_pstate) { // Are we in the slowest pstate already? host->setPstate(pstate + 1); - XBT_INFO("Increasing pstate to %d", pstate + 1); + XBT_INFO("Slowing down to pstate %d", pstate + 1); + } + else { + XBT_DEBUG("Cannot slow down even more, already in slowest pstate %d", pstate); } } } @@ -131,18 +141,13 @@ class HostDvfs { public: static simgrid::xbt::Extension EXTENSION_ID; - explicit HostDvfs(simgrid::s4u::Host* ptr); + explicit HostDvfs(simgrid::s4u::Host*); ~HostDvfs(); - -private: - simgrid::s4u::Host* host = nullptr; }; simgrid::xbt::Extension HostDvfs::EXTENSION_ID; -HostDvfs::HostDvfs(simgrid::s4u::Host* ptr) : host(ptr) -{ -} +HostDvfs::HostDvfs(simgrid::s4u::Host* ptr) {} HostDvfs::~HostDvfs() = default; } @@ -151,44 +156,57 @@ HostDvfs::~HostDvfs() = default; using simgrid::plugin::HostDvfs; /* **************************** events callback *************************** */ -static int check(int argc, char* argv[]); - static void on_host_added(simgrid::s4u::Host& host) { if (dynamic_cast(&host)) // Ignore virtual machines return; - // host.extension_set(new HostDvfs(&host)); - // This call must be placed in this function. Otherweise, the daemonize() call comes too late and - // SMPI will take this process as an MPI process! - MSG_process_daemonize(MSG_process_create("daemon", check, NULL, &host)); -} + std::string name = std::string("dvfs-daemon-") + host.getCname(); + simgrid::s4u::ActorPtr daemon = simgrid::s4u::Actor::createActor(name.c_str(), &host, []() { + /** + * This lambda function is the function the actor (daemon) will execute + * all the time - in the case of the dvfs plugin, this controls when to + * lower/raise the frequency. + */ + simgrid::s4u::ActorPtr daemonProc = simgrid::s4u::Actor::self(); + + XBT_DEBUG("DVFS process on %s is a daemon: %d", daemonProc->getHost()->getName().c_str(), daemonProc->isDaemon()); + + std::string dvfs_governor; + const char* host_conf = daemonProc->getHost()->getProperty("plugin/dvfs/governor"); + if (host_conf != nullptr) { + dvfs_governor = std::string(daemonProc->getHost()->getProperty("plugin/dvfs/governor")); + boost::algorithm::to_lower(dvfs_governor); + } else { + dvfs_governor = xbt_cfg_get_string("plugin/dvfs/governor"); + boost::algorithm::to_lower(dvfs_governor); + } -static int check(int argc, char* argv[]) -{ - msg_host_t host = MSG_host_self(); - - int isDaemon = (MSG_process_self())->getImpl()->isDaemon(); - XBT_INFO("Bin ein Daemon: %d", isDaemon); - - simgrid::plugin::dvfs::Conservative governor(host); - while (1) { - // Sleep before updating; important for startup (i.e., t = 0). - // In the beginning, we want to go with the pstates specified in the platform file - // (so we sleep first) - MSG_process_sleep(governor.samplingRate()); - governor.update(); - XBT_INFO("Governor just updated!"); - } + simgrid::plugin::dvfs::Governor governor(daemonProc->getHost()); + if (dvfs_governor == "conservative") { + governor = simgrid::plugin::dvfs::Conservative(daemonProc->getHost()); + } - // const char* dvfs_governor = host->property("plugin/dvfs/governor"); + while (1) { + // Sleep *before* updating; important for startup (i.e., t = 0). + // In the beginning, we want to go with the pstates specified in the platform file + // (so we sleep first) + simgrid::s4u::this_actor::sleep_for(governor.samplingRate()); + governor.update(); + XBT_INFO("Governor just updated!"); + } - XBT_INFO("I will never reach that point: daemons are killed when regular processes are done"); - return 0; + XBT_WARN("I should have never reached this point: daemons should be killed when all regular processes are done"); + return 0; + }); + + // This call must be placed in this function. Otherweise, the daemonize() call comes too late and + // SMPI will take this process as an MPI process! + daemon->daemonize(); } /* **************************** Public interface *************************** */ -SG_BEGIN_DECL() +extern "C" { /** \ingroup SURF_plugin_load * \brief Initializes the HostDvfs plugin @@ -206,6 +224,7 @@ void sg_host_dvfs_plugin_init() simgrid::s4u::Host::onCreation.connect(&on_host_added); xbt_cfg_register_double("plugin/dvfs/sampling_rate", 0.1, nullptr, "How often should the dvfs plugin check whether the frequency needs to be changed?"); + xbt_cfg_register_string("plugin/dvfs/governor", "performance", nullptr, + "Which Governor should be used that adapts the CPU frequency?"); +} } - -SG_END_DECL()