ConstConfigIOGroup.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef CONSTCONFIGIOGROUP_HPP_INCLUDE
#define CONSTCONFIGIOGROUP_HPP_INCLUDE
 
#include <map>
#include <string>
#include <memory>
 
#include "geopm/json11.hpp"
 
#include "geopm/IOGroup.hpp"
 
namespace geopm
{
    class PlatformTopo;
 
    class ConstConfigIOGroup : public IOGroup
    {
        public:
            ConstConfigIOGroup();
            ConstConfigIOGroup(const PlatformTopo& topo,
                               const std::string &user_file_path,
                               const std::string &default_file_path,
                               const std::string &hostname);
            std::set<std::string> signal_names(void) const override;
            std::set<std::string> control_names(void) const override;
            bool is_valid_signal(const std::string &signal_name) const override;
            bool is_valid_control(const std::string &control_name) const override;
            int signal_domain_type(const std::string &signal_name) const override;
            int control_domain_type(const std::string &control_name) const override;
            int push_signal(const std::string &signal_name, int domain_type, int domain_idx) override;
            int push_control(const std::string &control_name, int domain_type, int domain_idx) override;
            void read_batch(void) override;
            void write_batch(void) override;
            double sample(int batch_idx) override;
            void adjust(int batch_idx, double setting) override;
            double read_signal(const std::string &signal_name, int domain_type, int domain_idx) override;
            void write_control(const std::string &control_name, int domain_type, int domain_idx, double setting) override;
            void save_control(void) override;
            void restore_control(void) override;
            std::function<double(const std::vector<double> &)> agg_function(const std::string &signal_name) const override;
            std::function<std::string(double)> format_function(const std::string &signal_name) const override;
            std::string signal_description(const std::string &signal_name) const override;
            std::string control_description(const std::string &control_name) const override;
            int signal_behavior(const std::string &signal_name) const override;
            void save_control(const std::string &save_path) override;
            void restore_control(const std::string &save_path) override;
            std::string name(void) const override;
            static std::string plugin_name(void);
            static std::unique_ptr<IOGroup> make_plugin(void);
 
        private:
            struct m_signal_desc_s {
                json11::Json::Type type;
                bool required;
            };
 
            struct m_signal_info_s {
                int units;
                int domain;
                std::function<double(const std::vector<double> &)> agg_function;
                std::string description;
                bool is_common_value_provided;
                std::vector<double> values;
            };
 
            struct m_signal_ref_s {
                std::shared_ptr<m_signal_info_s> signal_info;
                int domain_idx;
            };
 
            void parse_config_json(const std::string &config);
            static json11::Json construct_config_json_obj(const std::string &config);
            static void check_json_signal(const json11::Json::object::value_type &signal);
 
            static const std::string M_PLUGIN_NAME;
            static const std::string M_SIGNAL_PREFIX;
            static const std::map<std::string, m_signal_desc_s> M_SIGNAL_FIELDS;
            static const std::string M_CONFIG_PATH_ENV;
            static const std::string M_DEFAULT_CONFIG_FILE_PATH;
 
            const PlatformTopo &m_platform_topo;
            const std::string M_THIS_HOST;
            std::map<std::string, std::shared_ptr<m_signal_info_s> > m_signal_available;
            std::vector<m_signal_ref_s> m_pushed_signals;
    };
}
 
#endif