X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8345310cee54ebaf86c3f21cbd6dfc145f2323a7..8f24427366ec39a4c5668eb9fc38acc17df12a2b:/src/plugins/host_dvfs.cpp?ds=sidebyside

diff --git a/src/plugins/host_dvfs.cpp b/src/plugins/host_dvfs.cpp
index b62cc98a93..4ad3fade0d 100644
--- a/src/plugins/host_dvfs.cpp
+++ b/src/plugins/host_dvfs.cpp
@@ -5,7 +5,10 @@
 
 #include "simgrid/plugins/dvfs.h"
 #include "simgrid/plugins/load.h"
+#include "simgrid/s4u/Engine.hpp"
+#include "src/kernel/activity/ExecImpl.hpp"
 #include "src/plugins/vm/VirtualMachineImpl.hpp"
+#include "src/smpi/plugins/ampi/ampi.hpp"
 #include <xbt/config.hpp>
 
 #include <boost/algorithm/string.hpp>
@@ -20,13 +23,14 @@ static simgrid::config::Flag<std::string> cfg_governor("plugin/dvfs/governor",
     "Which Governor should be used that adapts the CPU frequency?", "performance",
 
     std::map<std::string, std::string>({
+        {"adagio", "TODO: Doc"},
         {"conservative", "TODO: Doc"},
         {"ondemand", "TODO: Doc"},
         {"performance", "TODO: Doc"},
         {"powersave", "TODO: Doc"},
     }),
 
-    [](std::string val){if (val != "performance") sg_host_dvfs_plugin_init();});
+    [](std::string val) { if (val != "performance") sg_host_dvfs_plugin_init(); });
 
 /** @addtogroup SURF_plugin_load
 
@@ -40,20 +44,37 @@ namespace simgrid {
 namespace plugin {
 
 namespace dvfs {
+
+/**
+ *  Add this to your host tag:
+ *    - \<prop id="plugin/dvfs/governor" value="performance" /\>
+ *
+ *  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:
+ *
+ *    - \<prop id="plugin/dvfs/sampling-rate" value="2" /\>
+ *
+ *  This will run the update() method of the specified governor every 2 seconds
+ *  on that host.
+ *
+ *  These properties can also be used within the \<config\> tag to configure
+ *  these values globally. Using them within the \<host\> will overwrite this
+ *  global configuration
+ */
 class Governor {
 
 private:
   simgrid::s4u::Host* const host_;
   double sampling_rate_;
 
-protected:
-  simgrid::s4u::Host* get_host() const { return host_; }
-
 public:
 
   explicit Governor(simgrid::s4u::Host* ptr) : host_(ptr) { init(); }
   virtual ~Governor() = default;
-  virtual std::string get_name() = 0;
+  virtual std::string get_name() const = 0;
+  simgrid::s4u::Host* get_host() const { return host_; }
 
   void init()
   {
@@ -67,7 +88,7 @@ public:
   }
 
   virtual void update()         = 0;
-  double get_sampling_rate() { return sampling_rate_; }
+  double get_sampling_rate() const { return sampling_rate_; }
 };
 
 /**
@@ -83,7 +104,7 @@ public:
 class Performance : public Governor {
 public:
   explicit Performance(simgrid::s4u::Host* ptr) : Governor(ptr) {}
-  std::string get_name() override { return "Performance"; }
+  std::string get_name() const override { return "Performance"; }
 
   void update() override { get_host()->set_pstate(0); }
 };
@@ -101,7 +122,7 @@ public:
 class Powersave : public Governor {
 public:
   explicit Powersave(simgrid::s4u::Host* ptr) : Governor(ptr) {}
-  std::string get_name() override { return "Powersave"; }
+  std::string get_name() const override { return "Powersave"; }
 
   void update() override { get_host()->set_pstate(get_host()->get_pstate_count() - 1); }
 };
@@ -124,7 +145,7 @@ class OnDemand : public Governor {
 
 public:
   explicit OnDemand(simgrid::s4u::Host* ptr) : Governor(ptr) {}
-  std::string get_name() override { return "OnDemand"; }
+  std::string get_name() const override { return "OnDemand"; }
 
   void update() override
   {
@@ -151,6 +172,7 @@ public:
       XBT_DEBUG("Load: %f < threshold: %f --> changed to pstate %i", load, freq_up_threshold_, new_pstate);
     }
   }
+
 };
 
 /**
@@ -171,7 +193,7 @@ class Conservative : public Governor {
 
 public:
   explicit Conservative(simgrid::s4u::Host* ptr) : Governor(ptr) {}
-  virtual std::string get_name() override { return "Conservative"; }
+  virtual std::string get_name() const override { return "Conservative"; }
 
   virtual void update() override
   {
@@ -201,24 +223,101 @@ public:
   }
 };
 
-/**
- *  Add this to your host tag:
- *    - \<prop id="plugin/dvfs/governor" value="performance" /\>
- *
- *  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:
- *
- *    - \<prop id="plugin/dvfs/sampling-rate" value="2" /\>
- *
- *  This will run the update() method of the specified governor every 2 seconds
- *  on that host.
- *
- *  These properties can also be used within the \<config\> tag to configure
- *  these values globally. Using them within the \<host\> will overwrite this
- *  global configuration
- */
+class Adagio : public Governor {
+private:
+  int best_pstate     = 0;
+  double start_time   = 0;
+  double comp_counter = 0;
+  double comp_timer   = 0;
+
+  std::vector<std::vector<double>> rates;
+
+  unsigned int task_id   = 0;
+  bool iteration_running = false; /*< Are we currently between iteration_in and iteration_out calls? */
+
+public:
+  explicit Adagio(simgrid::s4u::Host* ptr)
+      : Governor(ptr), rates(100, std::vector<double>(host_->get_pstate_count(), 0.0))
+  {
+    simgrid::smpi::plugin::ampi::on_iteration_in.connect([this](simgrid::s4u::ActorPtr actor) {
+      // Every instance of this class subscribes to this event, so one per host
+      // This means that for any actor, all 'hosts' are normally notified of these
+      // changes, even those who don't currently run the actor 'proc_id'.
+      // -> Let's check if this signal call is for us!
+      if (get_host() == actor->get_host()) {
+        iteration_running = true;
+      }
+    });
+    simgrid::smpi::plugin::ampi::on_iteration_out.connect([this](simgrid::s4u::ActorPtr actor) {
+      if (get_host() == actor->get_host()) {
+        iteration_running = false;
+        task_id           = 0;
+      }
+    });
+    simgrid::kernel::activity::ExecImpl::on_creation.connect([this](simgrid::kernel::activity::ExecImplPtr activity) {
+      if (activity->host_ == get_host())
+        pre_task();
+    });
+    simgrid::kernel::activity::ExecImpl::on_completion.connect([this](simgrid::kernel::activity::ExecImplPtr activity) {
+      // For more than one host (not yet supported), we can access the host via
+      // simcalls_.front()->issuer->iface()->get_host()
+      if (activity->host_ == get_host() && iteration_running) {
+        comp_timer += activity->surf_action_->get_finish_time() - activity->surf_action_->get_start_time();
+      }
+    });
+    simgrid::s4u::Link::on_communicate.connect(
+        [this](kernel::resource::NetworkAction* action, s4u::Host* src, s4u::Host* dst) {
+          if ((get_host() == src || get_host() == dst) && iteration_running) {
+            post_task();
+          }
+        });
+  }
+
+  virtual std::string get_name() const override { return "Adagio"; }
+
+  void pre_task()
+  {
+    sg_host_load_reset(host_);
+    comp_counter = sg_host_get_computed_flops(host_); // Should be 0 because of the reset
+    comp_timer   = 0;
+    start_time   = simgrid::s4u::Engine::get_clock();
+    if (rates.size() <= task_id)
+      rates.resize(task_id + 5, std::vector<double>(host_->get_pstate_count(), 0.0));
+    if (rates[task_id][best_pstate] == 0)
+      best_pstate = 0;
+    host_->set_pstate(best_pstate); // Load our schedule
+    XBT_DEBUG("Set pstate to %i", best_pstate);
+  }
+
+  void post_task()
+  {
+    double computed_flops = sg_host_get_computed_flops(host_) - comp_counter;
+    double target_time    = (simgrid::s4u::Engine::get_clock() - start_time);
+    target_time =
+        target_time *
+        static_cast<double>(99.0 / 100.0); // FIXME We account for t_copy arbitrarily with 1% -- this needs to be fixed
+
+    bool is_initialized         = rates[task_id][best_pstate] != 0;
+    rates[task_id][best_pstate] = computed_flops / comp_timer;
+    if (not is_initialized) {
+      for (int i = 1; i < host_->get_pstate_count(); i++) {
+        rates[task_id][i] = rates[task_id][0] * (host_->get_pstate_speed(i) / host_->get_speed());
+      }
+      is_initialized = true;
+    }
+
+    for (int pstate = host_->get_pstate_count() - 1; pstate >= 0; pstate--) {
+      if (computed_flops / rates[task_id][pstate] <= target_time) {
+        // We just found the pstate we want to use!
+        best_pstate = pstate;
+        break;
+      }
+    }
+    task_id++;
+  }
+
+  virtual void update() override {}
+};
 } // namespace dvfs
 } // namespace plugin
 } // namespace simgrid
@@ -257,6 +356,9 @@ static void on_host_added(simgrid::s4u::Host& host)
       } else if (dvfs_governor == "ondemand") {
         return std::unique_ptr<simgrid::plugin::dvfs::Governor>(
             new simgrid::plugin::dvfs::OnDemand(daemon_proc->get_host()));
+      } else if (dvfs_governor == "adagio") {
+        return std::unique_ptr<simgrid::plugin::dvfs::Governor>(
+            new simgrid::plugin::dvfs::Adagio(daemon_proc->get_host()));
       } else if (dvfs_governor == "performance") {
         return std::unique_ptr<simgrid::plugin::dvfs::Governor>(
             new simgrid::plugin::dvfs::Performance(daemon_proc->get_host()));
@@ -291,10 +393,9 @@ static void on_host_added(simgrid::s4u::Host& host)
 
 /* **************************** Public interface *************************** */
 
-
-/** \ingroup SURF_plugin_load
- * \brief Initializes the HostDvfs plugin
- * \details The HostDvfs plugin provides an API to get the current load of each host.
+/** @ingroup SURF_plugin_load
+ * @brief Initializes the HostDvfs plugin
+ * @details The HostDvfs plugin provides an API to get the current load of each host.
  */
 void sg_host_dvfs_plugin_init()
 {