stats.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace threadman {
 
enum class ThreadState : std::uint8_t {
    Starting,   
    Running,    
    Idle,       
    Retiring,   
    Completed,  
    Failed,     
};
 
enum class TaskState : std::uint8_t {
    Queued,     
    Running,    
    Completed,  
    Failed,     
    Cancelled,  
};
 
enum class PoolState : std::uint8_t {
    Running,       
    ShuttingDown,  
    ShutdownNow,   
    Terminated,    
};
 
struct ThreadSnapshot {
    std::uint64_t id = 0;                  
    std::string name;                      
    std::uint64_t native_id = 0;           
    std::optional<std::uint64_t> pool_id;  
    ThreadState state = ThreadState::Starting;
    std::chrono::nanoseconds run_duration{0};  
    bool failed = false;                       
    bool is_core = true;                       
};
 
struct ThreadPoolStats {
    std::uint64_t pool_id = 0;
    std::string name;
    PoolState state = PoolState::Running;
    std::size_t workers = 0;       
    std::size_t core_workers = 0;  
    std::size_t max_workers = 0;
    std::size_t active = 0;  
    std::size_t idle = 0;    
    std::size_t queued = 0;  
    std::uint64_t completed = 0;
    std::uint64_t failed = 0;
    std::chrono::nanoseconds avg_execution_duration{
        0};  
    std::uint64_t scale_ups = 0;
    std::uint64_t scale_downs = 0;
};
 
struct TaskSnapshot {
    std::uint64_t id = 0;
    std::optional<std::string> name;
    std::uint64_t pool_id = 0;
    TaskState state = TaskState::Queued;
    std::chrono::steady_clock::time_point created_at;
    std::optional<std::chrono::steady_clock::time_point> started_at;
    std::optional<std::chrono::steady_clock::time_point> finished_at;
    bool failed = false;
};
 
struct FutureSnapshot {
    bool ready = false;
    bool has_exception = false;
    std::uint32_t continuation_count = 0;
    bool shared = false;
};
 
struct ManagerSummary {
    std::chrono::system_clock::time_point wall_clock;
    std::size_t live_threads = 0;
    std::size_t total_pools = 0;
    std::size_t total_live_workers = 0;
    std::size_t total_queued = 0;
    std::uint64_t total_completed = 0;
    std::uint64_t total_failed = 0;
    std::vector<ThreadPoolStats> per_pool_stats;
    std::vector<TaskSnapshot> stuck_tasks;
};
 
struct StuckTaskEvent {
    TaskSnapshot task;
    std::chrono::nanoseconds running_for{0};
    std::uint64_t pool_id = 0;
};
 
}  // namespace threadman