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) / total_physical);
        }

        NEFORCE_NODISCARD size_t available_memory() const noexcept;
    };

    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;
    };

    enum class architecture {
        UNKNOWN, 
        X86,     
        X64,     
        ARM,     
        ARM64,   
        IA64     
    };
 
private:
    system_info system_info_{};                         
    memory_info memory_info_{};                         
    CPU_info cpu_info_{};                               
    os_version_info os_version_info_{};                 
    architecture architecture_ = architecture::UNKNOWN; 
    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 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();
};
 // SystemInfo
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_SYSINFO_HPP__