sysinfo.h

Go to the documentation of this file.

#pragma once
 
 
 
#include <cx/cx.h>
#include <cx/sys/process.h>
 
CX_C_BEGIN
 
 
enum SysMemInfoValid {
    SYSMEM_Phys     = 0x0001,   
    SYSMEM_Commit   = 0x0002,   
    SYSMEM_Swap     = 0x0004,   
    SYSMEM_PageSize = 0x0008,   
};
 
typedef struct SysMemInfo {
    flags_t valid;
 
    uint64 physTotal;   
    uint64 physAvail;   
 
    uint64 commitTotal;
 
    uint64 commitAvail;   
 
    uint64 swapTotal;
 
    uint64 swapAvail;   
    uint64 pageSize;    
} SysMemInfo;
 
enum SysCPUTimesValid {
    SYSCPU_User   = 0x0001,   
    SYSCPU_System = 0x0002,   
    SYSCPU_Idle   = 0x0004,   
    SYSCPU_IOWait = 0x0008,   
    SYSCPU_IRQ    = 0x0010,   
    SYSCPU_Steal  = 0x0020,   
};
 
typedef struct SysCPUTimes {
    flags_t valid;
 
    int64 sampled;   
    int64 busy;      
    int64 total;     
 
    int64 user;      
    int64 system;    
    int64 idle;      
    int64 iowait;    
    int64 irq;       
    int64 steal;     
 
    int32 cpus;      
} SysCPUTimes;
 
enum SysUptimeValid {
    SYSUP_Uptime   = 0x0001,   
    SYSUP_BootTime = 0x0002,   
};
 
typedef struct SysUptime {
    flags_t valid;    
    int64 uptime;     
    int64 boottime;   
} SysUptime;
 
enum SysLoadAvgValid {
    SYSLOAD_Load1  = 0x0001,   
    SYSLOAD_Load5  = 0x0002,   
    SYSLOAD_Load15 = 0x0004,   
};
 
typedef struct SysLoadAvg {
    flags_t valid;     
    float64 load1;     
    float64 load5;     
    float64 load15;    
} SysLoadAvg;
 
enum ProcMemInfoValid {
    PROCMEM_Resident     = 0x0001,   
    PROCMEM_PeakResident = 0x0002,   
    PROCMEM_Virtual      = 0x0004,   
    PROCMEM_PeakVirtual  = 0x0008,   
    PROCMEM_Private      = 0x0010,   
    PROCMEM_Swapped      = 0x0020,   
};
 
typedef struct ProcMemInfo {
    flags_t valid;   
 
    uint64 resident;   
 
    uint64 peakResident;
 
    uint64 virtualSize;
 
    uint64 peakVirtualSize;   
 
    uint64 privateSize;
 
    uint64 swapped;           
} ProcMemInfo;
 
enum ProcCPUTimesValid {
    PROCCPU_User    = 0x0001,   
    PROCCPU_System  = 0x0002,   
    PROCCPU_Started = 0x0004,   
};
 
typedef struct ProcCPUTimes {
    flags_t valid;
 
    int64 sampled;   
    int64 total;     
    int64 user;      
    int64 system;    
    int64 started;   
} ProcCPUTimes;
 
enum ProcIOInfoValid {
    PROCIO_Bytes = 0x0001,   
    PROCIO_Ops   = 0x0002,   
    PROCIO_Other = 0x0004,   
};
 
typedef struct ProcIOInfo {
    flags_t valid;   
 
    uint64 readBytes;    
    uint64 writeBytes;   
    uint64 readOps;      
    uint64 writeOps;     
    uint64 otherBytes;   
    uint64 otherOps;     
} ProcIOInfo;
 
bool sysMemInfo(_Out_ SysMemInfo* out);
 
bool sysCPUTimes(_Out_ SysCPUTimes* out);
 
bool sysUptime(_Out_ SysUptime* out);
 
bool sysLoadAvg(_Out_ SysLoadAvg* out);
 
float64 sysCPUUsage(_In_ const SysCPUTimes* first, _In_ const SysCPUTimes* second);
 
typedef struct SysCPUSampler {
    SysCPUTimes last;   
    bool primed;        
} SysCPUSampler;
 
#define sysCPUSamplerInit(s) memset((s), 0, sizeof(SysCPUSampler))
 
bool sysCPUSample(_Inout_ SysCPUSampler* s, _Out_ float64* pct);
 
bool procMemInfo(_Out_ ProcMemInfo* out, _In_ Process* proc);
 
bool procMemInfoByID(_Out_ ProcMemInfo* out, ProcessID pid);
 
bool procCPUTimes(_Out_ ProcCPUTimes* out, _In_ Process* proc);
 
bool procCPUTimesByID(_Out_ ProcCPUTimes* out, ProcessID pid);
 
bool procIOInfo(_Out_ ProcIOInfo* out, _In_ Process* proc);
 
bool procIOInfoByID(_Out_ ProcIOInfo* out, ProcessID pid);
 
float64 procCPUUsage(_In_ const ProcCPUTimes* first, _In_ const ProcCPUTimes* second);
 
typedef struct ProcCPUSampler {
    ProcCPUTimes last;   
    bool primed;         
} ProcCPUSampler;
 
#define procCPUSamplerInit(s) memset((s), 0, sizeof(ProcCPUSampler))
 
bool procCPUSample(_Inout_ ProcCPUSampler* s, _In_ Process* proc, _Out_ float64* pct);
 
CX_C_END