PowerBalancerAgent.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef POWERBALANCERAGENT_HPP_INCLUDE
#define POWERBALANCERAGENT_HPP_INCLUDE
 
#include <vector>
#include <functional>
#include <memory>
 
#include "geopm/Agent.hpp"
 
namespace geopm
{
    class PlatformIO;
    class PlatformTopo;
    class PowerBalancer;
    class PowerGovernor;
    class SampleAggregator;
    class Waiter;
 
    class PowerBalancerAgent : public Agent
    {
        public:
            enum m_policy_e {
                M_POLICY_CPU_POWER_LIMIT,
                M_POLICY_STEP_COUNT,
                M_POLICY_MAX_EPOCH_RUNTIME,
                M_POLICY_POWER_SLACK,
                M_NUM_POLICY,
            };
 
            enum m_sample_e {
                M_SAMPLE_STEP_COUNT,
                M_SAMPLE_MAX_EPOCH_RUNTIME,
                M_SAMPLE_SUM_POWER_SLACK,
                M_SAMPLE_MIN_POWER_HEADROOM,
                M_NUM_SAMPLE,
            };
 
            enum m_trace_sample_e {
                M_TRACE_SAMPLE_POLICY_CPU_POWER_LIMIT,
                M_TRACE_SAMPLE_POLICY_STEP_COUNT,
                M_TRACE_SAMPLE_POLICY_MAX_EPOCH_RUNTIME,
                M_TRACE_SAMPLE_POLICY_POWER_SLACK,
                M_TRACE_SAMPLE_ENFORCED_POWER_LIMIT,
                M_TRACE_NUM_SAMPLE,
            };
 
            enum m_step_e {
                M_STEP_SEND_DOWN_LIMIT = 0L,
                M_STEP_MEASURE_RUNTIME,
                M_STEP_REDUCE_LIMIT,
                M_NUM_STEP,
            };
 
            PowerBalancerAgent(PlatformIO &platform_io,
                               const PlatformTopo &platform_topo,
                               std::shared_ptr<SampleAggregator> sample_agg,
                               std::vector<std::shared_ptr<PowerBalancer> > power_balancer,
                               double min_power,
                               double max_power,
                               std::shared_ptr<Waiter> waiter);
            PowerBalancerAgent();
            virtual ~PowerBalancerAgent() = default;
            void init(int level, const std::vector<int> &fan_in, bool is_level_root) override;
            void validate_policy(std::vector<double> &policy) const override;
            void split_policy(const std::vector<double> &in_policy,
                              std::vector<std::vector<double> > &out_policy) override;
            bool do_send_policy(void) const override;
            void aggregate_sample(const std::vector<std::vector<double> > &in_sample,
                                  std::vector<double> &out_sample) override;
            bool do_send_sample(void) const override;
            void adjust_platform(const std::vector<double> &in_policy) override;
            bool do_write_batch(void) const override;
            void sample_platform(std::vector<double> &out_sample) override;
            void wait(void) override;
            std::vector<std::pair<std::string, std::string> > report_header(void) const override;
            std::vector<std::pair<std::string, std::string> > report_host(void) const override;
            std::map<uint64_t, std::vector<std::pair<std::string, std::string> > > report_region(void) const override;
            std::vector<std::string> trace_names(void) const override;
            std::vector<std::function<std::string(double)> > trace_formats(void) const override;
            void trace_values(std::vector<double> &values) override;
            void enforce_policy(const std::vector<double> &policy) const override;
 
            static std::string plugin_name(void);
            static std::unique_ptr<Agent> make_plugin(void);
            static std::vector<std::string> policy_names(void);
            static std::vector<std::string> sample_names(void);
            static std::string format_step_count(double step);
        protected:
            class Step;
            class Role {
                public:
                    virtual bool descend(const std::vector<double> &in_policy,
                                         std::vector<std::vector<double> >&out_policy);
                    virtual bool ascend(const std::vector<std::vector<double> > &in_sample,
                                        std::vector<double> &out_sample);
                    virtual bool adjust_platform(const std::vector<double> &in_policy);
                    virtual bool sample_platform(std::vector<double> &out_sample);
                    virtual void trace_values(std::vector<double> &values);
                protected:
                    int step(size_t step_count) const;
                    int step(void) const;
                    const Step& step_imp();
                    Role(int num_node);
                    virtual ~Role() = default;
                    const std::vector<std::shared_ptr<const Step> > M_STEP_IMP;
                public:
                    std::vector<double> m_policy;
                protected:
                    int m_step_count;
                public:
                    const int M_NUM_NODE;
            };
 
            PlatformIO &m_platform_io;
            const PlatformTopo &m_platform_topo;
            std::shared_ptr<SampleAggregator> m_sample_agg;
            std::shared_ptr<Role> m_role;
            std::vector<std::shared_ptr<PowerBalancer> > m_power_balancer;
            static constexpr double M_WAIT_SEC = 0.005;
            double m_power_tdp;
            bool m_do_send_sample;
            bool m_do_send_policy;
            bool m_do_write_batch;
            const double M_MIN_PKG_POWER_SETTING;
            const double M_MAX_PKG_POWER_SETTING;
            const double M_TIME_WINDOW;
            std::shared_ptr<Waiter> m_waiter;
 
            class RootRole;
            class LeafRole;
            class TreeRole;
 
            class Step {
                public:
                    Step() = default;
                    virtual ~Step() = default;
                    virtual void update_policy(Role &role, const std::vector<double> &sample) const = 0;
                    virtual void enter_step(LeafRole &role, const std::vector<double> &in_policy) const = 0;
                    virtual void sample_platform(LeafRole &role) const = 0;
            };
 
            class SendDownLimitStep : public Step {
                public:
                    SendDownLimitStep() = default;
                   ~SendDownLimitStep() = default;
                   void update_policy(PowerBalancerAgent::Role &role, const std::vector<double> &sample) const;
                   void enter_step(PowerBalancerAgent::LeafRole &role, const std::vector<double> &in_policy) const;
                   void sample_platform(PowerBalancerAgent::LeafRole &role) const;
            };
 
            class MeasureRuntimeStep : public Step {
                public:
                    MeasureRuntimeStep() = default;
                    ~MeasureRuntimeStep() = default;
                    void update_policy(PowerBalancerAgent::Role &role, const std::vector<double> &sample) const;
                    void enter_step(PowerBalancerAgent::LeafRole &role, const std::vector<double> &in_policy) const;
                    void sample_platform(PowerBalancerAgent::LeafRole &role) const;
            };
 
            class ReduceLimitStep : public Step {
                public:
                    ReduceLimitStep() = default;
                    ~ReduceLimitStep() = default;
                    void update_policy(PowerBalancerAgent::Role &role, const std::vector<double> &sample) const;
                    void enter_step(PowerBalancerAgent::LeafRole &role, const std::vector<double> &in_policy) const;
                    void sample_platform(PowerBalancerAgent::LeafRole &role) const;
            };
 
            class TreeRole : public Role {
                friend class SendDownLimitStep;
                friend class MeasureRuntimeStep;
                friend class ReduceLimitStep;
                public:
                    TreeRole(int level, const std::vector<int> &fan_in);
                    virtual ~TreeRole() = default;
                    virtual bool descend(const std::vector<double> &in_policy,
                                         std::vector<std::vector<double> >&out_policy) override;
                    virtual bool ascend(const std::vector<std::vector<double> > &in_sample,
                                        std::vector<double> &out_sample) override;
                protected:
                    const std::vector<std::function<double(const std::vector<double>&)> > M_AGG_FUNC;
                    const int M_NUM_CHILDREN;
                    bool m_is_step_complete;
            };
 
            class RootRole : public TreeRole {
                friend class SendDownLimitStep;
                friend class MeasureRuntimeStep;
                friend class ReduceLimitStep;
                public:
                    RootRole(int level, const std::vector<int> &fan_in, double min_power, double max_power);
                    virtual ~RootRole() = default;
                    bool descend(const std::vector<double> &in_policy,
                                 std::vector<std::vector<double> >&out_policy) override;
                    bool ascend(const std::vector<std::vector<double> > &in_sample,
                                std::vector<double> &out_sample) override;
                private:
                    double m_root_cap;
                    const double M_MIN_PKG_POWER_SETTING;
                    const double M_MAX_PKG_POWER_SETTING;
            };
 
            class LeafRole : public Role {
                friend class SendDownLimitStep;
                friend class MeasureRuntimeStep;
                friend class ReduceLimitStep;
                public:
                    LeafRole(PlatformIO &platform_io,
                             const PlatformTopo &platform_topo,
                             std::shared_ptr<SampleAggregator> sample_agg,
                             std::vector<std::shared_ptr<PowerBalancer> > power_balancer,
                             double min_power,
                             double max_power,
                             double time_window,
                             bool is_single_node,
                             int num_node);
                    virtual ~LeafRole() = default;
                    bool adjust_platform(const std::vector<double> &in_policy) override;
                    bool sample_platform(std::vector<double> &out_sample) override;
                    void trace_values(std::vector<double> &values) override;
                private:
                    void init_platform_io(void);
                    void are_steps_complete(bool is_complete);
                    bool are_steps_complete(void);
                    PlatformIO &m_platform_io;
                    const PlatformTopo &m_platform_topo;
                    std::shared_ptr<SampleAggregator> m_sample_agg;
                    int m_num_domain;
                    std::vector<int> m_count_pio_idx;
                    std::vector<int> m_time_agg_idx;
                    std::vector<int> m_network_agg_idx;
                    std::vector<int> m_ignore_agg_idx;
                    std::vector<std::shared_ptr<PowerBalancer> > m_power_balancer;
                    const double M_STABILITY_FACTOR;
                    struct m_package_s {
                        int last_epoch_count;
                        double runtime;
                        double actual_limit;
                        double power_slack;
                        double power_headroom;
                        bool is_out_of_bounds;
                        bool is_step_complete;
                        int pio_power_idx;
                    };
                    std::vector<m_package_s> m_package;
                    const double M_MIN_PKG_POWER_SETTING;
                    const double M_MAX_PKG_POWER_SETTING;
                    bool m_is_single_node;
                    bool m_is_first_policy;
            };
    };
}
 
#endif