![[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: ! 1143: case -1: ! 1144: CheckRadioButton (hWnd, ! 1145: PVIEW_THREAD_HIGHEST, ! 1146: PVIEW_THREAD_LOWEST, ! 1147: PVIEW_THREAD_BELOW); ! 1148: break; ! 1149: ! 1150: case -2: ! 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.