MHO_Profiler.hh

Go to the documentation of this file.

#ifndef MHO_Profiler_HH__
#define MHO_Profiler_HH__
 
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
#include "MHO_SelfName.hh"
#include "MHO_Timer.hh"
 
//this define is passed in the compiler flags
//#define HOPS_USE_PROFILER
 
namespace hops
{
 
namespace sn = selfname;
 
enum MHO_ProfilerFlag : int
{
    pStartFlag = 1, //start time for this segment
    pStopFlag = 2   //stop timer for this segment
};
 
//short hand aliases
static const MHO_ProfilerFlag pStart = MHO_ProfilerFlag::pStartFlag;
static const MHO_ProfilerFlag pStop = MHO_ProfilerFlag::pStopFlag;
 
using hops::pStart;
using hops::pStop;
 
#define PROFILE_INFO_LEN 128
 
struct MHO_ProfileEvent
{
        int fFlag;       //indicates start/stop
        int fLineNumber; //line number of the file
        uint64_t fThreadID;
        double fTime;
        char fFilename[PROFILE_INFO_LEN]; //truncated filename
        char fFuncname[PROFILE_INFO_LEN]; //truncated function name
};
 
class MHO_Profiler
{
 
    public:
        //since this is a singleton we need to remove ability to copy/move
        MHO_Profiler(MHO_Profiler const&) = delete;
        MHO_Profiler(MHO_Profiler&&) = delete;
        MHO_Profiler& operator=(MHO_Profiler const&) = delete;
        MHO_Profiler& operator=(MHO_Profiler&&) = delete;
 
        static MHO_Profiler& GetInstance()
        {
            static MHO_Profiler instance;
            return instance;
        }
 
        void Enable() { fDisabled = false; };
 
        void Disable() { fDisabled = true; };
 
        bool IsEnabled() const { return !fDisabled; }
 
        void Lock() { fMutex.lock(); };
 
        void Unlock() { fMutex.unlock(); };
 
        void AddEntry(int flag, uint64_t thread_id, std::string filename, int line_num, std::string func_name);
 
        void GetEvents(std::vector< MHO_ProfileEvent >& events) { events = fEvents; }
 
        void DumpEvents();
 
    private:
        MHO_Profiler(): fNThreads(1)
        {
            fDisabled = true; //disabled by default
            fEvents.reserve(1000);
            fTimer.Start();
        };
 
        virtual ~MHO_Profiler(){};
 
        std::mutex fMutex;
        std::size_t fNThreads;
        bool fDisabled;
 
        //map each thread to a vector of events
        // std::vector< std::vector< MHO_ProfileEvent > > fThreadEvents;
        std::vector< MHO_ProfileEvent > fEvents;
 
        MHO_Timer fTimer;
};
 
#ifdef HOPS_USE_PROFILER
 
    //abuse do-while for multiline macros
    #define profiler_start()                                                                                                   \
        do                                                                                                                     \
        {                                                                                                                      \
            MHO_Profiler::GetInstance().Lock();                                                                                \
            MHO_Profiler::GetInstance().AddEntry(pStart, std::hash< std::thread::id >{}(std::this_thread::get_id()),           \
                                                 std::string(sn::file_basename(__FILE__)), __LINE__,                           \
                                                 std::string(__PRETTY_FUNCTION__));                                            \
            MHO_Profiler::GetInstance().Unlock();                                                                              \
        }                                                                                                                      \
        while(0)
 
    #define profiler_stop()                                                                                                    \
        do                                                                                                                     \
        {                                                                                                                      \
            MHO_Profiler::GetInstance().Lock();                                                                                \
            MHO_Profiler::GetInstance().AddEntry(pStop, std::hash< std::thread::id >{}(std::this_thread::get_id()),            \
                                                 std::string(sn::file_basename(__FILE__)), __LINE__,                           \
                                                 std::string(__PRETTY_FUNCTION__));                                            \
            MHO_Profiler::GetInstance().Unlock();                                                                              \
        }                                                                                                                      \
        while(0)
 
// RAII guard: calls profiler_start() on construction and profiler_stop() on destruction.
// __FILE__, __LINE__, __PRETTY_FUNCTION__ are captured by the macro at the call site
// so they reflect the enclosing function, not the guard class itself.
struct MHO_ProfilerGuard
{
        MHO_ProfilerGuard(uint64_t thread_id, std::string filename, int line_num, std::string funcname)
            : fThreadID(thread_id), fFilename(std::move(filename)), fFuncname(std::move(funcname))
        {
            MHO_Profiler::GetInstance().Lock();
            MHO_Profiler::GetInstance().AddEntry(pStart, fThreadID, fFilename, line_num, fFuncname);
            MHO_Profiler::GetInstance().Unlock();
        }
 
        ~MHO_ProfilerGuard()
        {
            MHO_Profiler::GetInstance().Lock();
            MHO_Profiler::GetInstance().AddEntry(pStop, fThreadID, fFilename, 0, fFuncname);
            MHO_Profiler::GetInstance().Unlock();
        }
 
        // non-copyable, non-movable
        MHO_ProfilerGuard(const MHO_ProfilerGuard&) = delete;
        MHO_ProfilerGuard& operator=(const MHO_ProfilerGuard&) = delete;
 
    private:
        uint64_t fThreadID;
        std::string fFilename;
        std::string fFuncname;
};
 
    // Helper macros for token-pasting to generate unique variable names
    #define PROFILER_CONCAT_(a, b) a##b
    #define PROFILER_CONCAT(a, b) PROFILER_CONCAT_(a, b)
 
    // Declare a scope-guard that automatically records start/stop for the enclosing function.
    // Place once at the top of any function body to profile the entire function.
    #define profiler_scope()                                                                                                   \
        hops::MHO_ProfilerGuard PROFILER_CONCAT(_pg_, __LINE__)(std::hash< std::thread::id >{}(std::this_thread::get_id()),    \
                                                                std::string(sn::file_basename(__FILE__)), __LINE__,            \
                                                                std::string(__PRETTY_FUNCTION__))
 
#else
 
    //profiling is not turned on, ifdef out of compilation
    #define profiler_start()
    #define profiler_stop()
    #define profiler_scope()
 
#endif
 
} // namespace hops
 
#endif