Profile.h

浏览该文件的文档.

#pragma once
 
#ifndef EVENGINE_COMMON_PROFILE_H
#define EVENGINE_COMMON_PROFILE_H
 
#include "common/Export.h"
 
#include <atomic>
#include <cstdint>
#include <string>
#include <vector>
 
// ---------------------------------------------------------------------------
// Engine-wide profiling core (Tracy / UE Insights style scoped zones).
//
// Any module may sprinkle scoped zones at its per-frame entry points:
//
//     void World::update(float dt) {
//         EV_PROFILE_MODULE("physics", "World::update");
//         ...
//     }
//
// Zones are cheap when disabled (a single atomic branch); when enabled they
// push {name, module, thread, start, end, parent} into a per-thread buffer and
// frameMark() aggregates the frame into a call tree with self/total time per
// module and per zone. This core lives in common/ so lower layers can use it
// without violating the module layering rules.
// ---------------------------------------------------------------------------
 
namespace eve::prof {
 
struct EVENGINE_API_FOUNDATION_INLINE ZoneRecord {
    const char* name      = nullptr;   // pointer is static storage, never freed
    uint32_t    module    = 0;         // interned module id (0 = default)
    uint32_t    threadId  = 0;
    int32_t     parent    = -1;        // index into the same thread's buffer
    int16_t     depth     = 0;
    int64_t     startNs   = 0;
    int64_t     endNs     = 0;         // 0 while open
    uint8_t     kind      = 0;         // 0 = CPU, 1 = GPU
};
 
struct EVENGINE_API_FOUNDATION_INLINE ZoneSample {
    std::string module;
    std::string name;
    std::string thread;
    double      selfMs   = 0.0;
    double      totalMs  = 0.0;
    int         count    = 0;
    int         minDepth = 0x7fffffff;
};
 
class EVENGINE_API_FOUNDATION Profiler {
public:
    static void setEnabled(bool on);
    static bool enabled();
 
    static void zoneBegin(const char* name, const char* module = nullptr);
    static void zoneEnd();
 
    static double frameMark();
 
    static bool hasFrame();
    static const std::vector<ZoneSample>& lastFrame();
    static std::string textReport();
 
    static void reset();
 
    static uint32_t moduleId(const char* module);
 
private:
    struct ThreadBuffer;
    struct Frame;
 
    static ThreadBuffer& currentBuffer();
 
    static std::vector<ThreadBuffer*>& threads();
    static Frame& lastFrameStorage();
    static bool& hasFrameFlag();
};
 
class EVENGINE_API_FOUNDATION_INLINE ZoneScope {
public:
    ZoneScope(const char* name, const char* module = nullptr) {
        Profiler::zoneBegin(name, module);
    }
    ~ZoneScope() { Profiler::zoneEnd(); }
    ZoneScope(const ZoneScope&)            = delete;
    ZoneScope& operator=(const ZoneScope&) = delete;
};
 
}  // namespace eve::prof
 
#define EV_PROFILE_CAT_I(a, b) a##b
#define EV_PROFILE_CAT(a, b) EV_PROFILE_CAT_I(a, b)
 
#define EV_PROFILE_ZONE_FUNC() \
    ::eve::prof::ZoneScope EV_PROFILE_CAT(ev_zone_, __LINE__)(__func__)
 
#define EV_PROFILE_ZONE(name) \
    ::eve::prof::ZoneScope EV_PROFILE_CAT(ev_zone_, __LINE__)(name)
 
#define EV_PROFILE_MODULE(module, name) \
    ::eve::prof::ZoneScope EV_PROFILE_CAT(ev_zone_, __LINE__)(name, module)
 
#endif