ExternalProfiler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringConv.h"
#include "CoreTypes.h"
#include "Features/IModularFeature.h"
#include "Misc/Build.h"
#include "ProfilingDebugging/ExternalProfilerConfig.h"
#include "UObject/NameTypes.h"
 
#if UE_EXTERNAL_PROFILING_ENABLED
 
class FExternalProfiler : public IModularFeature
{
 
public:
 
    CORE_API FExternalProfiler();
 
    virtual ~FExternalProfiler()
    {
    }
 
    UE_DEPRECATED(5.6, "Use FActiveExternalProfilerBase::PauseActiveProfiler instead")
    CORE_API void PauseProfiler();
 
    UE_DEPRECATED(5.6, "Use FActiveExternalProfilerBase::ResumeActiveProfiler instead")
    CORE_API void ResumeProfiler();
 
    virtual void FrameSync() = 0;
 
    virtual void Register() {}
 
    virtual void ProfilerPauseFunction() = 0;
 
    virtual void ProfilerResumeFunction() = 0;
 
    virtual const TCHAR* GetProfilerName() const = 0;
 
    static CORE_API FName GetFeatureName();
 
    virtual void OnEnableScopedEventsChanged(bool bEnabled) {};
 
    virtual void StartScopedEvent(const struct FColor& Color, const TCHAR* Text) {};
 
    virtual void StartScopedEvent(const struct FColor& Color, const ANSICHAR* Text) { StartScopedEvent(Color, ANSI_TO_TCHAR(Text)); };
 
    virtual void EndScopedEvent() {};
 
    virtual void SetThreadName(const TCHAR* Name) {}
};
 
class FActiveExternalProfilerBase
{
public: 
 
    static FExternalProfiler* GetActiveProfiler() { return ActiveProfiler;  };
 
    static CORE_API FExternalProfiler* InitActiveProfiler();
 
    static CORE_API bool SetActiveProfilerRecording(bool bRecording);
    static CORE_API bool IsActiveProfilerRecording();
 
    static CORE_API void EnableScopedEvents(bool bEnable);
 
    static CORE_API bool AreScopedEventsEnabled();
 
private:
    static CORE_API bool bDidInitialize;
 
    static CORE_API FExternalProfiler* ActiveProfiler;
 
    static std::atomic<bool> bIsRecording;
 
    static std::atomic<bool> bEnableScopedEvents;
};
 
class FScopedExternalProfilerBase : public FActiveExternalProfilerBase
{
protected:
    CORE_API void StartScopedTimer( const bool bWantPause );
 
    CORE_API void StopScopedTimer();
 
private:
    bool bWasRecording = false;
};
 
 
class FExternalProfilerIncluder : public FScopedExternalProfilerBase
{
public:
    FExternalProfilerIncluder()
    {
        const bool bWantPause = false;
        StartScopedTimer( bWantPause );
    }
 
    ~FExternalProfilerIncluder()
    {
        StopScopedTimer();
    }
};
 
 
class FExternalProfilerExcluder : public FScopedExternalProfilerBase
{
public:
    FExternalProfilerExcluder()
    {
        const bool bWantPause = true;
        StartScopedTimer( bWantPause );
    }
 
    ~FExternalProfilerExcluder()
    {
        StopScopedTimer();
    }
 
};
 
class FExternalProfilerTrace
{
public:
    inline static void StartScopedEvent(const struct FColor& Color, const TCHAR* Text)
    {
        if (FActiveExternalProfilerBase::AreScopedEventsEnabled())
        {
            if (FExternalProfiler* Profiler = FActiveExternalProfilerBase::GetActiveProfiler())
            {
                Profiler->StartScopedEvent(Color, Text);
            }
        }
    }
 
    inline static void StartScopedEvent(const struct FColor& Color, const ANSICHAR* Text)
    {
        if (FActiveExternalProfilerBase::AreScopedEventsEnabled())
        {
            if (FExternalProfiler* Profiler = FActiveExternalProfilerBase::GetActiveProfiler())
            {
                Profiler->StartScopedEvent(Color, Text);
            }
        }
    }
 
    inline static void EndScopedEvent()
    {
        if (FActiveExternalProfilerBase::AreScopedEventsEnabled())
        {
            if (FExternalProfiler* Profiler = FActiveExternalProfilerBase::GetActiveProfiler())
            {
                Profiler->EndScopedEvent();
            }
        }
    }
};
 
#define SCOPE_PROFILER_INCLUDER(X) FExternalProfilerIncluder ExternalProfilerIncluder_##X;
#define SCOPE_PROFILER_EXCLUDER(X) FExternalProfilerExcluder ExternalProfilerExcluder_##X;
 
#else   // UE_EXTERNAL_PROFILING_ENABLED
 
#define SCOPE_PROFILER_INCLUDER(X)
#define SCOPE_PROFILER_EXCLUDER(X)
 
#endif  // !UE_EXTERNAL_PROFILING_ENABLED