![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pviewdat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / pviewer|
Return to pviewdat.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / pviewer |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12:
13: /******************************************************************************
14:
15: P V I E W D A T A
16:
17: Name: pviewdat.c
18:
19: Description:
20: This module collects the data to be displayed in pview.
21:
22: ******************************************************************************/
23:
24: #include <windows.h>
25: #include <winperf.h>
26: #include "perfdata.h"
27: #include "pviewdat.h"
28: #include "pviewdlg.h"
29: #include <stdio.h>
30: #include <stdlib.h>
31: #include <string.h>
32:
33:
34: #define NODATA TEXT("--------")
35:
36:
37:
38:
39:
40: void FormatTimeFields
41: (double fTime,
42: PTIME_FIELD pTimeFld);
43:
44: DWORD PutCounterDWKB
45: (HWND hWnd,
46: DWORD dwItemID,
47: PPERF_INSTANCE pInst,
48: PPERF_OBJECT pObj,
49: DWORD dwCounterIdx);
50:
51: DWORD PutCounterHEX
52: (HWND hWnd,
53: DWORD dwItemID,
54: PPERF_INSTANCE pInst,
55: PPERF_OBJECT pObj,
56: DWORD dwCounterIdx);
57:
58: DWORD PutCounterDW
59: (HWND hWnd,
60: DWORD dwItemID,
61: PPERF_INSTANCE pInst,
62: PPERF_OBJECT pObj,
63: DWORD dwCounterIdx);
64:
65: void PaintAddressSpace
66: (HWND hMemDlg,
67: PPERF_INSTANCE pInst,
68: PPERF_OBJECT pObj,
69: DWORD TotalID,
70: DWORD NoAccessID,
71: DWORD NoAccessIndex,
72: DWORD ReadOnlyID,
73: DWORD ReadOnlyIndex,
74: DWORD ReadWriteID,
75: DWORD ReadWriteIndex,
76: DWORD WriteCopyID,
77: DWORD WriteCopyIndex,
78: DWORD ExecuteID,
79: DWORD ExecuteIndex1,
80: DWORD ExecuteIndex2,
81: DWORD ExecuteIndex3,
82: DWORD ExecuteIndex4);
83:
84: void PaintMemDlgAddrData
85: (HWND hMemDlg,
86: PPERF_INSTANCE pInst,
87: PPERF_OBJECT pObj);
88:
89: void PaintMemDlgVMData
90: (HWND hMemDlg,
91: PPERF_INSTANCE pInst,
92: PPERF_OBJECT pObj);
93:
94: void PaintPviewDlgMemoryData
95: (HWND hPviewDlg,
96: PPERF_INSTANCE pInst,
97: PPERF_OBJECT pObj);
98:
99: void RefreshMemoryDlgImageList
100: (HWND hImageList,
101: DWORD ParentIndex,
102: PPERF_OBJECT pImageObj);
103:
104: void SetProcessListText
105: (PPERF_INSTANCE pInst,
106: PPERF_COUNTER pCPU,
107: PPERF_COUNTER pPRIV,
108: PPERF_COUNTER pProcID,
109: double fTime,
110: LPTSTR str);
111:
112: void SetThreadListText
113: (PPERF_INSTANCE pInst,
114: PPERF_COUNTER pCPU,
115: PPERF_COUNTER pPRIV,
116: double fTime,
117: LPTSTR str);
118:
119:
120:
121:
122: //*********************************************************************
123: //
124: // FormatTimeFields
125: //
126: // Formats a double value to time fields.
127: //
128: void FormatTimeFields (double fTime,
129: PTIME_FIELD pTimeFld)
130: {
131: INT i;
132: double f;
133:
134: f = fTime/3600;
135:
136: pTimeFld->Hours = i = (int)f;
137:
138: f = f - i;
139: pTimeFld->Mins = i = (int)(f = f * 60);
140:
141: f = f - i;
142: pTimeFld->Secs = i = (int)(f = f * 60);
143:
144: f = f - i;
145: pTimeFld->mSecs = (int)(f * 1000);
146: }
147:
148:
149:
150:
151: //*********************************************************************
152: //
153: // PutCounterDWKB
154: //
155: // Display a DWORD counter's data in KB units.
156: //
157: DWORD PutCounterDWKB (HWND hWnd,
158: DWORD dwItemID,
159: PPERF_INSTANCE pInst,
160: PPERF_OBJECT pObj,
161: DWORD dwCounterIdx)
162: {
163: PPERF_COUNTER pCounter;
164: DWORD *pdwData;
165: TCHAR szTemp[20];
166:
167: if (pCounter = FindCounter (pObj, dwCounterIdx))
168: {
169: pdwData = (DWORD *) CounterData (pInst, pCounter);
170: wsprintf (szTemp, TEXT("%ld KB"), *pdwData/1024);
171: SetDlgItemText (hWnd, dwItemID, szTemp);
172:
173: return *pdwData;
174: }
175: else
176: {
177: SetDlgItemText (hWnd, dwItemID, NODATA);
178: return 0;
179: }
180:
181: }
182:
183:
184:
185:
186: //*********************************************************************
187: //
188: // PutCounterHEX
189: //
190: // Display a DWORD counter's data in hex.
191: //
192: DWORD PutCounterHEX (HWND hWnd,
193: DWORD dwItemID,
194: PPERF_INSTANCE pInst,
195: PPERF_OBJECT pObj,
196: DWORD dwCounterIdx)
197: {
198: PPERF_COUNTER pCounter;
199: DWORD *pdwData;
200: TCHAR szTemp[20];
201:
202: if (pCounter = FindCounter (pObj, dwCounterIdx))
203: {
204: pdwData = (DWORD *) CounterData (pInst, pCounter);
205: wsprintf (szTemp, TEXT("0x%08x"), *pdwData);
206: SetDlgItemText (hWnd, dwItemID, szTemp);
207:
208: return *pdwData;
209: }
210: else
211: {
212: SetDlgItemText (hWnd, dwItemID, NODATA);
213: return 0;
214: }
215:
216: }
217:
218:
219:
220:
221: //*********************************************************************
222: //
223: // PutCounterDWKB
224: //
225: // Display a DWORD counter's data.
226: //
227: DWORD PutCounterDW (HWND hWnd,
228: DWORD dwItemID,
229: PPERF_INSTANCE pInst,
230: PPERF_OBJECT pObj,
231: DWORD dwCounterIdx)
232: {
233: PPERF_COUNTER pCounter;
234: DWORD *pdwData;
235:
236: if (pCounter = FindCounter (pObj, dwCounterIdx))
237: {
238: pdwData = (DWORD *) CounterData (pInst, pCounter);
239: SetDlgItemInt (hWnd, dwItemID, *pdwData, FALSE);
240:
241: return *pdwData;
242: }
243: else
244: {
245: SetDlgItemText (hWnd, dwItemID, NODATA);
246: return 0;
247: }
248:
249: }
250:
251:
252:
253:
254: //*********************************************************************
255: //
256: // PaintAddressSpace
257: //
258: //
259: void PaintAddressSpace (HWND hMemDlg,
260: PPERF_INSTANCE pInst,
261: PPERF_OBJECT pObj,
262: DWORD TotalID,
263: DWORD NoAccessID,
264: DWORD NoAccessIndex,
265: DWORD ReadOnlyID,
266: DWORD ReadOnlyIndex,
267: DWORD ReadWriteID,
268: DWORD ReadWriteIndex,
269: DWORD WriteCopyID,
270: DWORD WriteCopyIndex,
271: DWORD ExecuteID,
272: DWORD ExecuteIndex1,
273: DWORD ExecuteIndex2,
274: DWORD ExecuteIndex3,
275: DWORD ExecuteIndex4)
276: {
277: PPERF_COUNTER pCounter;
278: DWORD *pdwData;
279: TCHAR szTemp[20];
280:
281: DWORD dwTotal = 0;
282: DWORD dwExecute = 0;
283: BOOL bCounter = FALSE;
284:
285:
286: dwTotal += PutCounterDWKB (hMemDlg, NoAccessID, pInst, pObj, NoAccessIndex);
287: dwTotal += PutCounterDWKB (hMemDlg, ReadOnlyID, pInst, pObj, ReadOnlyIndex);
288: dwTotal += PutCounterDWKB (hMemDlg, ReadWriteID, pInst, pObj, ReadWriteIndex);
289: dwTotal += PutCounterDWKB (hMemDlg, WriteCopyID, pInst, pObj, WriteCopyIndex);
290:
291:
292: // execute is the sum of the following
293: //
294: if (pCounter = FindCounter (pObj, ExecuteIndex1))
295: {
296: pdwData = (DWORD *) CounterData (pInst, pCounter);
297: dwTotal += *pdwData;
298: dwExecute += *pdwData;
299: bCounter = TRUE;
300: }
301:
302: if (pCounter = FindCounter (pObj, ExecuteIndex2))
303: {
304: pdwData = (DWORD *) CounterData (pInst, pCounter);
305: dwTotal += *pdwData;
306: dwExecute += *pdwData;
307: bCounter = TRUE;
308: }
309:
310: if (pCounter = FindCounter (pObj, ExecuteIndex3))
311: {
312: pdwData = (DWORD *) CounterData (pInst, pCounter);
313: dwTotal += *pdwData;
314: dwExecute += *pdwData;
315: bCounter = TRUE;
316: }
317:
318: if (pCounter = FindCounter (pObj, ExecuteIndex4))
319: {
320: pdwData = (DWORD *) CounterData (pInst, pCounter);
321: dwTotal += *pdwData;
322: dwExecute += *pdwData;
323: bCounter = TRUE;
324: }
325:
326: if (bCounter)
327: {
328: wsprintf (szTemp, TEXT("%ld KB"), dwExecute/1024);
329: SetDlgItemText (hMemDlg, ExecuteID, szTemp);
330: }
331: else
332: SetDlgItemText (hMemDlg, ExecuteID, NODATA);
333:
334: wsprintf (szTemp, TEXT("%ld KB"), dwTotal/1024);
335: SetDlgItemText (hMemDlg, TotalID, szTemp);
336:
337: }
338:
339:
340:
341:
342: //*********************************************************************
343: //
344: // PaintMemDlgAddrData
345: //
346: // Paint the memory dialog address space data.
347: //
348: void PaintMemDlgAddrData(HWND hMemDlg,
349: PPERF_INSTANCE pInst,
350: PPERF_OBJECT pObj)
351: {
352: PaintAddressSpace (hMemDlg, pInst, pObj,
353: MEMORY_TOTALPRIVATE_COMMIT,
354: MEMORY_PRIVATE_NOACCESS, PX_PROCESS_PRIVATE_NOACCESS,
355: MEMORY_PRIVATE_READONLY, PX_PROCESS_PRIVATE_READONLY,
356: MEMORY_PRIVATE_READWRITE, PX_PROCESS_PRIVATE_READWRITE,
357: MEMORY_PRIVATE_WRITECOPY, PX_PROCESS_PRIVATE_WRITECOPY,
358: MEMORY_PRIVATE_EXECUTE, PX_PROCESS_PRIVATE_EXECUTABLE,
359: PX_PROCESS_PRIVATE_EXE_READONLY,
360: PX_PROCESS_PRIVATE_EXE_READWRITE,
361: PX_PROCESS_PRIVATE_EXE_WRITECOPY);
362:
363: PaintAddressSpace (hMemDlg, pInst, pObj,
364: MEMORY_TOTALMAPPED_COMMIT,
365: MEMORY_MAPPED_NOACCESS, PX_PROCESS_MAPPED_NOACCESS,
366: MEMORY_MAPPED_READONLY, PX_PROCESS_MAPPED_READONLY,
367: MEMORY_MAPPED_READWRITE, PX_PROCESS_MAPPED_READWRITE,
368: MEMORY_MAPPED_WRITECOPY, PX_PROCESS_MAPPED_WRITECOPY,
369: MEMORY_MAPPED_EXECUTE, PX_PROCESS_MAPPED_EXECUTABLE,
370: PX_PROCESS_MAPPED_EXE_READONLY,
371: PX_PROCESS_MAPPED_EXE_READWRITE,
372: PX_PROCESS_MAPPED_EXE_WRITECOPY);
373:
374: PaintAddressSpace (hMemDlg, pInst, pObj,
375: MEMORY_TOTALIMAGE_COMMIT,
376: MEMORY_IMAGE_NOACCESS, PX_PROCESS_IMAGE_NOACCESS,
377: MEMORY_IMAGE_READONLY, PX_PROCESS_IMAGE_READONLY,
378: MEMORY_IMAGE_READWRITE, PX_PROCESS_IMAGE_READWRITE,
379: MEMORY_IMAGE_WRITECOPY, PX_PROCESS_IMAGE_WRITECOPY,
380: MEMORY_IMAGE_EXECUTE, PX_PROCESS_IMAGE_EXECUTABLE,
381: PX_PROCESS_IMAGE_EXE_READONLY,
382: PX_PROCESS_IMAGE_EXE_READWRITE,
383: PX_PROCESS_IMAGE_EXE_WRITECOPY);
384: }
385:
386:
387:
388:
389: //*********************************************************************
390: //
391: // PaintMemDlgVMData
392: //
393: // Paint the memory dialog Virtual Memory data.
394: //
395: void PaintMemDlgVMData (HWND hMemDlg,
396: PPERF_INSTANCE pInst,
397: PPERF_OBJECT pObj)
398: {
399:
400: PutCounterDWKB (hMemDlg, MEMORY_WS, pInst, pObj, PX_PROCESS_WORKING_SET);
401: PutCounterDWKB (hMemDlg, MEMORY_PEAK_WS, pInst, pObj, PX_PROCESS_PEAK_WS);
402: PutCounterDWKB (hMemDlg, MEMORY_PRIVATE_PAGE, pInst, pObj, PX_PROCESS_PRIVATE_PAGE);
403: PutCounterDWKB (hMemDlg, MEMORY_VSIZE, pInst, pObj, PX_PROCESS_VIRTUAL_SIZE);
404: PutCounterDWKB (hMemDlg, MEMORY_PEAK_VSIZE, pInst, pObj, PX_PROCESS_PEAK_VS);
405: PutCounterDWKB (hMemDlg, MEMORY_PFCOUNT, pInst, pObj, PX_PROCESS_FAULT_COUNT);
406:
407: }
408:
409:
410:
411:
412: //*********************************************************************
413: //
414: // PaintPviewDlgMemoryData
415: //
416: // Paint the memory data for pview dialog.
417: //
418: void PaintPviewDlgMemoryData (HWND hPviewDlg,
419: PPERF_INSTANCE pInst,
420: PPERF_OBJECT pObj)
421: {
422: PPERF_COUNTER pCounter;
423: TCHAR str[20];
424: DWORD *pdwData;
425: DWORD dwData = 0;
426: BOOL bCounter = FALSE;
427:
428:
429: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_NOACCESS))
430: {
431: pdwData = (DWORD *) CounterData (pInst, pCounter);
432: dwData += *pdwData;
433: bCounter = TRUE;
434: }
435:
436: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READONLY))
437: {
438: pdwData = (DWORD *) CounterData (pInst, pCounter);
439: dwData += *pdwData;
440: bCounter = TRUE;
441: }
442:
443: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READWRITE))
444: {
445: pdwData = (DWORD *) CounterData (pInst, pCounter);
446: dwData += *pdwData;
447: bCounter = TRUE;
448: }
449:
450: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_WRITECOPY))
451: {
452: pdwData = (DWORD *) CounterData (pInst, pCounter);
453: dwData += *pdwData;
454: bCounter = TRUE;
455: }
456:
457: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXECUTABLE))
458: {
459: pdwData = (DWORD *) CounterData (pInst, pCounter);
460: dwData += *pdwData;
461: bCounter = TRUE;
462: }
463:
464: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READONLY))
465: {
466: pdwData = (DWORD *) CounterData (pInst, pCounter);
467: dwData += *pdwData;
468: bCounter = TRUE;
469: }
470:
471: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READWRITE))
472: {
473: pdwData = (DWORD *) CounterData (pInst, pCounter);
474: dwData += *pdwData;
475: bCounter = TRUE;
476: }
477:
478: if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_WRITECOPY))
479: {
480: pdwData = (DWORD *) CounterData (pInst, pCounter);
481: dwData += *pdwData;
482: bCounter = TRUE;
483: }
484:
485: if (bCounter)
486: {
487: wsprintf (str, TEXT("%ld KB"), dwData/1024);
488: SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, str);
489: }
490: else
491: SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, NODATA);
492:
493: }
494:
495:
496:
497:
498: //*********************************************************************
499: //
500: // RefreshMemoryDlg
501: //
502: // Refresh the memory detail dialog.
503: //
504: BOOL RefreshMemoryDlg (HWND hMemDlg,
505: PPERF_INSTANCE pProcessInstance,
506: PPERF_OBJECT pProcessObject,
507: PPERF_OBJECT pAddressObject,
508: PPERF_OBJECT pImageObject)
509: {
510: DWORD *pProcessID1;
511: DWORD *pProcessID2;
512: PPERF_COUNTER pCounter1;
513: PPERF_COUNTER pCounter2;
514: PPERF_INSTANCE pAddressInstance;
515: HWND hImageList;
516: TCHAR szTemp[40];
517: BOOL bStat = FALSE;
518: INT InstIndex = 0;
519:
520:
521: if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) &&
522: (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID)))
523: {
524: pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1);
525:
526: wsprintf (szTemp, TEXT("%s (%#x)"), InstanceName (pProcessInstance), *pProcessID1);
527: SetDlgItemText (hMemDlg, MEMORY_PROCESS_ID, szTemp);
528:
529: pAddressInstance = FirstInstance (pAddressObject);
530:
531: while (InstIndex < pAddressObject->NumInstances)
532: {
533: pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2);
534:
535: if (*pProcessID1 == *pProcessID2)
536: {
537: PaintMemDlgAddrData (hMemDlg, pAddressInstance, pAddressObject);
538: PaintMemDlgVMData (hMemDlg, pProcessInstance, pProcessObject);
539:
540: hImageList = GetDlgItem (hMemDlg, MEMORY_IMAGE);
541: RefreshMemoryDlgImageList (hImageList, InstIndex, pImageObject);
542:
543: bStat = TRUE;
544: break;
545: }
546:
547: pAddressInstance = NextInstance (pAddressInstance);
548: InstIndex++;
549: }
550: }
551:
552: return bStat;
553:
554: }
555:
556:
557:
558:
559: //*********************************************************************
560: //
561: // RefreshMemoryDlgImageList
562: //
563: // Refresh the image list for memory dialog.
564: //
565: void RefreshMemoryDlgImageList (HWND hImageList,
566: DWORD ParentIndex,
567: PPERF_OBJECT pImageObj)
568: {
569: PPERF_INSTANCE pImageInst;
570: INT ListIndex;
571: INT InstIndex = 0;
572:
573:
574: ListIndex = SendMessage (hImageList, CB_ADDSTRING, 0, (DWORD)TEXT(" Total Commit"));
575: SendMessage (hImageList, CB_SETITEMDATA, ListIndex, 0xFFFFFFFF);
576:
577: if (pImageObj)
578: {
579: if (pImageInst = FirstInstance (pImageObj))
580: while (InstIndex < pImageObj->NumInstances)
581: {
582: if (ParentIndex == pImageInst->ParentObjectInstance)
583: {
584: ListIndex = SendMessage (hImageList,
585: CB_ADDSTRING,
586: 0,
587: (DWORD)InstanceName(pImageInst));
588: SendMessage (hImageList, CB_SETITEMDATA, ListIndex, InstIndex);
589: }
590:
591: pImageInst = NextInstance (pImageInst);
592: InstIndex++;
593: }
594: }
595: }
596:
597:
598:
599:
600: //*********************************************************************
601: //
602: // RefreshMemoryDlgImage
603: //
604: //
605: void RefreshMemoryDlgImage (HWND hMemDlg,
606: DWORD dwIndex,
607: PPERF_OBJECT pImageObject)
608: {
609: PPERF_INSTANCE pInst;
610:
611: pInst = FindInstanceN (pImageObject, dwIndex);
612:
613: PaintAddressSpace (hMemDlg, pInst, pImageObject,
614: MEMORY_TOTALIMAGE_COMMIT,
615: MEMORY_IMAGE_NOACCESS, PX_IMAGE_NOACCESS,
616: MEMORY_IMAGE_READONLY, PX_IMAGE_READONLY,
617: MEMORY_IMAGE_READWRITE, PX_IMAGE_READWRITE,
618: MEMORY_IMAGE_WRITECOPY, PX_IMAGE_WRITECOPY,
619: MEMORY_IMAGE_EXECUTE, PX_IMAGE_EXECUTABLE,
620: PX_IMAGE_EXE_READONLY,
621: PX_IMAGE_EXE_READWRITE,
622: PX_IMAGE_EXE_WRITECOPY);
623: }
624:
625:
626: //*********************************************************************
627: //
628: // RefreshPviewDlgMemoryData
629: //
630: // Update the memory data for pview dialog. This should be done
631: // after the ghCostlyData is collected and is not refreshing.
632: //
633: void RefreshPviewDlgMemoryData (HWND hPviewDlg,
634: PPERF_INSTANCE pProcessInstance,
635: PPERF_OBJECT pProcessObject,
636: PPERF_OBJECT pAddressObject)
637: {
638: DWORD *pProcessID1;
639: DWORD *pProcessID2;
640: PPERF_COUNTER pCounter1;
641: PPERF_COUNTER pCounter2;
642: PPERF_INSTANCE pAddressInstance;
643: INT i = 0;
644:
645:
646: if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) &&
647: (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID)))
648: {
649: pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1);
650:
651: pAddressInstance = FirstInstance (pAddressObject);
652:
653: while (i < pAddressObject->NumInstances)
654: {
655: pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2);
656:
657: if (*pProcessID1 == *pProcessID2)
658: {
659: PaintPviewDlgMemoryData (hPviewDlg, pAddressInstance, pAddressObject);
660: break;
661: }
662:
663: pAddressInstance = NextInstance (pAddressInstance);
664: i++;
665: }
666: }
667: }
668:
669:
670:
671:
672: //*********************************************************************
673: //
674: // RefreshPviewDlgThreadPC
675: //
676: // Update the thread PC value. This should be done after the ghCostlyData
677: // is collected and is no refreshing.
678: //
679: void RefreshPviewDlgThreadPC (HWND hPviewDlg,
680: LPTSTR szProcessName,
681: LPTSTR szThreadName,
682: PPERF_OBJECT pThreadDetailsObject,
683: PPERF_DATA pCostlyData)
684: {
685: PPERF_COUNTER pCounter;
686: PPERF_INSTANCE pInstance;
687: PPERF_INSTANCE pParent;
688: LPTSTR szInstanceName;
689: LPTSTR szParentName;
690: TCHAR str[20];
691: DWORD *pdwData;
692: INT i = 0;
693:
694:
695: if (pCounter = FindCounter (pThreadDetailsObject, PX_THREAD_PC))
696: {
697: pInstance = FirstInstance (pThreadDetailsObject);
698:
699: while (i < pThreadDetailsObject->NumInstances)
700: {
701: if (!(szInstanceName = InstanceName (pInstance)))
702: // can't find name
703: ;
704: else if (lstrcmp (szThreadName, szInstanceName))
705: // the thread name is different
706: ;
707: else if (!(pParent = FindInstanceParent (pInstance, pCostlyData)))
708: // can't find parent
709: ;
710: else if (!(szParentName = InstanceName (pParent)))
711: // can't find parent's name
712: ;
713: else if (!lstrcmp (szProcessName, szParentName))
714: {
715: // Parent's name matches, this is the right one.
716: //
717:
718: pdwData = CounterData (pInstance, pCounter);
719: wsprintf (str, TEXT("0x%08x"), *pdwData);
720: SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, str);
721:
722: return;
723: }
724:
725: pInstance = NextInstance (pInstance);
726: i++;
727: }
728: }
729:
730:
731: // We are here only because we can't find the data to display.
732: //
733:
734: SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, NODATA);
735:
736: }
737:
738:
739:
740:
741: //*********************************************************************
742: //
743: // ProcessPriority
744: //
745: // Returns the process priority dialog item id.
746: //
747: WORD ProcessPriority (PPERF_OBJECT pObject,
748: PPERF_INSTANCE pInstance)
749: {
750: PPERF_COUNTER pCounter;
751: DWORD *pdwData;
752:
753:
754: if (pCounter = FindCounter (pObject, PX_PROCESS_PRIO))
755: {
756: pdwData = (DWORD *) CounterData (pInstance, pCounter);
757:
758: if (*pdwData < 7)
759: return PVIEW_PRIORITY_IDL;
760: else if (*pdwData < 10)
761: return PVIEW_PRIORITY_NORMAL;
762: else
763: return PVIEW_PRIORITY_HIGH;
764: }
765: else
766: return PVIEW_PRIORITY_NORMAL;
767:
768: }
769:
770:
771:
772:
773: //*********************************************************************
774: //
775: // RefreshPerfData
776: //
777: // Get a new set of performance data. pData should be NULL initially.
778: //
779: PPERF_DATA RefreshPerfData (HKEY hPerfKey,
780: LPTSTR szObjectIndex,
781: PPERF_DATA pData,
782: DWORD *pDataSize)
783: {
784: if (GetPerfData (hPerfKey, szObjectIndex, &pData, pDataSize) == ERROR_SUCCESS)
785: return pData;
786: else
787: return NULL;
788: }
789:
790:
791:
792:
793: //*********************************************************************
794: //
795: // SetProcessListText
796: //
797: // Format the process list text.
798: //
799: void SetProcessListText (PPERF_INSTANCE pInst,
800: PPERF_COUNTER pCPU,
801: PPERF_COUNTER pPRIV,
802: PPERF_COUNTER pProcID,
803: double fTime,
804: LPTSTR str)
805: {
806: DWORD *pdwProcID;
807: LARGE_INTEGER *liCPU;
808: LARGE_INTEGER *liPRIV;
809: double fCPU = 0;
810: double fPRIV = 0;
811: INT PcntPRIV = 0;
812: INT PcntUSER = 0;
813: TIME_FIELD TimeFld;
814: TCHAR szTemp[100];
815:
816:
817: if (pCPU)
818: {
819: liCPU = (LARGE_INTEGER *) CounterData (pInst, pCPU);
820: fCPU = Li2Double (*liCPU);
821: }
822:
823: if (pPRIV)
824: {
825: liPRIV = (LARGE_INTEGER *) CounterData (pInst, pPRIV);
826: fPRIV = Li2Double (*liPRIV);
827: }
828:
829: if (fCPU > 0)
830: {
831: PcntPRIV = (INT)(fPRIV / fCPU * 100 + 0.5);
832: PcntUSER = 100 - PcntPRIV;
833: }
834:
835:
836:
837: if (pProcID)
838: {
839: pdwProcID = (DWORD *) CounterData (pInst, pProcID);
840: wsprintf (szTemp, TEXT("%ls (%#x)"), InstanceName(pInst), *pdwProcID);
841: }
842: else
843: wsprintf (szTemp, TEXT("%ls"), InstanceName(pInst));
844:
845:
846:
847: FormatTimeFields (fCPU/1.0e7, &TimeFld);
848:
849: wsprintf (str,
850: TEXT("%s\t%3ld:%02ld:%02ld.%03ld\t%3ld%%\t%3ld%%"),
851: szTemp,
852: TimeFld.Hours,
853: TimeFld.Mins,
854: TimeFld.Secs,
855: TimeFld.mSecs,
856: PcntPRIV,
857: PcntUSER);
858: }
859:
860:
861:
862:
863: //*********************************************************************
864: //
865: // RefreshProcessList
866: //
867: // Find all process and update the process list.
868: //
869: void RefreshProcessList (HWND hProcessList,
870: PPERF_OBJECT pObject)
871: {
872: PPERF_INSTANCE pInstance;
873: TCHAR szListText[256];
874: INT ListIndex;
875:
876: PPERF_COUNTER pCounterCPU;
877: PPERF_COUNTER pCounterPRIV;
878: PPERF_COUNTER pCounterProcID;
879: double fObjectFreq;
880: double fObjectTime;
881: double fTime;
882:
883: INT InstanceIndex = 0;
884: INT err;
885:
886:
887: if (pObject)
888: {
889: pCounterCPU = FindCounter (pObject, PX_PROCESS_CPU);
890: pCounterPRIV = FindCounter (pObject, PX_PROCESS_PRIV);
891: pCounterProcID = FindCounter (pObject, PX_PROCESS_ID);
892:
893: fObjectFreq = Li2Double (pObject->PerfFreq);
894: fObjectTime = Li2Double (pObject->PerfTime);
895: fTime = fObjectTime / fObjectFreq;
896:
897: pInstance = FirstInstance (pObject);
898:
899: while (InstanceIndex < pObject->NumInstances)
900: {
901: SetProcessListText (pInstance,
902: pCounterCPU,
903: pCounterPRIV,
904: pCounterProcID,
905: fTime,
906: szListText);
907:
908: ListIndex = SendMessage (hProcessList, LB_ADDSTRING, 0, (DWORD)szListText);
909: err = SendMessage (hProcessList, LB_SETITEMDATA, ListIndex, InstanceIndex);
910:
911: pInstance = NextInstance (pInstance);
912: InstanceIndex++;
913: }
914: }
915: }
916:
917:
918: //*********************************************************************
919: //
920: // RefreshProcessData
921: //
922: // Find data for a given process and update.
923: //
924: void RefreshProcessData (HWND hWnd,
925: PPERF_OBJECT pObject,
926: DWORD ProcessIndex)
927: {
928: PPERF_INSTANCE pInstance;
929:
930:
931: pInstance = FindInstanceN (pObject, ProcessIndex);
932:
933: PutCounterDWKB (hWnd, PVIEW_WS, pInstance, pObject, PX_PROCESS_WORKING_SET);
934:
935:
936: SetDlgItemText (hWnd, PVIEW_TOTALPRIVATE_COMMIT, NODATA);
937:
938: // set priority
939: //
940: CheckRadioButton (hWnd,
941: PVIEW_PRIORITY_HIGH,
942: PVIEW_PRIORITY_IDL,
943: ProcessPriority (pObject, pInstance));
944: }
945:
946:
947:
948:
949: //*********************************************************************
950: //
951: // SetThreadListText
952: //
953: // Format the thread list text.
954: //
955: void SetThreadListText (PPERF_INSTANCE pInst,
956: PPERF_COUNTER pCPU,
957: PPERF_COUNTER pPRIV,
958: double fTime,
959: LPTSTR str)
960: {
961: LARGE_INTEGER *liCPU;
962: LARGE_INTEGER *liPRIV;
963: double fCPU = 0;
964: double fPRIV = 0;
965: INT PcntPRIV = 0;
966: INT PcntUSER = 0;
967: TIME_FIELD TimeFld;
968: TCHAR szTemp[100];
969:
970:
971: if (pCPU)
972: {
973: liCPU = (LARGE_INTEGER *) CounterData (pInst, pCPU);
974: fCPU = Li2Double (*liCPU);
975: }
976:
977: if (pPRIV)
978: {
979: liPRIV = (LARGE_INTEGER *) CounterData (pInst, pPRIV);
980: fPRIV = Li2Double (*liPRIV);
981: }
982:
983: if (fCPU > 0)
984: {
985: PcntPRIV = (INT)(fPRIV / fCPU * 100 + 0.5);
986: PcntUSER = 100 - PcntPRIV;
987: }
988:
989:
990:
991: if (pInst->UniqueID != PERF_NO_UNIQUE_ID)
992: wsprintf (szTemp, TEXT("%ls (%#x)"), InstanceName(pInst), pInst->UniqueID);
993: else
994: wsprintf (szTemp, TEXT("%ls"), InstanceName(pInst));
995:
996:
997:
998:
999: FormatTimeFields (fCPU/1.0e7, &TimeFld);
1000:
1001: wsprintf (str,
1002: TEXT("%s\t%3ld:%02ld:%02ld.%03ld\t%3ld%%\t%3ld %%"),
1003: szTemp,
1004: TimeFld.Hours,
1005: TimeFld.Mins,
1006: TimeFld.Secs,
1007: TimeFld.mSecs,
1008: PcntPRIV,
1009: PcntUSER);
1010:
1011: }
1012:
1013:
1014:
1015:
1016: //*********************************************************************
1017: //
1018: // RefreshThreadList
1019: //
1020: // Find all threads for a given process and update the thread list.
1021: //
1022: void RefreshThreadList (HWND hThreadList,
1023: PPERF_OBJECT pObject,
1024: DWORD ParentIndex)
1025: {
1026: PPERF_INSTANCE pInstance;
1027: TCHAR szListText[256];
1028: INT ListIndex;
1029:
1030: PPERF_COUNTER pCounterCPU;
1031: PPERF_COUNTER pCounterPRIV;
1032: double fObjectFreq;
1033: double fObjectTime;
1034: double fTime;
1035:
1036: INT InstanceIndex = 0;
1037: INT err;
1038:
1039:
1040: if (pObject)
1041: {
1042: pCounterCPU = FindCounter (pObject, PX_THREAD_CPU);
1043: pCounterPRIV = FindCounter (pObject, PX_THREAD_PRIV);
1044:
1045: fObjectFreq = Li2Double (pObject->PerfFreq);
1046: fObjectTime = Li2Double (pObject->PerfTime);
1047: fTime = fObjectTime / fObjectFreq;
1048:
1049:
1050: pInstance = FirstInstance (pObject);
1051:
1052: while (InstanceIndex < pObject->NumInstances)
1053: {
1054: if (ParentIndex == pInstance->ParentObjectInstance)
1055: {
1056: SetThreadListText (pInstance,
1057: pCounterCPU,
1058: pCounterPRIV,
1059: fTime,
1060: szListText);
1061:
1062: ListIndex = SendMessage (hThreadList, LB_ADDSTRING, 0, (DWORD)szListText);
1063: err = SendMessage (hThreadList, LB_SETITEMDATA, ListIndex, InstanceIndex);
1064: }
1065:
1066: pInstance = NextInstance (pInstance);
1067: InstanceIndex++;
1068: }
1069: }
1070:
1071: }
1072:
1073:
1074:
1075:
1076: //*********************************************************************
1077: //
1078: // RefreshThreadData
1079: //
1080: // Find data for a given thread and update.
1081: //
1082: void RefreshThreadData (HWND hWnd,
1083: PPERF_OBJECT pThreadObj,
1084: DWORD ThreadIndex,
1085: PPERF_OBJECT pProcessObj,
1086: PPERF_INSTANCE pProcessInst)
1087: {
1088: PPERF_INSTANCE pInstance;
1089: PPERF_COUNTER pCounter;
1090: DWORD *pdwData;
1091: DWORD *pdwProcPrio;
1092: BOOL bPrioCounter;
1093:
1094:
1095: pInstance = FindInstanceN (pThreadObj, ThreadIndex);
1096:
1097:
1098: SetDlgItemText (hWnd, PVIEW_THREAD_PC, NODATA);
1099: PutCounterHEX (hWnd, PVIEW_THREAD_START, pInstance, pThreadObj, PX_THREAD_START);
1100: PutCounterDW (hWnd, PVIEW_THREAD_SWITCHES, pInstance, pThreadObj, PX_THREAD_SWITCHES);
1101: PutCounterDW (hWnd, PVIEW_THREAD_DYNAMIC, pInstance, pThreadObj, PX_THREAD_PRIO);
1102:
1103:
1104:
1105: // set thread base priority
1106: //
1107: bPrioCounter = TRUE;
1108:
1109: if (pCounter = FindCounter (pProcessObj, PX_THREAD_BASE_PRIO))
1110: pdwData = CounterData (pProcessInst, pCounter);
1111: else
1112: bPrioCounter = FALSE;
1113:
1114:
1115: if (pCounter = FindCounter (pProcessObj, PX_PROCESS_PRIO))
1116: pdwProcPrio = CounterData (pProcessInst, pCounter);
1117: else
1118: bPrioCounter = FALSE;
1119:
1120: if (!bPrioCounter)
1121: CheckRadioButton (hWnd,
1122: PVIEW_THREAD_HIGHEST,
1123: PVIEW_THREAD_LOWEST,
1124: PVIEW_THREAD_NORMAL);
1125: else
1126: {
1127: switch (*pdwData - *pdwProcPrio)
1128: {
1129: case 2:
1130: CheckRadioButton (hWnd,
1131: PVIEW_THREAD_HIGHEST,
1132: PVIEW_THREAD_LOWEST,
1133: PVIEW_THREAD_HIGHEST);
1134: break;
1135:
1136: case 1:
1137: CheckRadioButton (hWnd,
1138: PVIEW_THREAD_HIGHEST,
1139: PVIEW_THREAD_LOWEST,
1140: PVIEW_THREAD_ABOVE);
1141: break;
1142:
1.1.1.2 ! root 1143: case (DWORD) -1:
1.1 root 1144: CheckRadioButton (hWnd,
1145: PVIEW_THREAD_HIGHEST,
1146: PVIEW_THREAD_LOWEST,
1147: PVIEW_THREAD_BELOW);
1148: break;
1149:
1.1.1.2 ! root 1150: case (DWORD) -2:
1.1 root 1151: CheckRadioButton (hWnd,
1152: PVIEW_THREAD_HIGHEST,
1153: PVIEW_THREAD_LOWEST,
1154: PVIEW_THREAD_LOWEST);
1155: break;
1156:
1157: case 0:
1158: default:
1159: CheckRadioButton (hWnd,
1160: PVIEW_THREAD_HIGHEST,
1161: PVIEW_THREAD_LOWEST,
1162: PVIEW_THREAD_NORMAL);
1163: break;
1164: }
1165: }
1166: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.