BatchServer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef BATCHSERVER_HPP_INCLUDE
#define BATCHSERVER_HPP_INCLUDE
 
#include <memory>
#include <vector>
#include <string>
#include <functional>
#include <signal.h>
 
 
struct geopm_request_s;
 
namespace geopm
{
    class PlatformIO;
    class SharedMemory;
    class BatchStatus;
    class POSIXSignal;
 
    class BatchServer
    {
        public:
            BatchServer() = default;
            virtual ~BatchServer() = default;
            static std::unique_ptr<BatchServer> make_unique(int client_pid,
                                                            const std::vector<geopm_request_s> &signal_config,
                                                            const std::vector<geopm_request_s> &control_config);
            static std::string get_signal_shmem_key(
                const std::string &server_key);
            static std::string get_control_shmem_key(
                const std::string &server_key);
            virtual int server_pid(void) const = 0;
            virtual std::string server_key(void) const = 0;
            virtual void stop_batch(void) = 0;
            virtual bool is_active(void) = 0;
 
        protected:
            static constexpr const char* M_SHMEM_PREFIX =
                "/run/geopm/batch-buffer-";
    };
 
    class BatchServerImp : public BatchServer
    {
        public:
            BatchServerImp(int client_pid,
                           const std::vector<geopm_request_s> &signal_config,
                           const std::vector<geopm_request_s> &control_config);
            BatchServerImp(int client_pid,
                           const std::vector<geopm_request_s> &signal_config,
                           const std::vector<geopm_request_s> &control_config,
                           const std::string &signal_shmem_key,
                           const std::string &control_shmem_key,
                           PlatformIO &pio,
                           std::shared_ptr<BatchStatus> batch_status,
                           std::shared_ptr<POSIXSignal> posix_signal,
                           std::shared_ptr<SharedMemory> signal_shmem,
                           std::shared_ptr<SharedMemory> control_shmem,
                           int server_pid);
            BatchServerImp(const BatchServerImp &other) = delete;
            BatchServerImp &operator=(const BatchServerImp &other) = delete;
            virtual ~BatchServerImp();
            int server_pid(void) const override;
            std::string server_key(void) const override;
            void stop_batch(void) override;
            bool is_active(void) override;
            void run_batch(void);
            void create_shmem(void);
            int fork_with_setup(std::function<char(void)> setup,
                                std::function<void(void)> run);
            void child_register_handler(void);
            void parent_register_handler(void);
 
        private:
            void push_requests(void);
            void read_and_update(void);
            void update_and_write(void);
            void check_invalid_signal(void);
            void check_return(int ret, const std::string &func_name) const;
            char read_message(void);
            void write_message(char message);
            void event_loop(void);
 
            const int m_client_pid;
            const std::string m_server_key;
            const std::vector<geopm_request_s> m_signal_config;
            const std::vector<geopm_request_s> m_control_config;
            const std::string m_signal_shmem_key;
            const std::string m_control_shmem_key;
            PlatformIO &m_pio;
            std::shared_ptr<SharedMemory> m_signal_shmem;
            std::shared_ptr<SharedMemory> m_control_shmem;
            std::shared_ptr<BatchStatus> m_batch_status;
            std::shared_ptr<POSIXSignal> m_posix_signal;
            int m_server_pid;
            bool m_is_active;
            bool m_is_client_attached;
            bool m_is_client_waiting;
            std::vector<int> m_signal_handle;
            std::vector<int> m_control_handle;
    };
}
 
#endif