EndpointImp.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef ENDPOINTIMP_HPP_INCLUDE
#define ENDPOINTIMP_HPP_INCLUDE
 
#include <pthread.h>
 
#include "geopm_endpoint.h"
#include "geopm_time.h"
#include "geopm/Endpoint.hpp"
 
namespace geopm
{
    struct geopm_endpoint_policy_shmem_header {
        geopm_time_s timestamp;   // 16 bytes
        size_t count;         // 8 bytes
        double values;        // 8 bytes
    };
 
    struct geopm_endpoint_sample_shmem_header {
        geopm_time_s timestamp;   // 16 bytes
        char agent[GEOPM_ENDPOINT_AGENT_NAME_MAX]; // 256 bytes
        char profile_name[GEOPM_ENDPOINT_PROFILE_NAME_MAX];   // 256 bytes
        char hostlist_path[GEOPM_ENDPOINT_HOSTLIST_PATH_MAX];  // 512 bytes
        size_t count;             // 8 bytes
        double values;            // 8 bytes
    };
 
    struct geopm_endpoint_policy_shmem_s {
        geopm_time_s timestamp;
        size_t count;
        double values[(4096 - offsetof(struct geopm_endpoint_policy_shmem_header, values)) / sizeof(double)];
    };
 
    struct geopm_endpoint_sample_shmem_s {
        geopm_time_s timestamp;
        char agent[GEOPM_ENDPOINT_AGENT_NAME_MAX];
        char profile_name[GEOPM_ENDPOINT_PROFILE_NAME_MAX];
        char hostlist_path[GEOPM_ENDPOINT_HOSTLIST_PATH_MAX];
        size_t count;
        double values[(4096 - offsetof(struct geopm_endpoint_sample_shmem_header, values)) / sizeof(double)];
    };
 
    static_assert(sizeof(struct geopm_endpoint_policy_shmem_s) == 4096, "Alignment issue with geopm_endpoint_policy_shmem_s.");
    static_assert(sizeof(struct geopm_endpoint_sample_shmem_s) == 4096, "Alignment issue with geopm_endpoint_sample_shmem_s.");
 
    class SharedMemory;
 
    class EndpointImp : public Endpoint
    {
        public:
            EndpointImp() = delete;
            EndpointImp(const EndpointImp &other) = delete;
            EndpointImp &operator=(const EndpointImp &other) = delete;
 
            EndpointImp(const std::string &data_path);
            EndpointImp(const std::string &data_path,
                        std::shared_ptr<SharedMemory> policy_shmem,
                        std::shared_ptr<SharedMemory> sample_shmem,
                        size_t num_policy,
                        size_t num_sample);
            virtual ~EndpointImp();
 
            void open(void) override;
            void close(void) override;
            void write_policy(const std::vector<double> &policy) override;
            double read_sample(std::vector<double> &sample) override;
            std::string get_agent(void) override;
            void wait_for_agent_attach(double timeout) override;
            void wait_for_agent_detach(double timeout) override;
            void stop_wait_loop(void) override;
            void reset_wait_loop(void) override;
            std::string get_profile_name(void) override;
            std::set<std::string> get_hostnames(void) override;
            static std::string shm_policy_postfix(void);
            static std::string shm_sample_postfix(void);
        private:
            std::string m_path;
            std::shared_ptr<SharedMemory> m_policy_shmem;
            std::shared_ptr<SharedMemory> m_sample_shmem;
            size_t m_num_policy;
            size_t m_num_sample;
            bool m_is_open;
            volatile bool m_continue_loop;
    };
}
 
#endif