X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3cbf54871089cc3dc50b6832652b5765e1601039..30e93357d63b0846afb6a60db2004b6761607103:/src/surf/plugins/host_dvfs.cpp diff --git a/src/surf/plugins/host_dvfs.cpp b/src/surf/plugins/host_dvfs.cpp index 1f11563731..e5ea579ecb 100644 --- a/src/surf/plugins/host_dvfs.cpp +++ b/src/surf/plugins/host_dvfs.cpp @@ -1,22 +1,14 @@ -/* Copyright (c) 2010, 2012-2018. 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/dvfs.h" #include "simgrid/plugins/load.h" -#include "simgrid/simix.hpp" #include "src/plugins/vm/VirtualMachineImpl.hpp" -#include "src/surf/cpu_interface.hpp" +#include #include -#include -#include -#include -#include -#include -#include -#include /** @addtogroup SURF_plugin_load @@ -35,19 +27,22 @@ namespace plugin { namespace dvfs { class Governor { +private: + simgrid::s4u::Host* const host_; + protected: - simgrid::s4u::Host* host; + simgrid::s4u::Host* get_host() const { return host_; } public: double sampling_rate; - explicit Governor(simgrid::s4u::Host* ptr) : host(ptr) { init(); } + explicit Governor(simgrid::s4u::Host* ptr) : host_(ptr) { init(); } virtual ~Governor() = default; void init() { - const char* local_sampling_rate_config = host->getProperty(property_sampling_rate); - double global_sampling_rate_config = xbt_cfg_get_double(property_sampling_rate); + const char* local_sampling_rate_config = host_->getProperty(property_sampling_rate); + double global_sampling_rate_config = simgrid::config::get_value(property_sampling_rate); if (local_sampling_rate_config != nullptr) { sampling_rate = std::stod(local_sampling_rate_config); } else { @@ -74,7 +69,7 @@ class Performance : public Governor { public: explicit Performance(simgrid::s4u::Host* ptr) : Governor(ptr) {} - void update() override { host->setPstate(0); } + void update() override { get_host()->setPstate(0); } std::string getName() override { return "Performance"; } }; @@ -92,7 +87,7 @@ class Powersave : public Governor { public: explicit Powersave(simgrid::s4u::Host* ptr) : Governor(ptr) {} - void update() override { host->setPstate(host->getPstatesCount() - 1); } + void update() override { get_host()->setPstate(get_host()->getPstatesCount() - 1); } std::string getName() override { return "Powersave"; } }; @@ -107,7 +102,7 @@ public: */ class OnDemand : public Governor { /** - * See https://elixir.bootlin.com/linux/v4.15.4/source/drivers/cpufreq/cpufreq_ondemand.c + * See https://elixir.bootlin.com/linux/v4.15.4/source/drivers/cpufreq/cpufreq_ondemand.c * DEF_FREQUENCY_UP_THRESHOLD and od_update() */ double freq_up_threshold = 0.80; @@ -118,11 +113,11 @@ public: std::string getName() override { return "OnDemand"; } void update() override { - double load = host->getCoreCount() * sg_host_get_avg_load(host); - sg_host_load_reset(host); // Only consider the period between two calls to this method! + double load = get_host()->getCoreCount() * sg_host_get_avg_load(get_host()); + sg_host_load_reset(get_host()); // Only consider the period between two calls to this method! if (load > freq_up_threshold) { - host->setPstate(0); /* Run at max. performance! */ + get_host()->setPstate(0); /* Run at max. performance! */ XBT_INFO("Load: %f > threshold: %f --> changed to pstate %i", load, freq_up_threshold, 0); } else { /* The actual implementation uses a formula here: (See Kernel file cpufreq_ondemand.c:158) @@ -132,11 +127,11 @@ public: * So they assume that frequency increases by 100 MHz. We will just use * lowest_pstate - load*pstatesCount() */ - int max_pstate = host->getPstatesCount() - 1; + int max_pstate = get_host()->getPstatesCount() - 1; // Load is now < freq_up_threshold; exclude pstate 0 (the fastest) // because pstate 0 can only be selected if load > freq_up_threshold int new_pstate = max_pstate - load * (max_pstate + 1); - host->setPstate(new_pstate); + get_host()->setPstate(new_pstate); XBT_DEBUG("Load: %f < threshold: %f --> changed to pstate %i", load, freq_up_threshold, new_pstate); } @@ -165,22 +160,22 @@ public: virtual std::string getName() override { return "Conservative"; } virtual void update() override { - double load = host->getCoreCount() * sg_host_get_avg_load(host); - int pstate = host->getPstate(); - sg_host_load_reset(host); // Only consider the period between two calls to this method! + double load = get_host()->getCoreCount() * sg_host_get_avg_load(get_host()); + int pstate = get_host()->getPstate(); + sg_host_load_reset(get_host()); // Only consider the period between two calls to this method! if (load > freq_up_threshold) { if (pstate != 0) { - host->setPstate(pstate - 1); + get_host()->setPstate(pstate - 1); XBT_INFO("Load: %f > threshold: %f -> increasing performance to pstate %d", load, freq_up_threshold, pstate - 1); } else { XBT_DEBUG("Load: %f > threshold: %f -> but cannot speed up even more, already in highest pstate %d", load, freq_up_threshold, pstate); } } else if (load < freq_down_threshold) { - int max_pstate = host->getPstatesCount() - 1; + int max_pstate = get_host()->getPstatesCount() - 1; if (pstate != max_pstate) { // Are we in the slowest pstate already? - host->setPstate(pstate + 1); + get_host()->setPstate(pstate + 1); XBT_INFO("Load: %f < threshold: %f -> slowing down to pstate %d", load, freq_down_threshold, pstate + 1); } else { @@ -192,20 +187,20 @@ public: /** * Add this to your host tag: - * - + * - \ * * Valid values as of now are: performance, powersave, ondemand, conservative * It doesn't matter if you use uppercase or lowercase. * * For the sampling rate, use this: * - * - + * - \ * * This will run the update() method of the specified governor every 2 seconds * on that host. * - * These properties can also be used within the tag to configure - * these values globally. Using them within the will overwrite this + * These properties can also be used within the \ tag to configure + * these values globally. Using them within the \ will overwrite this * global configuration */ class HostDvfs { @@ -233,45 +228,45 @@ static void on_host_added(simgrid::s4u::Host& host) if (dynamic_cast(&host)) // Ignore virtual machines return; - std::string name = std::string("dvfs-daemon-") + host.getCname(); - simgrid::s4u::ActorPtr daemon = simgrid::s4u::Actor::createActor(name.c_str(), &host, []() { + std::string name = std::string("dvfs-daemon-") + host.get_cname(); + simgrid::s4u::ActorPtr daemon = simgrid::s4u::Actor::create(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(); + simgrid::s4u::ActorPtr daemon_proc = simgrid::s4u::Actor::self(); - XBT_DEBUG("DVFS process on %s is a daemon: %d", daemonProc->getHost()->getName().c_str(), daemonProc->isDaemon()); + XBT_DEBUG("DVFS process on %s is a daemon: %d", daemon_proc->get_host()->get_cname(), daemon_proc->is_daemon()); std::string dvfs_governor; - const char* host_conf = daemonProc->getHost()->getProperty(property_governor); + const char* host_conf = daemon_proc->get_host()->getProperty(property_governor); if (host_conf != nullptr) { - dvfs_governor = std::string(daemonProc->getHost()->getProperty(property_governor)); + dvfs_governor = std::string(daemon_proc->get_host()->getProperty(property_governor)); boost::algorithm::to_lower(dvfs_governor); } else { - dvfs_governor = xbt_cfg_get_string(property_governor); + dvfs_governor = simgrid::config::get_value(property_governor); boost::algorithm::to_lower(dvfs_governor); } - auto governor = [&dvfs_governor, &daemonProc]() { + auto governor = [&dvfs_governor, &daemon_proc]() { if (dvfs_governor == "conservative") { return std::unique_ptr( - new simgrid::plugin::dvfs::Conservative(daemonProc->getHost())); + new simgrid::plugin::dvfs::Conservative(daemon_proc->get_host())); } else if (dvfs_governor == "ondemand") { return std::unique_ptr( - new simgrid::plugin::dvfs::OnDemand(daemonProc->getHost())); + new simgrid::plugin::dvfs::OnDemand(daemon_proc->get_host())); } else if (dvfs_governor == "performance") { return std::unique_ptr( - new simgrid::plugin::dvfs::Performance(daemonProc->getHost())); + new simgrid::plugin::dvfs::Performance(daemon_proc->get_host())); } else if (dvfs_governor == "powersave") { return std::unique_ptr( - new simgrid::plugin::dvfs::Powersave(daemonProc->getHost())); + new simgrid::plugin::dvfs::Powersave(daemon_proc->get_host())); } else { XBT_CRITICAL("No governor specified for host %s, falling back to Performance", - daemonProc->getHost()->getCname()); + daemon_proc->get_host()->get_cname()); return std::unique_ptr( - new simgrid::plugin::dvfs::Performance(daemonProc->getHost())); + new simgrid::plugin::dvfs::Performance(daemon_proc->get_host())); } }(); @@ -308,9 +303,9 @@ void sg_host_dvfs_plugin_init() sg_host_load_plugin_init(); - simgrid::s4u::Host::onCreation.connect(&on_host_added); - xbt_cfg_register_double(property_sampling_rate, 0.1, nullptr, - "How often should the dvfs plugin check whether the frequency needs to be changed?"); - xbt_cfg_register_string(property_governor, "performance", nullptr, - "Which Governor should be used that adapts the CPU frequency?"); + simgrid::s4u::Host::on_creation.connect(&on_host_added); + simgrid::config::declare_flag( + property_sampling_rate, "How often should the dvfs plugin check whether the frequency needs to be changed?", 0.1); + simgrid::config::declare_flag( + property_governor, "Which Governor should be used that adapts the CPU frequency?", "performance"); }