Profiler.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <SDL3/SDL.h>
 
#include <array>
#include <atomic>
#include <cstdint>
#include <functional>
#include <limits>
 
namespace group2::perf
{

inline constexpr std::size_t k_maxScopes = 64;

inline constexpr std::size_t k_histogramBuckets = 32;

using ScopeId = std::uint16_t;
inline constexpr ScopeId k_invalidScope = static_cast<ScopeId>(-1);

ScopeId registerScope(const char* name);

const char* scopeName(ScopeId id);

std::size_t scopeCount();

struct PerScopeStats
{
    std::atomic<std::uint64_t> count{0};
    std::atomic<std::uint64_t> sumTicks{0};
    std::atomic<std::uint64_t> minTicks{std::numeric_limits<std::uint64_t>::max()};
    std::atomic<std::uint64_t> maxTicks{0};
    std::array<std::atomic<std::uint32_t>, k_histogramBuckets> hist{};
};

struct NetworkCounters
{
    std::atomic<std::uint64_t> bytesSent{0};
    std::atomic<std::uint64_t> bytesRecv{0};
    std::atomic<std::uint64_t> snapshotsSent{0};
    std::atomic<std::uint64_t> packetsSent{0};
    std::atomic<std::uint64_t> packetsRecv{0};
    std::atomic<std::uint32_t> peakBacklog{0};
    std::atomic<std::uint32_t> clientCount{0};
};

struct Snapshot
{
    struct ScopeSummary
    {
        const char* name = "";
        std::uint64_t count = 0;
        std::uint64_t minNs = 0;
        std::uint64_t p50Ns = 0;
        std::uint64_t p99Ns = 0;
        std::uint64_t maxNs = 0;
        std::uint64_t meanNs = 0;
    };
 
    std::array<ScopeSummary, k_maxScopes> scopes{};
    std::size_t scopeNum = 0;

    std::uint64_t tickCount = 0;
    std::uint64_t tickSumNs = 0;
    std::uint64_t tickMaxNs = 0;
    std::uint64_t tickP99Ns = 0;

    std::uint64_t bytesSent = 0;
    std::uint64_t bytesRecv = 0;
    std::uint64_t snapshotsSent = 0;
    std::uint64_t packetsSent = 0;
    std::uint64_t packetsRecv = 0;
    std::uint32_t peakBacklog = 0;
    std::uint32_t clientCount = 0;

    std::uint64_t windowStartMs = 0;
    std::uint64_t windowEndMs = 0;
};

extern std::atomic<bool> enabled;

void initFromEnv();

void startAggregator(std::function<void(const Snapshot&)> cb);

void stopAggregator();

void recordSample(ScopeId id, std::uint64_t ticks) noexcept;

void tickEnd(std::uint64_t tickWallNs) noexcept;

inline NetworkCounters& net()
{
    static NetworkCounters c;
    return c;
}

inline std::uint64_t ticksToNs(std::uint64_t ticks) noexcept
{
    static const std::uint64_t k_freq = SDL_GetPerformanceFrequency();
    // `ticks * 1e9 / freq` with intermediate clamp to avoid overflow at
    // ~18.4 s on a 1 GHz counter. We never measure that long.
    return (ticks / k_freq) * 1'000'000'000ULL + ((ticks % k_freq) * 1'000'000'000ULL) / k_freq;
}

class ScopeTimer
{
public:
    explicit ScopeTimer(ScopeId id) noexcept : scopeId(id), recording(enabled.load(std::memory_order_relaxed))
    {
        if (recording)
            startCounter = SDL_GetPerformanceCounter();
    }
    ~ScopeTimer() noexcept
    {
        if (!recording)
            return;
        const std::uint64_t end = SDL_GetPerformanceCounter();
        recordSample(scopeId, end - startCounter);
    }
 
    ScopeTimer(const ScopeTimer&) = delete;
    ScopeTimer& operator=(const ScopeTimer&) = delete;
    ScopeTimer(ScopeTimer&&) = delete;
    ScopeTimer& operator=(ScopeTimer&&) = delete;
 
private:
    ScopeId scopeId{k_invalidScope};
    bool recording{false};
    std::uint64_t startCounter{0};
};
 
} // namespace group2::perf
 
// ────────────────────────────────────────────────────────────────────
// Macros
// ────────────────────────────────────────────────────────────────────

#define GROUP2_PROF_CAT2(a, b) a##b
#define GROUP2_PROF_CAT(a, b) GROUP2_PROF_CAT2(a, b)

#define GROUP2_PROF_SCOPE(label)                                                                                       \
    ::group2::perf::ScopeTimer GROUP2_PROF_CAT(_gpScope, __LINE__)                                                     \
    {                                                                                                                  \
        []() noexcept -> ::group2::perf::ScopeId {                                                                     \
            static const ::group2::perf::ScopeId k_id = ::group2::perf::registerScope(label);                          \
            return k_id;                                                                                               \
        }()                                                                                                            \
    }