//*********************************************************************
//
// 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);
pAddressInstance = FirstInstance (pAddressObject);
while (pAddressInstance && i < pAddressObject->NumInstances)
{
pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2);
if (*pProcessID1 == *pProcessID2)
{
PaintPviewDlgMemoryData (hPviewDlg, pAddressInstance, pAddressObject);
break;
}
pAddressInstance = NextInstance (pAddressInstance);
i++;
}
}
}
//*********************************************************************
//
// 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 ListIndex;
PPERF_COUNTER pCounterCPU;
PPERF_COUNTER pCounterPRIV;
double fObjectFreq;
double fObjectTime;
double fTime;
INT InstanceIndex = 0;
INT err;
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,
(DWORD)szListText);
err = SendMessage (hThreadList, LB_SETITEMDATA, ListIndex, InstanceIndex);
}
pInstance = NextInstance (pInstance);
InstanceIndex++;
}
}
}
}
//*********************************************************************
//
// 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);
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 (*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;
}
//*********************************************************************
//
// RefreshProcessList
//
// Find all process and update the process list.
//
void RefreshProcessList (HWND hProcessList,
PPERF_OBJECT pObject)
{
PPERF_INSTANCE pInstance;
TCHAR szListText[256];
INT ListIndex;
PPERF_COUNTER pCounterCPU;
PPERF_COUNTER pCounterPRIV;
PPERF_COUNTER pCounterProcID;
double fObjectFreq;
double fObjectTime;
double fTime;
INT InstanceIndex = 0;
INT err;
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, (DWORD)szListText);
err = SendMessage (hProcessList, LB_SETITEMDATA, ListIndex, InstanceIndex);
pInstance = NextInstance (pInstance);
InstanceIndex++;
}
}
}
}
//*********************************************************************
//
// 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);
wsprintf (szTemp, TEXT("0x%08x"), *pdwData);
SetDlgItemText (hWnd, dwItemID, szTemp);
return *pdwData;
}
else
{
SetDlgItemText (hWnd, dwItemID, NODATA);
return 0;
}
}
//*********************************************************************
//
// 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);
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);
}
int StatsTable::GetCounterValue(const std::string& name, int pid)
{
if(!impl_)
{
return 0;
}
int row = FindCounter(name);
if(!row)
{
return 0;
}
return GetRowValue(row, pid);
}
/* internal counter access routine */
static void
MakeCounter(
struct dyn_counter **ppdc,
u_long ix,
u_long val,
u_long granularity,
char is_set) /* "set" as opposed to "add" */
{
u_long *pcounter;
/* if the counter tree doesn't exist yet, create it */
if (*ppdc == NULL) {
*ppdc = MakeCounterStruct();
}
/* check granularity */
if ((*ppdc)->gran == 0) {
(*ppdc)->gran = granularity;
} else {
/* error check */
if ((*ppdc)->gran != granularity) {
fprintf(stderr,"DYNCOUNTER: internal error, granularity changed\n");
exit(-1);
}
}
/* find/create the counter */
pcounter = FindCounter(ppdc, ix, 1);
/* add or set */
if (is_set) {
/* counter = val */
*pcounter = val;
} else {
/* counter += val */
*pcounter += val;
(*ppdc)->total_count += val;
}
/* check MAX counter value */
if (*pcounter > (*ppdc)->maxcount)
(*ppdc)->maxcount = *pcounter;
return;
}
//*********************************************************************
//
// 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 < 7)
return PVIEW_PRIORITY_IDL;
else if (*pdwData < 10)
return PVIEW_PRIORITY_NORMAL;
else
return PVIEW_PRIORITY_HIGH;
}
else
return PVIEW_PRIORITY_NORMAL;
}
//*********************************************************************
//
// 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);
SetDlgItemInt (hWnd, dwItemID, *pdwData, FALSE);
return *pdwData;
}
else
{
SetDlgItemText (hWnd, dwItemID, NODATA);
return 0;
}
}
/* read only, doesn't MAKE anything */
u_long
LookupCounter(
struct dyn_counter *pdc,
u_long ix)
{
u_long *pdigit;
if (ldebug)
fprintf(stderr,"LookupCounter(p,%lu) called\n", ix);
/* try to find the counter */
pdigit = FindCounter(&pdc,
ix,
0); /* do NOT create */
if (pdigit == NULL) {
/* no leaf node == no such counter */
if (ldebug)
fprintf(stderr,"LookupCounter(p,%lu): no such leaf\n", ix);
return(0);
}
return(*pdigit);
}
//*********************************************************************
//
// 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);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READONLY))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READWRITE))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_WRITECOPY))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXECUTABLE))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READONLY))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READWRITE))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwData += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_WRITECOPY))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
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);
}
//*********************************************************************
//
// 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);
dwTotal += *pdwData;
dwExecute += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, ExecuteIndex2))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwTotal += *pdwData;
dwExecute += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, ExecuteIndex3))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
dwTotal += *pdwData;
dwExecute += *pdwData;
bCounter = TRUE;
}
if (pCounter = FindCounter (pObj, ExecuteIndex4))
{
pdwData = (DWORD *) CounterData (pInst, pCounter);
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);
}
//*********************************************************************
//
// 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);
else
bPrioCounter = FALSE;
// get process priority
//
if (pCounter = FindCounter (pProcessObj, PX_PROCESS_PRIO))
pdwProcPrio = CounterData (pProcessInst, pCounter);
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;
}
}
}
