X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2648bf7b99690d4cabbb4c7c9979fcf3d8a17068..54f1b83628996d19f533048e309c020120bc582c:/src/surf/plugins/host_dvfs.cpp diff --git a/src/surf/plugins/host_dvfs.cpp b/src/surf/plugins/host_dvfs.cpp index 1863fc7fd7..2f21dcca1a 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. */ @@ -39,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() { @@ -52,49 +53,55 @@ public: } } - virtual void update() {} + virtual void update() = 0; + virtual std::string getName() = 0; 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); } + std::string getName() { return "Performance"; } }; 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); } + std::string getName() { return "Powersave"; } }; 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) {} + std::string getName() { return "OnDemand"; } 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; + int new_pstate = max_pstate - load * max_pstate; + host->setPstate(new_pstate); - host->setPstate(max_pstate - load * max_pstate); - XBT_INFO("Changed to pstate %f -- check: %i", max_pstate - load * max_pstate, host->getPstate()); + XBT_DEBUG("Load: %f --> changed to pstate %i", load*host->getCoreCount(), new_pstate); } } }; @@ -104,31 +111,30 @@ 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() + virtual std::string getName() { return "Conservative"; } + virtual 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("Increasing performance to pstate %d", pstate - 1); + XBT_INFO("Load: %f > threshold: %f -> increasing performance to pstate %d", load, freq_up_threshold, pstate - 1); } else { - XBT_DEBUG("Cannot speed up even more, already in slowest pstate %d", pstate); + XBT_DEBUG("Load: %f > threshold: %f -> but cannot speed up even more, already in highest pstate %d", load, freq_up_threshold, pstate); } - } - - if (load < freq_down_threshold) { + } else if (load < freq_down_threshold) { int max_pstate = host->getPstatesCount() - 1; if (pstate != max_pstate) { // Are we in the slowest pstate already? host->setPstate(pstate + 1); - XBT_INFO("Slowing down to pstate %d", pstate + 1); + XBT_INFO("Load: %f < threshold: %f -> slowing down to pstate %d", load, freq_down_threshold, pstate + 1); } else { - XBT_DEBUG("Cannot slow down even more, already in slowest pstate %d", pstate); + XBT_DEBUG("Load: %f < threshold: %f -> cannot slow down even more, already in slowest pstate %d", load, freq_down_threshold, pstate); } } } @@ -139,18 +145,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; } @@ -164,7 +165,7 @@ static void on_host_added(simgrid::s4u::Host& host) if (dynamic_cast(&host)) // Ignore virtual machines return; - std::string name = "dvfs-daemon-" + host.getName(); + 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 @@ -185,18 +186,28 @@ static void on_host_added(simgrid::s4u::Host& host) boost::algorithm::to_lower(dvfs_governor); } - simgrid::plugin::dvfs::Governor governor(daemonProc->getHost()); + // FIXME This is really ugly. When do we free the governor? Actually, never, because + // daemons never stop to run - they will be killed when the simulation is over. :( + simgrid::plugin::dvfs::Governor* governor; if (dvfs_governor == "conservative") { - governor = simgrid::plugin::dvfs::Conservative(daemonProc->getHost()); + governor = new simgrid::plugin::dvfs::Conservative(daemonProc->getHost()); + } else if (dvfs_governor == "ondemand") { + governor = new simgrid::plugin::dvfs::OnDemand(daemonProc->getHost()); + } else if (dvfs_governor == "performance") { + governor = new simgrid::plugin::dvfs::Performance(daemonProc->getHost()); + } else if (dvfs_governor == "powersave") { + governor = new simgrid::plugin::dvfs::Powersave(daemonProc->getHost()); + } else { + XBT_CRITICAL("No governor specified for host %s", daemonProc->getHost()->getCname()); } 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!"); + simgrid::s4u::this_actor::sleep_for(governor->samplingRate()); + governor->update(); + XBT_DEBUG("Governor (%s) just updated!", governor->getName().c_str()); } XBT_WARN("I should have never reached this point: daemons should be killed when all regular processes are done"); @@ -209,7 +220,7 @@ static void on_host_added(simgrid::s4u::Host& host) } /* **************************** Public interface *************************** */ -SG_BEGIN_DECL() +extern "C" { /** \ingroup SURF_plugin_load * \brief Initializes the HostDvfs plugin @@ -230,5 +241,4 @@ void sg_host_dvfs_plugin_init() xbt_cfg_register_string("plugin/dvfs/governor", "performance", nullptr, "Which Governor should be used that adapts the CPU frequency?"); } - -SG_END_DECL() +}