FrameStats.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** FrameStats
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
 
#include <array>
#include <chrono>
#include <cstdint>
#include <optional>
 
namespace evan
{
    struct PhaseStats {
        uint64_t lastNs = 0;
 
        uint64_t totalNs = 0;
 
        uint32_t samples = 0;
 
        void add(uint64_t ns) noexcept
        {
            lastNs = ns;
            totalNs += ns;
            ++samples;
        }
 
        void resetWindow() noexcept
        {
            totalNs = 0;
            samples = 0;
        }
 
        [[nodiscard]] uint64_t averageNs() const noexcept
        {
            return samples == 0 ? 0 : totalNs / samples;
        }
    };
 
    class ScopedTimer
    {
        public:
        explicit ScopedTimer(PhaseStats *phase) noexcept
            : _phase(phase)
            , _start(phase != nullptr ? Clock::now() : TimePoint {})
        {
        }
 
        ~ScopedTimer() noexcept
        {
            if (_phase == nullptr) {
                return;
            }
            _phase->add(static_cast<uint64_t>(
                std::chrono::duration_cast<std::chrono::nanoseconds>(
                    Clock::now() - _start)
                    .count()));
        }
 
        ScopedTimer(const ScopedTimer &)            = delete;
        ScopedTimer &operator=(const ScopedTimer &) = delete;
        ScopedTimer(ScopedTimer &&)                 = delete;
        ScopedTimer &operator=(ScopedTimer &&)      = delete;
 
        private:
        using Clock     = std::chrono::steady_clock;
        using TimePoint = Clock::time_point;
 
        PhaseStats *_phase;    
        TimePoint _start;      
    };
 
    struct FrameStats {
        bool enabled = false;
 
        bool gpuAvailable = false;
 
        // Frame-level CPU phases, one sample per frame each.
        PhaseStats transferFlush;    
        PhaseStats preprocess;       
        PhaseStats inFlightWait;     
        PhaseStats acquire;          
        PhaseStats updateUniform;    
        PhaseStats record;           
        PhaseStats submit;           
        PhaseStats renderWait;       
        PhaseStats present;          
        PhaseStats postprocess;      
 
        // Per-view-slot detail, indexed like the frame's view slots.
        std::array<PhaseStats, MAX_SWAPCHAINS>
            updateUniformView;    
        std::array<PhaseStats, MAX_SWAPCHAINS>
            recordView;    
        std::array<PhaseStats, MAX_SWAPCHAINS>
            submitView;    
        std::array<PhaseStats, MAX_SWAPCHAINS>
            gpuPass;    
 
        // Counters, accumulated over the current window.
        uint64_t frames           = 0;    
        uint64_t totalMeshes      = 0;    
        uint64_t visibleMeshes    = 0;    
        uint64_t culledMeshes     = 0;    
        uint64_t skippedMeshes    = 0;    
        uint64_t drawCalls        = 0;    
        uint64_t instancedDraws   = 0;    
        uint64_t pipelineBinds    = 0;    
        uint64_t descriptorBinds  = 0;    
        uint64_t syncCalls        = 0;    
        uint64_t syncSkips        = 0;    
        uint64_t meshCreations    = 0;    
        uint64_t meshDestructions = 0;    
        uint64_t uploadWaits      = 0;    
 
        [[nodiscard]] ScopedTimer timer(PhaseStats &phase) noexcept
        {
            return ScopedTimer(enabled ? &phase : nullptr);
        }
 
        void resetWindow() noexcept;
    };
 
    namespace stats
    {
        [[nodiscard]] bool enabled() noexcept;
 
        void setEnabledForTesting(std::optional<bool> state) noexcept;
 
        void countSync() noexcept;
 
        void countSyncSkip() noexcept;
 
        void countMeshCreation() noexcept;
 
        void countMeshDestruction() noexcept;
 
        void countUploadWait() noexcept;
 
        void takeGlobalDeltas(FrameStats &stats) noexcept;
 
        [[nodiscard]] inline uint64_t maskTimestamp(uint64_t value,
                                                    uint32_t validBits) noexcept
        {
            if (validBits >= 64) {
                return value;
            }
            if (validBits == 0) {
                return 0;
            }
            return value & ((uint64_t { 1 } << validBits) - 1);
        }
 
        [[nodiscard]] inline bool timestampDeltaNs(uint64_t begin, uint64_t end,
                                                   float period,
                                                   uint64_t &deltaNs) noexcept
        {
            if (end < begin || !(period > 0.0f)) {
                return false;
            }
            deltaNs = static_cast<uint64_t>(static_cast<double>(end - begin)
                                            * static_cast<double>(period));
            return true;
        }
    }    // namespace stats
}    // namespace evan