实时获取CPU使用率的类【转】

//=========================================================
//
// Copyright (c) 2000-2004  iWise Technologies，Co. Ltd.
// All Rights Reserved.
//
// Product: iW988
// file: CpuUsage.h
// Created: 天衣有缝
// 
// Des cription:
//     ValueAdded main program for iW988.
//                   Cont act:
//                       waterpub@mail.csdn.net
//
//=========================================================

#pragma once

#define SystemBasicInformation 0
#define SystemPerformanceInformation 2
#define SystemTimeInformation 3

#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))

class CCpuUsage
{
    public:
        CCpuUsage();
        ~CCpuUsage() ;

    public:
        int GetCpuUsage();                       //得到系统cpu利用率
        int SetRefreshInterval(int milli_sec);   //定时刷新间隔

    private:
             //类型定义
             typedef LONG (WINAPI *PROCNTQSI)(UINT,PVOID,ULONG,PULONG);

        typedef struct
        {
             DWORD dwUnknown1;
             ULONG uKeMaximumIncrement;
             ULONG uPageSize;
             ULONG uMmNumberOfPhysicalPages;
             ULONG uMmLowestPhysicalPage;
             ULONG uMmHighestPhysicalPage;
             ULONG uAllocationGranularity;
             PVOID pLowestUserAddress;
             PVOID pMmHighestUserAddress;
             ULONG uKeActiveProcessors;
             BYTE bKeNumberProcessors;
             BYTE bUnknown2;
             WORD wUnknown3;
        } SYSTEM_BASIC_INFORMATION;

        typedef struct
        {
             LARGE_INTEGER liIdleTime;
             DWORD dwSpare[76];
        } SYSTEM_PERFORMANCE_INFORMATION;

        typedef struct
        {
             LARGE_INTEGER liKeBootTime;
             LARGE_INTEGER liKeSystemTime;
             LARGE_INTEGER liExpTimeZoneBias;
             ULONG uCurrentTimeZoneId;
             DWORD dwReserved;
        } SYSTEM_TIME_INFORMATION;

        //变量定义
        SYSTEM_PERFO RMANCE_INFORMATION SysPerfInfo;
        SYSTEM_TIME_ INFORMATION SysTimeInfo;
        SYSTEM_BASIC _INFORMATION SysBaseInfo;

        double dbIdleTime;
        double dbSystemTime;

        LONG status;

        LARGE_INTEGE R liOldIdleTime;
        LARGE_INTEGE R liOldSystemTime;

        PROCNTQSI NtQuerySystemInformation;

        int m_nCpuUsage;

        //定时
        HWND m_hWnd;
        int  m_nRefreshInterval;//默认为1000毫秒
        int  m_nTimerID;

    private:
        static void CalcCpuUsage(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);
        int OnTimer();
};

inline CCpuUsage::CCpuUsage()
{
    //
    m_hWnd = NULL;
    m_nRefreshInterval = 1000;
    m_nTimerID = 1000;
    m_nCpuUsage = 0;

    //
    memset(&liOldIdleTime  ,   0, sizeof(LARGE_INTEGER));
    memset(&liOldSystemTime,   0, sizeof(LARGE_INTEGER));

    //
    NtQuerySystemInformation = (PROCNTQSI)GetProcAddress(
    GetModuleHandle(ntdll) , NtQuerySystemInformation);
    if (!NtQuerySystemInformation)
        return;

    // get number of processors in the system
    status = NtQuerySystemInformation(SystemBasicInformation,&SysBase Info,sizeof(SysBaseInfo),NULL);
    if (status != NO_ERROR)
        return;

    // create control for timer
    m_hWnd = ::CreateWindow(static, , 0, 0, 0, 0, 0, NULL, NULL, 0, NULL);
    ::SetWindowLong(m_hWnd , GWL_USERDATA , (long)(this) );

    TIMERPROC tp = (TIMERPROC)CalcCpuUsage;
    SetTimer(m_hWnd , m_nTimerID, m_nRefreshInterval, tp);

}

inline CCpuUsage::~CCpuUsage()
{
    KillTimer(m_hWnd , m_nTimerID);
    DestroyWindow(m_hWnd);
}

inline void CCpuUsage::CalcCpuUsage(
                 HWND hwnd,
                 UINT uMsg,
                 UINT _PTR idEvent,
                  DWORD dwTime
)
{
    CCpuUsage* pCpu = (CCpuUsage*)::GetWindowLong(hwnd , GWL_USERDATA);

    if ( pCpu )
    {
        pCpu->OnTimer();
    }

}

inline int CCpuUsage::OnTimer()
{
    status = NtQuerySystemInformation(SystemTimeInformation,&SysTimeI nfo,sizeof(SysTimeInfo),0);

    if (status!=NO_ERROR)
        return 0;

    // get new CPUs idle time
    status = NtQuerySystemInformation(SystemPerformanceInformation,&S ysPerfInfo,sizeof(SysPerfInfo),NULL);
    if (status != NO_ERROR)
        return 0;

    // if its a first call – skip it
    if (liOldIdleTime.QuadPart != 0)
    {
             // CurrentValue = NewValue – OldValue
        dbIdleTime = Li2Double(SysPerfInfo.liIdleTime) - Li2Double(liOldIdleTime);
        dbSystemTime = Li2Double(SysTimeInfo.liKeSystemTime) - Li2Double(liOldSystemTime);

             // CurrentCpuIdle = IdleTime / SystemTime
        dbIdleTime = dbIdleTime / dbSystemTime;

             // CurrentCpuUsage% = 100 – (CurrentCpuIdle * 100) / NumberOfProcessors
             dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SysBaseInfo.bKeNumberProcessors + 0.5;

             m_nCpuUsage = (UINT)dbIdleTime;
        }

    // store new CPUs idle and system time
    liOldIdleTime = SysPerfInfo.liIdleTime;
    liOldSystemTime = SysTimeInfo.liKeSystemTime;

    // wait one second

    return 0;
}

inline int CCpuUsage::GetCpuUsage()
{
    return m_nCpuUsage;
}

inline int CCpuUsage::SetRefreshInterval(int milli_sec)
{
    m_nRefreshInterval = milli_sec;

    if ( m_hWnd )
    {
        TIMERPROC tp = (TIMERPROC)CalcCpuUsage;
        SetTimer(m_h Wnd, m_nTimerID, m_nRefreshInterval ,tp);
    }

    return 0;

}