IOGroup.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef IOGROUP_HPP_INCLUDE
#define IOGROUP_HPP_INCLUDE
 
#include <functional>
#include <set>
#include <string>
#include <vector>
 
#include "geopm_public.h"
 
#include "PluginFactory.hpp"
 
namespace geopm
{
    class GEOPM_PUBLIC IOGroup
    {
        public:
            enum m_units_e {
                M_UNITS_NONE,
                M_UNITS_SECONDS,
                M_UNITS_HERTZ,
                M_UNITS_WATTS,
                M_UNITS_JOULES,
                M_UNITS_CELSIUS,
                M_UNITS_AMPERES,
                M_UNITS_VOLTS,
                M_NUM_UNITS
            };
 
            enum m_signal_behavior_e {
                M_SIGNAL_BEHAVIOR_CONSTANT,
                M_SIGNAL_BEHAVIOR_MONOTONE,
                M_SIGNAL_BEHAVIOR_VARIABLE,
                M_SIGNAL_BEHAVIOR_LABEL,
                M_NUM_SIGNAL_BEHAVIOR
            };
 
            IOGroup() = default;
            virtual ~IOGroup() = default;
            static std::vector<std::string> iogroup_names(void);
            static std::unique_ptr<IOGroup> make_unique(const std::string &iogroup_name);
            virtual std::set<std::string> signal_names(void) const = 0;
            virtual std::set<std::string> control_names(void) const = 0;
            virtual bool is_valid_signal(const std::string &signal_name) const = 0;
            virtual bool is_valid_control(const std::string &control_name) const = 0;
            virtual int signal_domain_type(const std::string &signal_name) const = 0;
            virtual int control_domain_type(const std::string &control_name) const = 0;
            virtual int push_signal(const std::string &signal_name,
                                    int domain_type,
                                    int domain_idx) = 0;
            virtual int push_control(const std::string &control_name,
                                     int domain_type,
                                     int domain_idx) = 0;
            virtual void read_batch(void) = 0;
            virtual void write_batch(void) = 0;
            virtual double sample(int sample_idx) = 0;
            virtual void adjust(int control_idx,
                                double setting) = 0;
            virtual double read_signal(const std::string &signal_name,
                                       int domain_type,
                                       int domain_idx) = 0;
            virtual void write_control(const std::string &control_name,
                                       int domain_type,
                                       int domain_idx,
                                       double setting) = 0;
            virtual void save_control(void) = 0;
            virtual void restore_control(void) = 0;
            virtual std::function<double(const std::vector<double> &)> agg_function(const std::string &signal_name) const = 0;
            virtual std::function<std::string(double)> format_function(const std::string &signal_name) const;
            virtual std::string signal_description(const std::string &signal_name) const = 0;
            virtual std::string control_description(const std::string &control_name) const = 0;
            virtual int signal_behavior(const std::string &signal_name) const = 0;
            virtual void save_control(const std::string &save_path) = 0;
            virtual void restore_control(const std::string &save_path) = 0;
            virtual std::string name(void) const = 0;
 
            static m_units_e string_to_units(const std::string &str);
            static std::string units_to_string(int);
            static m_signal_behavior_e string_to_behavior(const std::string &str);
 
            static const std::string M_PLUGIN_PREFIX;
 
        private:
            static const std::string M_UNITS[];
            static const std::string M_BEHAVIORS[];
            static const std::map<std::string, m_units_e> M_UNITS_STRING;
            static const std::map<std::string, m_signal_behavior_e> M_BEHAVIOR_STRING;
    };
 
    class GEOPM_PUBLIC IOGroupFactory : public PluginFactory<IOGroup>
    {
        public:
            IOGroupFactory();
            virtual ~IOGroupFactory() = default;
    };
 
    IOGroupFactory GEOPM_PUBLIC &
        iogroup_factory(void);
}
 
#endif