ServiceProxy.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef SERVICEPROXY_HPP_INCLUDE
#define SERVICEPROXY_HPP_INCLUDE
 
#include <memory>
#include <string>
#include <vector>
 
#include "geopm_public.h"
 
struct geopm_request_s;
 
namespace geopm
{
    class SDBus;
    class SDBusMessage;
 
    struct GEOPM_PUBLIC signal_info_s {
        std::string name;
        std::string description;
        int domain;
        int aggregation;
        int string_format;
        int behavior;
    };
 
    struct GEOPM_PUBLIC control_info_s {
        std::string name;
        std::string description;
        int domain;
    };
 
    class GEOPM_PUBLIC ServiceProxy
    {
        public:
            ServiceProxy() = default;
            virtual ~ServiceProxy() = default;
            static std::unique_ptr<ServiceProxy> make_unique(void);
            virtual void platform_get_user_access(
                std::vector<std::string> &signal_names,
                std::vector<std::string> &control_names) = 0;
            virtual std::vector<signal_info_s> platform_get_signal_info(
                const std::vector<std::string> &signal_names) = 0;
            virtual std::vector<control_info_s> platform_get_control_info(
                const std::vector<std::string> &control_names) = 0;
            virtual void platform_open_session(void) = 0;
            virtual void platform_close_session(void) = 0;
            virtual void platform_start_batch(
                const std::vector<struct geopm_request_s> &signal_config,
                const std::vector<struct geopm_request_s> &control_config,
                int &server_pid,
                std::string &server_key) = 0;
            virtual void platform_stop_batch(int server_pid) = 0;
            virtual double platform_read_signal(const std::string &signal_name,
                                                int domain,
                                                int domain_idx) = 0;
            virtual void platform_write_control(const std::string &control_name,
                                                int domain,
                                                int domain_idx,
                                                double setting) = 0;
            virtual void platform_restore_control(void) = 0;
            virtual std::string topo_get_cache(void) = 0;
            virtual void platform_start_profile(const std::string &profile_name) = 0;
            virtual void platform_stop_profile(const std::vector<std::string> &region_names) = 0;
            virtual std::vector<int> platform_get_profile_pids(const std::string &profile_name) = 0;
            virtual std::vector<std::string> platform_pop_profile_region_names(const std::string &profile_name) = 0;
    };
 
    class GEOPM_PUBLIC ServiceProxyImp : public ServiceProxy
    {
        public:
            ServiceProxyImp();
            ServiceProxyImp(std::shared_ptr<SDBus> bus);
            virtual ~ServiceProxyImp() = default;
            void platform_get_user_access(std::vector<std::string> &signal_names,
                                          std::vector<std::string> &control_names) override;
            std::vector<signal_info_s> platform_get_signal_info(const std::vector<std::string> &signal_names) override;
            std::vector<control_info_s> platform_get_control_info(const std::vector<std::string> &control_names) override;
            void platform_open_session(void) override;
            void platform_close_session(void) override;
            void platform_start_batch(const std::vector<struct geopm_request_s> &signal_config,
                                      const std::vector<struct geopm_request_s> &control_config,
                                      int &server_pid,
                                      std::string &server_key) override;
            void platform_stop_batch(int server_pid) override;
            double platform_read_signal(const std::string &signal_name,
                                        int domain,
                                        int domain_idx) override;
            void platform_write_control(const std::string &control_name,
                                        int domain,
                                        int domain_idx,
                                        double setting) override;
            void platform_restore_control() override;
            std::string topo_get_cache(void) override;
            void platform_start_profile(const std::string &profile_name) override;
            void platform_stop_profile(const std::vector<std::string> &region_names) override;
            std::vector<int> platform_get_profile_pids(const std::string &profile_name) override;
            std::vector<std::string> platform_pop_profile_region_names(const std::string &profile_name) override;
        private:
            std::vector<std::string> GEOPM_PRIVATE
                read_string_array(std::shared_ptr<SDBusMessage> bus_message);
            std::shared_ptr<SDBus> m_bus;
    };
}
 
#endif