Agent.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2025 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef AGENT_HPP_INCLUDE
#define AGENT_HPP_INCLUDE
 
#include <functional>
#include <map>
#include <string>
#include <vector>
#include <cstdint>
 
#include "geopm/PluginFactory.hpp"
#include "geopm_public.h"
 
namespace geopm
{
    class GEOPM_PUBLIC Agent
    {
        public:
            Agent() = default;
            virtual ~Agent() = default;
            static std::vector<std::string> agent_names(void);
            static std::unique_ptr<Agent> make_unique(const std::string &agent_name);
            virtual void init(int level, const std::vector<int> &fan_in, bool is_level_root) = 0;
            virtual void validate_policy(std::vector<double> &policy) const = 0;
            virtual void split_policy(const std::vector<double> &in_policy,
                                      std::vector<std::vector<double> > &out_policy) = 0;
            virtual bool do_send_policy(void) const = 0;
            virtual void aggregate_sample(const std::vector<std::vector<double> > &in_sample,
                                          std::vector<double> &out_sample) = 0;
            virtual bool do_send_sample(void) const = 0;
            virtual void adjust_platform(const std::vector<double> &in_policy) = 0;
            virtual bool do_write_batch(void) const = 0;
            virtual void sample_platform(std::vector<double> &out_sample) = 0;
            virtual void wait(void) = 0;
            virtual std::vector<std::pair<std::string, std::string> > report_header(void) const = 0;
            virtual std::vector<std::pair<std::string, std::string> > report_host(void) const = 0;
            virtual std::map<uint64_t, std::vector<std::pair<std::string, std::string> > > report_region(void) const = 0;
            virtual std::vector<std::string> trace_names(void) const = 0;
            virtual std::vector<std::function<std::string(double)> > trace_formats(void) const;
            virtual void trace_values(std::vector<double> &values) = 0;
            virtual void enforce_policy(const std::vector<double> &policy) const = 0;
            static int num_policy(const std::map<std::string, std::string> &dictionary);
            static int num_policy(const std::string &agent_name);
            static int num_sample(const std::map<std::string, std::string> &dictionary);
            static int num_sample(const std::string &agent_name);
            static std::vector<std::string> policy_names(const std::map<std::string, std::string> &dictionary);
            static std::vector<std::string> policy_names(const std::string &agent_name);
            static std::vector<std::string> sample_names(const std::map<std::string, std::string> &dictionary);
            static std::vector<std::string> sample_names(const std::string &agent_name);
            static std::map<std::string, std::string> make_dictionary(const std::vector<std::string> &policy_names,
                                                                      const std::vector<std::string> &sample_names);
            static void aggregate_sample(const std::vector<std::vector<double> > &in_sample,
                                         const std::vector<std::function<double(const std::vector<double>&)> > &agg_func,
                                         std::vector<double> &out_sample);
            static const std::string M_PLUGIN_PREFIX;
        private:
            static const std::string m_num_sample_string;
            static const std::string m_num_policy_string;
            static const std::string m_sample_prefix;
            static const std::string m_policy_prefix;
    };
 
    class GEOPM_PUBLIC AgentFactory : public PluginFactory<Agent>
    {
        public:
            AgentFactory();
            virtual ~AgentFactory() = default;
    };
 
    AgentFactory GEOPM_PUBLIC &
        agent_factory(void);
}
 
#endif