Profiler.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
JPH_SUPPRESS_WARNINGS_STD_BEGIN
#include <mutex>
JPH_SUPPRESS_WARNINGS_STD_END
 
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Core/TickCounter.h>
#include <Jolt/Core/UnorderedMap.h>
 
#if defined(JPH_EXTERNAL_PROFILE)
 
JPH_NAMESPACE_BEGIN
 
class alignas(16) ExternalProfileMeasurement : public NonCopyable
{   
public:                     
                                    ExternalProfileMeasurement(const char *inName, uint32 inColor = 0);
                                    ~ExternalProfileMeasurement();
 
private:
    uint8                           mUserData[64];
};
 
JPH_NAMESPACE_END
 
// Macros to do the actual profiling    
 
JPH_SUPPRESS_WARNING_PUSH
JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")
 
// Dummy implementations
#define JPH_PROFILE_THREAD_START(name)          
#define JPH_PROFILE_THREAD_END()                
#define JPH_PROFILE_NEXTFRAME()         
#define JPH_PROFILE_DUMP(...)               
                                
// Scope profiling measurement
#define JPH_PROFILE_TAG2(line)      profile##line
#define JPH_PROFILE_TAG(line)       JPH_PROFILE_TAG2(line)
 
#define JPH_PROFILE(...)            ExternalProfileMeasurement JPH_PROFILE_TAG(__LINE__)(__VA_ARGS__)
 
// Scope profiling for function
#define JPH_PROFILE_FUNCTION()      JPH_PROFILE(JPH_FUNCTION_NAME)
 
JPH_SUPPRESS_WARNING_POP
 
#elif defined(JPH_PROFILE_ENABLED)
 
JPH_NAMESPACE_BEGIN
 
class ProfileSample;
class ProfileThread;
 
class Profiler : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    void                        NextFrame();
 
    void                        Dump(const string_view &inTag = string_view());
 
    void                        AddThread(ProfileThread *inThread);
 
    void                        RemoveThread(ProfileThread *inThread);
 
    static Profiler *           sInstance;
                                
private:
    struct ThreadSamples
    {
        String                  mThreadName;
        ProfileSample *         mSamplesBegin;
        ProfileSample *         mSamplesEnd;
    };
 
    class Aggregator            
    {   
    public:                     
                                Aggregator(const char *inName)                                      : mName(inName) { }
                                
        void                    AccumulateMeasurement(uint64 inCyclesInCallWithChildren, uint64 inCyclesInChildren)
        {
            mCallCounter++;
            mTotalCyclesInCallWithChildren += inCyclesInCallWithChildren;
            mTotalCyclesInChildren += inCyclesInChildren;
            mMinCyclesInCallWithChildren = min(inCyclesInCallWithChildren, mMinCyclesInCallWithChildren);
            mMaxCyclesInCallWithChildren = max(inCyclesInCallWithChildren, mMaxCyclesInCallWithChildren);
        }
 
        bool                    operator < (const Aggregator &inRHS) const
        {
            return mTotalCyclesInCallWithChildren > inRHS.mTotalCyclesInCallWithChildren;
        }
 
        const char *            mName;                                                              
                                
        uint32                  mCallCounter = 0;                                                   
        uint64                  mTotalCyclesInCallWithChildren = 0;                                 
        uint64                  mTotalCyclesInChildren = 0;                                         
        uint64                  mMinCyclesInCallWithChildren = 0xffffffffffffffffUL;                
        uint64                  mMaxCyclesInCallWithChildren = 0;                                   
    };                          
 
    using Threads = Array<ThreadSamples>;
    using Aggregators = Array<Aggregator>;
    using KeyToAggregator = UnorderedMap<const char *, size_t>;
 
    static void                 sAggregate(int inDepth, uint32 inColor, ProfileSample *&ioSample, const ProfileSample *inEnd, Aggregators &ioAggregators, KeyToAggregator &ioKeyToAggregator);
 
    void                        DumpInternal();
    void                        DumpList(const char *inTag, const Aggregators &inAggregators);
    void                        DumpChart(const char *inTag, const Threads &inThreads, const KeyToAggregator &inKeyToAggregators, const Aggregators &inAggregators);
 
    std::mutex                  mLock;                                                              
    Array<ProfileThread *>      mThreads;                                                           
    bool                        mDump = false;                                                      
    String                      mDumpTag;                                                           
};                          
 
// Class that contains the information of a single scoped measurement
class alignas(16) ProfileSample : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    const char *                mName;                                                              
    uint32                      mColor;                                                             
    uint8                       mDepth;                                                             
    uint8                       mUnused[3];
    uint64                      mStartCycle;                                                        
    uint64                      mEndCycle;                                                          
};
 
class ProfileThread : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    inline                      ProfileThread(const string_view &inThreadName);
    inline                      ~ProfileThread();
 
    static const uint cMaxSamples = 65536;
 
    String                      mThreadName;                                                        
    ProfileSample               mSamples[cMaxSamples];                                              
    uint                        mCurrentSample = 0;                                                 
 
    static thread_local ProfileThread *sInstance;
};
 
class ProfileMeasurement : public NonCopyable
{   
public:                     
    inline                      ProfileMeasurement(const char *inName, uint32 inColor = 0);
    inline                      ~ProfileMeasurement();
                            
private:
    ProfileSample *             mSample;
    ProfileSample               mTemp;
 
    static bool                 sOutOfSamplesReported;
};
 
JPH_NAMESPACE_END
 
#include "Profiler.inl"
 
// Macros to do the actual profiling    
 
JPH_SUPPRESS_WARNING_PUSH
JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")
 
 
#define JPH_PROFILE_START(name)         do { Profiler::sInstance = new Profiler; JPH_PROFILE_THREAD_START(name); } while (false)
 
#define JPH_PROFILE_END()               do { JPH_PROFILE_THREAD_END(); delete Profiler::sInstance; Profiler::sInstance = nullptr; } while (false)
 
#define JPH_PROFILE_THREAD_START(name)  do { if (Profiler::sInstance) ProfileThread::sInstance = new ProfileThread(name); } while (false)
 
#define JPH_PROFILE_THREAD_END()        do { delete ProfileThread::sInstance; ProfileThread::sInstance = nullptr; } while (false)
                                
#define JPH_PROFILE_TAG2(line)          profile##line
#define JPH_PROFILE_TAG(line)           JPH_PROFILE_TAG2(line)
#define JPH_PROFILE(...)                ProfileMeasurement JPH_PROFILE_TAG(__LINE__)(__VA_ARGS__)
 
#define JPH_PROFILE_FUNCTION()          JPH_PROFILE(JPH_FUNCTION_NAME)
                                
#define JPH_PROFILE_NEXTFRAME()         Profiler::sInstance->NextFrame()
 
#define JPH_PROFILE_DUMP(...)           Profiler::sInstance->Dump(__VA_ARGS__)
 
JPH_SUPPRESS_WARNING_POP
 
#else
 
// Dummy profiling instructions
 
JPH_SUPPRESS_WARNING_PUSH
JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")
 
#define JPH_PROFILE_START(name)
#define JPH_PROFILE_END()
#define JPH_PROFILE_THREAD_START(name)
#define JPH_PROFILE_THREAD_END()
#define JPH_PROFILE(...)
#define JPH_PROFILE_FUNCTION()
#define JPH_PROFILE_NEXTFRAME()
#define JPH_PROFILE_DUMP(...)
 
JPH_SUPPRESS_WARNING_POP
 
#endif