perf_timer.h

Go to the documentation of this file.

 
#ifndef PERF_TIMER_H
#define PERF_TIMER_H
 
#include "gl_common.h"
#include <time.h>
 
typedef struct {
    struct timespec start; 
    struct timespec end;   
} PerfTimer;
 
typedef struct {
    GLuint query_start; 
    GLuint query_end;   
    int active; 
} GPUTimer;
 
#ifdef TRACY_ENABLE
#include <tracy/TracyC.h>
#endif
 
typedef struct {
    PerfTimer cpu; 
    GPUTimer gpu;  
#ifdef TRACY_ENABLE
    TracyCZoneCtx tracy_ctx; 
    TracyCZoneCtx host_ctx;  
#endif
} HybridTimer;
 
/* ========================================================================= */
/* CPU Timer API                                                             */
/* ========================================================================= */
 
void perf_timer_start(PerfTimer* timer);
 
double perf_timer_elapsed_ms(PerfTimer* timer);
 
double perf_timer_elapsed_us(PerfTimer* timer);
 
double perf_timer_elapsed_s(PerfTimer* timer);
 
/* ========================================================================= */
/* GPU Timer API                                                             */
/* ========================================================================= */
 
void gpu_timer_start(GPUTimer* timer);
 
void gpu_timer_stop(GPUTimer* timer);
 
double gpu_timer_elapsed_ms(GPUTimer* timer, int wait_for_result);
 
void gpu_timer_cleanup(GPUTimer* timer);
 
/* ========================================================================= */
/* Hybrid Timer API                                                          */
/* ========================================================================= */
 
HybridTimer perf_hybrid_start(void);
 
void perf_hybrid_stop(HybridTimer* timer, const char* label);
 
double perf_hybrid_stop_debug(HybridTimer* timer, const char* label);
 
/* ========================================================================= */
/* Macro Helpers                                                             */
/* ========================================================================= */
 
#define PERF_MEASURE_MS(var_name)                                              \
    double var_name = 0.0;                                                 \
    for (PerfTimer                                                         \
             _timer##var_name = {0},                                       \
             *_run = (perf_timer_start(&_timer##var_name), (PerfTimer*)1); \
         _run;                                                             \
         var_name = perf_timer_elapsed_ms(&_timer##var_name), _run = NULL)
 
#define PERF_MEASURE_LOG(label)                                            \
    for (PerfTimer _timer = {0},                                       \
                   *_run = (perf_timer_start(&_timer), (PerfTimer*)1); \
         _run; LOG_INFO("perf", "%s: %.2f ms", label,                  \
                        perf_timer_elapsed_ms(&_timer)),               \
                   _run = NULL)
 
#define GPU_MEASURE_MS(var_name)                                           \
    double var_name = 0.0;                                             \
    for (GPUTimer _gpu_timer##var_name = {0},                          \
                  *_gpu_run = (gpu_timer_start(&_gpu_timer##var_name), \
                               (GPUTimer*)1);                          \
         _gpu_run;                                                     \
         var_name = gpu_timer_elapsed_ms(&_gpu_timer##var_name, 1),    \
                  gpu_timer_cleanup(&_gpu_timer##var_name),            \
                  _gpu_run = NULL)
 
#define GPU_MEASURE_LOG(label)                                             \
    for (GPUTimer                                                      \
             _gpu_timer = {0},                                         \
             *_gpu_run = (gpu_timer_start(&_gpu_timer), (GPUTimer*)1); \
         _gpu_run; LOG_INFO("perf.gpu", "%s: %.2f ms", label,          \
                            gpu_timer_elapsed_ms(&_gpu_timer, 1)),     \
             gpu_timer_cleanup(&_gpu_timer), _gpu_run = NULL)
 
#define HYBRID_MEASURE_LOG(label)                                             \
    for (HybridTimer _h = perf_hybrid_start(), *_h_run = (HybridTimer*)1; \
         _h_run; perf_hybrid_stop(&_h, label), _h_run = NULL)
 
#define HYBRID_MEASURE_DEBUG_MS(var_name, label)                              \
    double var_name = 0.0;                                                \
    for (HybridTimer _h##var_name = perf_hybrid_start(),                  \
                     *_h_run = (HybridTimer*)1;                           \
         _h_run; var_name = perf_hybrid_stop_debug(&_h##var_name, label), \
                     _h_run = NULL)
 
typedef struct {
    HybridTimer timer;
    const char* label;
} HybridTimerRAII;
 
static inline void hybrid_timer_cleanup_raii(HybridTimerRAII* timer_raii)
{
    perf_hybrid_stop(&timer_raii->timer, timer_raii->label);
}
 
#define HYBRID_FUNC_TIMER(label)                                \
    HybridTimerRAII _h_raii                                 \
        __attribute__((cleanup(hybrid_timer_cleanup_raii))) \
        __attribute__((unused)) = {perf_hybrid_start(), label}
 
#endif /* PERF_TIMER_H */