Frame Budget & Profiling in Game C++

Frame time breakdown (16.67ms target):
┌─────────────────────────────────────────┐
│ Input handling          0.1ms           │
│ Physics update          2.0ms           │
│ AI / behavior trees     1.5ms           │
│ Animation update        1.0ms           │
│ Gameplay scripts        1.0ms           │
│ Culling + visibility    0.5ms           │
│ Draw call submission    2.0ms           │
│ GPU render              6.0ms           │
│ Audio mix               0.5ms           │
│ OS overhead / vsync     ~0.5ms          │
│ Headroom                1.57ms          │
└─────────────────────────────────────────┘
Total: 16.67ms

#include <chrono>

class FrameTimer {
public:
    void beginFrame() {
        frame_start_ = std::chrono::high_resolution_clock::now();
    }

    double endFrame() {
        auto end = std::chrono::high_resolution_clock::now();
        double ms = std::chrono::duration<double, std::milli>(end - frame_start_).count();
        history_[index_++ % HISTORY] = ms;
        return ms;
    }

    double average() const {
        double sum = 0;
        for (auto v : history_) sum += v;
        return sum / HISTORY;
    }

    double percentile95() const {
        auto sorted = history_;
        std::sort(sorted.begin(), sorted.end());
        return sorted[static_cast<int>(HISTORY * 0.95)];
    }

private:
    static constexpr size_t HISTORY = 128;
    std::chrono::high_resolution_clock::time_point frame_start_;
    std::array<double, HISTORY> history_{};
    size_t index_ = 0;
};

// CMakeLists.txt
FetchContent_Declare(tracy
    GIT_REPOSITORY https://github.com/wolfpld/tracy
    GIT_TAG v0.11.0)
FetchContent_MakeAvailable(tracy)
target_link_libraries(MyGame PRIVATE Tracy::TracyClient)
target_compile_definitions(MyGame PRIVATE TRACY_ENABLE)

// main.cpp — one-time setup
#include <tracy/Tracy.hpp>

int main() {
    // Tracy connects automatically when the viewer opens
    while (running) {
        FrameMark;  // marks frame boundary in Tracy timeline
        gameLoop();
    }
}

#include <tracy/Tracy.hpp>

void PhysicsSystem::update(float dt) {
    ZoneScoped;  // names zone after function automatically

    {
        ZoneScopedN("BroadPhase");
        broadPhase_.update();
    }
    {
        ZoneScopedN("NarrowPhase");
        narrowPhase_.solve(dt);
    }
}

// With color coding
void AISystem::update() {
    ZoneScopedC(tracy::Color::Orange);
    for (auto& agent : agents_)
        agent.tick();
}

// Track values over time
TracyPlot("LiveEntities", static_cast<int64_t>(entities_.size()));
TracyPlot("DrawCalls", static_cast<int64_t>(renderer_.drawCallCount()));

// Tag all allocations in Tracy
void* operator new(size_t size) {
    void* ptr = malloc(size);
    TracyAlloc(ptr, size);
    return ptr;
}

void operator delete(void* ptr) noexcept {
    TracyFree(ptr);
    free(ptr);
}

#include <optick.h>

void GameLoop() {
    OPTICK_FRAME("MainThread");

    {
        OPTICK_EVENT("Physics");
        physics_.update(dt);
    }
    {
        OPTICK_EVENT("Rendering");
        OPTICK_TAG("DrawCalls", renderer_.drawCallCount());
        renderer_.render();
    }
}

# Linux — record with call graph
perf record -g --call-graph dwarf -p $(pidof game)
perf report --sort=symbol,dso

# Generate flamegraph
perf script | stackcollapse-perf.pl | flamegraph.pl > frame.svg

// Isolate a suspect function
#include <benchmark/benchmark.h>

static void BM_AIUpdate(benchmark::State& state) {
    AISystem ai;
    ai.spawnAgents(state.range(0));
    for (auto _ : state)
        ai.update(0.016f);
    state.SetItemsProcessed(state.iterations() * state.range(0));
}

BENCHMARK(BM_AIUpdate)->Range(64, 4096);
BENCHMARK_MAIN();

// GPU timestamp queries (OpenGL example)
GLuint queries[2];
glGenQueries(2, queries);

glQueryCounter(queries[0], GL_TIMESTAMP);
drawScene();
glQueryCounter(queries[1], GL_TIMESTAMP);

GLint done = 0;
while (!done)
    glGetQueryObjectiv(queries[1], GL_QUERY_RESULT_AVAILABLE, &done);

GLuint64 start_ns, end_ns;
glGetQueryObjectui64v(queries[0], GL_QUERY_RESULT, &start_ns);
glGetQueryObjectui64v(queries[1], GL_QUERY_RESULT, &end_ns);
double gpu_ms = (end_ns - start_ns) / 1e6;

class AIScheduler {
public:
    // Budget: update at most `budget_ms` worth of AI per frame
    void update(float budget_ms, float dt) {
        auto deadline = std::chrono::high_resolution_clock::now()
            + std::chrono::duration<float, std::milli>(budget_ms);

        while (!queue_.empty()) {
            if (std::chrono::high_resolution_clock::now() >= deadline)
                break;  // defer remaining to next frame

            auto* agent = queue_.front();
            queue_.pop();
            agent->think(dt);
            // Re-enqueue at next desired tick time
            queue_.push(agent);
        }
    }

private:
    std::queue<AIAgent*> queue_;
};

// Detect stutter frames
void detectStutter(double frame_ms, double target_ms) {
    if (frame_ms > target_ms * 1.5) {
        // Log spike with Tracy marker
        TracyMessageL("STUTTER FRAME");
        logFrameBreakdown();
    }
}