thread_info.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "job_info.h"
 
#include <chrono>
#include <cstdint>
#include <iomanip>
#include <optional>
#include <sstream>
#include <string>
#include <thread>
 
namespace kcenon::thread::diagnostics
{
    enum class worker_state
    {
        idle,       
        active,     
        stopping,   
        stopped     
    };
 
    [[nodiscard]] inline auto worker_state_to_string(worker_state state) -> std::string
    {
        switch (state)
        {
            case worker_state::idle: return "IDLE";
            case worker_state::active: return "ACTIVE";
            case worker_state::stopping: return "STOPPING";
            case worker_state::stopped: return "STOPPED";
            default: return "UNKNOWN";
        }
    }
 
    struct thread_info
    {
        std::thread::id thread_id;
 
        std::string thread_name;
 
        std::size_t worker_id{0};
 
        worker_state state{worker_state::idle};
 
        std::chrono::steady_clock::time_point state_since;
 
        std::optional<job_info> current_job;
 
        // =========================================================================
        // Statistics
        // =========================================================================
 
        std::uint64_t jobs_completed{0};
 
        std::uint64_t jobs_failed{0};
 
        std::chrono::nanoseconds total_busy_time{0};
 
        std::chrono::nanoseconds total_idle_time{0};
 
        double utilization{0.0};
 
        // =========================================================================
        // Computed Properties
        // =========================================================================
 
        [[nodiscard]] auto state_duration() const -> std::chrono::nanoseconds
        {
            return std::chrono::steady_clock::now() - state_since;
        }
 
        [[nodiscard]] auto total_jobs() const -> std::uint64_t
        {
            return jobs_completed + jobs_failed;
        }
 
        [[nodiscard]] auto success_rate() const -> double
        {
            auto total = total_jobs();
            if (total == 0)
            {
                return 1.0;
            }
            return static_cast<double>(jobs_completed) / static_cast<double>(total);
        }
 
        [[nodiscard]] auto is_busy() const -> bool
        {
            return state == worker_state::active;
        }
 
        [[nodiscard]] auto is_available() const -> bool
        {
            return state == worker_state::idle;
        }
 
        auto update_utilization() -> void
        {
            auto total_time = total_busy_time + total_idle_time;
            if (total_time.count() == 0)
            {
                utilization = 0.0;
            }
            else
            {
                utilization = static_cast<double>(total_busy_time.count()) /
                              static_cast<double>(total_time.count());
            }
        }
 
        [[nodiscard]] auto busy_time_ms() const -> double
        {
            return std::chrono::duration<double, std::milli>(total_busy_time).count();
        }
 
        [[nodiscard]] auto idle_time_ms() const -> double
        {
            return std::chrono::duration<double, std::milli>(total_idle_time).count();
        }
 
        [[nodiscard]] auto to_json() const -> std::string
        {
            std::ostringstream oss;
            oss << "{\n";
            oss << "  \"worker_id\": " << worker_id << ",\n";
            oss << "  \"thread_name\": \"" << thread_name << "\",\n";
 
            // Format thread_id as string
            std::ostringstream tid_oss;
            tid_oss << thread_id;
            oss << "  \"thread_id\": \"" << tid_oss.str() << "\",\n";
 
            oss << "  \"state\": \"" << worker_state_to_string(state) << "\",\n";
            oss << std::fixed << std::setprecision(3);
            oss << "  \"state_duration_ms\": "
                << std::chrono::duration<double, std::milli>(state_duration()).count() << ",\n";
            oss << "  \"jobs_completed\": " << jobs_completed << ",\n";
            oss << "  \"jobs_failed\": " << jobs_failed << ",\n";
            oss << std::setprecision(4);
            oss << "  \"success_rate\": " << success_rate() << ",\n";
            oss << "  \"utilization\": " << utilization << ",\n";
            oss << std::setprecision(3);
            oss << "  \"busy_time_ms\": " << busy_time_ms() << ",\n";
            oss << "  \"idle_time_ms\": " << idle_time_ms();
 
            if (current_job.has_value())
            {
                oss << ",\n  \"current_job\": " << current_job.value().to_json();
            }
            else
            {
                oss << ",\n  \"current_job\": null";
            }
 
            oss << "\n}";
            return oss.str();
        }
 
        [[nodiscard]] auto to_string() const -> std::string
        {
            std::ostringstream oss;
 
            auto duration_sec = std::chrono::duration<double>(state_duration()).count();
 
            // First line: name, thread id, state, duration
            oss << thread_name << " [tid:" << thread_id << "] "
                << worker_state_to_string(state)
                << " (" << std::fixed << std::setprecision(1) << duration_sec << "s)\n";
 
            // Current job if present
            if (current_job.has_value())
            {
                const auto& job = current_job.value();
                auto exec_time_ms_val = std::chrono::duration<double, std::milli>(
                    job.execution_time).count();
                oss << "  Current Job: " << job.job_name << "#" << job.job_id
                    << " (running " << std::setprecision(0) << exec_time_ms_val << "ms)\n";
            }
 
            // Job statistics
            oss << "  Jobs: " << jobs_completed << " completed, "
                << jobs_failed << " failed ("
                << std::setprecision(1) << (success_rate() * 100.0) << "% success)\n";
 
            // Utilization
            oss << "  Utilization: " << std::setprecision(1)
                << (utilization * 100.0) << "%";
 
            return oss.str();
        }
    };
 
} // namespace kcenon::thread::diagnostics