MSRIOGroup.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2025 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef MSRIOGROUP_HPP_INCLUDE
#define MSRIOGROUP_HPP_INCLUDE
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "geopm/json11.hpp"
 
#include "geopm/Cpuid.hpp"
#include "geopm_time.h"
#include "geopm_access.h"
 
#include "geopm/IOGroup.hpp"
 
namespace geopm
{
    class MSRIO;
    class PlatformTopo;
    class PlatformIO;
    class Signal;
    class Control;
    class SaveControl;
 
    class MSRIOGroup : public IOGroup
    {
        public:
            enum m_cpuid_e {
                M_CPUID_SNB = 0x62D,
                M_CPUID_IVT = 0x63E,
                M_CPUID_HSX = 0x63F,
                M_CPUID_BDX = 0x64F,
                M_CPUID_KNL = 0x657,
                M_CPUID_SKX = 0x655,
                M_CPUID_ICX = 0x66A,
                M_CPUID_SPR = 0x68F,
                M_CPUID_EMR = 0x6CF,
                M_CPUID_GNRSP = 0x6AD,
                M_CPUID_GNRAP = 0x6AE,
                M_CPUID_SRF = 0x6AF,
                M_CPUID_CWF = 0x6DD,
                M_CPUID_DMR = 0x1301,
            };
 
            MSRIOGroup() = delete;
            MSRIOGroup(bool use_msr_safe);
            MSRIOGroup(const PlatformTopo &platform_topo,
                       std::shared_ptr<MSRIO> msrio,
                       std::shared_ptr<Cpuid> cpuid,
                       std::shared_ptr<SaveControl> save_control);
            virtual ~MSRIOGroup() = default;
            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 sample_idx) override;
            void adjust(int control_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;
 
            void parse_json_msrs(const std::string &str);
            static std::string msr_allowlist(int cpuid);
            static std::string msr_allowlist(int cpuid,
                                             const PlatformTopo &topo,
                                             std::shared_ptr<MSRIO> msrio);
 
            static int cpuid(void);
            static std::string plugin_name(void);
            static std::unique_ptr<IOGroup> make_plugin(void);
            static std::unique_ptr<IOGroup> make_plugin_safe(void);
        private:
            static void parse_json_msrs_allowlist(const std::string &str,
                                                  std::map<uint64_t, std::pair<uint64_t, std::string> > &allowlist_data,
                                                  const PlatformTopo &topo,
                                                  std::shared_ptr<MSRIO> msrio);
            static std::string format_allowlist(const std::map<uint64_t, std::pair<uint64_t, std::string> > &allowlist_data);
 
            static std::string platform_data(int cpu_id);
 
            enum MsrConfigWarningPreference_e {
                SILENCE_CONFIG_DEPRECATION_WARNING,
                EMIT_CONFIG_DEPRECATION_WARNING,
            };
            static std::set<std::string> msr_data_files(
                    MsrConfigWarningPreference_e warning_preference = SILENCE_CONFIG_DEPRECATION_WARNING);
            void set_signal_description(const std::string &name, const std::string &description);
            void set_control_description(const std::string &name, const std::string &description);
            void register_signal_alias(const std::string &signal_name, const std::string &msr_field_name);
            void register_control_alias(const std::string &control_name, const std::string &msr_field_name);
            void register_temperature_signals(void);
            void register_power_signals(void);
            void register_pcnt_scalability_signals(void);
            void register_rdt_signals(void);
            void register_frequency_signals(void);
            void register_frequency_controls(void);
            void check_control(const std::string &control_name);
 
            void check_control_pwrite(void);
 
            void check_control_lock(const std::string &lock_name, const std::string &error);
 
            static void check_top_level(const json11::Json &root);
            static void check_msr_root(const json11::Json &msr_root,
                                       const std::string &msr_name);
            static void check_msr_field(const json11::Json &msr_field,
                                        const std::string &msr_name,
                                        const std::string &msr_field_name);
            // Used to validate type and value of JSON objects
            static bool json_check_null_func(const json11::Json &obj);
            static bool json_check_is_hex_string(const json11::Json &obj);
            static bool json_check_is_valid_offset(const json11::Json &obj);
            static bool json_check_is_valid_domain(const json11::Json &domain);
            static bool json_check_is_integer(const json11::Json &num);
            static bool json_check_is_valid_aggregation(const json11::Json &obj);
            // Add raw MSR as an available signal
            void add_raw_msr_signal(const std::string &msr_name, int domain_type, uint64_t msr_offset);
            // Add a bitfield of an MSR as an available signal
            void add_msr_field_signal(const std::string &msr_name, const std::string &msr_field_name,
                                      int domain_type, int begin_bit, int end_bit, int function,
                                      double scalar, int units, const std::string &aggregation,
                                      const std::string &description, int behavior,
                                      const std::function<std::string(double)> &format_function);
            // Add a bitfield of an MSR as an available control
            void add_msr_field_control(const std::string &msr_field_name, int domain_type,
                                       uint64_t msr_offset, int begin_bit, int end_bit,
                                       int function, double scalar, int units,
                                       const std::string &description);
 
            static const std::string M_DEFAULT_DESCRIPTION;
            static const std::string M_PLUGIN_NAME;
            static const std::string M_NAME_PREFIX;
            const PlatformTopo &m_platform_topo;
            std::shared_ptr<MSRIO> m_msrio;
            int m_save_restore_ctx;
            std::shared_ptr<Cpuid> m_cpuid;
            bool m_is_active;
            bool m_is_read;
 
            // time for derivative signals
            std::shared_ptr<geopm_time_s> m_time_zero;
            std::shared_ptr<double> m_time_batch;
 
            bool m_is_hwp_enabled;
 
            Cpuid::rdt_info_s m_rdt_info;
 
            uint32_t m_pmc_bit_width;
 
            int m_derivative_window;
            double m_sleep_time;
 
            // All available signals: map from name to signal_info.
            // The signals vector is over the indices for the domain.
            // The signals pointers should be copied when signal is
            // pushed and used directly for read_signal.
            struct signal_info
            {
                std::vector<std::shared_ptr<Signal> > signals;
                int domain;
                int units;
                std::function<double(const std::vector<double> &)> agg_function;
                std::string description;
                int behavior;
                std::function<std::string(double)> format_function;
            };
            std::map<std::string, signal_info> m_signal_available;
 
            struct control_info
            {
                std::vector<std::shared_ptr<Control> > controls;
                int domain;
                int units;
                std::string description;
            };
            std::map<std::string, control_info> m_control_available;
 
            // Mapping of signal index to pushed signals.
            std::vector<std::shared_ptr<Signal> > m_signal_pushed;
            // Mapping of control index to pushed controls
            std::vector<std::shared_ptr<Control> > m_control_pushed;
 
            std::shared_ptr<SaveControl> m_mock_save_ctl;
            // Mapping of control index to enable bit control index
            std::map<int, int> m_power_control_enable_idx;
    };
}
 
#endif