stats.h

Go to the documentation of this file.

 
#ifdef FLECS_STATS
 
#ifndef FLECS_STATS_H
#define FLECS_STATS_H
 
#ifndef FLECS_MODULE
#define FLECS_MODULE
#endif
 
#ifndef FLECS_PIPELINE
#define FLECS_PIPELINE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ECS_STAT_WINDOW (60)
 
typedef struct ecs_gauge_t {
    ecs_float_t avg[ECS_STAT_WINDOW];
    ecs_float_t min[ECS_STAT_WINDOW];
    ecs_float_t max[ECS_STAT_WINDOW];
} ecs_gauge_t;
 
typedef struct ecs_counter_t {
    ecs_gauge_t rate;                     
    double value[ECS_STAT_WINDOW];
} ecs_counter_t;
 
typedef union ecs_metric_t {
    ecs_gauge_t gauge;
    ecs_counter_t counter;
} ecs_metric_t;
 
typedef struct ecs_world_stats_t {
    int64_t first_;
 
    /* Entities */
    struct {
        ecs_metric_t count;               
        ecs_metric_t not_alive_count;     
    } entities;
 
    /* Component ids */
    struct {
        ecs_metric_t tag_count;           
        ecs_metric_t component_count;     
        ecs_metric_t pair_count;          
        ecs_metric_t type_count;          
        ecs_metric_t create_count;        
        ecs_metric_t delete_count;        
    } components;
 
    /* Tables */
    struct {
        ecs_metric_t count;                
        ecs_metric_t empty_count;          
        ecs_metric_t create_count;         
        ecs_metric_t delete_count;         
    } tables;
 
    /* Queries & events */
    struct {
        ecs_metric_t query_count;          
        ecs_metric_t observer_count;       
        ecs_metric_t system_count;         
    } queries;
 
    /* Commands */
    struct {
        ecs_metric_t add_count;
        ecs_metric_t remove_count;
        ecs_metric_t delete_count;
        ecs_metric_t clear_count;
        ecs_metric_t set_count;
        ecs_metric_t ensure_count;
        ecs_metric_t modified_count;
        ecs_metric_t other_count;
        ecs_metric_t discard_count;
        ecs_metric_t batched_entity_count;
        ecs_metric_t batched_count;
    } commands;
 
    /* Frame data */
    struct {
        ecs_metric_t frame_count;          
        ecs_metric_t merge_count;          
        ecs_metric_t rematch_count;        
        ecs_metric_t pipeline_build_count; 
        ecs_metric_t systems_ran;          
        ecs_metric_t observers_ran;        
        ecs_metric_t event_emit_count;     
    } frame;
 
    /* Timing */
    struct {
        ecs_metric_t world_time_raw;       
        ecs_metric_t world_time;           
        ecs_metric_t frame_time;           
        ecs_metric_t system_time;          
        ecs_metric_t emit_time;            
        ecs_metric_t merge_time;           
        ecs_metric_t rematch_time;         
        ecs_metric_t fps;                  
        ecs_metric_t delta_time;           
    } performance;
 
    struct {
        /* Memory allocation data */
        ecs_metric_t alloc_count;          
        ecs_metric_t realloc_count;        
        ecs_metric_t free_count;           
        ecs_metric_t outstanding_alloc_count; 
        /* Memory allocator data */
        ecs_metric_t block_alloc_count;    
        ecs_metric_t block_free_count;     
        ecs_metric_t block_outstanding_alloc_count; 
        ecs_metric_t stack_alloc_count;    
        ecs_metric_t stack_free_count;     
        ecs_metric_t stack_outstanding_alloc_count; 
    } memory;
 
    /* HTTP statistics */
    struct {
        ecs_metric_t request_received_count;
        ecs_metric_t request_invalid_count;
        ecs_metric_t request_handled_ok_count;
        ecs_metric_t request_handled_error_count;
        ecs_metric_t request_not_handled_count;
        ecs_metric_t request_preflight_count;
        ecs_metric_t send_ok_count;
        ecs_metric_t send_error_count;
        ecs_metric_t busy_count;
    } http;
 
    int64_t last_;
 
    int32_t t;
} ecs_world_stats_t;
 
typedef struct ecs_query_stats_t {
    int64_t first_;
    ecs_metric_t result_count;              
    ecs_metric_t matched_table_count;       
    ecs_metric_t matched_entity_count;      
    int64_t last_;
 
    int32_t t; 
} ecs_query_stats_t;
 
typedef struct ecs_system_stats_t {
    int64_t first_;
    ecs_metric_t time_spent;       
    int64_t last_;
 
    bool task;                     
    ecs_query_stats_t query;
} ecs_system_stats_t;
 
typedef struct ecs_sync_stats_t {
    int64_t first_;
    ecs_metric_t time_spent;
    ecs_metric_t commands_enqueued;
    int64_t last_;
 
    int32_t system_count;
    bool multi_threaded;
    bool immediate;
} ecs_sync_stats_t;
 
typedef struct ecs_pipeline_stats_t {
    /* Allow for initializing struct with {0} */
    int8_t canary_;
 
    ecs_vec_t systems;
 
    ecs_vec_t sync_points;
 
    int32_t t;
 
    int32_t system_count;        
    int32_t active_system_count; 
    int32_t rebuild_count;       
} ecs_pipeline_stats_t;
 
FLECS_API
void ecs_world_stats_get(
    const ecs_world_t *world,
    ecs_world_stats_t *stats);
 
FLECS_API
void ecs_world_stats_reduce(
    ecs_world_stats_t *dst,
    const ecs_world_stats_t *src);
 
FLECS_API
void ecs_world_stats_reduce_last(
    ecs_world_stats_t *stats,
    const ecs_world_stats_t *old,
    int32_t count);
 
FLECS_API
void ecs_world_stats_repeat_last(
    ecs_world_stats_t *stats);
 
FLECS_API
void ecs_world_stats_copy_last(
    ecs_world_stats_t *dst,
    const ecs_world_stats_t *src);
 
FLECS_API
void ecs_world_stats_log(
    const ecs_world_t *world,
    const ecs_world_stats_t *stats);
 
FLECS_API
void ecs_query_stats_get(
    const ecs_world_t *world,
    const ecs_query_t *query,
    ecs_query_stats_t *stats);
 
FLECS_API 
void ecs_query_cache_stats_reduce(
    ecs_query_stats_t *dst,
    const ecs_query_stats_t *src);
 
FLECS_API
void ecs_query_cache_stats_reduce_last(
    ecs_query_stats_t *stats,
    const ecs_query_stats_t *old,
    int32_t count);
 
FLECS_API
void ecs_query_cache_stats_repeat_last(
    ecs_query_stats_t *stats);
 
FLECS_API
void ecs_query_cache_stats_copy_last(
    ecs_query_stats_t *dst,
    const ecs_query_stats_t *src);
 
FLECS_API
bool ecs_system_stats_get(
    const ecs_world_t *world,
    ecs_entity_t system,
    ecs_system_stats_t *stats);
 
FLECS_API
void ecs_system_stats_reduce(
    ecs_system_stats_t *dst,
    const ecs_system_stats_t *src);
 
FLECS_API
void ecs_system_stats_reduce_last(
    ecs_system_stats_t *stats,
    const ecs_system_stats_t *old,
    int32_t count);
 
FLECS_API
void ecs_system_stats_repeat_last(
    ecs_system_stats_t *stats);
 
FLECS_API
void ecs_system_stats_copy_last(
    ecs_system_stats_t *dst,
    const ecs_system_stats_t *src);
 
FLECS_API
bool ecs_pipeline_stats_get(
    ecs_world_t *world,
    ecs_entity_t pipeline,
    ecs_pipeline_stats_t *stats);
 
FLECS_API
void ecs_pipeline_stats_fini(
    ecs_pipeline_stats_t *stats);
 
FLECS_API
void ecs_pipeline_stats_reduce(
    ecs_pipeline_stats_t *dst,
    const ecs_pipeline_stats_t *src);
 
FLECS_API
void ecs_pipeline_stats_reduce_last(
    ecs_pipeline_stats_t *stats,
    const ecs_pipeline_stats_t *old,
    int32_t count);
 
FLECS_API
void ecs_pipeline_stats_repeat_last(
    ecs_pipeline_stats_t *stats);
 
FLECS_API
void ecs_pipeline_stats_copy_last(
    ecs_pipeline_stats_t *dst,
    const ecs_pipeline_stats_t *src);
 
FLECS_API
void ecs_metric_reduce(
    ecs_metric_t *dst,
    const ecs_metric_t *src,
    int32_t t_dst,
    int32_t t_src);
 
FLECS_API
void ecs_metric_reduce_last(
    ecs_metric_t *m,
    int32_t t,
    int32_t count);
 
FLECS_API
void ecs_metric_copy(
    ecs_metric_t *m,
    int32_t dst,
    int32_t src);
 
FLECS_API extern ECS_COMPONENT_DECLARE(FlecsStats);        
FLECS_API extern ECS_COMPONENT_DECLARE(EcsWorldStats);     
FLECS_API extern ECS_COMPONENT_DECLARE(EcsWorldSummary);   
FLECS_API extern ECS_COMPONENT_DECLARE(EcsSystemStats);    
FLECS_API extern ECS_COMPONENT_DECLARE(EcsPipelineStats);  
/* Memory statistics components */
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_entities_memory_t);    
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_component_index_memory_t); 
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_query_memory_t);           
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_component_memory_t);       
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_table_memory_t);           
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_misc_memory_t);        
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_table_histogram_t);        
FLECS_API extern ECS_COMPONENT_DECLARE(ecs_allocator_memory_t); 
FLECS_API extern ECS_COMPONENT_DECLARE(EcsWorldMemory);               
FLECS_API extern ecs_entity_t EcsPeriod1s;                 
FLECS_API extern ecs_entity_t EcsPeriod1m;                 
FLECS_API extern ecs_entity_t EcsPeriod1h;                 
FLECS_API extern ecs_entity_t EcsPeriod1d;                 
FLECS_API extern ecs_entity_t EcsPeriod1w;                 
typedef struct {
    ecs_ftime_t elapsed;
    int32_t reduce_count;
} EcsStatsHeader;
 
typedef struct {
    EcsStatsHeader hdr;
    ecs_world_stats_t *stats;
} EcsWorldStats;
 
typedef struct {
    EcsStatsHeader hdr;
    ecs_map_t stats;
} EcsSystemStats;
 
typedef struct {
    EcsStatsHeader hdr;
    ecs_map_t stats;
} EcsPipelineStats;
 
typedef struct {
    /* Time */
    double target_fps;          
    double time_scale;          
    double fps;                 
    /* Totals */
    double frame_time_total;    
    double system_time_total;   
    double merge_time_total;    
    int64_t entity_count;
    int64_t table_count;
    int64_t frame_count;        
    int64_t command_count;      
    int64_t merge_count;        
    int64_t systems_ran_total;
    int64_t observers_ran_total;
    int64_t queries_ran_total;
 
    int32_t tag_count;           
    int32_t component_count;     
    int32_t pair_count;          
    /* Per frame */
    double frame_time_frame;    
    double system_time_frame;   
    double merge_time_frame;    
    int64_t merge_count_frame;
    int64_t systems_ran_frame;
    int64_t observers_ran_frame;
    int64_t queries_ran_frame;
    int64_t command_count_frame; 
    double simulation_time;     
    uint32_t uptime;            
    /* Build info */
    ecs_build_info_t build_info; 
} EcsWorldSummary;
 
typedef struct {
    int32_t alive_count;                 
    int32_t not_alive_count;             
    ecs_size_t bytes_entity_index;       
    ecs_size_t bytes_names;              
    ecs_size_t bytes_doc_strings;        
} ecs_entities_memory_t;
 
/* Component memory. */
typedef struct {
    int32_t instances;                  
    ecs_size_t bytes_table_components;  
    ecs_size_t bytes_table_components_unused; 
    ecs_size_t bytes_toggle_bitsets;    
    ecs_size_t bytes_sparse_components; 
} ecs_component_memory_t;
 
typedef struct {
    int32_t count;                      
    ecs_size_t bytes_component_record;  
    ecs_size_t bytes_table_cache;       
    ecs_size_t bytes_name_index;        
    ecs_size_t bytes_ordered_children;  
    ecs_size_t bytes_reachable_cache;   
} ecs_component_index_memory_t;
 
typedef struct {
    int32_t count;                      
    int32_t cached_count;               
    ecs_size_t bytes_query;             
    ecs_size_t bytes_cache;             
    ecs_size_t bytes_group_by;          
    ecs_size_t bytes_order_by;          
    ecs_size_t bytes_plan;              
    ecs_size_t bytes_terms;             
    ecs_size_t bytes_misc;              
} ecs_query_memory_t;
 
#define ECS_TABLE_MEMORY_HISTOGRAM_BUCKET_COUNT 14
#define ECS_TABLE_MEMORY_HISTOGRAM_MAX_COUNT (1 << ECS_TABLE_MEMORY_HISTOGRAM_BUCKET_COUNT)
 
typedef struct {
    int32_t count;                      
    int32_t empty_count;                
    int32_t column_count;               
    ecs_size_t bytes_table;             
    ecs_size_t bytes_type;              
    ecs_size_t bytes_entities;          
    ecs_size_t bytes_overrides;         
    ecs_size_t bytes_columns;           
    ecs_size_t bytes_table_records;     
    ecs_size_t bytes_column_map;        
    ecs_size_t bytes_component_map;     
    ecs_size_t bytes_dirty_state;       
    ecs_size_t bytes_edges;             
} ecs_table_memory_t;
 
typedef struct {
    int32_t entity_counts[ECS_TABLE_MEMORY_HISTOGRAM_BUCKET_COUNT];
} ecs_table_histogram_t;
 
typedef struct {
    ecs_size_t bytes_world;             
    ecs_size_t bytes_observers;         
    ecs_size_t bytes_systems;           
    ecs_size_t bytes_pipelines;         
    ecs_size_t bytes_table_lookup;      
    ecs_size_t bytes_component_record_lookup; 
    ecs_size_t bytes_type_info;         
    ecs_size_t bytes_commands;          
    ecs_size_t bytes_rematch_monitor;   
    ecs_size_t bytes_component_ids;     
    ecs_size_t bytes_reflection;        
    ecs_size_t bytes_stats;             
    ecs_size_t bytes_rest;              
} ecs_misc_memory_t;
 
typedef struct {
    ecs_size_t bytes_graph_edge;        
    ecs_size_t bytes_component_record;  
    ecs_size_t bytes_pair_record;       
    ecs_size_t bytes_table_diff;        
    ecs_size_t bytes_sparse_chunk;      
    ecs_size_t bytes_allocator;         
    ecs_size_t bytes_stack_allocator;   
    ecs_size_t bytes_cmd_entry_chunk;   
    ecs_size_t bytes_query_impl;        
    ecs_size_t bytes_query_cache;       
    ecs_size_t bytes_misc;              
} ecs_allocator_memory_t;
 
typedef struct {
    ecs_entities_memory_t entities;
    ecs_component_memory_t components;
    ecs_component_index_memory_t component_index;
    ecs_query_memory_t queries;
    ecs_table_memory_t tables;
    ecs_table_histogram_t table_histogram;
    ecs_misc_memory_t misc;
    ecs_allocator_memory_t allocators;
    double collection_time; 
} EcsWorldMemory;
 
FLECS_API
ecs_entities_memory_t ecs_entity_memory_get(
    const ecs_world_t *world);
 
void ecs_component_record_memory_get(
    const ecs_component_record_t *cr,
    ecs_component_index_memory_t *result);
 
FLECS_API
ecs_component_index_memory_t ecs_component_index_memory_get(
    const ecs_world_t *world);
 
FLECS_API
void ecs_query_memory_get(
    const ecs_query_t *query,
    ecs_query_memory_t *result);
 
FLECS_API
ecs_query_memory_t ecs_queries_memory_get(
    const ecs_world_t *world);
 
void ecs_table_component_memory_get(
    const ecs_table_t *table,
    ecs_component_memory_t *result);
 
FLECS_API
ecs_component_memory_t ecs_component_memory_get(
    const ecs_world_t *world);
 
void ecs_table_memory_get(
    const ecs_table_t *table,
    ecs_table_memory_t *result);
 
FLECS_API
ecs_table_memory_t ecs_tables_memory_get(
    const ecs_world_t *world);
 
FLECS_API
ecs_table_histogram_t ecs_table_histogram_get(
    const ecs_world_t *world);
 
FLECS_API
ecs_misc_memory_t ecs_misc_memory_get(
    const ecs_world_t *world);
 
FLECS_API
ecs_allocator_memory_t ecs_allocator_memory_get(
    const ecs_world_t *world);
 
FLECS_API
ecs_size_t ecs_memory_get(
    const ecs_world_t *world);
 
 
FLECS_API
void FlecsStatsImport(
    ecs_world_t *world);
 
#ifdef __cplusplus
}
#endif
 
#endif
 
#endif