获取进程cpu使用率

最新推荐文章于 2023-01-10 15:29:38 发布
最新推荐文章于 2023-01-10 15:29:38 发布
阅读量7.7k 收藏 4
点赞数
分类专栏： 系统 文章标签： integer performance system struct buffer basic
C/C++ code 
   
   

    
    
    
    
typedef 
    
    struct
    
     _THREAD_INFO
{
    LARGE_INTEGER CreateTime;
    DWORD dwUnknown1;
    DWORD dwStartAddress;
    DWORD StartEIP;
    DWORD dwOwnerPID;
    DWORD dwThreadId;
    DWORD dwCurrentPriority;
    DWORD dwBasePriority;
    DWORD dwContextSwitches;
    DWORD Unknown;
    DWORD WaitReason;

}THREADINFO, 
    
    *
    
    PTHREADINFO;

typedef 
    
    struct
    
     _UNICODE_STRING
{
    USHORT Length;
    USHORT MaxLength;
    PWSTR Buffer;
} UNICODE_STRING;

typedef 
    
    struct
    
     _PROCESS_INFO
{
    DWORD dwOffset;
    DWORD dwThreadsCount;
    DWORD dwUnused1[
    
    6
    
    ];
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER KernelTime;
    UNICODE_STRING ProcessName;

    DWORD dwBasePriority;
    DWORD dwProcessID;
    DWORD dwParentProcessId;
    DWORD dwHandleCount;
    DWORD dwUnused3[
    
    2
    
    ];

    DWORD dwVirtualBytesPeak;
    DWORD dwVirtualBytes;
    ULONG dwPageFaults;
    DWORD dwWorkingSetPeak;
    DWORD dwWorkingSet;
    DWORD dwQuotaPeakPagedPoolUsage;
    DWORD dwQuotaPagedPoolUsage;
    DWORD dwQuotaPeakNonPagedPoolUsage;
    DWORD dwQuotaNonPagedPoolUsage;
    DWORD dwPageFileUsage;
    DWORD dwPageFileUsagePeak;

    DWORD dCommitCharge;
    THREADINFO ThreadSysInfo[
    
    1
    
    ];

} PROCESSINFO, 
    
    *
    
    PPROCESSINFO;


    
    int
    
      PrintProcessUsageInfo(
    
    int
    
       id)
{
    
    
    int
    
     cpuusage
    
    =
    
    0
    
    ;
    PVOID pProcInfo 
    
    =
    
     NULL;
    DWORD dwInfoSize 
    
    =
    
     
    
    0x20000
    
    ;
    PPROCESSINFO pProcessInfo;
    DWORD dwWorkingSet;
    
    
    long
    
     ( __stdcall 
    
    *
    
    NtQuerySystemInformation )( DWORD, PVOID, DWORD, DWORD );


    
    
    static
    
     __int64 LastTotalProcessCPUUsage 
    
    =
    
     
    
    0
    
    ;
    
    
    static
    
     __int64 LastCurrentProcessCPUUsage 
    
    =
    
     
    
    0
    
    ;

    
    
    int
    
     CurrentDelta;
    
    
    int
    
     TotalDelta;

    __int64 TotalProcessCPUUsage 
    
    =
    
     
    
    0
    
    ;
    __int64 CurrentProcessCPUUsage 
    
    =
    
     
    
    0
    
    ;

    
    
    /

    
    
    pProcInfo 
    
    =
    
     (PVOID)(
    
    new
    
     
    
    byte
    
    [dwInfoSize]);

    NtQuerySystemInformation 
    
    =
    
     (
    
    long
    
    (__stdcall
    
    *
    
    )(DWORD,PVOID,DWORD,DWORD))
        GetProcAddress( GetModuleHandle( 
    
    "
    
    ntdll.dll
    
    "
    
     ),
    
    "
    
    NtQuerySystemInformation
    
    "
    
     );

    NtQuerySystemInformation(
    
    5
    
    ,pProcInfo,dwInfoSize,
    
    0
    
    );

    pProcessInfo 
    
    =
    
     (PPROCESSINFO)pProcInfo;

    
    
    do
    
    
    {
        TotalProcessCPUUsage 
    
    +=
    
     (__int64)pProcessInfo
    
    ->
    
    KernelTime.QuadPart 
    
    +
    
     (__int64)pProcessInfo
    
    ->
    
    UserTime.QuadPart;

        
    
    if
    
    (pProcessInfo
    
    ->
    
    dwProcessID 
    
    ==
    
     id)
        {
            dwWorkingSet 
    
    =
    
     pProcessInfo
    
    ->
    
    dwWorkingSet; 
            CurrentProcessCPUUsage 
    
    +=
    
     (__int64)pProcessInfo
    
    ->
    
    KernelTime.QuadPart 
    
    +
    
     (__int64)pProcessInfo
    
    ->
    
    UserTime.QuadPart;
        }

        
    
    /

    
            
    
    if
    
    (pProcessInfo
    
    ->
    
    dwOffset 
    
    ==
    
     
    
    0
    
    )
        {
            
    
    break
    
    ;
        }

        pProcessInfo 
    
    =
    
     (PPROCESSINFO)((
    
    byte
    
    *
    
    )pProcessInfo 
    
    +
    
     pProcessInfo
    
    ->
    
    dwOffset);
    }
    
    
    while
    
    (
    
    true
    
    );

    TotalDelta 
    
    =
    
     TotalProcessCPUUsage 
    
    -
    
     LastTotalProcessCPUUsage;
    CurrentDelta 
    
    =
    
     CurrentProcessCPUUsage 
    
    -
    
     LastCurrentProcessCPUUsage;
    
    
    if
    
    (TotalDelta 
    
    !=
    
     
    
    0
    
    )
        cpuusage 
    
    =
    
     
    
    100
    
     
    
    *
    
     CurrentDelta 
    
    /
    
     TotalDelta;

    
    
    //
    
    this->Caption = "CPU = " + IntToStr(100 * CurrentDelta / TotalDelta) + 
    
    
    //
    
    "Memory = "+ IntToStr(dwWorkingSet / 1024) " K";
    
    

    
    
    LastTotalProcessCPUUsage 
    
    =
    
     TotalProcessCPUUsage;
    LastCurrentProcessCPUUsage 
    
    =
    
     CurrentProcessCPUUsage;

    delete[] pProcInfo;
    cout
    
    <<
    
    "
    
    /tProcessor Usage:    
    
    "
    
    <<
    
    cpuusage
    
    <<
    
    endl;
    
    
    return
    
     
    
    0
    
    ;
    
}



    
    int
    
     main(){
    
    
    while
    
    (
    
    1
    
    ){
        PrintProcessUsageInfo(
    
    3400
    
    );
        Sleep(
    
    1000
    
    );
    }    

}



获取单个进程的cpu使用率，可以得到正确的结果（3400对应到我机器上的qq进程）
但是当我在一个for循环中，把内存中所有的进程id传递给PrintProcessUsageInfo函数时，得到的结果却是错的~~~ ，因为这里用了静态变量，不是每个进程对应一个了

    static __int64 LastTotalProcessCPUUsage = 0;
    static __int64 LastCurrentProcessCPUUsage = 0;

-------------------------------------------------------------------------------------------

#include "cpu.h"

CRITICAL_SECTION    PerfDataCriticalSection;
CpuData            *pPerfDataOld = NULL; /* Older perf data (saved to establish delta values) */
CpuData            *pPerfData = NULL;    /* Most recent copy of perf data */
ULONG              ProcessCountOld = 0;
ULONG              ProcessCount = 0;
SYSTEM_BASIC_INFORMATION        SystemBasicInfo;
SYSTEM_PERFORMANCE_INFORMATION    SystemPerfInfo;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SystemProcessorTimeInfo = NULL;
LARGE_INTEGER                    liOldIdleTime = {{0,0}};
double                            dbIdleTime;
double                            dbKernelTime;
double                            dbSystemTime;
double                            OldKernelTime = 0;
LARGE_INTEGER                    liOldSystemTime = {{0,0}};
long ( __stdcall *NtQuerySystemInformation )( DWORD, PVOID, DWORD, DWORD* );


BOOL PerfDataInitialize(void)
{
    SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY};
    NTSTATUS    status;

    InitializeCriticalSection(&PerfDataCriticalSection);
NtQuerySystemInformation = (long(__stdcall*)(DWORD,PVOID,DWORD,DWORD*))
        GetProcAddress(
        GetModuleHandle( "ntdll.dll" ),
        "NtQuerySystemInformation"
        );

    /*
    * Get number of processors in the system
    */
    status = NtQuerySystemInformation(0, &SystemBasicInfo, sizeof(SystemBasicInfo), NULL);
    if (status != NO_ERROR)
        return FALSE;

    /*
    * Create the SYSTEM Sid
    */
    return TRUE;
}

void PerfDataUninitialize(void)
{
    DeleteCriticalSection(&PerfDataCriticalSection);
}


void GetAllProcCPUUsage()
{
    ULONG                            ulSize;
    LONG                          status;
    LPBYTE                            pBuffer;
    ULONG                            BufferSize;
    PSYSTEM_PROCESS_INFORMATION            pSPI;
    pCpuData                          pPDOld;
    ULONG                            Idx, Idx2;
    HANDLE                            hProcess;
    HANDLE                            hProcessToken;
    double                            CurrentKernelTime;
    SYSTEM_PERFORMANCE_INFORMATION    SysPerfInfo;
    SYSTEM_TIMEOFDAY_INFORMATION      SysTimeInfo;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SysProcessorTimeInfo;
    ULONG                            Buffer[64]; /* must be 4 bytes aligned! */



/* Get new system time */
    status = NtQuerySystemInformation(3, &SysTimeInfo, sizeof(SysTimeInfo), 0);
    if (status != NO_ERROR)
        return;

    /* Get new CPU's idle time */
    status = NtQuerySystemInformation(2, &SysPerfInfo, sizeof(SysPerfInfo), NULL);
    if (status != NO_ERROR)
        return;

    /* Get processor time information */
    SysProcessorTimeInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)HeapAlloc(GetProcessHeap(), 0, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors);
    status = NtQuerySystemInformation(8, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors, &ulSize);
    if (status != NO_ERROR)
        return;

    /* Get process information
    * We don't know how much data there is so just keep
    * increasing the buffer size until the call succeeds
    */
    BufferSize = 0;
    do
    {
        BufferSize += 0x10000;
        pBuffer = (LPBYTE)HeapAlloc(GetProcessHeap(), 0, BufferSize);

        status = NtQuerySystemInformation(5, pBuffer, BufferSize, &ulSize);

        if (status == STATUS_INFO_LENGTH_MISMATCH) {
            HeapFree(GetProcessHeap(), 0, pBuffer);
        }

    } while (status == STATUS_INFO_LENGTH_MISMATCH);

    EnterCriticalSection(&PerfDataCriticalSection);

    /*
    * Save system performance info
    */
    memcpy(&SystemPerfInfo, &SysPerfInfo, sizeof(SYSTEM_PERFORMANCE_INFORMATION));

    /*
    * Save system processor time info
    */
    if (SystemProcessorTimeInfo)
{
        HeapFree(GetProcessHeap(), 0, SystemProcessorTimeInfo);
    }
    SystemProcessorTimeInfo = SysProcessorTimeInfo;

    /*
    * Save system handle info
    */

    for (CurrentKernelTime=0, Idx=0; Idx <(ULONG)SystemBasicInfo.NumberOfProcessors; Idx++) {
        CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].KernelTime);
        CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].DpcTime);
        CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].InterruptTime);
    }

    /* If it's a first call - skip idle time calcs */
    if (liOldIdleTime.QuadPart != 0) {
        /*  CurrentValue = NewValue - OldValue */
        dbIdleTime = Li2Double(SysPerfInfo.IdleProcessTime) - Li2Double(liOldIdleTime);
        dbKernelTime = CurrentKernelTime - OldKernelTime;
        dbSystemTime = Li2Double(SysTimeInfo.CurrentTime) - Li2Double(liOldSystemTime);

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

        /*  CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors */
        dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
        dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
    }

    /* Store new CPU's idle and system time */
    liOldIdleTime = SysPerfInfo.IdleProcessTime;
    liOldSystemTime = SysTimeInfo.CurrentTime;
    OldKernelTime = CurrentKernelTime;

    /* Determine the process count
    * We loop through the data we got from NtQuerySystemInformation
    * and count how many structures there are (until RelativeOffset is 0)
    */

ProcessCountOld = ProcessCount;
    ProcessCount = 0;
    pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
    while (pSPI)
{
        ProcessCount++;
        if (pSPI->NextEntryOffset == 0)
            break;
        pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
    }

    /* Now alloc a new PERFDATA array and fill in the data */
    if (pPerfDataOld) {
        HeapFree(GetProcessHeap(), 0, pPerfDataOld);
    }
    pPerfDataOld = pPerfData;
    pPerfData = (pCpuData)HeapAlloc(GetProcessHeap(), 0, sizeof(CpuData) * ProcessCount);
    pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
    for (Idx=0; Idx <ProcessCount; Idx++)
{
        /* Get the old perf data for this process (if any) */
        /* so that we can establish delta values */
        pPDOld = NULL;
        for (Idx2=0; Idx2 <ProcessCountOld; Idx2++)
  {
            if (pPerfDataOld[Idx2].dwPID == pSPI->UniqueProcessId)
  {
                pPDOld = &pPerfDataOld[Idx2];
                break;
            }
        }

        /* Clear out process perf data structure */
        memset(&pPerfData[Idx], 0, sizeof(CpuData));

        pPerfData[Idx].dwPID = pSPI->UniqueProcessId;

        if (pPDOld) 
  {
            double    CurTime = Li2Double(pSPI->KernelTime) + Li2Double(pSPI->UserTime);
            double    OldTime = Li2Double(pPDOld->KernelTime) + Li2Double(pPDOld->UserTime);
            double    CpuTime = (CurTime - OldTime) / dbSystemTime;
            CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
            pPerfData[Idx].cpuusage = (ULONG)CpuTime;
        }
        pPerfData[Idx].cputime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;

        if (pSPI->UniqueProcessId != NULL)
  {
            hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | READ_CONTROL, FALSE, PtrToUlong(pSPI->UniqueProcessId));
            if (hProcess)
  {
                /* don't query the information of the system process. It's possible but
                  returns Administrators as the owner of the process instead of SYSTEM */
                if (pSPI->UniqueProcessId != 0x4)
                {
                    if (OpenProcessToken(hProcess, TOKEN_QUERY, &hProcessToken))
                    {
                        DWORD RetLen = 0;
                        BOOL Ret;

                        Ret = GetTokenInformation(hProcessToken, TokenUser, (LPVOID)Buffer, sizeof(Buffer), &RetLen);
                        CloseHandle(hProcessToken);
    }

                }

                CloseHandle(hProcess);
            }
        }
        pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
        pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
        pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
    }
    HeapFree(GetProcessHeap(), 0, pBuffer);
    LeaveCriticalSection(&PerfDataCriticalSection);
}

int PerfGetIndexByProcessId(DWORD dwProcessId)
{
    int Index, FoundIndex = -1;

    EnterCriticalSection(&PerfDataCriticalSection);

    for (Index = 0; Index < (int)ProcessCount; Index++)
    {
        if ((DWORD)pPerfData[Index].dwPID == dwProcessId)
        {
            FoundIndex = Index;
            break;
        }
    }

    LeaveCriticalSection(&PerfDataCriticalSection);

    return FoundIndex;
}



ULONG PerfDataGetCPUUsage(DWORD dwProcessId)
{
    ULONG    CpuUsage;
    int Index, FoundIndex = -1;

    EnterCriticalSection(&PerfDataCriticalSection);


for (Index = 0; Index < (int)ProcessCount; Index++)
    {
        if ((DWORD)pPerfData[Index].dwPID == dwProcessId)
        {
            FoundIndex = Index;
            break;
        }
    }

    if (Index < (int)ProcessCount)
        CpuUsage = pPerfData[Index].cpuusage;
    else
        CpuUsage = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return CpuUsage;
}

int main(void)
{
PerfDataInitialize();
while(1)
{
  GetAllProcCPUUsage();
  printf("PID:0  CPU:%u/n",PerfDataGetCPUUsage(0));
  printf("PID:4  CPU:%u/n",PerfDataGetCPUUsage(4));
  printf("PID:4032  CPU:%u/n/n/n/n/n/n/n/n/n",PerfDataGetCPUUsage(3660));
  Sleep(1000);
}
return 0;
}

/*头文件*****************************************************/

#include <stdio.h>
#include <windows.h>



#define STATUS_INFO_LENGTH_MISMATCH      ((NTSTATUS)0xC0000004)
typedef LONG NTSTATUS;
#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))



//self def struct.
typedef struct CpuData
{
DWORD dwPID;
UINT cpuusage;
__int64  lastidle;
__int64  lastsys;
LARGE_INTEGER  cputime;
LARGE_INTEGER  KernelTime;
LARGE_INTEGER  UserTime;
} *pCpuData;

typedef struct
{
    LARGE_INTEGER IdleProcessTime;
    LARGE_INTEGER IoReadTransferCount;
    LARGE_INTEGER IoWriteTransferCount;
    LARGE_INTEGER IoOtherTransferCount;
    ULONG IoReadOperationCount;
    ULONG IoWriteOperationCount;
    ULONG IoOtherOperationCount;
    ULONG AvailablePages;
    ULONG CommittedPages;
    ULONG CommitLimit;
    ULONG PeakCommitment;
    ULONG PageFaultCount;
    ULONG CopyOnWriteCount;
    ULONG TransitionCount;
    ULONG CacheTransitionCount;
    ULONG DemandZeroCount;
    ULONG PageReadCount;
    ULONG PageReadIoCount;
    ULONG CacheReadCount;
    ULONG CacheIoCount;
    ULONG DirtyPagesWriteCount;
    ULONG DirtyWriteIoCount;
    ULONG MappedPagesWriteCount;
    ULONG MappedWriteIoCount;
    ULONG PagedPoolPages;
    ULONG NonPagedPoolPages;
    ULONG PagedPoolAllocs;
    ULONG PagedPoolFrees;
    ULONG NonPagedPoolAllocs;
    ULONG NonPagedPoolFrees;
    ULONG FreeSystemPtes;
    ULONG ResidentSystemCodePage;
    ULONG TotalSystemDriverPages;
    ULONG TotalSystemCodePages;
    ULONG NonPagedPoolLookasideHits;
    ULONG PagedPoolLookasideHits;
    ULONG Spare3Count;
    ULONG ResidentSystemCachePage;
    ULONG ResidentPagedPoolPage;
    ULONG ResidentSystemDriverPage;
    ULONG CcFastReadNoWait;
    ULONG CcFastReadWait;
    ULONG CcFastReadResourceMiss;
    ULONG CcFastReadNotPossible;
    ULONG CcFastMdlReadNoWait;
    ULONG CcFastMdlReadWait;
    ULONG CcFastMdlReadResourceMiss;
    ULONG CcFastMdlReadNotPossible;
    ULONG CcMapDataNoWait;
    ULONG CcMapDataWait;
    ULONG CcMapDataNoWaitMiss;
    ULONG CcMapDataWaitMiss;
    ULONG CcPinMappedDataCount;
    ULONG CcPinReadNoWait;
    ULONG CcPinReadWait;
    ULONG CcPinReadNoWaitMiss;
    ULONG CcPinReadWaitMiss;
    ULONG CcCopyReadNoWait;
    ULONG CcCopyReadWait;
    ULONG CcCopyReadNoWaitMiss;
    ULONG CcCopyReadWaitMiss;
    ULONG CcMdlReadNoWait;
    ULONG CcMdlReadWait;
    ULONG CcMdlReadNoWaitMiss;
    ULONG CcMdlReadWaitMiss;
    ULONG CcReadAheadIos;
    ULONG CcLazyWriteIos;
    ULONG CcLazyWritePages;
    ULONG CcDataFlushes;
    ULONG CcDataPages;
    ULONG ContextSwitches;
    ULONG FirstLevelTbFills;
    ULONG SecondLevelTbFills;
    ULONG SystemCalls;
} SYSTEM_PERFORMANCE_INFORMATION;

typedef struct _SYSTEM_TIMEOFDAY_INFORMATION
{
    LARGE_INTEGER BootTime;
    LARGE_INTEGER CurrentTime;
    LARGE_INTEGER TimeZoneBias;
    ULONG TimeZoneId;
    ULONG Reserved;
} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION;

//include sys header
typedef struct _THREAD_INFO
{
LARGE_INTEGER CreateTime;
DWORD dwUnknown1;
DWORD dwStartAddress;
DWORD StartEIP;
DWORD dwOwnerPID;
DWORD dwThreadId;
DWORD dwCurrentPriority;
DWORD dwBasePriority;
DWORD dwContextSwitches;
DWORD Unknown;
DWORD WaitReason;

}THREADINFO, *PTHREADINFO;

typedef struct _UNICODE_STRING
{
USHORT Length;
USHORT MaxLength;
PWSTR Buffer;
} UNICODE_STRING;

typedef struct _SYSTEM_PROCESS_INFORMATION
{
    ULONG NextEntryOffset;
    ULONG NumberOfThreads;
    LARGE_INTEGER SpareLi1;
    LARGE_INTEGER SpareLi2;
    LARGE_INTEGER SpareLi3;
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER KernelTime;
    UNICODE_STRING ImageName;
    DWORD BasePriority;
    DWORD UniqueProcessId;
    DWORD InheritedFromUniqueProcessId;
    ULONG HandleCount;
    ULONG SessionId;
    ULONG PageDirectoryFrame;

    //
    // This part corresponds to VM_COUNTERS_EX.
    // NOTE: *NOT* THE SAME AS VM_COUNTERS!
    //
    ULONG PeakVirtualSize;
    ULONG VirtualSize;
    ULONG PageFaultCount;
    ULONG PeakWorkingSetSize;
    ULONG WorkingSetSize;
    ULONG QuotaPeakPagedPoolUsage;
    ULONG QuotaPagedPoolUsage;
    ULONG QuotaPeakNonPagedPoolUsage;
    ULONG QuotaNonPagedPoolUsage;
    ULONG PagefileUsage;
    ULONG PeakPagefileUsage;
    ULONG PrivateUsage;

    //
    // This part corresponds to IO_COUNTERS
    //
    LARGE_INTEGER ReadOperationCount;
    LARGE_INTEGER WriteOperationCount;
    LARGE_INTEGER OtherOperationCount;
    LARGE_INTEGER ReadTransferCount;
    LARGE_INTEGER WriteTransferCount;
    LARGE_INTEGER OtherTransferCount;

    THREADINFO TH[1];
} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;


typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
    LARGE_INTEGER IdleTime;
    LARGE_INTEGER KernelTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER DpcTime;
    LARGE_INTEGER InterruptTime;
    ULONG InterruptCount;
} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;


typedef struct _SYSTEM_BASIC_INFORMATION
{
    ULONG Reserved;
    ULONG TimerResolution;
    ULONG PageSize;
    ULONG NumberOfPhysicalPages;
    ULONG LowestPhysicalPageNumber;
    ULONG HighestPhysicalPageNumber;
    ULONG AllocationGranularity;
    ULONG MinimumUserModeAddress;
    ULONG MaximumUserModeAddress;
    ULONG ActiveProcessorsAffinityMask;
    CCHAR NumberOfProcessors;
} SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;

void Button2Click();//参数是进程ID

mergerly
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
获取单个进程cpu使用效率
nihaozhanghua的博客
02-06 2580
//获取单个进程的CPU使用率 double procCpu = Tool.getProcCpu(Process.myPid()); public class Tool { public static boolean isExsit() { File file = new File(Environment.getExternalSto
易语言取指定进程CPU占用率
07-16
易语言取指定进程CPU占用率源码,取指定进程CPU占用率,格式名称,UpdateValues,AddCounter,PdhCollectQueryData,PdhVbGetDoubleCounterValue,PdhOpenQuery,PdhVbAddCounter
获取单个进程CPU使用率
雁南飞
04-07 6606
via windows: 通过NtQuerySystemInfomation Native API 实现 Sample: Header: Cpu.h#include #include  #define STATUS_INFO_LENGTH_MISMATCH      ((NTSTATUS)0xC0000004)typedef LONG NTSTATUS;#defin
w3wp对应进程_服务器W3WP进程占用CPU过高的解决办法和思路
weixin_42300574的博客
12-30 1364
服务器W3WP进程占用CPU过高的解决办法和思路1.找到是哪个进程占用CPU过高，如果是异常进程，就要结束掉，同时进行杀毒查杀。2.如果是网站进程W3WP占用过高，就是网站方面的问题了，这时候如果只有一个网站的话，就很容易查到是这个网站的问题，然后重点对网站代码进行检查。3.如果服务器上有多个网站，就要首先定位是哪个网站引起的CPU过高。如果有多个网站，可以对每个网站设置单独的应用程序池。然后在任...
Idea 编写groovy脚本，CPU100%问题解决
dasini321的博客
08-25 2592
不多BB 在idea 编辑groovy脚本时，编译时总是卡的要死，cpu占用率居高不下，严重影响工作进度 我用的是idea 2021.2（请购买正版） 查看CPU占用率 help ---Diagnostic Tools ---Activity Monitor %CPU Subsystem 392.0 <Process total CPU usage> 156.7 psi (in com.intellij) 151.4 Plugin Groovy: groovy.lang.p
获取总的cpu信息与进程cpu使用率计算
一只攻城的柿子
08-23 2277
1、获取总的cpu信息 # cat /proc/stat cpu 161911 2406 35826 1860803 14982 685 3810 0 cpu0 161911 2406 35826 1860803 14982 685 381 0 0 intr 3304665 0 0 0 0 0 0 0 0 0 0 0 1102551 181196 0 0 0 0 0 0 0 0
C++ 获取进程CPU占用率
08-26
"C++ 获取进程CPU占用率" C++ 获取进程CPU占用率是计算机编程中的一种常见操作。为了获取进程的CPU占用率，我们需要使用Windows API中的GetProcessTimes函数和GetSystemTimeAsFileTime函数来获取进程的时间信息，...
C++获取特定进程CPU使用率的实现代码
08-26
C++获取特定进程CPU使用率的实现代码 本文将介绍如何使用 C++ 实现获取特定进程的 CPU 使用率，并提供相关的实现代码。 一、获取进程 CPU 使用率的原理 要获取进程的 CPU 使用率，我们需要使用 Windows API 中的 ...
Windows下用C语言获取进程cpu使用率
05-01
在Windows操作系统中，使用C语言获取进程的CPU使用率、内存使用情况以及I/O状态是一项基本的任务，这对于系统监控、性能分析以及优化程序性能都至关重要。以下是对这些知识点的详细解释： 1. **CPU使用率**： CPU...
获得系统的总信息,如CPU使用率,内存使用率等.如何取得像任务管理器的,进程CPU占用率啊_ZwQuerySystemInformation详解
03-20
为了获取类似任务管理器显示的进程CPU占用率，你需要遍历`SystemProcessInformation`中的所有进程，累加它们的CPU时间，同时考虑到多核CPU的情况。这可能涉及到一些复杂的同步和计时问题，因为CPU时间是随着时间推移...
cpu-use_CPU使用率_源码
10-04
计算 windows 每个cpu 使用率
解决打开IDEA CPU占用巨大的问题
u010679782的博客
11-23 3937
写在开始:一个搬砖程序员的随缘记录 我的IDEA版本是2021.2.3，实测解决问题 没改配置之前： 改了过后： 方法如下： 然后里面的配置参数替换一下： -Xms4096m -Xmx4096m -Xmn3072m -XX:MetaspaceSize=1024m -XX:MaxMetaspaceSize=1024m -XX:+AlwaysPreTouch -XX:InitialCodeCacheSize=1200m -XX:ReservedCodeCacheSize=1200m -XX:+UseCo
取得某个进程CPU的占用率
weixin_30314813的博客
05-02 207
/* percent = (user_time_diff + kernel_time_diff) * 100 / (cpu_num * system_time_diff) */ #include<windows.h> #include<stdio.h> #include <pdh.h> #include <Tlhelp32.h> int...
CPU使用率100%如何定位分析？
一只小白
01-07 1796
按shft+p按照cpu占用进行排序，按shift+m按照内存占用进行排序
Linux性能之CPU使用率
cwj1112的专栏
01-10 870
用户 CPU 和 Nice CPU 高，说明用户态进程占用了较多的 CPU，所以应该着重排查进程的性能问题。系统 CPU 高，说明内核态占用了较多的 CPU，所以应该着重排查内核线程或者系统调用的性能问题。I/O 等待 CPU 高，说明等待 I/O 的时间比较长，所以应该着重排查系统存储是不是出现了 I/O 问题。软中断和硬中断高，说明软中断或硬中断的处理程序占用了较多的 CPU，所以应该着重排查内核中的中断服务程序。
idea对CPU的占用率过大问题的解决
热门推荐
xiaoyong5854的博客
06-24 2万+
背景：昨晚有一次敲完代码运行完程序后，idea非常卡顿，连输入代码都不能进行，因为有点晚并且累了，所有就关了电脑，今天早上再次打开idea，还是一样卡顿，因为idea的试用期明天就到期了，所有就先破解了idea，破解完之后，还是非常流畅的，但是一运行程序就拉胯了，就先百度看一下解决方案，以下几个解决方案试了，基本问题还是没有解决，就在群里问了几个大佬，方案不是重装系统就是换电脑，同时开始了电脑的配置讨论，重装系统和换电脑的什么是不可能的，所有只有自己慢慢摸索了。 1 修改idea配置文件安装目录下的bin
vb6获取CPU序列号
yangour4118的博客
09-17 3200
Dim CPUID, strComputer As String     Dim objWMIService, colDevices, objDevice     strComputer = "."     On Error Resume Next     Set objWMIService = GetObject("winmgmts:\\" & strComputer)     Set
vb6获取cpu序列号怎么有重复的_iTOP-4418和6818开发板-获取CPU唯一ID
weixin_39939668的博客
12-09 663
4418 和 6818 芯片内部都有唯一的标识 ID，也就是 UID，它是一个 64 位二进制数，可以作为唯一板子标识。本文档介绍的是在最小 linux 系统下 iTOP-4418 UID 读取方法，6818类似，其它系统也是类似。和文档一起压缩包中的有“catuid”和“readUID”两个程序，“catuid”是通过命令来获取 CPU 唯一序列号，“readUID”是通过文件流来获取唯一序列号...
VB6.0超级模块函数.GetCpuIdEx获取电脑CPUI序列号
追逐光芒，追随内心
09-28 1105
Function GetCpuIdEx() As String Dim TemMacId As String, TemMacId2 As String TemMacId2 = GetMAC TemMacId = geshi(TemMacId2) Dim temko As String Dim retstr As String Dim lentem As Long temko = GetCpuId lentem = Len(temko) .
c# 获取进程cpu使用率
最新发布
06-01
你可以使用 System.Diagnostics 命名空间下的 Process 类来获取进程的 CPU 使用率。以下是一个示例代码： ``` using System.Diagnostics; ... // 创建一个 Process 对象 Process process = Process....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值