Profiling.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/DynamicArray.h>
#include <Foundation/Containers/StaticRingBuffer.h>
#include <Foundation/System/Process.h>
#include <Foundation/Time/Time.h>
 
class plStreamWriter;
class plThread;
 
class PL_FOUNDATION_DLL plProfilingScope
{
public:
  plProfilingScope(plStringView sName, const char* szFunctionName, plTime timeout);
  ~plProfilingScope();
 
protected:
  plStringView m_sName;
  const char* m_szFunction;
  plTime m_BeginTime;
  plTime m_Timeout;
};
 
class plProfilingListScope
{
public:
  PL_FOUNDATION_DLL plProfilingListScope(plStringView sListName, plStringView sFirstSectionName, const char* szFunctionName);
  PL_FOUNDATION_DLL ~plProfilingListScope();
 
  PL_FOUNDATION_DLL static void StartNextSection(plStringView sNextSectionName);
 
protected:
  static thread_local plProfilingListScope* s_pCurrentList;
 
  plProfilingListScope* m_pPreviousList;
 
  plStringView m_sListName;
  const char* m_szListFunction;
  plTime m_ListBeginTime;
 
  plStringView m_sCurSectionName;
  plTime m_CurSectionBeginTime;
};
 
class PL_FOUNDATION_DLL plProfilingSystem
{
public:
  struct ThreadInfo
  {
    plUInt64 m_uiThreadId;
    plString m_sName;
  };
 
  struct CPUScope
  {
    PL_DECLARE_POD_TYPE();
 
    static constexpr plUInt32 NAME_SIZE = 40;
 
    const char* m_szFunctionName;
    plTime m_BeginTime;
    plTime m_EndTime;
    char m_szName[NAME_SIZE];
  };
 
  struct CPUScopesBufferFlat
  {
    plDynamicArray<CPUScope> m_Data;
    plUInt64 m_uiThreadId = 0;
  };
 
  struct GPUScope
  {
    PL_DECLARE_POD_TYPE();
 
    static constexpr plUInt32 NAME_SIZE = 48;
 
    plTime m_BeginTime;
    plTime m_EndTime;
    char m_szName[NAME_SIZE];
  };
 
  struct PL_FOUNDATION_DLL ProfilingData
  {
    plUInt32 m_uiFramesThreadID = 0;
    plUInt32 m_uiProcessSortIndex = 0;
    plOsProcessID m_uiProcessID = 0;
 
    plHybridArray<ThreadInfo, 16> m_ThreadInfos;
 
    plDynamicArray<CPUScopesBufferFlat> m_AllEventBuffers;
 
    plUInt64 m_uiFrameCount = 0;
    plDynamicArray<plTime> m_FrameStartTimes;
 
    plDynamicArray<plDynamicArray<GPUScope>> m_GPUScopes;
 
    plResult Write(plStreamWriter& ref_outputStream) const;
 
    void Clear();
 
    static void Merge(ProfilingData& out_merged, plArrayPtr<const ProfilingData*> inputs);
  };
 
public:
  static void Clear();
 
  static void Capture(plProfilingSystem::ProfilingData& out_capture, bool bClearAfterCapture = false);
 
  static void SetDiscardThreshold(plTime threshold);
 
  using ScopeTimeoutDelegate = plDelegate<void(plStringView sName, plStringView sFunctionName, plTime duration)>;
 
  static void SetScopeTimeoutCallback(ScopeTimeoutDelegate callback);
 
  static void StartNewFrame();
 
  static void AddCPUScope(plStringView sName, const char* szFunctionName, plTime beginTime, plTime endTime, plTime scopeTimeout);
 
  static plUInt64 GetFrameCount();
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, ProfilingSystem);
  friend plUInt32 RunThread(plThread* pThread);
 
  static void Initialize();
  static void Reset();
 
  static void SetThreadName(plStringView sThreadName);
  static void RemoveThread();
 
public:
  static void InitializeGPUData(plUInt32 uiGpuCount = 1);
 
  static void AddGPUScope(plStringView sName, plTime beginTime, plTime endTime, plUInt32 uiGpuIndex = 0);
};
 
#if PL_ENABLED(PL_USE_PROFILING) || defined(PL_DOCS)
 
#  define PL_PROFILE_SCOPE(ScopeName) \
    plProfilingScope PL_PP_CONCAT(_plProfilingScope, PL_SOURCE_LINE)(ScopeName, PL_SOURCE_FUNCTION, plTime::MakeZero())
 
#  define PL_PROFILE_SCOPE_WITH_TIMEOUT(ScopeName, Timeout) \
    plProfilingScope PL_PP_CONCAT(_plProfilingScope, PL_SOURCE_LINE)(ScopeName, PL_SOURCE_FUNCTION, Timeout)
 
#  define PL_PROFILE_LIST_SCOPE(ListName, FirstSectionName) \
    plProfilingListScope PL_PP_CONCAT(_plProfilingScope, PL_SOURCE_LINE)(ListName, FirstSectionName, PL_SOURCE_FUNCTION)
 
#  define PL_PROFILE_LIST_NEXT_SECTION(NextSectionName) \
    plProfilingListScope::StartNextSection(NextSectionName)
 
#  define PL_PROFILER_FRAME_MARKER()
 
#else
#  define PL_PROFILE_SCOPE(ScopeName)
#  define PL_PROFILE_SCOPE_WITH_TIMEOUT(ScopeName, Timeout)
#  define PL_PROFILE_LIST_SCOPE(ListName, FirstSectionName)
#  define PL_PROFILE_LIST_NEXT_SECTION(NextSectionName)
#  define PL_PROFILER_FRAME_MARKER()
#endif
 
// Let Tracy override the macros.
#include <Foundation/Profiling/Profiling_Tracy.h>