admin

[系统应用] 获取cpu使用率及内存情况

Uses MemoryCpuUtils;//首先引用该单元  

  

//声明下列变量用来存储读取的数值  

Var  

     iTotalPhysics, iTotalVirtual, iTotalPageFile,   

     iCurPhysics, iCurVirtual, iCurPageFile : DWord;  

  

//CPU数量  

Format('系统中共有 %d 个CPU中央存储器',[GetCPUCount]);  

//其中i表示获取第几个CPU的使用率  

Format('CPU使用率为 #%d - %5.2f%%',[i,GetCPUUsage(i)*100]);  

//初始化OR读取各内存总量  

GetMemoryTotalSize(iTotalPhysics ,iTotalVirtual ,iTotalPageFile);  

//物理内存总量  

InttoStr(Round(iTotalPhysics/1024/1024)) + ' MB';  

//虚拟内存总量  

InttoStr(Round(iTotalVirtual/1024/1024)) + ' MB';  

//页面内存(交换内存)总量  

InttoStr(Round(iTotalPageFile/1024/1024)) + ' MB';  

//读取各内存当前可用容量  

GetMemoryTotalSize(iCurPhysics,iCurVirtual,iCurPageFile);  

//物理内存可用容量  

InttoStr(Round(iCurPhysics/1024/1024)) + ' MB';  

//虚拟内存可用容量  

InttoStr(Round(iCurVirtual/1024/1024)) + ' MB';  

//页面内存(交换内存)可用容量  

InttoStr(Round(iCurPageFile/1024/1024)) + ' MB';  

//获取内存使用率  

Format('当前内存使用率为 %5.2f%%',[GetMemoryUsage]);  

//直接获取CPU厂商  

GetCPUVendor  

  

那么如何计算当前各内存使用比例呢?  

//物理内存使用比  

Format('物理内存使用比为 %5.2f%%',[iCurPhysics/iTotalPhysics*100]);  

//虚拟内存使用比  

Format('虚拟内存使用比为 %5.2f%%',[iCurVirtual/iTotalVirtual*100]);  

//页面内存使用比  

Format('页面内存使用比为 %5.2f%%',[iCurPageFile/iTotalPageFile*100]);  

  

   

  

下载后直接引用即可,如果您还不是会员,可以直接COPY下面的代码。  

  

  

{==================================================================}  

{ Get Memory And Cpu Informations Utils         }  

{==================================================================}  

  

Unit MemoryCpuUtils;  

  

interface  

  

Uses  

     Windows, SysUtils;  

  

type  

     TVendor = array[0..11] of Char;  

  

{内存区}  

//获取物理内存、虚拟内存、交换区(页面)内存的总容量,做初始化动作。  

procedure GetMemoryTotalSize(Var iPhysicsMemoryTotalSize,  

         iVirtualMemoryTotalSize,  

         iPageFileMemoryTotalSize : DWORD);  

  

//获取当前物理内存、虚拟内存、交换区(页面)内存的实时可用容量,做监控显示动作。  

procedure GetMemoryCurrentSize(Var iPhysicsMemoryCurrentSize,  

         iVirtualMemoryCurrentSize,  

         iPageFileMemoryCurrentSize : DWORD);  

  

//返回内存当前使用率 总的是100%,传回的是0-100%间的使用率,可以自己做转换。          

function GetMemoryUsage : Double;  

  

{CPU区}  

//刷新CPU数据  

procedure CollectCPUData;  

  

//获取CPU在系统中的总数  

function GetCPUCount: Integer;  

  

//获取CPU使用率  

function GetCPUUsage(Index: Integer): Double;  

  

procedure ReleaseCPUData;  

  

//获取CPU制造厂商  

function GetCPUVendor : TVendor; assembler; register;  

  

implementation  

  

{$ifndef ver110}  

  

     {$ifndef ver90}  

     {$ifndef ver100}  

     {$define UseInt64}  

     {$endif}  

     {$endif}  

  

  

     {$ifdef UseInt64}  

     type TInt64 = Int64;  

     {$else}  

     type TInt64 = Comp;  

     {$endif}  

  

{$else}  

  

     type TInt64 = TLargeInteger;  

  

{$endif}  

  

type  

     PInt64 = ^TInt64;  

  

type  

     TPERF_DATA_BLOCK = record  

     Signature : array[0..4 - 1] of WCHAR;  

     LittleEndian : DWORD;  

     Version : DWORD;  

     Revision : DWORD;  

     TotalByteLength : DWORD;  

     HeaderLength : DWORD;  

     NumObjectTypes : DWORD;  

     DefaultObject : Longint;  

     SystemTime : TSystemTime;  

     Reserved: DWORD;  

     PerfTime : TInt64;  

     PerfFreq : TInt64;  

     PerfTime100nSec : TInt64;  

     SystemNameLength : DWORD;  

     SystemNameOffset : DWORD;  

     end;  

  

     PPERF_DATA_BLOCK = ^TPERF_DATA_BLOCK;  

  

     TPERF_OBJECT_TYPE = record  

     TotalByteLength : DWORD;  

     DefinitionLength : DWORD;  

     HeaderLength : DWORD;  

     ObjectNameTitleIndex : DWORD;  

     ObjectNameTitle : LPWSTR;  

     ObjectHelpTitleIndex : DWORD;  

     ObjectHelpTitle : LPWSTR;  

     DetailLevel : DWORD;  

     NumCounters : DWORD;  

     DefaultCounter : Longint;  

     NumInstances : Longint;  

     CodePage : DWORD;  

     PerfTime : TInt64;  

     PerfFreq : TInt64;  

     end;  

  

     PPERF_OBJECT_TYPE = ^TPERF_OBJECT_TYPE;  

  

     type  

     TPERF_COUNTER_DEFINITION = record  

         ByteLength : DWORD;  

         CounterNameTitleIndex : DWORD;  

         CounterNameTitle : LPWSTR;  

         CounterHelpTitleIndex : DWORD;  

         CounterHelpTitle : LPWSTR;  

         DefaultScale : Longint;  

         DetailLevel : DWORD;  

         CounterType : DWORD;  

         CounterSize : DWORD;  

         CounterOffset : DWORD;  

     end;  

  

     PPERF_COUNTER_DEFINITION = ^TPERF_COUNTER_DEFINITION;  

  

     TPERF_COUNTER_BLOCK = record  

         ByteLength : DWORD;  

     end;  

  

     PPERF_COUNTER_BLOCK = ^TPERF_COUNTER_BLOCK;  

  

     TPERF_INSTANCE_DEFINITION = record  

         ByteLength : DWORD;  

         ParentObjectTitleIndex : DWORD;  

         ParentObjectInstance : DWORD;  

         UniqueID : Longint;  

         NameOffset : DWORD;  

         NameLength : DWORD;  

     end;  

  

     PPERF_INSTANCE_DEFINITION = ^TPERF_INSTANCE_DEFINITION;  

  

     {$ifdef ver130}  

     {$L-}         // The L+ causes internal error in Delphi 5 compiler  

     {$O-}         // The O+ causes internal error in Delphi 5 compiler  

     {$Y-}         // The Y+ causes internal error in Delphi 5 compiler  

     {$endif}  

  

{$ifndef ver110}  

     type  

     TInt64F = TInt64;  

     {$else}  

     type  

     TInt64F = Extended;  

{$endif}  

  

{$ifdef ver110}  

function FInt64(Value: TInt64): TInt64F;  

function Int64D(Value: DWORD): TInt64;  

{$else}  

type  

     FInt64 = TInt64F;  

     Int64D = TInt64;  

{$endif}  

  

{$ifdef ver110}  

function FInt64(Value: TInt64): TInt64F;  

Var  

     V: TInt64;  

begin  

     if (Value.HighPart and $80000000) = 0 then // positive value  

     begin  

     result:=Value.HighPart;  

     result:=result*$10000*$10000;  

     result:=result+Value.LowPart;  

     end  

     else  

     begin  

     V.HighPart:=Value.HighPart xor $FFFFFFFF;  

     V.LowPart:=Value.LowPart xor $FFFFFFFF;  

     result:= -1 - FInt64(V);  

     end;  

end;  

  

function Int64D(Value: DWORD): TInt64;  

begin  

     Result.LowPart:=Value;  

     Result.HighPart := 0; // positive only  

end;  

{$endif}  

  

Const  

     Processor_IDX_Str = '238';  

     Processor_IDX = 238;  

     CPUUsageIDX = 6;  

  

type  

     AInt64F = array[0..$FFFF] of TInt64F;  

     PAInt64F = ^AInt64F;  

  

Var  

     _PerfData : PPERF_DATA_BLOCK;  

     _BufferSize: Integer;  

     _POT : PPERF_OBJECT_TYPE;  

     _PCD: PPerf_Counter_Definition;  

     _ProcessorsCount: Integer;  

     _Counters: PAInt64F;  

     _PrevCounters: PAInt64F;  

     _SysTime: TInt64F;  

     _PrevSysTime: TInt64F;  

     _IsWinNT: Boolean;  

  

     _W9xCollecting: Boolean;  

     _W9xCpuUsage: DWORD;  

     _W9xCpuKey: HKEY;  

  

procedure GetMemoryTotalSize(Var iPhysicsMemoryTotalSize,  

         iVirtualMemoryTotalSize,  

         iPageFileMemoryTotalSize : DWORD);  

iPhysicsMemoryTotalSize 物理内存总容量 

iVirtualMemoryTotalSize 虚拟内存总容量 

iPageFileMemoryTotalSize 交换内存(页面)总容量 

}  

Var  

     msMemory : TMemoryStatus;  

begin  

     msMemory.dwLength := SizeOf(msMemory);  

     GlobalMemoryStatus(msMemory);  

     iPhysicsMemoryTotalSize := msMemory.dwTotalPhys;  

     iVirtualMemoryTotalSize := msMemory.dwTotalVirtual;  

     iPageFileMemoryTotalSize := msMemory.dwTotalPageFile;  

end;  

  

procedure GetMemoryCurrentSize(Var iPhysicsMemoryCurrentSize,  

         iVirtualMemoryCurrentSize,  

         iPageFileMemoryCurrentSize : DWORD);  

iPhysicsMemoryCurrentSize 物理内存可用容量 

iVirtualMemoryCurrentSize 虚拟内存可用容量 

iPageFileMemoryCurrentSize 交换内存(页面)可用容量 

}  

Var  

     msMemory : TMemoryStatus;  

begin  

     msMemory.dwLength := SizeOf(msMemory);  

     GlobalMemoryStatus(msMemory);  

     iPhysicsMemoryCurrentSize := msMemory.dwAvailPhys;  

     iVirtualMemoryCurrentSize := msMemory.dwAvailVirtual;  

     iPageFileMemoryCurrentSize := msMemory.dwAvailPageFile;  

end;  

  

function GetMemoryUsage : Double;  

返回内存当前使用率 总的是100%,传回的是0-100%间的使用率,可以自己做转换。 

}  

Var  

     msMemory : TMemoryStatus;  

begin  

     try  

     msMemory.dwLength := SizeOf(msMemory);  

     GlobalMemoryStatus(msMemory);  

     Result := msMemory.dwMemoryLoad;  

     except  

     Result := 0;  

     end;  

end;  

  

function GetCPUCount: Integer;  

获取CPU数量 

}  

begin  

     if _IsWinNT then  

     begin  

     if _ProcessorsCount < 0 then  

         CollectCPUData;  

     Result:=_ProcessorsCount;  

     end  

     else  

     begin  

     Result:=1;  

     end;  

end;  

  

procedure ReleaseCPUData;  

Var  

     H: HKEY;  

     R: DWORD;  

     DwDataSize, DwType: DWORD;  

begin  

     if _IsWinNT then Exit;  

     if Not _W9xCollecting then Exit;  

     _W9xCollecting := False;  

     RegCloseKey(_W9xCpuKey);  

     R := RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StopStat', 0, KEY_ALL_ACCESS, H);  

     if R <> ERROR_SUCCESS then Exit;  

     dwDataSize := Sizeof(DWORD);  

     RegQueryValueEx(H,'KERNEL/CPUUsage', Nil, @DwType, PBYTE(@_W9xCpuUsage), @DwDataSize);  

     RegCloseKey(H);  

end;  

  

function GetCPUUsage(Index: Integer): Double;  

获取CPU当前使用率 

}  

begin  

     if _IsWinNT then  

     begin  

     if _ProcessorsCount < 0 then CollectCPUData;  

     if (Index >= _ProcessorsCount) Or (Index < 0) then  

         Raise Exception.Create('CPU index out of bounds');  

     if _PrevSysTime = _SysTime then  

         Result := 0  

     else  

         Result := 1-(_Counters[index] - _PrevCounters[index])/(_SysTime-_PrevSysTime);  

     end  

     else  

     begin  

     if Index <> 0 then  

         Raise Exception.Create('CPU index out of bounds');  

     if Not _W9xCollecting then  

         CollectCPUData;  

     Result := _W9xCpuUsage/100;  

     end;  

end;  

  

Var  

     VI: TOSVERSIONINFO;  

  

procedure CollectCPUData;  

Var  

     BS, i : Integer;  

     _PCB_Instance : PPERF_COUNTER_BLOCK;  

     _PID_Instance : PPERF_INSTANCE_DEFINITION;  

     ST : TFileTime;  

     H : HKEY;  

     R : DWORD;  

     DwDataSize, dwType: DWORD;  

begin  

     if _IsWinNT then  

     begin  

     BS:=_BufferSize;  

     while RegQueryValueEx( HKEY_PERFORMANCE_DATA, Processor_IDX_Str, nil, nil,  

         PByte(_PerfData), @BS ) = ERROR_MORE_DATA do  

     begin  

         INC(_BufferSize,$1000);  

         BS:=_BufferSize;  

         ReallocMem( _PerfData, _BufferSize );  

     end;  

  

     _POT := PPERF_OBJECT_TYPE(DWORD(_PerfData) + _PerfData.HeaderLength);  

     for i := 1 to _PerfData.NumObjectTypes do  

     begin  

         if _POT.ObjectNameTitleIndex = Processor_IDX then Break;  

         _POT := PPERF_OBJECT_TYPE(DWORD(_POT) + _POT.TotalByteLength);  

     end;  

  

     if _POT.ObjectNameTitleIndex <> Processor_IDX then  

         Raise Exception.Create('Unable to locate the "Processor" performance object');  

  

     if _ProcessorsCount < 0 then  

     begin  

         _ProcessorsCount:=_POT.NumInstances;  

         GetMem(_Counters,_ProcessorsCount*SizeOf(TInt64));  

         GetMem(_PrevCounters,_ProcessorsCount*SizeOf(TInt64));  

     end;  

  

     _PCD := PPERF_Counter_DEFINITION(DWORD(_POT) + _POT.HeaderLength);  

     for i := 1 to _POT.NumCounters do  

     begin  

         if _PCD.CounterNameTitleIndex = CPUUsageIDX then Break;  

         _PCD := PPERF_COUNTER_DEFINITION(DWORD(_PCD) + _PCD.ByteLength);  

     end;  

  

     if _PCD.CounterNameTitleIndex <> CPUUsageIDX then  

         Raise Exception.Create('Unable to locate the "% of CPU usage" performance counter');  

  

     _PID_Instance := PPERF_INSTANCE_DEFINITION(DWORD(_POT) + _POT.DefinitionLength);  

     for i := 0 to _ProcessorsCount-1 do  

     begin  

         _PCB_Instance := PPERF_COUNTER_BLOCK(DWORD(_PID_Instance) + _PID_Instance.ByteLength);  

         _PrevCounters[i]:=_Counters[i];  

         _Counters[i]:=FInt64(PInt64(DWORD(_PCB_Instance) + _PCD.CounterOffset)^);  

         _PID_Instance := PPERF_INSTANCE_DEFINITION(DWORD(_PCB_Instance) + _PCB_Instance.ByteLength);  

     end;  

  

     _PrevSysTime:=_SysTime;  

     SystemTimeToFileTime(_PerfData.SystemTime, ST);  

     _SysTime:=FInt64(TInt64(ST));  

     end  

     else  

     begin  

     if Not _W9xCollecting then  

     begin  

         R:=RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StartStat', 0, KEY_ALL_ACCESS, H );  

         if R <> ERROR_SUCCESS then  

         Raise Exception.Create('Unable to start performance monitoring');  

         dwDataSize:=sizeof(DWORD);  

         RegQueryValueEx( H, 'KERNEL/CPUUsage', nil, @dwType, PBYTE(@_W9xCpuUsage), @dwDataSize );  

         RegCloseKey(H);  

         R:=RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StatData', 0,KEY_READ, _W9xCpuKey );  

         if R <> ERROR_SUCCESS then  

         Raise Exception.Create('Unable to read performance data');  

         _W9xCollecting:=True;  

     end;  

  

     dwDataSize:=sizeof(DWORD);  

     RegQueryValueEx( _W9xCpuKey, 'KERNEL/CPUUsage', nil,@dwType, PBYTE(@_W9xCpuUsage), @dwDataSize );  

     end;  

end;  

  

function GetCPUVendor : TVendor; assembler; register;  

asm  

     PUSH     EBX                                         {Save affected register}  

     PUSH     EDI  

     MOV     EDI,EAX                         {@Result (TVendor)}  

     MOV     EAX,0  

     DW     $A20F                                 {CPUID Command}  

     MOV     EAX,EBX  

     XCHG                 EBX,ECX     {save ECX result}  

     MOV                         ECX,4  

@1:  

     STOSB  

     SHR     EAX,8  

     LOOP     @1  

     MOV     EAX,EDX  

     MOV                         ECX,4  

@2:  

     STOSB  

     SHR     EAX,8  

     LOOP     @2  

     MOV     EAX,EBX  

     MOV                         ECX,4  

@3:  

     STOSB  

     SHR     EAX,8  

     LOOP     @3  

     POP     EDI                                         {Restore registers}  

     POP     EBX  

end;  

  

initialization  

     _ProcessorsCount:= -1;  

     _BufferSize:= $2000;  

     _PerfData := AllocMem(_BufferSize);  

     VI.dwOSVersionInfoSize := SizeOf(VI);  

     if Not GetVersionEx(VI) then  

     Raise Exception.Create('Can''t get the Windows version');  

     _IsWinNT := VI.dwPlatformId = VER_PLATFORM_WIN32_NT;  

  

finalization  

     ReleaseCPUData;  

     FreeMem(_PerfData);  

      

end.  


#1楼
发帖时间:6月前   |   查看数:0   |   回复数:0
游客组