/****************************************************************************** P V I E W D A T A Name: pviewdat.c Description: This module collects the data to be displayed in pview. ******************************************************************************/ #include #include #include "perfdata.h" #include "pviewdat.h" #include "pviewdlg.h" #include #include #include #include #define NODATA TEXT("--------") void FormatTimeFields (double fTime, PTIME_FIELD pTimeFld); DWORD PutCounterDWKB (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx); DWORD PutCounterHEX (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx); DWORD PutCounterDW (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx); void PaintAddressSpace (HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD TotalID, DWORD NoAccessID, DWORD NoAccessIndex, DWORD ReadOnlyID, DWORD ReadOnlyIndex, DWORD ReadWriteID, DWORD ReadWriteIndex, DWORD WriteCopyID, DWORD WriteCopyIndex, DWORD ExecuteID, DWORD ExecuteIndex1, DWORD ExecuteIndex2, DWORD ExecuteIndex3, DWORD ExecuteIndex4); void PaintMemDlgAddrData (HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj); void PaintMemDlgVMData (HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj); void PaintPviewDlgMemoryData (HWND hPviewDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj); void RefreshMemoryDlgImageList (HWND hImageList, DWORD ParentIndex, PPERF_OBJECT pImageObj); WORD ProcessPriority (PPERF_OBJECT pObject, PPERF_INSTANCE pInstance); void SetProcessListText (PPERF_INSTANCE pInst, PPERF_COUNTER pCPU, PPERF_COUNTER pPRIV, PPERF_COUNTER pProcID, double fTime, LPTSTR str); void SetThreadListText (PPERF_INSTANCE pInst, PPERF_COUNTER pCPU, PPERF_COUNTER pPRIV, double fTime, LPTSTR str); //********************************************************************* // // FormatTimeFields // // Formats a double value to time fields. // void FormatTimeFields (double fTime, PTIME_FIELD pTimeFld) { INT i; double f; f = fTime/3600; pTimeFld->Hours = i = (int)f; f = f - i; pTimeFld->Mins = i = (int)(f = f * 60); f = f - i; pTimeFld->Secs = i = (int)(f = f * 60); f = f - i; pTimeFld->mSecs = (int)(f * 1000); } //********************************************************************* // // PutCounterDWKB // // Display a DWORD counter's data in KB units. // DWORD PutCounterDWKB (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx) { PPERF_COUNTER pCounter; DWORD *pdwData; TCHAR szTemp[20]; if (pCounter = FindCounter (pObj, dwCounterIdx)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { wsprintf (szTemp, TEXT("%ld KB"), *pdwData/1024); SetDlgItemText (hWnd, dwItemID, szTemp); return *pdwData; } else { return 0; } } else { SetDlgItemText (hWnd, dwItemID, NODATA); return 0; } } //********************************************************************* // // PutCounterHEX // // Display a DWORD counter's data in hex. // DWORD PutCounterHEX (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx) { PPERF_COUNTER pCounter; DWORD *pdwData; TCHAR szTemp[20]; if (pCounter = FindCounter (pObj, dwCounterIdx)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { wsprintf (szTemp, TEXT("0x%08x"), *pdwData); SetDlgItemText (hWnd, dwItemID, szTemp); return *pdwData; } else { return 0; } } else { SetDlgItemText (hWnd, dwItemID, NODATA); return 0; } } //********************************************************************* // // PutCounterDWKB // // Display a DWORD counter's data. // DWORD PutCounterDW (HWND hWnd, DWORD dwItemID, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD dwCounterIdx) { PPERF_COUNTER pCounter; DWORD *pdwData; if (pCounter = FindCounter (pObj, dwCounterIdx)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { SetDlgItemInt (hWnd, dwItemID, *pdwData, FALSE); return *pdwData; } else { return 0; } } else { SetDlgItemText (hWnd, dwItemID, NODATA); return 0; } } //********************************************************************* // // PaintAddressSpace // // void PaintAddressSpace (HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj, DWORD TotalID, DWORD NoAccessID, DWORD NoAccessIndex, DWORD ReadOnlyID, DWORD ReadOnlyIndex, DWORD ReadWriteID, DWORD ReadWriteIndex, DWORD WriteCopyID, DWORD WriteCopyIndex, DWORD ExecuteID, DWORD ExecuteIndex1, DWORD ExecuteIndex2, DWORD ExecuteIndex3, DWORD ExecuteIndex4) { PPERF_COUNTER pCounter; DWORD *pdwData; TCHAR szTemp[20]; DWORD dwTotal = 0; DWORD dwExecute = 0; BOOL bCounter = FALSE; dwTotal += PutCounterDWKB (hMemDlg, NoAccessID, pInst, pObj, NoAccessIndex); dwTotal += PutCounterDWKB (hMemDlg, ReadOnlyID, pInst, pObj, ReadOnlyIndex); dwTotal += PutCounterDWKB (hMemDlg, ReadWriteID, pInst, pObj, ReadWriteIndex); dwTotal += PutCounterDWKB (hMemDlg, WriteCopyID, pInst, pObj, WriteCopyIndex); // execute is the sum of the following // if (pCounter = FindCounter (pObj, ExecuteIndex1)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwTotal += *pdwData; dwExecute += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, ExecuteIndex2)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwTotal += *pdwData; dwExecute += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, ExecuteIndex3)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwTotal += *pdwData; dwExecute += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, ExecuteIndex4)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwTotal += *pdwData; dwExecute += *pdwData; bCounter = TRUE; } } if (bCounter) { wsprintf (szTemp, TEXT("%ld KB"), dwExecute/1024); SetDlgItemText (hMemDlg, ExecuteID, szTemp); } else SetDlgItemText (hMemDlg, ExecuteID, NODATA); wsprintf (szTemp, TEXT("%ld KB"), dwTotal/1024); SetDlgItemText (hMemDlg, TotalID, szTemp); } //********************************************************************* // // PaintMemDlgAddrData // // Paint the memory dialog address space data. // void PaintMemDlgAddrData(HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj) { PaintAddressSpace (hMemDlg, pInst, pObj, MEMORY_TOTALPRIVATE_COMMIT, MEMORY_PRIVATE_NOACCESS, PX_PROCESS_PRIVATE_NOACCESS, MEMORY_PRIVATE_READONLY, PX_PROCESS_PRIVATE_READONLY, MEMORY_PRIVATE_READWRITE, PX_PROCESS_PRIVATE_READWRITE, MEMORY_PRIVATE_WRITECOPY, PX_PROCESS_PRIVATE_WRITECOPY, MEMORY_PRIVATE_EXECUTE, PX_PROCESS_PRIVATE_EXECUTABLE, PX_PROCESS_PRIVATE_EXE_READONLY, PX_PROCESS_PRIVATE_EXE_READWRITE, PX_PROCESS_PRIVATE_EXE_WRITECOPY); PaintAddressSpace (hMemDlg, pInst, pObj, MEMORY_TOTALMAPPED_COMMIT, MEMORY_MAPPED_NOACCESS, PX_PROCESS_MAPPED_NOACCESS, MEMORY_MAPPED_READONLY, PX_PROCESS_MAPPED_READONLY, MEMORY_MAPPED_READWRITE, PX_PROCESS_MAPPED_READWRITE, MEMORY_MAPPED_WRITECOPY, PX_PROCESS_MAPPED_WRITECOPY, MEMORY_MAPPED_EXECUTE, PX_PROCESS_MAPPED_EXECUTABLE, PX_PROCESS_MAPPED_EXE_READONLY, PX_PROCESS_MAPPED_EXE_READWRITE, PX_PROCESS_MAPPED_EXE_WRITECOPY); PaintAddressSpace (hMemDlg, pInst, pObj, MEMORY_TOTALIMAGE_COMMIT, MEMORY_IMAGE_NOACCESS, PX_PROCESS_IMAGE_NOACCESS, MEMORY_IMAGE_READONLY, PX_PROCESS_IMAGE_READONLY, MEMORY_IMAGE_READWRITE, PX_PROCESS_IMAGE_READWRITE, MEMORY_IMAGE_WRITECOPY, PX_PROCESS_IMAGE_WRITECOPY, MEMORY_IMAGE_EXECUTE, PX_PROCESS_IMAGE_EXECUTABLE, PX_PROCESS_IMAGE_EXE_READONLY, PX_PROCESS_IMAGE_EXE_READWRITE, PX_PROCESS_IMAGE_EXE_WRITECOPY); } //********************************************************************* // // PaintMemDlgVMData // // Paint the memory dialog Virtual Memory data. // void PaintMemDlgVMData (HWND hMemDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj) { PutCounterDWKB (hMemDlg, MEMORY_WS, pInst, pObj, PX_PROCESS_WORKING_SET); PutCounterDWKB (hMemDlg, MEMORY_PEAK_WS, pInst, pObj, PX_PROCESS_PEAK_WS); PutCounterDWKB (hMemDlg, MEMORY_PRIVATE_PAGE, pInst, pObj, PX_PROCESS_PRIVATE_PAGE); PutCounterDWKB (hMemDlg, MEMORY_VSIZE, pInst, pObj, PX_PROCESS_VIRTUAL_SIZE); PutCounterDWKB (hMemDlg, MEMORY_PEAK_VSIZE, pInst, pObj, PX_PROCESS_PEAK_VS); PutCounterDWKB (hMemDlg, MEMORY_PFCOUNT, pInst, pObj, PX_PROCESS_FAULT_COUNT); } //********************************************************************* // // PaintPviewDlgMemoryData // // Paint the memory data for pview dialog. // void PaintPviewDlgMemoryData (HWND hPviewDlg, PPERF_INSTANCE pInst, PPERF_OBJECT pObj) { PPERF_COUNTER pCounter; TCHAR str[20]; DWORD *pdwData; DWORD dwData = 0; BOOL bCounter = FALSE; if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_NOACCESS)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READONLY)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READWRITE)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_WRITECOPY)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXECUTABLE)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READONLY)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READWRITE)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_WRITECOPY)) { pdwData = (DWORD *) CounterData (pInst, pCounter); if (pdwData) { dwData += *pdwData; bCounter = TRUE; } } if (bCounter) { wsprintf (str, TEXT("%ld KB"), dwData/1024); SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, str); } else SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, NODATA); } //********************************************************************* // // RefreshMemoryDlg // // Refresh the memory detail dialog. // BOOL RefreshMemoryDlg (HWND hMemDlg, PPERF_INSTANCE pProcessInstance, PPERF_OBJECT pProcessObject, PPERF_OBJECT pAddressObject, PPERF_OBJECT pImageObject) { DWORD *pProcessID1; DWORD *pProcessID2; PPERF_COUNTER pCounter1; PPERF_COUNTER pCounter2; PPERF_INSTANCE pAddressInstance; HWND hImageList; TCHAR szTemp[40]; BOOL bStat = FALSE; INT InstIndex = 0; if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) && (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID))) { pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1); if (pProcessID1) { wsprintf (szTemp, TEXT("%s (%#x)"), InstanceName (pProcessInstance), *pProcessID1); SetDlgItemText (hMemDlg, MEMORY_PROCESS_ID, szTemp); pAddressInstance = FirstInstance (pAddressObject); while (pAddressInstance && InstIndex < pAddressObject->NumInstances) { pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2); if (pProcessID2) { if (*pProcessID1 == *pProcessID2) { PaintMemDlgAddrData (hMemDlg, pAddressInstance, pAddressObject); PaintMemDlgVMData (hMemDlg, pProcessInstance, pProcessObject); hImageList = GetDlgItem (hMemDlg, MEMORY_IMAGE); RefreshMemoryDlgImageList (hImageList, InstIndex, pImageObject); bStat = TRUE; break; } } pAddressInstance = NextInstance (pAddressInstance); InstIndex++; } } } return bStat; } //********************************************************************* // // RefreshMemoryDlgImageList // // Refresh the image list for memory dialog. // void RefreshMemoryDlgImageList (HWND hImageList, DWORD ParentIndex, PPERF_OBJECT pImageObj) { PPERF_INSTANCE pImageInst; INT_PTR ListIndex; INT_PTR InstIndex = 0; ListIndex = SendMessage (hImageList, CB_ADDSTRING, 0, (DWORD_PTR)TEXT(" Total Commit")); SendMessage (hImageList, CB_SETITEMDATA, ListIndex, 0xFFFFFFFF); if (pImageObj) { pImageInst = FirstInstance (pImageObj); while (pImageInst && InstIndex < pImageObj->NumInstances) { if (ParentIndex == pImageInst->ParentObjectInstance) { ListIndex = SendMessage (hImageList, CB_ADDSTRING, 0, (LPARAM)InstanceName(pImageInst)); SendMessage (hImageList, CB_SETITEMDATA, ListIndex, InstIndex); } pImageInst = NextInstance (pImageInst); InstIndex++; } } } //********************************************************************* // // RefreshMemoryDlgImage // // void RefreshMemoryDlgImage (HWND hMemDlg, DWORD dwIndex, PPERF_OBJECT pImageObject) { PPERF_INSTANCE pInst; if (pInst = FindInstanceN (pImageObject, dwIndex)) PaintAddressSpace (hMemDlg, pInst, pImageObject, MEMORY_TOTALIMAGE_COMMIT, MEMORY_IMAGE_NOACCESS, PX_IMAGE_NOACCESS, MEMORY_IMAGE_READONLY, PX_IMAGE_READONLY, MEMORY_IMAGE_READWRITE, PX_IMAGE_READWRITE, MEMORY_IMAGE_WRITECOPY, PX_IMAGE_WRITECOPY, MEMORY_IMAGE_EXECUTE, PX_IMAGE_EXECUTABLE, PX_IMAGE_EXE_READONLY, PX_IMAGE_EXE_READWRITE, PX_IMAGE_EXE_WRITECOPY); } //********************************************************************* // // RefreshPviewDlgMemoryData // // Update the memory data for pview dialog. This should be done // after the ghCostlyData is collected and is not refreshing. // void RefreshPviewDlgMemoryData (HWND hPviewDlg, PPERF_INSTANCE pProcessInstance, PPERF_OBJECT pProcessObject, PPERF_OBJECT pAddressObject) { DWORD *pProcessID1; DWORD *pProcessID2; PPERF_COUNTER pCounter1; PPERF_COUNTER pCounter2; PPERF_INSTANCE pAddressInstance; INT i = 0; if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) && (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID))) { pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1); if (pProcessID1) { pAddressInstance = FirstInstance (pAddressObject); while (pAddressInstance && i < pAddressObject->NumInstances) { pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2); if (pProcessID2){ if (*pProcessID1 == *pProcessID2) { PaintPviewDlgMemoryData (hPviewDlg, pAddressInstance, pAddressObject); break; } pAddressInstance = NextInstance (pAddressInstance); i++; } } } } } //********************************************************************* // // RefreshPviewDlgThreadPC // // Update the thread PC value. This should be done after the ghCostlyData // is collected and is no refreshing. // void RefreshPviewDlgThreadPC (HWND hPviewDlg, LPTSTR szProcessName, LPTSTR szThreadName, PPERF_OBJECT pThreadDetailsObject, PPERF_DATA pCostlyData) { PPERF_COUNTER pCounter; PPERF_INSTANCE pInstance; PPERF_INSTANCE pParent; LPTSTR szInstanceName; LPTSTR szParentName; TCHAR str[20]; DWORD *pdwData; INT i = 0; if (pCounter = FindCounter (pThreadDetailsObject, PX_THREAD_PC)) { pInstance = FirstInstance (pThreadDetailsObject); while (pInstance && i < pThreadDetailsObject->NumInstances) { if (!(szInstanceName = InstanceName (pInstance))) // can't find name ; else if (lstrcmp (szThreadName, szInstanceName)) // the thread name is different ; else if (!(pParent = FindInstanceParent (pInstance, pCostlyData))) // can't find parent ; else if (!(szParentName = InstanceName (pParent))) // can't find parent's name ; else if (!lstrcmp (szProcessName, szParentName)) { // Parent's name matches, this is the right one. // pdwData = CounterData (pInstance, pCounter); if (pdwData) { wsprintf (str, TEXT("0x%08x"), *pdwData); SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, str); } return; } pInstance = NextInstance (pInstance); i++; } } // We are here only because we can't find the data to display. // SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, NODATA); } //********************************************************************* // // ProcessPriority // // Returns the process priority dialog item id. // WORD ProcessPriority (PPERF_OBJECT pObject, PPERF_INSTANCE pInstance) { PPERF_COUNTER pCounter; DWORD *pdwData; if (pCounter = FindCounter (pObject, PX_PROCESS_PRIO)) { pdwData = (DWORD *) CounterData (pInstance, pCounter); if (pdwData) { if (*pdwData < 7) return PVIEW_PRIORITY_IDL; else if (*pdwData < 10) return PVIEW_PRIORITY_NORMAL; else return PVIEW_PRIORITY_HIGH; } else { return PVIEW_PRIORITY_NORMAL; } } else return PVIEW_PRIORITY_NORMAL; } //********************************************************************* // // RefreshPerfData // // Get a new set of performance data. pData should be NULL initially. // PPERF_DATA RefreshPerfData (HKEY hPerfKey, LPTSTR szObjectIndex, PPERF_DATA pData, DWORD *pDataSize) { if (GetPerfData (hPerfKey, szObjectIndex, &pData, pDataSize) == ERROR_SUCCESS) return pData; else return NULL; } //********************************************************************* // // SetProcessListText // // Format the process list text. // void SetProcessListText (PPERF_INSTANCE pInst, PPERF_COUNTER pCPU, PPERF_COUNTER pPRIV, PPERF_COUNTER pProcID, double fTime, LPTSTR str) { DWORD *pdwProcID; LARGE_INTEGER *liCPU; LARGE_INTEGER *liPRIV; double fCPU = 0; double fPRIV = 0; INT PcntPRIV = 0; INT PcntUSER = 0; TIME_FIELD TimeFld; TCHAR szTemp[100]; if (pCPU) { liCPU = (LARGE_INTEGER *) CounterData (pInst, pCPU); if (liCPU) { fCPU = Li2Double (*liCPU); } } if (pPRIV) { liPRIV = (LARGE_INTEGER *) CounterData (pInst, pPRIV); if (liPRIV) fPRIV = Li2Double (*liPRIV); } if (fCPU > 0) { PcntPRIV = (INT)(fPRIV / fCPU * 100 + 0.5); PcntUSER = 100 - PcntPRIV; } if (pProcID) { pdwProcID = (DWORD *) CounterData (pInst, pProcID); if (pdwProcID) wsprintf (szTemp, TEXT("%ls (%#x)"), InstanceName(pInst), *pdwProcID); else wsprintf (szTemp, TEXT("%ls"), InstanceName(pInst)); } else wsprintf (szTemp, TEXT("%ls"), InstanceName(pInst)); FormatTimeFields (fCPU/1.0e7, &TimeFld); wsprintf (str, TEXT("%s\t%3ld:%02ld:%02ld.%03ld\t%3ld%%\t%3ld%%"), szTemp, TimeFld.Hours, TimeFld.Mins, TimeFld.Secs, TimeFld.mSecs, PcntPRIV, PcntUSER); } //********************************************************************* // // RefreshProcessList // // Find all process and update the process list. // void RefreshProcessList (HWND hProcessList, PPERF_OBJECT pObject) { PPERF_INSTANCE pInstance; TCHAR szListText[256]; INT_PTR ListIndex; PPERF_COUNTER pCounterCPU; PPERF_COUNTER pCounterPRIV; PPERF_COUNTER pCounterProcID; double fObjectFreq; double fObjectTime; double fTime; INT InstanceIndex = 0; if (pObject) { if ((pCounterCPU = FindCounter (pObject, PX_PROCESS_CPU)) && (pCounterPRIV = FindCounter (pObject, PX_PROCESS_PRIV)) && (pCounterProcID = FindCounter (pObject, PX_PROCESS_ID))) { fObjectFreq = Li2Double (pObject->PerfFreq); fObjectTime = Li2Double (pObject->PerfTime); fTime = fObjectTime / fObjectFreq; pInstance = FirstInstance (pObject); while (pInstance && InstanceIndex < pObject->NumInstances) { SetProcessListText (pInstance, pCounterCPU, pCounterPRIV, pCounterProcID, fTime, szListText); ListIndex = SendMessage (hProcessList, LB_ADDSTRING, 0, (LPARAM)szListText); SendMessage (hProcessList, LB_SETITEMDATA, ListIndex, InstanceIndex); pInstance = NextInstance (pInstance); InstanceIndex++; } } } } //********************************************************************* // // RefreshProcessData // // Find data for a given process and update. // void RefreshProcessData (HWND hWnd, PPERF_OBJECT pObject, DWORD ProcessIndex) { PPERF_INSTANCE pInstance; if (pInstance = FindInstanceN (pObject, ProcessIndex)) { PutCounterDWKB (hWnd, PVIEW_WS, pInstance, pObject, PX_PROCESS_WORKING_SET); SetDlgItemText (hWnd, PVIEW_TOTALPRIVATE_COMMIT, NODATA); // set priority // CheckRadioButton (hWnd, PVIEW_PRIORITY_HIGH, PVIEW_PRIORITY_IDL, ProcessPriority (pObject, pInstance)); } } //********************************************************************* // // SetThreadListText // // Format the thread list text. // void SetThreadListText (PPERF_INSTANCE pInst, PPERF_COUNTER pCPU, PPERF_COUNTER pPRIV, double fTime, LPTSTR str) { LARGE_INTEGER *liCPU; LARGE_INTEGER *liPRIV; double fCPU = 0; double fPRIV = 0; INT PcntPRIV = 0; INT PcntUSER = 0; TIME_FIELD TimeFld; TCHAR szTemp[100]; if (pCPU) { liCPU = (LARGE_INTEGER *) CounterData (pInst, pCPU); if (liCPU) fCPU = Li2Double (*liCPU); } if (pPRIV) { liPRIV = (LARGE_INTEGER *) CounterData (pInst, pPRIV); if (liPRIV) fPRIV = Li2Double (*liPRIV); } if (fCPU > 0) { PcntPRIV = (INT)(fPRIV / fCPU * 100 + 0.5); PcntUSER = 100 - PcntPRIV; } if (pInst->UniqueID != PERF_NO_UNIQUE_ID) wsprintf (szTemp, TEXT("%ls (%#x)"), InstanceName(pInst), pInst->UniqueID); else wsprintf (szTemp, TEXT("%ls"), InstanceName(pInst)); FormatTimeFields (fCPU/1.0e7, &TimeFld); wsprintf (str, TEXT("%s\t%3ld:%02ld:%02ld.%03ld\t%3ld%%\t%3ld %%"), szTemp, TimeFld.Hours, TimeFld.Mins, TimeFld.Secs, TimeFld.mSecs, PcntPRIV, PcntUSER); } //********************************************************************* // // RefreshThreadList // // Find all threads for a given process and update the thread list. // void RefreshThreadList (HWND hThreadList, PPERF_OBJECT pObject, DWORD ParentIndex) { PPERF_INSTANCE pInstance; TCHAR szListText[256]; INT_PTR ListIndex; PPERF_COUNTER pCounterCPU; PPERF_COUNTER pCounterPRIV; double fObjectFreq; double fObjectTime; double fTime; INT InstanceIndex = 0; if (pObject) { if ((pCounterCPU = FindCounter (pObject, PX_THREAD_CPU)) && (pCounterPRIV = FindCounter (pObject, PX_THREAD_PRIV))) { fObjectFreq = Li2Double (pObject->PerfFreq); fObjectTime = Li2Double (pObject->PerfTime); fTime = fObjectTime / fObjectFreq; pInstance = FirstInstance (pObject); while (pInstance && InstanceIndex < pObject->NumInstances) { if (ParentIndex == pInstance->ParentObjectInstance) { SetThreadListText (pInstance, pCounterCPU, pCounterPRIV, fTime, szListText); ListIndex = SendMessage (hThreadList, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)szListText); SendMessage (hThreadList, LB_SETITEMDATA, ListIndex, InstanceIndex); } pInstance = NextInstance (pInstance); InstanceIndex++; } } } } //********************************************************************* // // RefreshThreadData // // Find data for a given thread and update. // void RefreshThreadData (HWND hWnd, PPERF_OBJECT pThreadObj, DWORD ThreadIndex, PPERF_OBJECT pProcessObj, PPERF_INSTANCE pProcessInst) { PPERF_INSTANCE pInstance; PPERF_COUNTER pCounter; DWORD *pdwData; DWORD *pdwProcPrio; BOOL bPrioCounter = TRUE; if (pInstance = FindInstanceN (pThreadObj, ThreadIndex)) { SetDlgItemText (hWnd, PVIEW_THREAD_PC, NODATA); PutCounterHEX (hWnd, PVIEW_THREAD_START, pInstance, pThreadObj, PX_THREAD_START); PutCounterDW (hWnd, PVIEW_THREAD_SWITCHES, pInstance, pThreadObj, PX_THREAD_SWITCHES); PutCounterDW (hWnd, PVIEW_THREAD_DYNAMIC, pInstance, pThreadObj, PX_THREAD_PRIO); } if (pInstance) { // get thread base priority // if (pCounter = FindCounter (pThreadObj, PX_THREAD_BASE_PRIO)) { pdwData = CounterData (pInstance, pCounter); if (!pdwData) { bPrioCounter = FALSE; } } else bPrioCounter = FALSE; // get process priority // if (pCounter = FindCounter (pProcessObj, PX_PROCESS_PRIO)) { pdwProcPrio = CounterData (pProcessInst, pCounter); if (!pdwProcPrio) { bPrioCounter = FALSE; } } else bPrioCounter = FALSE; } else bPrioCounter = FALSE; // set thread base priority // if (!bPrioCounter) CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_NORMAL); else { switch (*pdwData - *pdwProcPrio) { case 2: CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_HIGHEST); break; case 1: CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_ABOVE); break; case -1: CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_BELOW); break; case -2: CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_LOWEST); break; case 0: default: CheckRadioButton (hWnd, PVIEW_THREAD_HIGHEST, PVIEW_THREAD_LOWEST, PVIEW_THREAD_NORMAL); break; } } }