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>
#include <chrono>
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
 
#ifdef JPH_SHARED_LIBRARY
using ProfileStartMeasurementFunction = void (*)(const char *inName, uint32 inColor, uint8 *ioUserData);
using ProfileEndMeasurementFunction = void (*)(uint8 *ioUserData);
 
JPH_EXPORT extern ProfileStartMeasurementFunction ProfileStartMeasurement;
JPH_EXPORT extern ProfileEndMeasurementFunction ProfileEndMeasurement;
#endif // JPH_SHARED_LIBRARY
 
class alignas(16) ExternalProfileMeasurement : public NonCopyable
{
public:
#ifdef JPH_SHARED_LIBRARY
    JPH_INLINE                      ExternalProfileMeasurement(const char *inName, uint32 inColor = 0) { ProfileStartMeasurement(inName, inColor, mUserData); }
    JPH_INLINE                      ~ExternalProfileMeasurement() { ProfileEndMeasurement(mUserData); }
#else
                                    ExternalProfileMeasurement(const char *inName, uint32 inColor = 0);
                                    ~ExternalProfileMeasurement();
#endif
 
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_START(name)
#define JPH_PROFILE_END()
#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 JPH_EXPORT Profiler : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                Profiler()                                                          { UpdateReferenceTime(); }
 
    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)
        {
            mCallCounter++;
            mTotalCyclesInCallWithChildren += inCyclesInCallWithChildren;
            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                  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                        UpdateReferenceTime();
 
    uint64                      GetProcessorTicksPerSecond() const;
 
    void                        DumpInternal();
    void                        DumpChart(const char *inTag, const Threads &inThreads, const KeyToAggregator &inKeyToAggregators, const Aggregators &inAggregators);
 
    std::mutex                  mLock;                                                              
    uint64                      mReferenceTick;                                                     
    std::chrono::high_resolution_clock::time_point mReferenceTime;                                  
    Array<ProfileThread *>      mThreads;                                                           
    bool                        mDump = false;                                                      
    String                      mDumpTag;                                                           
};
 
// Class that contains the information of a single scoped measurement
class alignas(16) JPH_EXPORT_GCC_BUG_WORKAROUND 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;                                                 
 
#ifdef JPH_SHARED_LIBRARY
    JPH_EXPORT static void      sSetInstance(ProfileThread *inInstance);
    JPH_EXPORT static ProfileThread *sGetInstance();
#else
    static inline void          sSetInstance(ProfileThread *inInstance)                             { sInstance = inInstance; }
    static inline ProfileThread *sGetInstance()                                                     { return sInstance; }
 
private:
    static thread_local ProfileThread *sInstance;
#endif
};
 
class JPH_EXPORT 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::sSetInstance(new ProfileThread(name)); } while (false)
 
#define JPH_PROFILE_THREAD_END()        do { delete ProfileThread::sGetInstance(); ProfileThread::sSetInstance(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