sysinfo.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_SYSINFO_HPP__
#define NEFORCE_CORE_SYSTEM_SYSINFO_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API sysinfo {
public:
    struct system_info {
        uint32_t processor_numbers{0};      
        uint32_t page_size{0};              
        uint32_t allocation_granularity{0}; 
        uintptr_t min_app_address{0};       
        uintptr_t max_app_address{0};       
        uintptr_t active_processor_mask{0}; 
        uint16_t processor_level{0};        
        uint16_t processor_revision{0};     
    };

    struct NEFORCE_API memory_info {
        uint64_t total_physical{0};      
        uint64_t available_physical{0};  
        uint64_t total_virtual{0};       
        uint64_t available_virtual{0};   
        uint64_t total_page_file{0};     
        uint64_t available_page_file{0}; 

        NEFORCE_NODISCARD float64_t physical_memory_usage() const noexcept {
            if (total_physical == 0) {
                return 0.0;
            }
            return 100.0 * (1.0 - static_cast<float64_t>(available_physical) / static_cast<float64_t>(total_physical));
        }

        NEFORCE_NODISCARD size_t available_memory() const noexcept { return available_physical + available_virtual; }
    };

    struct NEFORCE_API disk_info {
        string path;             
        uint64_t total_bytes{0}; 
        uint64_t free_bytes{0};  
        uint64_t used_bytes{0};  

        NEFORCE_NODISCARD float64_t usage_percent() const noexcept {
            if (total_bytes == 0) {
                return 0.0;
            }
            return 100.0 * static_cast<float64_t>(used_bytes) / static_cast<float64_t>(total_bytes);
        }
    };

    struct CPU_info {
        string vendor;                  
        string brand;                   
        uint32_t max_MHz{0};            
        uint32_t current_MHz{0};        
        uint32_t cores{0};              
        uint32_t logical_processors{0}; 
        string features;                

        NEFORCE_NODISCARD bool hyperthreading() const noexcept { return logical_processors > cores; }
    };

    struct NEFORCE_API os_version_info {
        uint32_t major{0};       
        uint32_t minor{0};       
        uint32_t build{0};       
        uint32_t platform_id{0}; 
        string csd_version;      
        string product_name;     

        NEFORCE_NODISCARD string version() const;
    };

    struct network_interface {
        string name;       
        string address;    
        string netmask;    
        string mac;        
        bool is_up{false}; 
    };

    enum class architecture {
        UNKNOWN,     
        X86,         
        X64,         
        ARM,         
        ARM64,       
        RISCV32,     
        RISCV64,     
        LOONGARCH64, 
        LOONGARCH32  
    };

    struct numa_node_info {
        uint32_t node_id{0};        
        uint32_t core_count{0};     
        uint64_t core_mask{0};      
        vector<uint32_t> core_list; 
    };
 
private:
    system_info system_info_{};                        
    memory_info memory_info_{};                        
    CPU_info cpu_info_{};                              
    os_version_info os_version_info_{};                
    architecture architecture_{architecture::UNKNOWN}; 
    vector<numa_node_info> numa_nodes_;                
    atomic<bool> initialized_{false};                  

    sysinfo() noexcept;

    ~sysinfo() = default;

    void init();
 
public:
    static sysinfo& instance() noexcept {
        static sysinfo instance;
        return instance;
    }
 
    sysinfo(const sysinfo&) = delete;
    sysinfo& operator=(const sysinfo&) = delete;
    sysinfo(sysinfo&&) = delete;
    sysinfo& operator=(sysinfo&&) = delete;

    void refresh();

    NEFORCE_NODISCARD const system_info& get_system_info() const noexcept { return system_info_; }

    NEFORCE_NODISCARD const memory_info& get_memory_info() const noexcept { return memory_info_; }

    NEFORCE_NODISCARD const CPU_info& get_CPU_info() const noexcept { return cpu_info_; }

    NEFORCE_NODISCARD const os_version_info& get_os_version_info() const noexcept { return os_version_info_; }

    NEFORCE_NODISCARD architecture get_architecture() const noexcept { return architecture_; }

    NEFORCE_NODISCARD const vector<numa_node_info>& get_numa_info() const noexcept { return numa_nodes_; }

    NEFORCE_NODISCARD bool is_initialized() const noexcept { return initialized_.load(memory_order_acquire); }

    NEFORCE_NODISCARD static float64_t cpu_usage();

    NEFORCE_NODISCARD static uint32_t process_count();

    NEFORCE_NODISCARD static disk_info get_disk_info(const char* path = nullptr);

    NEFORCE_NODISCARD static vector<network_interface> network_interfaces();

    NEFORCE_NODISCARD static uint64_t uptime_seconds();
};
 // SystemInfo
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_SYSINFO_HPP__