gpu_collector.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
 
namespace kcenon {
namespace monitoring {
 
enum class gpu_vendor {
    unknown,  
    nvidia,   
    amd,      
    intel,    
    apple,    
    other     
};
 
inline std::string gpu_vendor_to_string(gpu_vendor vendor) {
    switch (vendor) {
        case gpu_vendor::nvidia:
            return "nvidia";
        case gpu_vendor::amd:
            return "amd";
        case gpu_vendor::intel:
            return "intel";
        case gpu_vendor::apple:
            return "apple";
        case gpu_vendor::other:
            return "other";
        default:
            return "unknown";
    }
}
 
enum class gpu_type {
    unknown,     
    discrete,    
    integrated,  
    virtual_gpu  
};
 
inline std::string gpu_type_to_string(gpu_type type) {
    switch (type) {
        case gpu_type::discrete:
            return "discrete";
        case gpu_type::integrated:
            return "integrated";
        case gpu_type::virtual_gpu:
            return "virtual";
        default:
            return "unknown";
    }
}
 
struct gpu_device_info {
    std::string id;              
    std::string name;            
    std::string device_path;     
    std::string driver_version;  
    gpu_vendor vendor{gpu_vendor::unknown};  
    gpu_type type{gpu_type::unknown};        
    uint32_t device_index{0};                
};
 
struct gpu_reading {
    gpu_device_info device;  
 
    // Utilization metrics
    double utilization_percent{0.0};  
 
    // Memory metrics
    uint64_t memory_used_bytes{0};   
    uint64_t memory_total_bytes{0};  
 
    // Thermal metrics
    double temperature_celsius{0.0};  
 
    // Power metrics
    double power_watts{0.0};        
    double power_limit_watts{0.0};  
 
    // Clock metrics
    double clock_mhz{0.0};         
    double memory_clock_mhz{0.0};  
 
    // Fan metrics
    double fan_speed_percent{0.0};  
 
    // Availability flags
    bool utilization_available{false};   
    bool memory_available{false};        
    bool temperature_available{false};   
    bool power_available{false};         
    bool clock_available{false};         
    bool fan_available{false};           
 
    std::chrono::system_clock::time_point timestamp;  
};
 
// Forward declaration
namespace platform {
class metrics_provider;
}  // namespace platform
 
class gpu_info_collector {
   public:
    gpu_info_collector();
    ~gpu_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    gpu_info_collector(const gpu_info_collector&) = delete;
    gpu_info_collector& operator=(const gpu_info_collector&) = delete;
    gpu_info_collector(gpu_info_collector&&) = delete;
    gpu_info_collector& operator=(gpu_info_collector&&) = delete;
 
    bool is_gpu_available() const;
 
    std::vector<gpu_device_info> enumerate_gpus();
 
    std::vector<gpu_reading> read_all_gpu_metrics();
 
   private:
    std::unique_ptr<platform::metrics_provider> provider_;
};
 
class gpu_collector : public collector_plugin {
   public:
    gpu_collector();
    ~gpu_collector() override = default;
 
    // Non-copyable, non-moveable due to internal state
    gpu_collector(const gpu_collector&) = delete;
    gpu_collector& operator=(const gpu_collector&) = delete;
    gpu_collector(gpu_collector&&) = delete;
    gpu_collector& operator=(gpu_collector&&) = delete;
 
    // collector_plugin implementation
    auto name() const -> std::string_view override { return "gpu"; }
    auto collect() -> std::vector<metric> override;
    auto interval() const -> std::chrono::milliseconds override { return std::chrono::seconds(5); }
    auto is_available() const -> bool override;
    auto get_metric_types() const -> std::vector<std::string> override;
 
    auto get_metadata() const -> plugin_metadata override {
        return plugin_metadata{
            .name = name(),
            .description = "GPU metrics (utilization, memory, temperature, power)",
            .category = plugin_category::hardware,
            .version = "1.0.0",
            .dependencies = {},
            .requires_platform_support = true
        };
    }
 
    auto initialize(const config_map& config) -> bool override;
    void shutdown() override {}
    auto get_statistics() const -> stats_map override;
 
    std::vector<gpu_reading> get_last_readings() const;
 
    bool is_gpu_available() const;
 
   private:
    std::unique_ptr<gpu_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    bool collect_utilization_{true};
    bool collect_memory_{true};
    bool collect_temperature_{true};
    bool collect_power_{true};
    bool collect_clock_{true};
    bool collect_fan_{true};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
    std::atomic<size_t> gpus_found_{0};
    std::vector<gpu_reading> last_readings_;
 
    // Helper methods
    metric create_metric(const std::string& name, double value, const gpu_reading& reading,
                         const std::string& unit = "") const;
    void add_gpu_metrics(std::vector<metric>& metrics, const gpu_reading& reading);
};
 
}  // namespace monitoring
}  // namespace kcenon