Delphi 获取内存及CPU信息的函数

[delphi] view plaincopy

1. Uses MemoryCpuUtils;//首先引用该单元  
2.   
3. //声明下列变量用来存储读取的数值  
4. Var  
5.      iTotalPhysics, iTotalVirtual, iTotalPageFile,   
6.      iCurPhysics, iCurVirtual, iCurPageFile : DWord;  
7.   
8. //CPU数量  
9. Format('系统中共有 %d 个CPU中央存储器',[GetCPUCount]);  
10. //其中i表示获取第几个CPU的使用率  
11. Format('CPU使用率为 #%d - %5.2f%%',[i,GetCPUUsage(i)*100]);  
12. //初始化OR读取各内存总量  
13. GetMemoryTotalSize(iTotalPhysics ,iTotalVirtual ,iTotalPageFile);  
14. //物理内存总量  
15. InttoStr(Round(iTotalPhysics/1024/1024)) + ' MB';  
16. //虚拟内存总量  
17. InttoStr(Round(iTotalVirtual/1024/1024)) + ' MB';  
18. //页面内存(交换内存)总量  
19. InttoStr(Round(iTotalPageFile/1024/1024)) + ' MB';  
20. //读取各内存当前可用容量  
21. GetMemoryTotalSize(iCurPhysics,iCurVirtual,iCurPageFile);  
22. //物理内存可用容量  
23. InttoStr(Round(iCurPhysics/1024/1024)) + ' MB';  
24. //虚拟内存可用容量  
25. InttoStr(Round(iCurVirtual/1024/1024)) + ' MB';  
26. //页面内存(交换内存)可用容量  
27. InttoStr(Round(iCurPageFile/1024/1024)) + ' MB';  
28. //获取内存使用率  
29. Format('当前内存使用率为 %5.2f%%',[GetMemoryUsage]);  
30. //直接获取CPU厂商  
31. GetCPUVendor  
32.   
33. 那么如何计算当前各内存使用比例呢？  
34. //物理内存使用比  
35. Format('物理内存使用比为 %5.2f%%',[iCurPhysics/iTotalPhysics*100]);  
36. //虚拟内存使用比  
37. Format('虚拟内存使用比为 %5.2f%%',[iCurVirtual/iTotalVirtual*100]);  
38. //页面内存使用比  
39. Format('页面内存使用比为 %5.2f%%',[iCurPageFile/iTotalPageFile*100]);  
40.   
41.    
42.   
43. 下载后直接引用即可，如果您还不是会员，可以直接COPY下面的代码。  
44.   
45.   
46. {==================================================================}  
47. { Get Memory And Cpu Informations Utils         }  
48. {==================================================================}  
49.   
50. Unit MemoryCpuUtils;  
51.   
52. interface  
53.   
54. Uses  
55.      Windows, SysUtils;  
56.   
57. type  
58.      TVendor = array[0..11] of Char;  
59.   
60. {内存区}  
61. //获取物理内存、虚拟内存、交换区(页面)内存的总容量，做初始化动作。  
62. procedure GetMemoryTotalSize(Var iPhysicsMemoryTotalSize,  
63.          iVirtualMemoryTotalSize,  
64.          iPageFileMemoryTotalSize : DWORD);  
65.   
66. //获取当前物理内存、虚拟内存、交换区(页面)内存的实时可用容量，做监控显示动作。  
67. procedure GetMemoryCurrentSize(Var iPhysicsMemoryCurrentSize,  
68.          iVirtualMemoryCurrentSize,  
69.          iPageFileMemoryCurrentSize : DWORD);  
70.   
71. //返回内存当前使用率 总的是100%，传回的是0-100%间的使用率，可以自己做转换。          
72. function GetMemoryUsage : Double;  
73.   
74. {CPU区}  
75. //刷新CPU数据  
76. procedure CollectCPUData;  
77.   
78. //获取CPU在系统中的总数  
79. function GetCPUCount: Integer;  
80.   
81. //获取CPU使用率  
82. function GetCPUUsage(Index: Integer): Double;  
83.   
84. procedure ReleaseCPUData;  
85.   
86. //获取CPU制造厂商  
87. function GetCPUVendor : TVendor; assembler; register;  
88.   
89. implementation  
90.   
91. {$ifndef ver110}  
92.   
93.      {$ifndef ver90}  
94.      {$ifndef ver100}  
95.      {$define UseInt64}  
96.      {$endif}  
97.      {$endif}  
98.   
99.   
100.      {$ifdef UseInt64}  
101.      type TInt64 = Int64;  
102.      {$else}  
103.      type TInt64 = Comp;  
104.      {$endif}  
105.   
106. {$else}  
107.   
108.      type TInt64 = TLargeInteger;  
109.   
110. {$endif}  
111.   
112. type  
113.      PInt64 = ^TInt64;  
114.   
115. type  
116.      TPERF_DATA_BLOCK = record  
117.      Signature : array[0..4 - 1] of WCHAR;  
118.      LittleEndian : DWORD;  
119.      Version : DWORD;  
120.      Revision : DWORD;  
121.      TotalByteLength : DWORD;  
122.      HeaderLength : DWORD;  
123.      NumObjectTypes : DWORD;  
124.      DefaultObject : Longint;  
125.      SystemTime : TSystemTime;  
126.      Reserved: DWORD;  
127.      PerfTime : TInt64;  
128.      PerfFreq : TInt64;  
129.      PerfTime100nSec : TInt64;  
130.      SystemNameLength : DWORD;  
131.      SystemNameOffset : DWORD;  
132.      end;  
133.   
134.      PPERF_DATA_BLOCK = ^TPERF_DATA_BLOCK;  
135.   
136.      TPERF_OBJECT_TYPE = record  
137.      TotalByteLength : DWORD;  
138.      DefinitionLength : DWORD;  
139.      HeaderLength : DWORD;  
140.      ObjectNameTitleIndex : DWORD;  
141.      ObjectNameTitle : LPWSTR;  
142.      ObjectHelpTitleIndex : DWORD;  
143.      ObjectHelpTitle : LPWSTR;  
144.      DetailLevel : DWORD;  
145.      NumCounters : DWORD;  
146.      DefaultCounter : Longint;  
147.      NumInstances : Longint;  
148.      CodePage : DWORD;  
149.      PerfTime : TInt64;  
150.      PerfFreq : TInt64;  
151.      end;  
152.   
153.      PPERF_OBJECT_TYPE = ^TPERF_OBJECT_TYPE;  
154.   
155.      type  
156.      TPERF_COUNTER_DEFINITION = record  
157.          ByteLength : DWORD;  
158.          CounterNameTitleIndex : DWORD;  
159.          CounterNameTitle : LPWSTR;  
160.          CounterHelpTitleIndex : DWORD;  
161.          CounterHelpTitle : LPWSTR;  
162.          DefaultScale : Longint;  
163.          DetailLevel : DWORD;  
164.          CounterType : DWORD;  
165.          CounterSize : DWORD;  
166.          CounterOffset : DWORD;  
167.      end;  
168.   
169.      PPERF_COUNTER_DEFINITION = ^TPERF_COUNTER_DEFINITION;  
170.   
171.      TPERF_COUNTER_BLOCK = record  
172.          ByteLength : DWORD;  
173.      end;  
174.   
175.      PPERF_COUNTER_BLOCK = ^TPERF_COUNTER_BLOCK;  
176.   
177.      TPERF_INSTANCE_DEFINITION = record  
178.          ByteLength : DWORD;  
179.          ParentObjectTitleIndex : DWORD;  
180.          ParentObjectInstance : DWORD;  
181.          UniqueID : Longint;  
182.          NameOffset : DWORD;  
183.          NameLength : DWORD;  
184.      end;  
185.   
186.      PPERF_INSTANCE_DEFINITION = ^TPERF_INSTANCE_DEFINITION;  
187.   
188.      {$ifdef ver130}  
189.      {$L-}         // The L+ causes internal error in Delphi 5 compiler  
190.      {$O-}         // The O+ causes internal error in Delphi 5 compiler  
191.      {$Y-}         // The Y+ causes internal error in Delphi 5 compiler  
192.      {$endif}  
193.   
194. {$ifndef ver110}  
195.      type  
196.      TInt64F = TInt64;  
197.      {$else}  
198.      type  
199.      TInt64F = Extended;  
200. {$endif}  
201.   
202. {$ifdef ver110}  
203. function FInt64(Value: TInt64): TInt64F;  
204. function Int64D(Value: DWORD): TInt64;  
205. {$else}  
206. type  
207.      FInt64 = TInt64F;  
208.      Int64D = TInt64;  
209. {$endif}  
210.   
211. {$ifdef ver110}  
212. function FInt64(Value: TInt64): TInt64F;  
213. Var  
214.      V: TInt64;  
215. begin  
216.      if (Value.HighPart and $80000000) = 0 then // positive value  
217.      begin  
218.      result:=Value.HighPart;  
219.      result:=result*$10000*$10000;  
220.      result:=result+Value.LowPart;  
221.      end  
222.      else  
223.      begin  
224.      V.HighPart:=Value.HighPart xor $FFFFFFFF;  
225.      V.LowPart:=Value.LowPart xor $FFFFFFFF;  
226.      result:= -1 - FInt64(V);  
227.      end;  
228. end;  
229.   
230. function Int64D(Value: DWORD): TInt64;  
231. begin  
232.      Result.LowPart:=Value;  
233.      Result.HighPart := 0; // positive only  
234. end;  
235. {$endif}  
236.   
237. Const  
238.      Processor_IDX_Str = '238';  
239.      Processor_IDX = 238;  
240.      CPUUsageIDX = 6;  
241.   
242. type  
243.      AInt64F = array[0..$FFFF] of TInt64F;  
244.      PAInt64F = ^AInt64F;  
245.   
246. Var  
247.      _PerfData : PPERF_DATA_BLOCK;  
248.      _BufferSize: Integer;  
249.      _POT : PPERF_OBJECT_TYPE;  
250.      _PCD: PPerf_Counter_Definition;  
251.      _ProcessorsCount: Integer;  
252.      _Counters: PAInt64F;  
253.      _PrevCounters: PAInt64F;  
254.      _SysTime: TInt64F;  
255.      _PrevSysTime: TInt64F;  
256.      _IsWinNT: Boolean;  
257.   
258.      _W9xCollecting: Boolean;  
259.      _W9xCpuUsage: DWORD;  
260.      _W9xCpuKey: HKEY;  
261.   
262. procedure GetMemoryTotalSize(Var iPhysicsMemoryTotalSize,  
263.          iVirtualMemoryTotalSize,  
264.          iPageFileMemoryTotalSize : DWORD);  
265. { 
266. iPhysicsMemoryTotalSize 物理内存总容量 
267. iVirtualMemoryTotalSize 虚拟内存总容量 
268. iPageFileMemoryTotalSize 交换内存（页面）总容量 
269. }  
270. Var  
271.      msMemory : TMemoryStatus;  
272. begin  
273.      msMemory.dwLength := SizeOf(msMemory);  
274.      GlobalMemoryStatus(msMemory);  
275.      iPhysicsMemoryTotalSize := msMemory.dwTotalPhys;  
276.      iVirtualMemoryTotalSize := msMemory.dwTotalVirtual;  
277.      iPageFileMemoryTotalSize := msMemory.dwTotalPageFile;  
278. end;  
279.   
280. procedure GetMemoryCurrentSize(Var iPhysicsMemoryCurrentSize,  
281.          iVirtualMemoryCurrentSize,  
282.          iPageFileMemoryCurrentSize : DWORD);  
283. { 
284. iPhysicsMemoryCurrentSize 物理内存可用容量 
285. iVirtualMemoryCurrentSize 虚拟内存可用容量 
286. iPageFileMemoryCurrentSize 交换内存（页面）可用容量 
287. }  
288. Var  
289.      msMemory : TMemoryStatus;  
290. begin  
291.      msMemory.dwLength := SizeOf(msMemory);  
292.      GlobalMemoryStatus(msMemory);  
293.      iPhysicsMemoryCurrentSize := msMemory.dwAvailPhys;  
294.      iVirtualMemoryCurrentSize := msMemory.dwAvailVirtual;  
295.      iPageFileMemoryCurrentSize := msMemory.dwAvailPageFile;  
296. end;  
297.   
298. function GetMemoryUsage : Double;  
299. { 
300. 返回内存当前使用率 总的是100%，传回的是0-100%间的使用率，可以自己做转换。 
301. }  
302. Var  
303.      msMemory : TMemoryStatus;  
304. begin  
305.      try  
306.      msMemory.dwLength := SizeOf(msMemory);  
307.      GlobalMemoryStatus(msMemory);  
308.      Result := msMemory.dwMemoryLoad;  
309.      except  
310.      Result := 0;  
311.      end;  
312. end;  
313.   
314. function GetCPUCount: Integer;  
315. { 
316. 获取CPU数量 
317. }  
318. begin  
319.      if _IsWinNT then  
320.      begin  
321.      if _ProcessorsCount < 0 then  
322.          CollectCPUData;  
323.      Result:=_ProcessorsCount;  
324.      end  
325.      else  
326.      begin  
327.      Result:=1;  
328.      end;  
329. end;  
330.   
331. procedure ReleaseCPUData;  
332. Var  
333.      H: HKEY;  
334.      R: DWORD;  
335.      DwDataSize, DwType: DWORD;  
336. begin  
337.      if _IsWinNT then Exit;  
338.      if Not _W9xCollecting then Exit;  
339.      _W9xCollecting := False;  
340.      RegCloseKey(_W9xCpuKey);  
341.      R := RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StopStat', 0, KEY_ALL_ACCESS, H);  
342.      if R <> ERROR_SUCCESS then Exit;  
343.      dwDataSize := Sizeof(DWORD);  
344.      RegQueryValueEx(H,'KERNEL/CPUUsage', Nil, @DwType, PBYTE(@_W9xCpuUsage), @DwDataSize);  
345.      RegCloseKey(H);  
346. end;  
347.   
348. function GetCPUUsage(Index: Integer): Double;  
349. { 
350. 获取CPU当前使用率 
351. }  
352. begin  
353.      if _IsWinNT then  
354.      begin  
355.      if _ProcessorsCount < 0 then CollectCPUData;  
356.      if (Index >= _ProcessorsCount) Or (Index < 0) then  
357.          Raise Exception.Create('CPU index out of bounds');  
358.      if _PrevSysTime = _SysTime then  
359.          Result := 0  
360.      else  
361.          Result := 1-(_Counters[index] - _PrevCounters[index])/(_SysTime-_PrevSysTime);  
362.      end  
363.      else  
364.      begin  
365.      if Index <> 0 then  
366.          Raise Exception.Create('CPU index out of bounds');  
367.      if Not _W9xCollecting then  
368.          CollectCPUData;  
369.      Result := _W9xCpuUsage/100;  
370.      end;  
371. end;  
372.   
373. Var  
374.      VI: TOSVERSIONINFO;  
375.   
376. procedure CollectCPUData;  
377. Var  
378.      BS, i : Integer;  
379.      _PCB_Instance : PPERF_COUNTER_BLOCK;  
380.      _PID_Instance : PPERF_INSTANCE_DEFINITION;  
381.      ST : TFileTime;  
382.      H : HKEY;  
383.      R : DWORD;  
384.      DwDataSize, dwType: DWORD;  
385. begin  
386.      if _IsWinNT then  
387.      begin  
388.      BS:=_BufferSize;  
389.      while RegQueryValueEx( HKEY_PERFORMANCE_DATA, Processor_IDX_Str, nil, nil,  
390.          PByte(_PerfData), @BS ) = ERROR_MORE_DATA do  
391.      begin  
392.          INC(_BufferSize,$1000);  
393.          BS:=_BufferSize;  
394.          ReallocMem( _PerfData, _BufferSize );  
395.      end;  
396.   
397.      _POT := PPERF_OBJECT_TYPE(DWORD(_PerfData) + _PerfData.HeaderLength);  
398.      for i := 1 to _PerfData.NumObjectTypes do  
399.      begin  
400.          if _POT.ObjectNameTitleIndex = Processor_IDX then Break;  
401.          _POT := PPERF_OBJECT_TYPE(DWORD(_POT) + _POT.TotalByteLength);  
402.      end;  
403.   
404.      if _POT.ObjectNameTitleIndex <> Processor_IDX then  
405.          Raise Exception.Create('Unable to locate the "Processor" performance object');  
406.   
407.      if _ProcessorsCount < 0 then  
408.      begin  
409.          _ProcessorsCount:=_POT.NumInstances;  
410.          GetMem(_Counters,_ProcessorsCount*SizeOf(TInt64));  
411.          GetMem(_PrevCounters,_ProcessorsCount*SizeOf(TInt64));  
412.      end;  
413.   
414.      _PCD := PPERF_Counter_DEFINITION(DWORD(_POT) + _POT.HeaderLength);  
415.      for i := 1 to _POT.NumCounters do  
416.      begin  
417.          if _PCD.CounterNameTitleIndex = CPUUsageIDX then Break;  
418.          _PCD := PPERF_COUNTER_DEFINITION(DWORD(_PCD) + _PCD.ByteLength);  
419.      end;  
420.   
421.      if _PCD.CounterNameTitleIndex <> CPUUsageIDX then  
422.          Raise Exception.Create('Unable to locate the "% of CPU usage" performance counter');  
423.   
424.      _PID_Instance := PPERF_INSTANCE_DEFINITION(DWORD(_POT) + _POT.DefinitionLength);  
425.      for i := 0 to _ProcessorsCount-1 do  
426.      begin  
427.          _PCB_Instance := PPERF_COUNTER_BLOCK(DWORD(_PID_Instance) + _PID_Instance.ByteLength);  
428.          _PrevCounters[i]:=_Counters[i];  
429.          _Counters[i]:=FInt64(PInt64(DWORD(_PCB_Instance) + _PCD.CounterOffset)^);  
430.          _PID_Instance := PPERF_INSTANCE_DEFINITION(DWORD(_PCB_Instance) + _PCB_Instance.ByteLength);  
431.      end;  
432.   
433.      _PrevSysTime:=_SysTime;  
434.      SystemTimeToFileTime(_PerfData.SystemTime, ST);  
435.      _SysTime:=FInt64(TInt64(ST));  
436.      end  
437.      else  
438.      begin  
439.      if Not _W9xCollecting then  
440.      begin  
441.          R:=RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StartStat', 0, KEY_ALL_ACCESS, H );  
442.          if R <> ERROR_SUCCESS then  
443.          Raise Exception.Create('Unable to start performance monitoring');  
444.          dwDataSize:=sizeof(DWORD);  
445.          RegQueryValueEx( H, 'KERNEL/CPUUsage', nil, @dwType, PBYTE(@_W9xCpuUsage), @dwDataSize );  
446.          RegCloseKey(H);  
447.          R:=RegOpenKeyEx( HKEY_DYN_DATA, 'PerfStats/StatData', 0,KEY_READ, _W9xCpuKey );  
448.          if R <> ERROR_SUCCESS then  
449.          Raise Exception.Create('Unable to read performance data');  
450.          _W9xCollecting:=True;  
451.      end;  
452.   
453.      dwDataSize:=sizeof(DWORD);  
454.      RegQueryValueEx( _W9xCpuKey, 'KERNEL/CPUUsage', nil,@dwType, PBYTE(@_W9xCpuUsage), @dwDataSize );  
455.      end;  
456. end;  
457.   
458. function GetCPUVendor : TVendor; assembler; register;  
459. asm  
460.      PUSH     EBX                                         {Save affected register}  
461.      PUSH     EDI  
462.      MOV     EDI,EAX                         {@Result (TVendor)}  
463.      MOV     EAX,0  
464.      DW     $A20F                                 {CPUID Command}  
465.      MOV     EAX,EBX  
466.      XCHG                 EBX,ECX     {save ECX result}  
467.      MOV                         ECX,4  
468. @1:  
469.      STOSB  
470.      SHR     EAX,8  
471.      LOOP     @1  
472.      MOV     EAX,EDX  
473.      MOV                         ECX,4  
474. @2:  
475.      STOSB  
476.      SHR     EAX,8  
477.      LOOP     @2  
478.      MOV     EAX,EBX  
479.      MOV                         ECX,4  
480. @3:  
481.      STOSB  
482.      SHR     EAX,8  
483.      LOOP     @3  
484.      POP     EDI                                         {Restore registers}  
485.      POP     EBX  
486. end;  
487.   
488. initialization  
489.      _ProcessorsCount:= -1;  
490.      _BufferSize:= $2000;  
491.      _PerfData := AllocMem(_BufferSize);  
492.      VI.dwOSVersionInfoSize := SizeOf(VI);  
493.      if Not GetVersionEx(VI) then  
494.      Raise Exception.Create('Can''t get the Windows version');  
495.      _IsWinNT := VI.dwPlatformId = VER_PLATFORM_WIN32_NT;  
496.   
497. finalization  
498.      ReleaseCPUData;  
499.      FreeMem(_PerfData);  
500.       
501. end.