Controller.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef CONTROLLER_HPP_INCLUDE
#define CONTROLLER_HPP_INCLUDE
 
#include <pthread.h>
 
#include <string>
#include <memory>
#include <vector>
#include <map>
#include <set>
 
namespace geopm
{
    class Comm;
    class PlatformIO;
    class EndpointUser;
    class FilePolicy;
    class ApplicationIO;
    class Reporter;
    class Tracer;
    class EndpointPolicyTracer;
    class TreeComm;
    class Agent;
    class ProfileTracer;
    class ApplicationSampler;
    class InitControl;
 
    class Controller
    {
        public:
            Controller();
            Controller(std::shared_ptr<Comm> ppn1_comm);
            Controller(std::shared_ptr<Comm> comm,
                       PlatformIO &plat_io,
                       const std::string &agent_name,
                       int num_send_down,
                       int num_send_up,
                       std::unique_ptr<TreeComm> tree_comm,
                       ApplicationSampler &application_sampler,
                       std::shared_ptr<ApplicationIO> application_io,
                       std::unique_ptr<Reporter> reporter,
                       std::unique_ptr<Tracer> tracer,
                       std::unique_ptr<EndpointPolicyTracer> policy_tracer,
                       std::shared_ptr<ProfileTracer> profile_tracer,
                       std::vector<std::unique_ptr<Agent> > level_agent,
                       std::vector<std::string> policy_names,
                       const std::string &policy_path,
                       bool do_policy,
                       std::unique_ptr<EndpointUser> endpoint,
                       const std::string &endpoint_path,
                       bool do_endpoint,
                       std::shared_ptr<InitControl> init_control,
                       bool do_init_control);
 
            Controller(const Controller &other) = delete;
            Controller &operator=(const Controller &other) = delete;
            virtual ~Controller();
            void run(void);
            void step(void);
            void walk_down(void);
            void walk_up(void);
            void generate(void);
            void pthread(const pthread_attr_t *attr, pthread_t *thread);
            void setup_trace(void);
            void abort(void);
            std::set<std::string> get_hostnames(const std::string &hostname);
        private:
            void create_agents(void);
            void init_agents(void);
 
            std::shared_ptr<Comm> m_comm;
            PlatformIO &m_platform_io;
            std::string m_agent_name;
            const int m_num_send_down;
            const int m_num_send_up;
            std::unique_ptr<TreeComm> m_tree_comm;
            const int m_num_level_ctl;
            const int m_max_level;
            const int m_root_level;
            ApplicationSampler &m_application_sampler;
            std::shared_ptr<ApplicationIO> m_application_io;
            std::unique_ptr<Reporter> m_reporter;
            std::unique_ptr<Tracer> m_tracer;
            std::unique_ptr<EndpointPolicyTracer> m_policy_tracer;
            std::shared_ptr<ProfileTracer> m_profile_tracer;
            std::vector<std::unique_ptr<Agent> > m_agent;
            const bool m_is_root;
            std::vector<double> m_in_policy;
            std::vector<double> m_last_policy;
            std::vector<std::vector<std::vector<double> > > m_out_policy;
            std::vector<std::vector<std::vector<double> > > m_in_sample;
            std::vector<double> m_out_sample;
            std::vector<double> m_trace_sample;
 
            std::unique_ptr<EndpointUser> m_endpoint;
            bool m_do_endpoint;
            std::unique_ptr<FilePolicy> m_file_policy;
            bool m_do_policy;
 
            std::vector<std::string> m_agent_policy_names;
            std::vector<std::string> m_agent_sample_names;
            std::string m_shm_key;
 
            std::shared_ptr<InitControl> m_init_control;
            bool m_do_init_control;
            bool m_do_restore;
    };
}
#endif