ApplicationRecordLog.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef APPLICATIONRECORDLOG_HPP_INCLUDE
#define APPLICATIONRECORDLOG_HPP_INCLUDE
 
#include <cstdint>
#include <cstddef>
#include <map>
#include <vector>
#include <memory>
 
#include "geopm_time.h"
#include "record.hpp"
 
namespace geopm
{
    class SharedMemory;
    class SharedMemoryScopedLock;
    class Scheduler;
 
    class ApplicationRecordLog
    {
        public:
            static std::unique_ptr<ApplicationRecordLog> make_unique(std::shared_ptr<SharedMemory> shmem);
            virtual ~ApplicationRecordLog() = default;
            virtual void enter(uint64_t hash, const geopm_time_s &time) = 0;
            virtual void exit(uint64_t hash, const geopm_time_s &time) = 0;
            virtual void epoch(const geopm_time_s &time) = 0;
            virtual void dump(std::vector<record_s> &records,
                              std::vector<short_region_s> &short_regions) = 0;
            virtual void affinity(const geopm_time_s &time, int cpu_idx) = 0;
            virtual void cpuset_changed(const geopm_time_s &time) = 0;
            virtual void start_profile(const geopm_time_s &time, const std::string &profile_name) = 0;
            virtual void stop_profile(const geopm_time_s &time, const std::string &profile_name) = 0;
            virtual void overhead(const geopm_time_s &time, double overhead_sec) = 0;
            static size_t buffer_size(void);
            static size_t max_record(void);
            static size_t max_region(void);
        protected:
            ApplicationRecordLog() = default;
            static constexpr size_t M_LAYOUT_SIZE = 57384;
            static constexpr int M_MAX_RECORD = 1024;
            static constexpr int M_MAX_REGION = M_MAX_RECORD + 1;
    };
    class ApplicationRecordLogImp : public ApplicationRecordLog
    {
        public:
            ApplicationRecordLogImp(std::shared_ptr<SharedMemory> shmem);
            ApplicationRecordLogImp(std::shared_ptr<SharedMemory> shmem,
                                    int process,
                                    std::shared_ptr<Scheduler> scheduler);
            virtual ~ApplicationRecordLogImp() = default;
            void enter(uint64_t hash, const geopm_time_s &time) override;
            void exit(uint64_t hash, const geopm_time_s &time) override;
            void epoch(const geopm_time_s &time) override;
            void dump(std::vector<record_s> &records,
                      std::vector<short_region_s> &short_regions) override;
            void affinity(const geopm_time_s &time, int cpu_idx) override;
            void cpuset_changed(const geopm_time_s &time) override;
            void start_profile(const geopm_time_s &time, const std::string &profile_name) override;
            void stop_profile(const geopm_time_s &time, const std::string &profile_name) override;
            void overhead(const geopm_time_s &time, double overhead_sec) override;
        private:
            struct m_layout_s {
                int32_t num_record;
                record_s record_table[M_MAX_RECORD];
                int32_t num_region;
                short_region_s region_table[M_MAX_REGION];
            };
            static_assert(sizeof(m_layout_s) <= M_LAYOUT_SIZE,
                          "Layout size used in geopmdpy/system_files.py to create shared memory footprint is smaller than required by C++ code");
 
            struct m_region_enter_s {
                int record_idx;
                int region_idx;
                geopm_time_s enter_time;
                bool is_short;
            };
            void check_reset(m_layout_s &layout);
            void append_record(m_layout_s &layout, const record_s &record);
            int m_process;
            std::shared_ptr<SharedMemory> m_shmem;
            std::map<uint64_t, m_region_enter_s> m_hash_region_enter_map;
            uint64_t m_epoch_count;
            uint64_t m_entered_region_hash;
            std::shared_ptr<Scheduler> m_scheduler;
    };
}
 
#endif