4. CPU Last messen ...

CPU Last messen ...

  • S

    Hallo ... 🙂

    Ich würde gerne die CPU Last in % messen allerdings habe ich keine Ahnung wie das gehen könnte. Ich habe mich schon die MSDN geschlagen, aber ohne Erfolg. In den FAQs habe ich es auch nicht gefunden ( 😉 dafür aber andere sehr nützliche Tips!! Spitze!! 🙂 ). Daher meine direkte Frage.

    Wie kann ich die CPU Last auswerten??

    Bessten Dank im ******* ....

    Cu David

    0
  • ?

    hi!
    indem du den regestrieungs schlüssel HKEY_DYN_DATA\PerfStats\StartStat\KERNEL\CPUUsage ausließt

    0
  • B

    bei mir steht da nur:
    00 00 00 00
    😕

    0
  • H

    doch das geht mit KERNEL\CPUUsage nur ist der wert binär, muss also noch umgerechnet werden

    0
  • T

    Hmm, unter WinXP gibts den Schlüssel HKEY_DYN_DATA nicht. Was nun?

    0
  • E

    CPU usage konkret:

    Win 95/98: http://www.codepile.com/tric20.shtml

    Windows NT/2000: http://www.codepile.com/tric21.shtml

    0
  • S

    Spitzenmäßig ....

    Von der Registry-Version für Win98 habe ich schon gehört. Natürlich mach NT es einem nicht so einfach ....

    😉 Danke!!!! 🕶

    P.S.: wäre doch was für die FAQ oder??

    0
  • D

    Original erstellt von Spaceman:
    P.S.: wäre doch was für die FAQ oder??

    Klar 🙂

    0
  • V

    @Mods

    Ich mußte zwar das halbe Inet durchwühlen... aber es hat sich gelohnt 😃

    Damit der Eintrag im FAQ wieder Sinn macht 😉

    Win 95/98: http://www.codepile.com/tric20.shtml

    // cpusage9x.cpp (Windows 95/95)
//
// Getting the CPU usage in percent on Windows 9x
//
// (c)1999 Ashot Oganesyan K, SmartLine, Inc
// mailto:ashot@aha.ru, http://www.protect-me.com, http://www.codepile.com

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

void main(void)
{
HKEY hkey;
DWORD dwDataSize;
DWORD dwType;
DWORD dwCpuUsage;

// starting the counter
if ( RegOpenKeyEx( HKEY_DYN_DATA, "PerfStats\\StartStat", 0,KEY_ALL_ACCESS, &hkey ) != ERROR_SUCCESS)
     return;

dwDataSize=sizeof(DWORD);
RegQueryValueEx( hkey, "KERNEL\\CPUUsage", NULL,&dwType, (LPBYTE)&dwCpuUsage, &dwDataSize );

RegCloseKey(hkey);

// geting current counter's value
if ( RegOpenKeyEx( HKEY_DYN_DATA, "PerfStats\\StatData", 0,KEY_READ, &hkey ) != ERROR_SUCCESS)
    return;

printf("\nCPU Usage (press any key to exit): ");
while(!_kbhit())
{
    dwDataSize=sizeof(DWORD);
    RegQueryValueEx( hkey, "KERNEL\\CPUUsage", NULL,&dwType, (LPBYTE) &dwCpuUsage, &dwDataSize );
    Sleep(500);
    printf("\b\b\b\b%3d%%",dwCpuUsage);
}
printf("\n");

RegCloseKey(hkey);

// stoping the counter
if ( RegOpenKeyEx( HKEY_DYN_DATA, "PerfStats\\StopStat", 0,KEY_ALL_ACCESS, &hkey ) != ERROR_SUCCESS)
    return;

dwDataSize=sizeof(DWORD);
RegQueryValueEx( hkey, "KERNEL\\CPUUsage", NULL,&dwType,(LPBYTE)&dwCpuUsage, &dwDataSize );

RegCloseKey(hkey);
}
    0
  • V

    Win WinNT/Win2k/WinXP: http://www.codepile.com/tric21.shtml

    // cpusagent.cpp (Windows NT/2000)
//
// Getting the CPU usage in percent on Windows NT/2000
//
// (c)2000 Ashot Oganesyan K, SmartLine, Inc
// mailto:ashot@aha.ru, http://www.protect-me.com, http://www.codepile.com

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

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

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

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;

// ntdll!NtQuerySystemInformation (NT specific!)
//
// The function copies the system information of the
// specified type into a buffer
//
// NTSYSAPI
// NTSTATUS
// NTAPI
// NtQuerySystemInformation(
// IN UINT SystemInformationClass, // information type
// OUT PVOID SystemInformation, // pointer to buffer
// IN ULONG SystemInformationLength, // buffer size in bytes
// OUT PULONG ReturnLength OPTIONAL // pointer to a 32-bit
// // variable that receives
// // the number of bytes
// // written to the buffer 
// );
typedef LONG (WINAPI *PROCNTQSI)(UINT,PVOID,ULONG,PULONG);

PROCNTQSI NtQuerySystemInformation;

void main(void)
{
    SYSTEM_PERFORMANCE_INFORMATION SysPerfInfo;
    SYSTEM_TIME_INFORMATION SysTimeInfo;
    SYSTEM_BASIC_INFORMATION SysBaseInfo;
    double dbIdleTime;
    double dbSystemTime;
    LONG status;
    LARGE_INTEGER liOldIdleTime = {0,0};
    LARGE_INTEGER liOldSystemTime = {0,0};

    NtQuerySystemInformation = (PROCNTQSI)GetProcAddress( GetModuleHandle("ntdll"), "NtQuerySystemInformation" );

    if (!NtQuerySystemInformation)
        return;

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

    printf("\nCPU Usage (press any key to exit): ");
    while( !_kbhit() )
    {
        // get new system time
        status = NtQuerySystemInformation( SystemTimeInformation,&SysTimeInfo,sizeof(SysTimeInfo),0 );
        if (status!=NO_ERROR)
            return;

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

        // if it's 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;

            printf("\b\b\b\b%3d%%",(UINT)dbIdleTime);
        }

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

        // wait one second
        Sleep(1000);
    }
    printf("\n");
}

    MfG veganza 😉

    0
Anmelden zum Antworten