perf.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
#include <optional>
#include <string>
#include <string_view>
 
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
 
namespace rex::platform {

enum class CounterID : u8 {
  kFrameTimeUs,
  kFps,
};

enum class CounterType : u8 {
  kAccumulator, 
  kGauge,       
};

inline constexpr size_t kMaxCounters = 64;

[[nodiscard]] REX_API Result<CounterID> RegisterCounter(
    const char* name, CounterType type = CounterType::kAccumulator);

REX_API std::optional<CounterID> FindCounter(std::string_view name);

REX_API const char* GetCounterName(CounterID id);
 
REX_API void SetCounter(CounterID id, i64 value);

REX_API void IncrementCounter(CounterID id, i64 delta = 1);

REX_API i64 GetCounter(CounterID id);

REX_API void ResetFrameCounters();

REX_API i64 GetSnapshotCounter(CounterID id);

REX_API void InitCounters();

REX_API void SetCSVLogPath(const std::string& path);

REX_API void WriteCSVFrame();
 
REX_API void CloseCSV();
 
}  // namespace rex::platform
 
#ifdef REXGLUE_ENABLE_PERF_COUNTERS

#define REX_PERF_APPLY(name, call)                                         \
  do {                                                                     \
    static const auto rex_perf_found = ::rex::platform::FindCounter(name); \
    if (rex_perf_found) {                                                  \
      const ::rex::platform::CounterID rex_perf_id = *rex_perf_found;      \
      call;                                                                \
    }                                                                      \
  } while (false)

#define REX_PERF_SET(name, value) \
  REX_PERF_APPLY(name, ::rex::platform::SetCounter(rex_perf_id, value))

#define REX_PERF_INC(name) REX_PERF_APPLY(name, ::rex::platform::IncrementCounter(rex_perf_id))

#define REX_PERF_ADD(name, delta) \
  REX_PERF_APPLY(name, ::rex::platform::IncrementCounter(rex_perf_id, delta))
 
#else

#define REX_PERF_SET(name, value)
#define REX_PERF_INC(name)
#define REX_PERF_ADD(name, delta)
 
#endif
 
#ifdef REXGLUE_ENABLE_PROFILING
 
#include <tracy/Tracy.hpp>

#define REX_PROFILE_SCOPE(name) ZoneNamedN(___tracy_cpu_zone, name, TracyIsStarted)

#define REX_PROFILE_SCOPE_TEXT(name, detail)             \
  ZoneNamedN(___tracy_cpu_zone_i, name, TracyIsStarted); \
  ZoneTextV(___tracy_cpu_zone_i, detail, std::strlen(detail))

#define REX_PROFILE_THREAD(name)  \
  do {                            \
    if (TracyIsStarted)           \
      tracy::SetThreadName(name); \
  } while (0)
 
#ifdef TRACY_FIBERS
#define REX_PROFILE_FIBER_ENTER(name) \
  do {                                \
    if (TracyIsStarted)               \
      TracyFiberEnter(name);          \
  } while (0)

#define REX_PROFILE_FIBER_LEAVE() \
  do {                            \
    if (TracyIsStarted)           \
      TracyFiberLeave;            \
  } while (0)
#else
#define REX_PROFILE_FIBER_ENTER(name) ((void)sizeof(decltype(name)))
#define REX_PROFILE_FIBER_LEAVE()
#endif

#define REX_PROFILE_PLOT(name, value)                  \
  do {                                                 \
    if (TracyIsStarted)                                \
      TracyPlot(name, static_cast<::rex::i64>(value)); \
  } while (0)

#define REX_PROFILE_PLOT_F64(name, value)              \
  do {                                                 \
    if (TracyIsStarted)                                \
      TracyPlot(name, static_cast<::rex::f64>(value)); \
  } while (0)

#define REX_PROFILE_ALLOC(ptr, size) \
  do {                               \
    if (TracyIsStarted)              \
      TracyAlloc(ptr, size);         \
  } while (0)

#define REX_PROFILE_FREE(ptr) \
  do {                        \
    if (TracyIsStarted)       \
      TracyFree(ptr);         \
  } while (0)

#define REX_PROFILE_ALLOC_NAMED(ptr, size, pool) \
  do {                                           \
    if (TracyIsStarted)                          \
      TracyAllocN(ptr, size, pool);              \
  } while (0)

#define REX_PROFILE_FREE_NAMED(ptr, pool) \
  do {                                    \
    if (TracyIsStarted)                   \
      TracyFreeN(ptr, pool);              \
  } while (0)

#define REX_PROFILE_ALLOC_STACK(ptr, size, depth) \
  do {                                            \
    if (TracyIsStarted)                           \
      TracyAllocS(ptr, size, depth);              \
  } while (0)

#define REX_PROFILE_FREE_STACK(ptr, depth) \
  do {                                     \
    if (TracyIsStarted)                    \
      TracyFreeS(ptr, depth);              \
  } while (0)

#define REX_PROFILE_ALLOC_NAMED_STACK(ptr, size, depth, pool) \
  do {                                                        \
    if (TracyIsStarted)                                       \
      TracyAllocNS(ptr, size, depth, pool);                   \
  } while (0)

#define REX_PROFILE_FREE_NAMED_STACK(ptr, depth, pool) \
  do {                                                 \
    if (TracyIsStarted)                                \
      TracyFreeNS(ptr, depth, pool);                   \
  } while (0)

#define REX_PROFILE_SCOPE_DYNAMIC(name)                 \
  ZoneNamed(___tracy_cpu_zone_d, TracyIsStarted);       \
  const std::string_view ___tracy_zone_name_d = (name); \
  ZoneNameV(___tracy_cpu_zone_d, ___tracy_zone_name_d.data(), ___tracy_zone_name_d.size())

#define REX_PROFILE_FRAME() \
  do {                      \
    if (TracyIsStarted)     \
      FrameMark;            \
  } while (0)

#define REX_PROFILE_IS_CONNECTED() (TracyIsStarted && TracyIsConnected)
 
#else

#define REX_PROFILE_SCOPE(name)
#define REX_PROFILE_SCOPE_TEXT(name, detail)
#define REX_PROFILE_THREAD(name)
#define REX_PROFILE_FIBER_ENTER(name) ((void)sizeof(decltype(name)))
#define REX_PROFILE_FIBER_LEAVE()
#define REX_PROFILE_PLOT(name, value)
#define REX_PROFILE_PLOT_F64(name, value)
#define REX_PROFILE_ALLOC(ptr, size)
#define REX_PROFILE_FREE(ptr)
#define REX_PROFILE_ALLOC_NAMED(ptr, size, pool)
#define REX_PROFILE_FREE_NAMED(ptr, pool)
#define REX_PROFILE_ALLOC_STACK(ptr, size, depth)
#define REX_PROFILE_FREE_STACK(ptr, depth)
#define REX_PROFILE_ALLOC_NAMED_STACK(ptr, size, depth, pool)
#define REX_PROFILE_FREE_NAMED_STACK(ptr, depth, pool)
#define REX_PROFILE_SCOPE_DYNAMIC(name)
#define REX_PROFILE_FRAME()
#define REX_PROFILE_IS_CONNECTED() (false)
 
#endif  // REXGLUE_ENABLE_PROFILING
 
namespace rex::platform {

class Profiler {
 public:
  static void Startup() {
#ifdef REXGLUE_ENABLE_PROFILING
    if (!tracy::IsProfilerStarted())
      tracy::StartupProfiler();
#endif
  }

  static void OnThreadEnter(const char* name = nullptr) {
#ifdef REXGLUE_ENABLE_PROFILING
    if (name && tracy::IsProfilerStarted())
      tracy::SetThreadName(name);
#else
    (void)name;
#endif
  }
 
  static void OnThreadExit() {}

  static void EndFrame() {
#ifdef REXGLUE_ENABLE_PROFILING
    if (tracy::IsProfilerStarted()) {
      FrameMark;
    }
#endif
#ifdef REXGLUE_ENABLE_PERF_COUNTERS
    ResetFrameCounters();
    WriteCSVFrame();
#endif
  }
 
  static void Flush() {}

  static void Shutdown() {
#ifdef REXGLUE_ENABLE_PROFILING
    if (tracy::IsProfilerStarted())
      tracy::ShutdownProfiler();
#endif
#ifdef REXGLUE_ENABLE_PERF_COUNTERS
    CloseCSV();
#endif
  }

  static bool IsEnabled() {
#ifdef REXGLUE_ENABLE_PROFILING
    return tracy::IsProfilerStarted();
#else
    return false;
#endif
  }
};
 
}  // namespace rex::platform