Profile.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef PROFILE_HPP_INCLUDE
#define PROFILE_HPP_INCLUDE
 
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <stack>
#include <string>
#include <vector>
 
#include "geopm_hash.h"
#include "geopm_hint.h"
#include "geopm_public.h"
#include "geopm_time.h"
 
/****************************************/
/* Encode/decode function for region_id */
/****************************************/
 
enum geopm_region_id_e {
    GEOPM_REGION_ID_EPOCH =        1ULL << 63, /* Signaling the start of an epoch, no associated Region */
    GEOPM_REGION_ID_MPI =          1ULL << 62, /* Execution of MPI calls */
};
 
static inline uint64_t geopm_region_id_hash(uint64_t region_id)
{
    uint64_t ret = ((region_id << 32) >> 32);
 
    if (GEOPM_REGION_HASH_INVALID == ret) {
        ret = GEOPM_REGION_HASH_UNMARKED;
    }
    return ret;
}
 
static inline int geopm_region_id_is_mpi(uint64_t region_id)
{
    return (region_id & GEOPM_REGION_ID_MPI) ? 1 : 0;
}
 
static inline geopm_region_hint_e geopm_region_id_hint(uint64_t region_id)
{
    geopm_region_hint_e ret;
    if (GEOPM_REGION_HASH_UNMARKED == region_id) {
        ret = GEOPM_REGION_HINT_UNKNOWN;
    }
    else if (geopm_region_id_is_mpi(region_id)) {
        ret = GEOPM_REGION_HINT_NETWORK;
    }
    else {
        ret = (geopm_region_hint_e)(region_id >> 32);
        if (!ret || ret >= GEOPM_NUM_REGION_HINT) {
            ret = GEOPM_REGION_HINT_UNKNOWN;
        }
    }
    return ret;
}
 
static inline uint64_t geopm_region_id_set_hint(uint64_t hint_type, uint64_t region_id)
{
    return (region_id | (hint_type << 32));
}
 
static inline int geopm_region_id_hint_is_equal(uint64_t hint_type, uint64_t region_id)
{
    return (region_id & (hint_type << 32)) ? 1 : 0;
}
 
 
namespace geopm
{
    class GEOPM_PUBLIC Profile
    {
        public:
            Profile() = default;
            virtual ~Profile() = default;
            static Profile &default_profile(void);
 
            virtual uint64_t region(const std::string &region_name, long hint) = 0;
            virtual void enter(uint64_t region_id) = 0;
            virtual void exit(uint64_t region_id) = 0;
            virtual void epoch(void) = 0;
            virtual void shutdown(void) = 0;
            virtual void thread_init(uint32_t num_work_unit) = 0;
            //
            virtual void thread_post(int cpu) = 0;
 
            virtual std::vector<std::string> region_names(void) = 0;
 
            virtual void reset_cpu_set(void) = 0;
            virtual void overhead(double overhead_sec) = 0;
            virtual void connect(void) = 0;
            static int get_cpu(void);
    };
 
    class SharedMemory;
    class ApplicationRecordLog;
    class ApplicationStatus;
    class ServiceProxy;
    class Scheduler;
 
    class GEOPM_PUBLIC ProfileImp : public Profile
    {
        public:
            ProfileImp();
            ProfileImp(const std::string &prof_name,
                       const std::string &report,
                       int num_cpu,
                       std::set<int> cpu_set,
                       std::shared_ptr<ApplicationStatus> app_status,
                       std::shared_ptr<ApplicationRecordLog> app_record_log,
                       bool do_profile,
                       std::shared_ptr<ServiceProxy> service_proxy,
                       std::shared_ptr<Scheduler> scheduler,
                       int registered_pid);
            ProfileImp(const ProfileImp &other) = delete;
            ProfileImp operator=(const ProfileImp &other) = delete;
            virtual ~ProfileImp();
            uint64_t region(const std::string &region_name, long hint) override;
            void enter(uint64_t region_id) override;
            void exit(uint64_t region_id) override;
            void epoch(void) override;
            void shutdown(void) override;
            void thread_init(uint32_t num_work_unit) override;
            void thread_post(int cpu) override;
            std::vector<std::string> region_names(void) override;
            void reset_cpu_set(void) override;
            void overhead(double overhead_sec) override;
            void connect(void) override;
        protected:
            bool m_is_enabled;
        private:
            void GEOPM_PRIVATE
                init_app_status(void);
            void GEOPM_PRIVATE
                init_app_record_log(void);
            void GEOPM_PRIVATE
                set_hint(uint64_t hint);
 
            std::string m_prof_name;
            std::string m_report;
            uint64_t m_curr_region_id;
            uint64_t m_current_hash;
            int m_num_cpu;
            std::set<int> m_cpu_set;
 
            std::shared_ptr<ApplicationStatus> m_app_status;
            std::shared_ptr<ApplicationRecordLog> m_app_record_log;
            std::stack<geopm_region_hint_e> m_hint_stack;
 
            double m_overhead_time;
            double m_overhead_time_startup;
            double m_overhead_time_shutdown;
            bool m_do_profile;
            std::map<std::string, uint64_t> m_region_names;
 
            std::shared_ptr<ServiceProxy> m_service_proxy;
            std::shared_ptr<Scheduler> m_scheduler;
            int m_pid_registered;
 
            enum m_profile_const_e {
                M_PID_INIT = -1,
                M_PID_TEST = -2,
            };
 
            std::set<uint64_t> m_region_ids;
    };
}
 
#endif