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