ProfileIOGroup.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef PROFILEIOGROUP_HPP_INCLUDE
#define PROFILEIOGROUP_HPP_INCLUDE
 
#include <set>
#include <string>
#include <functional>
#include <array>
 
#include "geopm/IOGroup.hpp"
 
namespace geopm
{
    class ApplicationSampler;
    class PlatformTopo;
 
    class ProfileIOGroup : public IOGroup
    {
        public:
            ProfileIOGroup();
            ProfileIOGroup(const PlatformTopo &topo, ApplicationSampler &application_sampler);
            virtual ~ProfileIOGroup();
            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 signal_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;
            static std::string plugin_name(void);
            static std::unique_ptr<IOGroup> make_plugin(void);
            void connect(void);
 
        private:
            enum m_signal_type {
                M_SIGNAL_REGION_HASH,
                M_SIGNAL_REGION_HINT,
                M_SIGNAL_THREAD_PROGRESS,
                M_SIGNAL_TIME_HINT_UNSET,
                M_SIGNAL_TIME_HINT_UNKNOWN,
                M_SIGNAL_TIME_HINT_COMPUTE,
                M_SIGNAL_TIME_HINT_MEMORY,
                M_SIGNAL_TIME_HINT_NETWORK,
                M_SIGNAL_TIME_HINT_IO,
                M_SIGNAL_TIME_HINT_SERIAL,
                M_SIGNAL_TIME_HINT_PARALLEL,
                M_SIGNAL_TIME_HINT_IGNORE,
                M_SIGNAL_TIME_HINT_SPIN,
                M_NUM_SIGNAL,
            };
            struct m_signal_config {
                int signal_type;
                int domain_type;
                int domain_idx;
            };
 
            int check_signal(const std::string &signal_name, int domain_type, int domain_idx) const;
            static double hash_to_signal(uint64_t hash);
            static double hint_to_signal(uint64_t hint);
            static uint64_t signal_type_to_hint(int signal_type);
 
            ApplicationSampler &m_application_sampler;
 
            std::map<std::string, int> m_signal_idx_map;
            const PlatformTopo &m_platform_topo;
            const int m_num_cpu;
            std::vector<bool> m_do_read;
            bool m_is_batch_read;
            std::vector<struct m_signal_config> m_active_signal;
            std::array<std::vector<double>, M_NUM_SIGNAL> m_per_cpu_sample;
            std::map<int, int> m_rid_idx;
            bool m_is_pushed;
    };
}
 
#endif