ApplicationStatus.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef APPLICATIONSTATUS_HPP_INCLUDE
#define APPLICATIONSTATUS_HPP_INCLUDE
 
#include <cstdint>
 
#include <memory>
#include <vector>
#include <set>
 
#include "geopm/Helper.hpp"
 
namespace geopm
{
    class SharedMemory;
 
    class ApplicationStatus
    {
        public:
            virtual ~ApplicationStatus() = default;
 
            virtual void set_hint(int cpu_idx, uint64_t hint) = 0;
            virtual uint64_t get_hint(int cpu_idx) const = 0;
            virtual void set_hash(int cpu_idx, uint64_t hash, uint64_t hint) = 0;
            virtual uint64_t get_hash(int cpu_idx) const = 0;
            virtual void reset_work_units(int cpu_idx) = 0;
            virtual void set_total_work_units(int cpu_idx, int work_units) = 0;
            virtual void increment_work_unit(int cpu_idx) = 0;
            virtual double get_progress_cpu(int cpu_idx) const = 0;
            virtual void update_cache(void) = 0;
 
            static std::unique_ptr<ApplicationStatus> make_unique(int num_cpu,
                                                                  std::shared_ptr<SharedMemory> shmem);
            static size_t buffer_size(int num_cpu);
 
        protected:
            static constexpr size_t M_STATUS_SIZE = geopm::hardware_destructive_interference_size;
    };
 
    class ApplicationStatusImp : public ApplicationStatus
    {
        public:
            ApplicationStatusImp(int num_cpu,
                                 std::shared_ptr<SharedMemory> shmem);
            virtual ~ApplicationStatusImp() = default;
            void set_hint(int cpu_idx, uint64_t hint) override;
            uint64_t get_hint(int cpu_idx) const override;
            void set_hash(int cpu_idx, uint64_t hash, uint64_t hint) override;
            uint64_t get_hash(int cpu_idx) const override;
            void reset_work_units(int cpu_idx) override;
            void set_total_work_units(int cpu_idx, int work_units) override;
            void increment_work_unit(int cpu_idx) override;
            double get_progress_cpu(int cpu_idx) const override;
            void update_cache(void) override;
        private:
            // These fields must all be 32-bit int
            struct m_app_status_s
            {
                int32_t process; // can be negative, indicating unset process
                uint32_t hint;
                uint32_t hash;
                uint32_t total_work;
                uint32_t completed_work;
                char padding[44];
            };
            static_assert((sizeof(ApplicationStatusImp::m_app_status_s) % geopm::hardware_destructive_interference_size) == 0,
                          "m_app_status_s not aligned to cache lines");
            static_assert(sizeof(ApplicationStatusImp::m_app_status_s) == ApplicationStatus::M_STATUS_SIZE,
                          "M_STATUS_SIZE does not match size of m_app_status_s");
 
            int m_num_cpu;
            std::shared_ptr<SharedMemory> m_shmem;
            m_app_status_s *m_buffer;
            std::vector<m_app_status_s> m_cache;
    };
}
 
#endif