code: new energy example: sequencer+dvfs toggle

meson.build

@@ -66,6 +66,8 @@ src = [
     'src/algo/rejecter.hpp',
     'src/algo/sequencer.cpp',
     'src/algo/sequencer.hpp',
+    'src/algo/sequencer_dvfs.cpp',
+    'src/algo/sequencer_dvfs.hpp',
     'src/algo/sleeper.cpp',
     'src/algo/sleeper.hpp',
     'src/algo/submitter.cpp',

src/algo/sequencer_dvfs.cpp

+#include "sequencer_dvfs.hpp"
+
+#include <loguru.hpp>
+
+#include "../pempek_assert.hpp"
+
+SequencerDVFS::SequencerDVFS(Workload *workload,
+                   SchedulingDecision *decision,
+                   Queue *queue,
+                   ResourceSelector *selector,
+                   double rjms_delay,
+                   rapidjson::Document *variant_options) :
+    ISchedulingAlgorithm(workload, decision, queue, selector, rjms_delay, variant_options)
+{
+    PPK_ASSERT_ERROR(variant_options->HasMember("monitoring_period"), "invalid options: 'monitoring_period' is missing");
+    PPK_ASSERT_ERROR((*variant_options)["monitoring_period"].IsNumber(), "invalid options: 'monitoring_period' is not a number");
+    _monitoring_period = (*variant_options)["monitoring_period"].GetDouble();
+    PPK_ASSERT_ERROR(_monitoring_period > 0, "invalid options: 'monitoring period' should be strictly positive but got %g", _monitoring_period);
+
+    PPK_ASSERT_ERROR(variant_options->HasMember("pstate_compute_fast"), "invalid options: 'pstate_compute_fast' is missing");
+    PPK_ASSERT_ERROR((*variant_options)["pstate_compute_fast"].IsNumber(), "invalid options: 'pstate_compute_fast' is not a number");
+    _pstate_compute_fast = (*variant_options)["pstate_compute_fast"].GetInt();
+    PPK_ASSERT_ERROR(_pstate_compute_fast >= 0, "invalid options: 'pstate_compute_fast period' should be positive but got %d", _pstate_compute_fast);
+
+    PPK_ASSERT_ERROR(variant_options->HasMember("pstate_compute_slow"), "invalid options: 'pstate_compute_slow' is missing");
+    PPK_ASSERT_ERROR((*variant_options)["pstate_compute_slow"].IsNumber(), "invalid options: 'pstate_compute_slow' is not a number");
+    _pstate_compute_slow = (*variant_options)["pstate_compute_slow"].GetInt();
+    PPK_ASSERT_ERROR(_pstate_compute_slow >= 0, "invalid options: 'pstate_compute_slow period' should be positive but got %d", _pstate_compute_slow);
+
+    PPK_ASSERT_ERROR(_pstate_compute_fast != _pstate_compute_slow, "invalid options: 'pstate_compute_fast' and 'pstate_compute_slow' should be different but both have value %d", _pstate_compute_fast);
+
+    LOG_SCOPE_FUNCTION(INFO);
+    LOG_F(INFO, "monitoring_period: %g", _monitoring_period);
+    LOG_F(INFO, "pstate_compute_fast: %d", _pstate_compute_fast);
+    LOG_F(INFO, "pstate_compute_slow: %d", _pstate_compute_slow);
+}
+
+SequencerDVFS::~SequencerDVFS()
+{
+
+}
+
+void SequencerDVFS::on_simulation_start(double date, const rapidjson::Value &batsim_config)
+{
+    (void) date;
+    (void) batsim_config;
+
+    _machines.insert(IntervalSet::ClosedInterval(0, _nb_machines - 1));
+    PPK_ASSERT_ERROR(_machines.size() == (unsigned int) _nb_machines);
+
+    // Request the initial future call. Future ones will be requested in the on_requested_call function.
+    _decision->add_call_me_later(date + _monitoring_period, date);
+}
+
+void SequencerDVFS::on_simulation_end(double date)
+{
+}
+
+void SequencerDVFS::on_requested_call(double date)
+{
+    LOG_SCOPE_FUNCTION(INFO);
+    LOG_F(INFO, "requested call received!");
+
+    // Request a future call at current date + period (unless simulation is about to finish)
+    if (!_no_more_static_job_to_submit_received || _is_job_running)
+    {
+        _decision->add_call_me_later(date + _monitoring_period, date);
+    }
+
+    // Toggle DVFS state of allocated machines if a job is being run
+    if (_is_job_running)
+    {
+        int new_pstate = _currently_fast ? _pstate_compute_slow : _pstate_compute_fast;
+        _decision->add_set_resource_state(_allocated_machines, new_pstate, date);
+    }
+}
+
+void SequencerDVFS::make_decisions(double date,
+                              SortableJobOrder::UpdateInformation *update_info,
+                              SortableJobOrder::CompareInformation *compare_info)
+{
+    // This algorithm executes all the jobs, one after the other.
+    // At any time, either 0 or 1 job is running on the platform.
+    // The order of the sequence depends on the queue order.
+
+    // Up to one job finished since last call.
+    PPK_ASSERT_ERROR(_jobs_ended_recently.size() <= 1);
+    if (!_jobs_ended_recently.empty())
+    {
+        PPK_ASSERT_ERROR(_is_job_running);
+        _is_job_running = false;
+    }
+
+    // Add valid jobs into the queue
+    for (const std::string & job_id : _jobs_released_recently)
+    {
+        const Job * job = (*_workload)[job_id];
+
+        if (job->nb_requested_resources <= _nb_machines)
+            _queue->append_job(job, update_info);
+        else
+            _decision->add_reject_job(job->id, date);
+    }
+
+    // Sort queue if needed
+    _queue->sort_queue(update_info, compare_info);
+
+    // Execute the first job if the machine is empty
+    const Job * job = _queue->first_job_or_nullptr();
+    if (job != nullptr && !_is_job_running)
+    {
+        _allocated_machines = _machines.left(job->nb_requested_resources);
+        _decision->add_execute_job(job->id, _allocated_machines, date);
+        _is_job_running = true;
+        _queue->remove_job(job);
+    }
+}

src/algo/sequencer_dvfs.hpp

+#pragma once
+
+#include "../isalgorithm.hpp"
+
+#include "../locality.hpp"
+#include <intervalset.hpp>
+
+class Workload;
+class SchedulingDecision;
+
+class SequencerDVFS : public ISchedulingAlgorithm
+{
+public:
+    SequencerDVFS(Workload * workload, SchedulingDecision * decision, Queue * queue, ResourceSelector * selector,
+             double rjms_delay, rapidjson::Document * variant_options);
+
+    virtual ~SequencerDVFS();
+
+    virtual void on_simulation_start(double date, const rapidjson::Value & batsim_config);
+
+    virtual void on_simulation_end(double date);
+
+    virtual void on_requested_call(double date);
+
+    virtual void make_decisions(double date,
+                                SortableJobOrder::UpdateInformation * update_info,
+                                SortableJobOrder::CompareInformation * compare_info);
+
+private:
+    IntervalSet _machines;
+    IntervalSet _allocated_machines;
+    bool _is_job_running = false;
+    double _monitoring_period = -1;
+
+    int _pstate_compute_fast = -1;
+    int _pstate_compute_slow = -1;
+    bool _currently_fast = true;
+};

src/main.cpp

@@ -40,6 +40,7 @@
 #include "algo/rejecter.hpp"
 #include "algo/sleeper.hpp"
 #include "algo/sequencer.hpp"
+#include "algo/sequencer_dvfs.hpp"
 #include "algo/submitter.hpp"
 #include "algo/wt_estimator.hpp"
 
@@ -80,7 +81,7 @@ int main(int argc, char ** argv)
                                       "energy_bf_monitoring_inertial", "energy_bf_subpart_sleeper",
                                       "energy_watcher", "fcfs", "fcfs_fast",
                                       "filler", "killer", "killer2", "random", "rejecter",
-                                      "sequencer", "sleeper", "submitter", "waiting_time_estimator"};
+                                      "sequencer", "sequencer_dvfs", "sleeper", "submitter", "waiting_time_estimator"};
     const set<string> policies_set = {"basic", "contiguous"};
     const set<string> queue_orders_set = {"fcfs", "lcfs", "desc_bounded_slowdown", "desc_slowdown",
                                           "asc_size", "desc_size", "asc_walltime", "desc_walltime"};
@@ -298,6 +299,8 @@ int main(int argc, char ** argv)
             algo = new Rejecter(&w, &decision, queue, selector, rjms_delay, &json_doc_variant_options);
         else if (scheduling_variant == "sequencer")
             algo = new Sequencer(&w, &decision, queue, selector, rjms_delay, &json_doc_variant_options);
+        else if (scheduling_variant == "sequencer_dvfs")
+            algo = new SequencerDVFS(&w, &decision, queue, selector, rjms_delay, &json_doc_variant_options);
         else if (scheduling_variant == "sleeper")
             algo = new Sleeper(&w, &decision, queue, selector, rjms_delay, &json_doc_variant_options);
         else if (scheduling_variant == "submitter")