title image


Smiley Re: Prozessorauslastung eines Prozesses ermitteln


//*****************************************************************************

//*

//*

//* CpuLoad.h

//*

//*

//*****************************************************************************

#ifndef __CPULOAD_H__

#define __CPULOAD_H__





int CpuInit(); // Initialisierung

int CpuExit(); // Deinitialisierung

int CpuCount(); // CPU-Anzahl abfragen

int CpuUpdate(); // CPU-Auslastungsdaten hollen

int CpuLoad(unsigned uCpu); // CPU-Auslastungs für eine CPU abfragen





#endif



//*****************************************************************************

//*

//*

//* CpuLoad.cpp

//*

//*

//*****************************************************************************

#include

#include "CpuLoad.h"







#define PROCESSOR_IDX 238

#define CPU_USAGE_IDX 6



static HKEY hWin9xKey = 0;

static BOOL bIsWinNt = 0;

static DWORD dwDataSize = 0;

static DWORD dwWin9xUsage = 0;

static __int64 *pCounterAct = 0;

static __int64 *pCounterPre = 0;

static __int64 iSysTimeAct = 1;

static __int64 iSysTimePre = 0;

static unsigned uCpuCount = 0;

static union

{

PERF_DATA_BLOCK *o;

BYTE *b;

}pData;



//*****************************************************************************

//*

//* CpuUpdate

//*

//*****************************************************************************

// Hollt die neuesten Daten für die CPU-Auslastung

// Ergibt 1 wenn ok sonst 0

int CpuUpdate()

{

DWORD dwSize,dwType;

int iError;

unsigned u;

union

{

PERF_OBJECT_TYPE *o;

BYTE *b;

}pType;

union

{

PERF_COUNTER_DEFINITION *o;

BYTE *b;

}pCounter;

union

{

PERF_INSTANCE_DEFINITION*o;

BYTE *b;

}pInstance;

union

{

PERF_COUNTER_BLOCK *o;

BYTE *b;

}pBlock;





//******************** Win 98 *************************************************



if(!bIsWinNt)

{

if(!hWin9xKey)

{

HKEY hKey;



iError=RegOpenKeyEx(HKEY_DYN_DATA,"PerfStats\\StartStat",0,KEY_ALL_ACCESS,&hKey);



if(iError!=ERROR_SUCCESS){hWin9xKey=0;return 0;}



dwSize=sizeof(DWORD);



RegQueryValueEx(hKey,"KERNEL\\CPUUsage",0,&dwType,(LPBYTE)&dwWin9xUsage, &dwSize);

RegCloseKey(hKey);



iError=RegOpenKeyEx( HKEY_DYN_DATA,"PerfStats\\StatData",0,KEY_READ,&hWin9xKey);



if(iError!=ERROR_SUCCESS){hWin9xKey=0;return 0;}

if(!uCpuCount)uCpuCount=1;

}





dwSize=sizeof(DWORD);

RegQueryValueEx(hWin9xKey,"KERNEL\\CPUUsage",0,&dwType,(LPBYTE)&dwWin9xUsage,&dwSize);



return 1;

}



//******************** Win NT *************************************************



while(1)

{

dwSize=dwDataSize;

iError=RegQueryValueEx( HKEY_PERFORMANCE_DATA, "238", 0, 0,pData.b,&dwSize);

if(iError!=ERROR_MORE_DATA)break;

dwDataSize+=256;

if(pData.o)delete pData.o;

pData.b=new BYTE[dwDataSize];

}



if(iError!=ERROR_SUCCESS || !pData.o)

{

if(pData.o)delete pData.o;

return 0;

}



pType.b = ((BYTE*)pData.o)+pData.o->HeaderLength;



for(u=0;uNumObjectTypes;u++)

{

if(pType.o->ObjectNameTitleIndex==PROCESSOR_IDX)break;

pType.o += pType.o->TotalByteLength;

}



if(u>=pData.o->NumObjectTypes)

{

delete pData.o;

return 0;

}



if(!uCpuCount && pType.o->NumInstances>(int)uCpuCount)

{

uCpuCount = pType.o->NumInstances;

pCounterAct = new __int64[uCpuCount*2];

pCounterPre = pCounterAct+uCpuCount;

}



pCounter.b = pType.b + pType.o->HeaderLength;



for(u=1;uNumCounters;u++)

{

if(pCounter.o->CounterNameTitleIndex == CPU_USAGE_IDX)break;

pCounter.b += pCounter.o->ByteLength;

}



if(u>=pType.o->NumCounters)

{

delete pData.o;

return 0;

}



pInstance.b = pType.b + pType.o->DefinitionLength;



for(u = 0; (int)uNumInstances ; u++)

{

pBlock.b = pInstance.b + pInstance.o->ByteLength;



pCounterPre[u]=pCounterAct[u];

pCounterAct [u]=*(__int64*)(pBlock.b + pCounter.o->CounterOffset);

pInstance.b = pBlock.b + pBlock.o->ByteLength;

}



iSysTimePre = iSysTimeAct;

SystemTimeToFileTime(&pData.o->SystemTime,(LPFILETIME)&iSysTimeAct);

if(iSysTimePre == iSysTimeAct)iSysTimeAct++;



return 1;

}





//*****************************************************************************

//*

//* CpuInit

//*

//*****************************************************************************

// Initialisiert die CPU-Auslastungsberechnung

// Ergibt 1 wenn ok sonst 0

int CpuInit()

{

DWORD dwVersion;





dwVersion=GetVersion();

dwVersion=((dwVersion&0xFF00)>>8) | ((dwVersion&0x00FF)<<8);



if(dwVersion>=0x0500 || dwVersion==0x0400 || dwVersion==0x0300)bIsWinNt=TRUE;



if(!CpuUpdate())return 0;





return 1;

}



//*****************************************************************************

//*

//* CpuExit

//*

//*****************************************************************************

// Gibt alle Speicherbereiche wieder frei

// Ergibt 1 wenn ok sonst 0

int CpuExit()

{



dwDataSize = 0;

uCpuCount = 0;



if(pCounterAct){delete pCounterAct;pCounterAct = 0;pCounterPre = 0;}

if(pData.b ){delete pData.b ;pData.b = 0;}

if(hWin9xKey )

{

int iError;

HKEY hKey;

DWORD dwSize,dwType;



RegCloseKey(hWin9xKey);

hWin9xKey = 0;



iError=RegOpenKeyEx(HKEY_DYN_DATA,"PerfStats\\StopStat",0,KEY_ALL_ACCESS,&hKey);

if(iError!=ERROR_SUCCESS)return 0;



dwSize=sizeof(DWORD);



RegQueryValueEx(hKey,"KERNEL\\CPUUsage",0,&dwType,(LPBYTE)&dwWin9xUsage,&dwSize);

RegCloseKey(hKey);

}



return 1;

}





//*****************************************************************************

//*

//* CpuLoad

//*

//*****************************************************************************

// Ergibt die aktuelle CPU-Auslastung (0 bis 1024)

//

// uCpu : Ist die Nummer der CPU

//

// Danmit das funktioniert muss zuvor eine Zeit gewartet werden

// und CpuUpdate aufgerufen werden

// z.B. Sleep(1000);

// CpuUpdate();

// CpuLoad(0);

// CpuLoad(1);

// ...

int CpuLoad(unsigned uCpu)

{

__int64 iValue;

int iLoad;





if(uCpu>=uCpuCount)return -1;



if(!bIsWinNt) // Windows 95/98

{

if(!hWin9xKey)return -1;

iLoad = (dwWin9xUsage<<10) / 100;

}

else{ // Windows NT/2000/XP

iValue = pCounterAct[uCpu]-pCounterPre[uCpu];

iValue <<= 10;

iValue /= iSysTimeAct-iSysTimePre;



iLoad = 1024-(int)iValue;

}



if(iLoad< 0)iLoad=0;

if(iLoad>1024)iLoad=1024;





return iLoad;

}



//*****************************************************************************

//*

//* CpuCount

//*

//*****************************************************************************

// Gibt die Anzah aller CPU's

int CpuCount()

{

SYSTEM_INFO sInfo;





if(!uCpuCount)CpuInit();



GetSystemInfo(&sInfo);

if(uCpuCount


return sInfo.dwNumberOfProcessors;

}



//*****************************************************************************

//*

//*

//* Main.cpp

//*

//*

//*****************************************************************************

#include

#include

#include

#include

#include "CpuLoad.h"





//*****************************************************************************

//*

//* main

//*

//*****************************************************************************

int main()

{

int i,iProzent,iCpuCount;





CpuInit();

iCpuCount=CpuCount();



while(1)

{

if(kbhit())

{

getch();

break;

}



Sleep(1000); // Eine Sekunde warten

CpuUpdate(); // Neue Daten holen



printf("\n");

for(i=0;i
{

iProzent=(CpuLoad(i)*100)>>10;

printf("CPU_%i = %i%%\t",i,iProzent);

}

}



CpuExit();





return 0;

}


Schöne Grüße Anton 

Meine Webseite



geschrieben von

Login

E-Mail:
  

Passwort:
  

Beitrag anfügen

Symbol:
 
 
 
 
 
 
 
 
 
 
 
 
 

Überschrift: