archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/shell/shlwapi/shperf.c

1679 lines
66 KiB
Raw Permalink Blame History

#include "priv.h"
#include "shlwapip.h"
#include "mshtmdbg.h"
#define STOPWATCH_MAX_DESC 256
#define STOPWATCH_MAX_TITLE 192
#define STOPWATCH_MAX_BUF 1024
// Perftags defines and typedefs
typedef PERFTAG (WINAPI *PFN_PERFREGISTER)(char *, char *, char *);
typedef void (WINAPIV *PFN_PERFLOGFN)(PERFTAG, void *, const char *, ...);
typedef char *(WINAPI *PFN_DECODEMESSAGE)(INT);
// IceCAP function typedefs
typedef void (WINAPI *PFN_ICAP)(void);
// MemWatch function typedefs
typedef HRESULT (WINAPI *PFN_MWCONFIG)(DWORD, DWORD, DWORD);
typedef HRESULT (WINAPI *PFN_MWBEGIN)(BOOL, BOOL);
typedef HRESULT (WINAPI *PFN_MWSNAPSHOT)();
typedef HRESULT (WINAPI *PFN_MWEND)(char *);
typedef HRESULT (WINAPI *PFN_MWMARK)(char *);
typedef HRESULT (WINAPI *PFN_MWEXIT)();
#ifndef NO_ETW_TRACING
#include <wmistr.h>
#include <evntrace.h>
typedef TRACEHANDLE (WINAPI *PFN_GTLOGHANDLE)(PVOID);
typedef ULONG (WINAPI *PFN_REGTRACE)(WMIDPREQUEST,
PVOID,
LPCGUID,
ULONG,
PTRACE_GUID_REGISTRATION,
LPCTSTR,
LPCTSTR,
PTRACEHANDLE
);
typedef ULONG (WINAPI *PFN_UNREGTRACE)(TRACEHANDLE);
typedef ULONG (WINAPI *PFN_TRACE)(TRACEHANDLE, PEVENT_TRACE_HEADER);
#endif
// Stopwatch memory buffer
typedef struct _STOPWATCH
{
DWORD dwId; // Node identifier
DWORD dwTID; // Thread ID;
DWORD dwType; // Node type - start, lap, stop, emtpy
DWORD dwCount; // Tick count
DWORD dwFlags; // Node flags - memlog, debugout
TCHAR szDesc[STOPWATCH_MAX_DESC];
} STOPWATCH, *PSTOPWATCH;
// Global stopwatch info data
typedef struct _STOPWATCHINFO
{
DWORD dwStopWatchMode;
DWORD dwStopWatchProfile;
DWORD dwStopWatchListIndex;
DWORD dwStopWatchListMax;
DWORD dwStopWatchPaintInterval;
// SPMODE_MSGTRACE data
DWORD dwStopWatchMaxDispatchTime;
DWORD dwStopWatchMaxMsgTime;
DWORD dwStopWatchMsgInterval;
DWORD dwcStopWatchOverflow;
DWORD dwStopWatchLastLocation;
DWORD dwStopWatchTraceMsg;
DWORD dwStopWatchTraceMsgCnt;
DWORD *pdwStopWatchMsgTime;
// SPMODE_MEMWATCH config data and function pointers
DWORD dwMemWatchPages;
DWORD dwMemWatchTime;
DWORD dwMemWatchFlags;
BOOL fMemWatchConfig;
HMODULE hModMemWatch;
PFN_MWCONFIG pfnMemWatchConfig;
PFN_MWBEGIN pfnMemWatchBegin;
PFN_MWSNAPSHOT pfnMemWatchSnapShot;
PFN_MWEND pfnMemWatchEnd;
PFN_MWMARK pfnMemWatchMark;
PFN_MWEXIT pfnMemWatchExit;
// Perftag data and function pointers
PERFTAG tagStopWatchStart;
PERFTAG tagStopWatchStop;
PERFTAG tagStopWatchLap;
PFN_PERFREGISTER pfnPerfRegister;
PFN_PERFLOGFN pfnPerfLogFn;
PFN_DECODEMESSAGE pfnDecodeMessage;
#ifndef NO_ETW_TRACING
DWORD dwEventTraceMode;
PFN_GTLOGHANDLE pfnGetLogHandle;
PFN_REGTRACE pfnRegisterTraceGuids;
PFN_UNREGTRACE pfnUnRegisterTraceGuids;
PFN_TRACE pfnTraceEvent;
#endif
LPTSTR pszClassNames;
PSTOPWATCH pStopWatchList;
// IceCAP data and function pointers
HMODULE hModICAP;
PFN_ICAP pfnStartCAPAll;
PFN_ICAP pfnStopCAPAll;
HANDLE hMapHtmPerfCtl;
HTMPERFCTL *pHtmPerfCtl;
} STOPWATCHINFO, *PSTOPWATCHINFO;
#ifndef NO_ETW_TRACING
#define c_szBrowserResourceName TEXT("Browse")
// Used to turn on/off event tracing. Setting the registry key enable event
// tracing use, but doesn't turn it on.
// {5576F62E-4142-45a8-9516-262A510C13F0}
const GUID c_BrowserControlGuid = {
0x5576f62e,
0x4142,
0x45a8,
0x95, 0x16, 0x26, 0x2a, 0x51, 0xc, 0x13, 0xf0};
// Maps to the structure sent to ETW. ETW definition in
// \nt\sdktools\trace\tracedmp\mofdata.guid
// {2B992163-736F-4a68-9153-95BC5F34D884}
const GUID c_BrowserTraceGuid = {
0x2b992163,
0x736f,
0x4a68,
0x91, 0x53, 0x95, 0xbc, 0x5f, 0x34, 0xd8, 0x84};
TRACE_GUID_REGISTRATION g_BrowserTraceGuidReg[] =
{
{ (LPGUID)&c_BrowserTraceGuid,
NULL
}
};
//
// The mof fields point to the following data.
// MOF_FIELD MofData[0]; // Holds ptr to Url Name
//
typedef struct _ETW_BROWSER_EVENT {
EVENT_TRACE_HEADER Header;
MOF_FIELD MofData[1];
} ETW_BROWSER_EVENT, *PETW_BROWSER_EVENT;
static TRACEHANDLE s_hEtwBrowserRegHandle;
static TRACEHANDLE s_hEtwBrowserLogHandle;
// For SHInterlockedCompareExchange
static BOOL s_fTRUE = TRUE;
static PVOID s_pvEtwBrowserTraceOnFlag = NULL;
static PVOID s_pvEtwBrowserRegistered = NULL;
static PVOID s_pvEtwBrowserRegistering = NULL;
#endif
PSTOPWATCHINFO g_pswi = NULL;
const TCHAR c_szDefClassNames[] = {STOPWATCH_DEFAULT_CLASSNAMES};
void StopWatch_SignalEvent();
//===========================================================================================
// INTERNAL FUNCTIONS
//===========================================================================================
//===========================================================================================
//===========================================================================================
void PerfCtlCallback(DWORD dwArg1, void * pvArg2)
{
const TCHAR c_szFmtBrowserStop[] = TEXT("Browser Frame Stop (%s)");
TCHAR szTitle[STOPWATCH_MAX_TITLE];
TCHAR szText[STOPWATCH_MAX_TITLE + ARRAYSIZE(c_szFmtBrowserStop) + 1];
LPTSTR ptr = szTitle;
#ifndef UNICODE
INT rc;
#endif
if(g_pswi->dwStopWatchMode & SPMODE_BROWSER) // Temp hack to deal with ansi,unicode. This code will go away when we impl hook in mshtml.
{
// GetWindowText(hwnd, szTitle, ARRAYSIZE(szTitle)-1);
#ifndef UNICODE
rc = WideCharToMultiByte(CP_ACP, 0, pvArg2, -1, szTitle, STOPWATCH_MAX_TITLE - 1, NULL, NULL);
if(!rc)
StrCpyN(szTitle, "ERROR converting wide to multi", ARRAYSIZE(szTitle) - 1);
#else
ptr = (LPTSTR) pvArg2;
#endif
wnsprintf(szText, ARRAYSIZE(szText), c_szFmtBrowserStop, ptr);
StopWatch_Stop(SWID_BROWSER_FRAME, szText, SPMODE_BROWSER | SPMODE_DEBUGOUT);
if((g_pswi->dwStopWatchMode & (SPMODE_EVENT | SPMODE_BROWSER)) == (SPMODE_EVENT | SPMODE_BROWSER))
{
StopWatch_SignalEvent();
}
}
}
#ifndef NO_ETW_TRACING
/*++
Routine Name:
ulEtwBrowserControlCallback()
Routine Description:
This is the function we provide to the ETW subsystem as a callback, it is used to
start and stop the trace events.
Arguments:
IN WMIDPREQUESTCODE RequestCode : The function to provide (enable/disable)
IN PVOID Context : Not used by us.
IN OUT ULONG *InOutBufferSize : The Buffersize
IN OUT PVOID Buffer : The buffer to use for the events
Returns ERROR_SUCCESS on success, or an error code.
--*/
ULONG
ulEtwBrowserControlCallback(
IN WMIDPREQUESTCODE RequestCode,
IN PVOID pvContext,
IN OUT ULONG *InOutBufferSize,
IN OUT PVOID pvBuffer
)
{
ULONG Status;
if (!s_pvEtwBrowserRegistered) {
// Registration hasn't happened yet.
return ERROR_GEN_FAILURE;
}
Status = ERROR_SUCCESS;
switch (RequestCode)
{
case WMI_ENABLE_EVENTS:
{
#if STOPWATCH_DEBUG
OutputDebugString("shperf.c:ulEtwBrowserControlCallback enable\n");
#endif
ASSERT(g_pswi->pfnGetLogHandle);
s_hEtwBrowserLogHandle = g_pswi->pfnGetLogHandle( pvBuffer );
#if STOPWATCH_DEBUG
if (s_hEtwBrowserLogHandle == INVALID_HANDLE_VALUE) {
TCHAR szDbg[256];
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1,
"ulEtwBrowserControlCallback GLE=%u\n", GetLastError());
OutputDebugString(szDbg);
}
#endif
SHInterlockedCompareExchange(&s_pvEtwBrowserTraceOnFlag, &s_fTRUE, NULL);
break;
}
case WMI_DISABLE_EVENTS:
{
#if STOPWATCH_DEBUG
OutputDebugString("shperf.c:ulEtwBrowserControlCallback disable\n");
#endif
SHInterlockedCompareExchange(&s_pvEtwBrowserTraceOnFlag, NULL, &s_fTRUE);
s_hEtwBrowserLogHandle = 0;
break;
}
default:
{
Status = ERROR_INVALID_PARAMETER;
break;
}
}
*InOutBufferSize = 0;
return(Status);
}
/*++
Routine Name:
RegisterTracing()
Routine Description:
Registers us to the ETW tools
Arguments:
Returns ERROR_SUCCESS on success of all registrations.
--*/
ULONG RegisterTracing()
{
ULONG Status = ERROR_SUCCESS;
TCHAR szImagePath[MAX_PATH];
Status = GetModuleFileName(NULL, szImagePath, sizeof(szImagePath)/sizeof(TCHAR));
if (Status == 0) {
Status = ERROR_FILE_NOT_FOUND;
}
else {
if (g_pswi->dwEventTraceMode & SPTRACE_BROWSER) {
PVOID fRegOn;
// If browser tracing is not registered, register it, preventing
// anybody else from trying to do this at the same time.
fRegOn = SHInterlockedCompareExchange(&s_pvEtwBrowserRegistering, &s_fTRUE, NULL);
if (!fRegOn) {
if (!s_pvEtwBrowserRegistered) {
ASSERT(g_pswi->pfnRegisterTraceGuids);
Status = g_pswi->pfnRegisterTraceGuids(
ulEtwBrowserControlCallback,
NULL,
(LPGUID)&c_BrowserControlGuid,
1,
g_BrowserTraceGuidReg,
szImagePath,
c_szBrowserResourceName,
&s_hEtwBrowserRegHandle);
if (Status == ERROR_SUCCESS) {
SHInterlockedCompareExchange(&s_pvEtwBrowserRegistered, &s_fTRUE, NULL);
}
#if STOPWATCH_DEBUG
else {
OutputDebugString("shperf.c:Registration of event tracing guids failed.\n");
}
#endif
}
SHInterlockedCompareExchange(&s_pvEtwBrowserRegistering, NULL, &s_fTRUE);
}
}
}
return Status;
}
/*++
Routine Name:
UnRegisterTracing()
Routine Description:
Deregisters us from the ETW tools
Arguments:
Returns ERROR_SUCCESS on success. a Winerror otherwise.
--*/
ULONG UnRegisterTracing()
{
ULONG Status = ERROR_SUCCESS;
// If browser tracing is registered, unregister it.
if (s_pvEtwBrowserRegistered) {
SHInterlockedCompareExchange(&s_pvEtwBrowserTraceOnFlag, NULL, &s_fTRUE);
if(g_pswi && g_pswi->pfnUnRegisterTraceGuids) {
Status = g_pswi->pfnUnRegisterTraceGuids(s_hEtwBrowserRegHandle);
}
if (Status == ERROR_SUCCESS) {
SHInterlockedCompareExchange(&s_pvEtwBrowserRegistered, NULL, &s_fTRUE);
}
#if STOPWATCH_DEBUG
else {
OutputDebugString("shperf.c:UnRegistration of event tracing guids failed.\n");
}
#endif
}
return Status;
}
/*++
Routine Name:
EventTraceHandler()
Routine Description:
If tracing is turned on, this sends the event to the WMI subsystem.
Arguments:
UCHAR EventType : Kind of trace event
PVOID Data : Data associated with event
--*/
void WINAPI EventTraceHandler(UCHAR uchEventType, PVOID pvData)
{
if ((g_pswi->dwEventTraceMode & SPTRACE_BROWSER))
{
if (s_pvEtwBrowserTraceOnFlag)
{
ETW_BROWSER_EVENT EtwEvent;
ULONG Status;
LPWSTR wszUrl = pvData;
//
// Record data.
//
ZeroMemory(&EtwEvent, sizeof(EtwEvent));
EtwEvent.Header.Size = sizeof(ETW_BROWSER_EVENT);
EtwEvent.Header.Flags = (WNODE_FLAG_TRACED_GUID | WNODE_FLAG_USE_MOF_PTR);
EtwEvent.Header.Class.Type = uchEventType;
EtwEvent.Header.Guid = c_BrowserTraceGuid;
EtwEvent.MofData[0].DataPtr = (ULONG64)wszUrl;
EtwEvent.MofData[0].Length = (wszUrl
? (wcslen(wszUrl)+1)*sizeof(WCHAR)
: 0);
ASSERT(g_pswi->pfnTraceEvent);
Status = g_pswi->pfnTraceEvent(
s_hEtwBrowserLogHandle,
(PEVENT_TRACE_HEADER) &EtwEvent);
#if STOPWATCH_DEBUG
if (Status != ERROR_SUCCESS) {
TCHAR szDbg[256];
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1,
"shperf.c:Call to trace event failed %I64x GLE=%u\n",
s_hEtwBrowserLogHandle, Status);
OutputDebugString(szDbg);
}
#endif
}
// Signal event when full web page is downloaded.
if ((uchEventType == EVENT_TRACE_TYPE_BROWSE_LOADEDPARSED) &&
(g_pswi->dwStopWatchMode & SPMODE_EVENT)) {
StopWatch_SignalEvent();
}
}
}
// Called through a pointer in the shared memory map section.
void PerfCtlEvntCallback(DWORD dwArg1, void * pvArg2)
{
EventTraceHandler((UCHAR)dwArg1, pvArg2);
}
#endif
//===========================================================================================
//===========================================================================================
HRESULT SetPerfCtl(DWORD dwFlags)
{
if (dwFlags == HTMPF_CALLBACK_ONLOAD ||
dwFlags == HTMPF_CALLBACK_ONEVENT)
{
char achName[sizeof(HTMPERFCTL_NAME) + 8 + 1];
StringCchPrintfA(achName, ARRAYSIZE(achName), "%s%08lX", HTMPERFCTL_NAME, GetCurrentProcessId());
if (g_pswi->hMapHtmPerfCtl == NULL)
g_pswi->hMapHtmPerfCtl = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, achName);
if (g_pswi->hMapHtmPerfCtl == NULL)
return(E_FAIL);
if (g_pswi->pHtmPerfCtl == NULL)
g_pswi->pHtmPerfCtl = (HTMPERFCTL *)MapViewOfFile(g_pswi->hMapHtmPerfCtl, FILE_MAP_WRITE, 0, 0, 0);
if (g_pswi->pHtmPerfCtl == NULL)
return(E_FAIL);
g_pswi->pHtmPerfCtl->dwSize = sizeof(HTMPERFCTL);
g_pswi->pHtmPerfCtl->dwFlags = dwFlags;
#ifndef NO_ETW_TRACING
if (dwFlags == HTMPF_CALLBACK_ONEVENT) {
RegisterTracing();
// Used by clients, like mshtml, to log events.
g_pswi->pHtmPerfCtl->pfnCall = PerfCtlEvntCallback;
}
else
#endif
g_pswi->pHtmPerfCtl->pfnCall = PerfCtlCallback;
g_pswi->pHtmPerfCtl->pvHost = NULL;
}
return S_OK;
}
//===========================================================================================
//===========================================================================================
void StopWatch_SignalEvent()
{
static HANDLE hEvent = NULL;
if(hEvent == NULL)
{
TCHAR szEventName[256];
wnsprintf(szEventName, ARRAYSIZE(szEventName), TEXT("%s%x"), TEXT("STOPWATCH_STOP_EVENT"), GetCurrentProcessId());
hEvent = CreateEvent((LPSECURITY_ATTRIBUTES)NULL, FALSE, FALSE, szEventName);
}
if(hEvent != NULL)
SetEvent(hEvent);
}
//===========================================================================================
//===========================================================================================
HRESULT DoMemWatchConfig(VOID)
{
HRESULT hr = ERROR_SUCCESS;
if(g_pswi->hModMemWatch == NULL)
{
if((g_pswi->hModMemWatch = LoadLibrary("mwshelp.dll")) != NULL)
{
g_pswi->pfnMemWatchConfig = (PFN_MWCONFIG) GetProcAddress(g_pswi->hModMemWatch, "MemWatchConfigure");
g_pswi->pfnMemWatchBegin = (PFN_MWBEGIN) GetProcAddress(g_pswi->hModMemWatch, "MemWatchBegin");
g_pswi->pfnMemWatchSnapShot = (PFN_MWSNAPSHOT) GetProcAddress(g_pswi->hModMemWatch, "MemWatchSnapShot");
g_pswi->pfnMemWatchEnd = (PFN_MWEND) GetProcAddress(g_pswi->hModMemWatch, "MemWatchEnd");
g_pswi->pfnMemWatchMark = (PFN_MWMARK) GetProcAddress(g_pswi->hModMemWatch, "MemWatchMark");
g_pswi->pfnMemWatchExit = (PFN_MWEXIT) GetProcAddress(g_pswi->hModMemWatch, "MemWatchExit");
if(g_pswi->pfnMemWatchConfig != NULL)
{
hr = g_pswi->pfnMemWatchConfig(g_pswi->dwMemWatchPages, g_pswi->dwMemWatchTime, g_pswi->dwMemWatchFlags);
if(FAILED(hr))
g_pswi->dwStopWatchMode &= ~SPMODE_MEMWATCH;
else
g_pswi->fMemWatchConfig = TRUE;
}
}
else
{
g_pswi->hModMemWatch = (HMODULE)1;
}
}
return(hr);
}
//===========================================================================================
// Function: VOID InitStopWatchMode(VOID)
//
// If HKLM\software\microsoft\windows\currentversion\explorer\performance\mode key value
// is set to one of the values described below, the stopwatch mode will be enabled by
// setting the global variable g_pswi->dwStopWatchMode.
//
// SPMODE_SHELL - Allows the flushing of stopwatch timings to a log file
// SPMODE_DEBUGOUT - Display timing via OutputDebugString. Only timings marked with SPMODE_DEBUGOUT
// through the StopWatch_* calls will be displayed.
// SPMODE_TEST - Used to display test output. This allow another level of SPMODE_DEBUGOUT
// like output.
//
// If HKLM\software\microsoft\windows\currentversion\explorer\performance\nodes key value
// is set, the size of the timing array will be set to this value. The default is 100 nodes.
//===========================================================================================
#define REGKEY_PERFMODE REGSTR_PATH_EXPLORER TEXT("\\Performance")
VOID InitStopWatchMode(VOID)
{
HKEY hkeyPerfMode;
DWORD dwVal = 0;
DWORD cbBuffer;
DWORD dwType;
TCHAR szClassNames[256];
#if STOPWATCH_DEBUG
TCHAR szDbg[256];
#endif
if(NO_ERROR == RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_PERFMODE, 0L, MAXIMUM_ALLOWED, &hkeyPerfMode))
{
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("Mode"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
{
if((dwVal & SPMODES) == 0) // Low word is mode, high word is paint timer interval
dwVal |= SPMODE_SHELL;
if((g_pswi = (PSTOPWATCHINFO)LocalAlloc(LPTR, SIZEOF(STOPWATCHINFO))) == NULL)
dwVal = 0;
}
if(dwVal != 0)
{
g_pswi->dwStopWatchMode = dwVal;
g_pswi->dwStopWatchListMax = STOPWATCH_MAX_NODES;
g_pswi->dwStopWatchPaintInterval = STOPWATCH_DEFAULT_PAINT_INTERVAL;
g_pswi->dwStopWatchMaxDispatchTime = STOPWATCH_DEFAULT_MAX_DISPATCH_TIME;
g_pswi->dwStopWatchMaxMsgTime = STOPWATCH_DEFAULT_MAX_MSG_TIME;
g_pswi->dwStopWatchMsgInterval = STOPWATCH_DEFAULT_MAX_MSG_INTERVAL;
g_pswi->pszClassNames = (LPTSTR)c_szDefClassNames;
g_pswi->dwMemWatchPages = MEMWATCH_DEFAULT_PAGES;
g_pswi->dwMemWatchTime = MEMWATCH_DEFAULT_TIME;
g_pswi->dwMemWatchFlags = MEMWATCH_DEFAULT_FLAGS;
#ifndef NO_ETW_TRACING
g_pswi->dwEventTraceMode = 0;
#endif
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("Profile"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchProfile = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("Nodes"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchListMax = dwVal;
cbBuffer = SIZEOF(szClassNames);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("ClassNames"), NULL, &dwType, (LPBYTE)&szClassNames, &cbBuffer))
{
if((g_pswi->pszClassNames = (LPTSTR)LocalAlloc(LPTR, SIZEOF(LPTSTR) * cbBuffer)) != NULL)
CopyMemory(g_pswi->pszClassNames, szClassNames, SIZEOF(LPTSTR) * cbBuffer);
}
cbBuffer = SIZEOF(dwVal);
// begin - Remove this after StopWatch users convert to using PaintInterval key
g_pswi->dwStopWatchPaintInterval = HIWORD(g_pswi->dwStopWatchMode) ?HIWORD(g_pswi->dwStopWatchMode) :STOPWATCH_DEFAULT_PAINT_INTERVAL; // Use high word of mode reg key value for interval
// end - Remove this after StopWatch users convert to using PaintInterval key
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("PaintInterval"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchPaintInterval = dwVal;
// Get MemWatch data
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MWPages"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwMemWatchPages = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MWTime"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwMemWatchTime = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MWFlags"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwMemWatchFlags = dwVal;
#ifndef NO_ETW_TRACING
if (g_pswi->dwStopWatchMode & SPMODE_EVENTTRACE) {
// Load the ETW operations individually to make sure the system
// this proc is running on supports them.
HMODULE hMod;
if ((hMod = LoadLibrary("advapi32.dll")) != NULL) {
g_pswi->pfnGetLogHandle = (PFN_GTLOGHANDLE) GetProcAddress(hMod, "GetTraceLoggerHandle");
g_pswi->pfnUnRegisterTraceGuids = (PFN_UNREGTRACE) GetProcAddress(hMod, "UnregisterTraceGuids");
g_pswi->pfnTraceEvent = (PFN_TRACE) GetProcAddress(hMod, "TraceEvent");
g_pswi->pfnRegisterTraceGuids =
#if defined(UNICODE) || defined(_UNICODE)
(PFN_REGTRACE) GetProcAddress(hMod, "RegisterTraceGuidsW");
#else
(PFN_REGTRACE) GetProcAddress(hMod, "RegisterTraceGuidsA");
#endif
}
else {
g_pswi->pfnGetLogHandle = NULL;
g_pswi->pfnUnRegisterTraceGuids = NULL;
g_pswi->pfnTraceEvent = NULL;
g_pswi->pfnRegisterTraceGuids = NULL;
}
if (!hMod ||
!g_pswi->pfnGetLogHandle ||
!g_pswi->pfnUnRegisterTraceGuids ||
!g_pswi->pfnTraceEvent ||
!g_pswi->pfnRegisterTraceGuids) {
// Event trace calls will never be made now.
#if STOPWATCH_DEBUG
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1, "~SPMODE_EVENTTRACE load procs from advapi32.dll failed.\n");
OutputDebugString(szDbg);
#endif
g_pswi->dwStopWatchMode &= ~SPMODE_EVENTTRACE;
}
else {
// Set type of event tracing before setting up the call back.
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("EventTrace"), NULL,
&dwType, (LPBYTE)&dwVal, &cbBuffer)) {
g_pswi->dwEventTraceMode = dwVal;
// You can only have one callback, so don't allow browser
// stopwatch and browser event tracing.
g_pswi->dwStopWatchMode &= ~SPMODE_BROWSER;
}
}
}
#endif
if(g_pswi->dwStopWatchMode & SPMODES)
{
#ifndef NO_ETW_TRACING
SetPerfCtl(g_pswi->dwStopWatchMode & SPMODE_EVENTTRACE
// See mshtmdbg.h
? HTMPF_CALLBACK_ONEVENT
: HTMPF_CALLBACK_ONLOAD);
#else
SetPerfCtl(HTMPF_CALLBACK_ONLOAD);
#endif
}
if(g_pswi->dwStopWatchMode & SPMODE_MSGTRACE)
{
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MaxDispatchTime"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchMaxDispatchTime = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MaxMsgTime"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchMaxMsgTime = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("MsgInterval"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchMsgInterval = dwVal;
cbBuffer = SIZEOF(dwVal);
if(NO_ERROR == RegQueryValueEx(hkeyPerfMode, TEXT("TraceMsg"), NULL, &dwType, (LPBYTE)&dwVal, &cbBuffer))
g_pswi->dwStopWatchTraceMsg = dwVal;
if((g_pswi->pdwStopWatchMsgTime = (DWORD *)LocalAlloc(LPTR, sizeof(DWORD) * (g_pswi->dwStopWatchMaxMsgTime / g_pswi->dwStopWatchMsgInterval))) == NULL)
g_pswi->dwStopWatchMode &= ~SPMODE_MSGTRACE;
}
if((g_pswi->pStopWatchList = (PSTOPWATCH)LocalAlloc(LPTR, sizeof(STOPWATCH)* g_pswi->dwStopWatchListMax)) == NULL) {
g_pswi->dwStopWatchMode = 0;
#ifndef NO_ETW_TRACING
// Just in case this didn't fail too.
UnRegisterTracing();
#endif
}
if(g_pswi->dwStopWatchMode & SPMODE_PERFTAGS)
{
HMODULE hMod;
if((hMod = LoadLibrary("mshtmdbg.dll")) != NULL)
{
g_pswi->pfnPerfRegister = (PFN_PERFREGISTER) GetProcAddress(hMod, "DbgExPerfRegister");
g_pswi->pfnPerfLogFn = (PFN_PERFLOGFN) GetProcAddress(hMod, "DbgExPerfLogFn");
g_pswi->pfnDecodeMessage = (PFN_DECODEMESSAGE) GetProcAddress(hMod, "DbgExDecodeMessage");
}
else
{
#if STOPWATCH_DEBUG
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1, "~SPMODE_PERFTAGS loadlib mshtmdbg.dll failed GLE=0x%x\n", GetLastError());
OutputDebugString(szDbg);
#endif
g_pswi->dwStopWatchMode &= ~SPMODE_PERFTAGS;
}
if(g_pswi->pfnPerfRegister != NULL)
{
g_pswi->tagStopWatchStart = g_pswi->pfnPerfRegister("tagStopWatchStart", "StopWatchStart", "SHLWAPI StopWatch start time");
g_pswi->tagStopWatchStop = g_pswi->pfnPerfRegister("tagStopWatchStop", "StopWatchStop", "SHLWAPI StopWatch stop time");
g_pswi->tagStopWatchLap = g_pswi->pfnPerfRegister("tagStopWatchLap", "StopWatchLap", "SHLWAPI StopWatch lap time");
}
}
#ifdef STOPWATCH_DEBUG
// Display option values
{
LPCTSTR ptr;
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1, TEXT("StopWatch Mode=0x%x Profile=0x%x Nodes=%d PaintInterval=%d MemBuf=%d bytes\n"),
g_pswi->dwStopWatchMode, g_pswi->dwStopWatchProfile, g_pswi->dwStopWatchListMax, g_pswi->dwStopWatchPaintInterval, g_pswi->dwStopWatchListMax * sizeof(STOPWATCH));
OutputDebugString(szDbg);
OutputDebugString(TEXT("Stopwatch ClassNames="));
ptr = g_pswi->pszClassNames;
while(*ptr)
{
wnsprintf(szDbg, ARRAYSIZE(szDbg) - 1, TEXT("'%s' "), ptr);
OutputDebugString(szDbg);
ptr = ptr + (lstrlen(ptr) + 1);
}
OutputDebugString(TEXT("\n"));
if(g_pswi->dwStopWatchMode & SPMODE_MSGTRACE)
{
wnsprintf(szDbg, ARRAYSIZE(szDbg)-1, TEXT("StopWatch MaxDispatchTime=%dms MaxMsgTime=%dms MsgInterval=%dms TraceMsg=0x%x MemBuf=%d bytes\n"),
g_pswi->dwStopWatchMaxDispatchTime, g_pswi->dwStopWatchMaxMsgTime, g_pswi->dwStopWatchMsgInterval, g_pswi->dwStopWatchTraceMsg, sizeof(DWORD) * (g_pswi->dwStopWatchMaxMsgTime / g_pswi->dwStopWatchMsgInterval));
OutputDebugString(szDbg);
}
if(g_pswi->dwStopWatchMode & SPMODE_MEMWATCH)
{
wnsprintf(szDbg, ARRAYSIZE(szDbg)-1, TEXT("StopWatch MemWatch Pages=%d Time=%dms Flags=%d\n"),
g_pswi->dwMemWatchPages, g_pswi->dwMemWatchTime, g_pswi->dwMemWatchFlags);
OutputDebugString(szDbg);
}
}
#endif
} // if(dwVal != 0)
RegCloseKey(hkeyPerfMode);
}
}
//===========================================================================================
// EXPORTED FUNCTIONS
//===========================================================================================
//===========================================================================================
// Function: DWORD WINAPI StopWatchMode(VOID)
//
// Returns: The value of the global mode variable. Modules should use this call, set their
// own global, and use this global to minimize and overhead when stopwatch mode
// is not enabled.
//===========================================================================================
DWORD WINAPI StopWatchMode(VOID)
{
if(g_pswi != NULL)
return(g_pswi->dwStopWatchMode);
else
return(0);
}
//===========================================================================================
//===========================================================================================
const TCHAR c_szBrowserStop[] = TEXT("Browser Frame Stop (%s)");
DWORD MakeStopWatchDesc(DWORD dwId, DWORD dwMarkType, LPCTSTR pszDesc, LPTSTR *ppszText, DWORD dwTextLen)
{
LPSTR lpszFmt = NULL;
DWORD dwRC = 0;
switch(SWID(dwId))
{
case SWID_BROWSER_FRAME:
lpszFmt = (LPSTR)c_szBrowserStop;
break;
default:
return(dwRC);
}
if(((DWORD)(lstrlen(lpszFmt) + lstrlen(pszDesc)) - 1) < dwTextLen)
dwRC = wnsprintf(*ppszText, dwTextLen - 1, lpszFmt, pszDesc);
else
StrCpyN(*ppszText, TEXT("ERROR:Desc too long!"), dwTextLen -1);
return(dwRC);
}
#define STARTCAPALL 1
#define STOPCAPALL 2
#define iStartCAPAll() CallICAP(STARTCAPALL)
#define iStopCAPAll() CallICAP(STOPCAPALL)
//===========================================================================================
//===========================================================================================
VOID CallICAP(DWORD dwFunc)
{
if(g_pswi->hModICAP == NULL)
{
if((g_pswi->hModICAP = LoadLibrary("icap.dll")) != NULL)
{
g_pswi->pfnStartCAPAll = (PFN_ICAP) GetProcAddress(g_pswi->hModICAP, "StartCAPAll");
g_pswi->pfnStopCAPAll = (PFN_ICAP) GetProcAddress(g_pswi->hModICAP, "StopCAPAll");
}
else
{
g_pswi->hModICAP = (HMODULE)1;
}
}
switch(dwFunc)
{
case STARTCAPALL:
if(g_pswi->pfnStartCAPAll != NULL)
g_pswi->pfnStartCAPAll();
break;
case STOPCAPALL:
if(g_pswi->pfnStopCAPAll != NULL)
g_pswi->pfnStopCAPAll();
break;
}
}
//===========================================================================================
//===========================================================================================
VOID CapBreak(BOOL fStart)
{
if((g_pswi->dwStopWatchMode & SPMODE_PROFILE) || (g_pswi->pHtmPerfCtl->dwFlags & HTMPF_ENABLE_PROFILE))
{
if(fStart)
iStartCAPAll();
else
iStopCAPAll();
}
if((g_pswi->dwStopWatchMode & SPMODE_MEMWATCH) || (g_pswi->pHtmPerfCtl->dwFlags & HTMPF_ENABLE_MEMWATCH))
{
if(g_pswi->hModMemWatch == NULL)
DoMemWatchConfig();
if(fStart)
{
if(g_pswi->pfnMemWatchBegin != NULL)
{
g_pswi->pfnMemWatchBegin(TRUE, FALSE); // synchronous and don't use timer
}
}
else
{
if(g_pswi->pfnMemWatchSnapShot != NULL)
{
g_pswi->pfnMemWatchSnapShot();
}
if(g_pswi->pfnMemWatchEnd != NULL)
{
CHAR szOutFile[MAX_PATH];
DWORD dwLen;
HRESULT hr;
#if STOPWATCH_DEBUG
CHAR szDbg[256];
#endif
*szOutFile = '\0';
GetWindowsDirectoryA(szOutFile, ARRAYSIZE(szOutFile) - 1);
dwLen = lstrlenA(szOutFile);
if ((dwLen > 0) && (szOutFile[dwLen-1] == '\\'))
{
// See if windows is installed in the root
szOutFile[dwLen-1] = '\0';
}
StringCchCatA(szOutFile, ARRAYSIZE(szOutFile), "\\shperf.mws");
hr = g_pswi->pfnMemWatchEnd(szOutFile);
#if STOPWATCH_DEBUG
switch(hr)
{
case E_FAIL:
wnsprintfA(szDbg, ARRAYSIZE(szDbg) - 1, "MemWatch SaveBuffer:%s failed. GLE:0x%x\n", szOutFile, GetLastError());
OutputDebugStringA(szDbg);
break;
case E_ABORT:
wnsprintfA(szDbg, ARRAYSIZE(szDbg) - 1, "MemWatch SaveBuffer: No data to save.\n");
OutputDebugStringA(szDbg);
break;
}
#endif
if(g_pswi->pfnMemWatchExit != NULL)
{
g_pswi->pfnMemWatchExit();
}
}
}
}
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGBREAK)
{
DebugBreak();
}
}
//===========================================================================================
// Function: DWORD WINAPI StopWatch(
// DWORD dwId, // The unique identifier, SWID_*, used to associate start, lap, and
// // stop timings for a given timing sequence.
// LPCSTR pszDesc, // Descriptive text for the timing.
// DWORD dwMarkType, // START_NODE, LAP_NODE, STOP_NODE
// DWORD dwFlags, // SPMODE_SHELL, SPMODE_DEBUGOUT, SPMODE_*. The timing call is used
// only if g_pswi->dwStopWatchMode contains dwFlags
// DWORD dwID) // Unique ID (Thread ID or user-supplied value)
//
// Macros: StopWatch_Start(dwId, pszDesc, dwFlags)
// StopWatch_Lap(dwId, pszDesc, dwFlags)
// StopWatch_Stop(dwId, pszDesc, dwFlags)
//
// Returns: ERROR_SUCCESS or ERROR_NOT_ENOUGH_MEMORY if out of nodes
//===========================================================================================
DWORD _StopWatch(DWORD dwId, LPCTSTR pszDesc, DWORD dwMarkType, DWORD dwFlags, DWORD dwCount, DWORD dwUniqueID)
{
PSTOPWATCH psp;
#ifdef STOPWATCH_DEBUG
PSTOPWATCH pspPrev;
#endif
DWORD dwDelta = 0;
DWORD dwRC = ERROR_SUCCESS;
DWORD dwIndex;
TCHAR szText[STOPWATCH_MAX_DESC];
LPTSTR psz;
if((SWID(dwId) && g_pswi->dwStopWatchProfile) && (dwMarkType == STOP_NODE))
{
CapBreak(FALSE);
}
if((g_pswi->pStopWatchList != NULL) && ((dwFlags & g_pswi->dwStopWatchMode) & SPMODES))
{
ENTERCRITICAL;
dwIndex = g_pswi->dwStopWatchListIndex++;
LEAVECRITICAL;
if(dwIndex < (g_pswi->dwStopWatchListMax-1))
{
psp = g_pswi->pStopWatchList + (dwIndex);
psp->dwCount = (dwCount != 0 ?dwCount :GetPerfTime()); // Save the data
psp->dwId = dwId;
psp->dwTID = dwUniqueID ? dwUniqueID : GetCurrentThreadId();
psp->dwType = dwMarkType;
psp->dwFlags = dwFlags;
psz = (LPTSTR)pszDesc;
if(dwFlags & SPMODE_FORMATTEXT)
{
psz = (LPTSTR)szText;
MakeStopWatchDesc(dwId, dwMarkType, pszDesc, &psz, ARRAYSIZE(szText));
}
StrCpyN(psp->szDesc, psz, ARRAYSIZE(psp->szDesc)-1);
if((g_pswi->dwStopWatchMode & SPMODE_PERFTAGS) && (g_pswi->pfnPerfLogFn != NULL))
{
if(dwMarkType == START_NODE)
g_pswi->pfnPerfLogFn(g_pswi->tagStopWatchStart, IntToPtr(dwId), psz);
if(dwMarkType == STOP_NODE)
g_pswi->pfnPerfLogFn(g_pswi->tagStopWatchStop, IntToPtr(dwId), psz);
if(dwMarkType == LAP_NODE)
g_pswi->pfnPerfLogFn(g_pswi->tagStopWatchLap, IntToPtr(dwId), psz);
}
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
const TCHAR c_szFmt_StopWatch_DbgOut[] = TEXT("StopWatch: 0x%x: %s: Time: %u ms\r\n");
TCHAR szBuf[STOPWATCH_MAX_DESC + ARRAYSIZE(c_szFmt_StopWatch_DbgOut) + 40]; // 8=dwTID 10=dwDelta
if(psp->dwType > START_NODE) // Find the previous associated node to get delta time
{
pspPrev = psp - 1;
while(pspPrev >= g_pswi->pStopWatchList)
{
if((SWID(pspPrev->dwId) == SWID(psp->dwId)) && // Found a match
(pspPrev->dwTID == psp->dwTID) &&
(pspPrev->dwType == START_NODE))
{
dwDelta = psp->dwCount - pspPrev->dwCount;
break;
}
pspPrev--;
}
}
wnsprintf((LPTSTR)szBuf, ARRAYSIZE(szBuf), c_szFmt_StopWatch_DbgOut, psp->dwTID, psp->szDesc, dwDelta);
OutputDebugString(szBuf);
}
#endif
if((dwMarkType == STOP_NODE) && (g_pswi->dwStopWatchMode & SPMODE_FLUSH) && (SWID(dwId) == SWID_FRAME))
{
StopWatchFlush();
}
}
else
{
psp = g_pswi->pStopWatchList + (g_pswi->dwStopWatchListMax-1); // Set the last node to a message so the user knows we ran out or mem
psp->dwId = 0;
psp->dwType = OUT_OF_NODES;
psp->dwFlags = dwFlags;
wnsprintf(psp->szDesc, STOPWATCH_MAX_DESC, TEXT("Out of perf timing nodes."));
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(psp->szDesc);
#endif
dwRC = ERROR_NOT_ENOUGH_MEMORY;
}
}
if((SWID(dwId) && g_pswi->dwStopWatchProfile) && (dwMarkType == START_NODE))
{
CapBreak(TRUE);
}
return(dwRC);
}
//===========================================================================================
//===========================================================================================
DWORD WINAPI StopWatchA(DWORD dwId, LPCSTR pszDesc, DWORD dwMarkType, DWORD dwFlags, DWORD dwCount)
{
#ifdef UNICODE
INT rc;
WCHAR wszDesc[STOPWATCH_MAX_DESC];
rc = MultiByteToWideChar(CP_ACP, 0, pszDesc, -1, wszDesc, STOPWATCH_MAX_DESC);
if(!rc)
return(ERROR_NOT_ENOUGH_MEMORY);
return(_StopWatch(dwId, (LPCTSTR)wszDesc, dwMarkType, dwFlags, dwCount, 0));
#else
return(_StopWatch(dwId, (LPCTSTR)pszDesc, dwMarkType, dwFlags, dwCount, 0));
#endif
}
//===========================================================================================
//===========================================================================================
DWORD WINAPI StopWatchW(DWORD dwId, LPCWSTR pwszDesc, DWORD dwMarkType, DWORD dwFlags, DWORD dwCount)
{
#ifndef UNICODE
INT rc;
CHAR szDesc[STOPWATCH_MAX_DESC];
rc = WideCharToMultiByte(CP_ACP, 0, pwszDesc, -1, szDesc, STOPWATCH_MAX_DESC, NULL, NULL);
if(!rc)
return(ERROR_NOT_ENOUGH_MEMORY);
return(_StopWatch(dwId, (LPCTSTR)szDesc, dwMarkType, dwFlags, dwCount, 0));
#else
return(_StopWatch(dwId, (LPCTSTR)pwszDesc, dwMarkType, dwFlags, dwCount, 0));
#endif
}
//===========================================================================================
//===========================================================================================
DWORD WINAPI StopWatchExA(DWORD dwId, LPCSTR pszDesc, DWORD dwMarkType, DWORD dwFlags, DWORD dwCount, DWORD dwCookie)
{
#ifdef UNICODE
INT rc;
WCHAR wszDesc[STOPWATCH_MAX_DESC];
rc = MultiByteToWideChar(CP_ACP, 0, pszDesc, -1, wszDesc, STOPWATCH_MAX_DESC);
if(!rc)
return(ERROR_NOT_ENOUGH_MEMORY);
return(_StopWatch(dwId, (LPCTSTR)wszDesc, dwMarkType, dwFlags, dwCount, dwCookie));
#else
return(_StopWatch(dwId, (LPCTSTR)pszDesc, dwMarkType, dwFlags, dwCount, dwCookie));
#endif
}
//===========================================================================================
//===========================================================================================
DWORD WINAPI StopWatchExW(DWORD dwId, LPCWSTR pwszDesc, DWORD dwMarkType, DWORD dwFlags, DWORD dwCount, DWORD dwCookie)
{
#ifndef UNICODE
INT rc;
CHAR szDesc[STOPWATCH_MAX_DESC];
rc = WideCharToMultiByte(CP_ACP, 0, pwszDesc, -1, szDesc, STOPWATCH_MAX_DESC, NULL, NULL);
if(!rc)
return(ERROR_NOT_ENOUGH_MEMORY);
return(_StopWatch(dwId, (LPCTSTR)szDesc, dwMarkType, dwFlags, dwCount, dwCookie));
#else
return(_StopWatch(dwId, (LPCTSTR)pwszDesc, dwMarkType, dwFlags, dwCount, dwCookie));
#endif
}
//===========================================================================================
// Function: DWORD WINAPI StopWatchFlush(VOID)
//
// This function will flush any SPMODE_SHELL nodes to windir\shperf.log. Calling this function
// will also clear all nodes.
//
// Return: ERROR_SUCCESS if the log file was generated
// ERROR_NO_DATA if the timing array is empty
// ERROR_INVALID_DATA if stopwatch mode is not enabled or the timing array does
// not exist.
//===========================================================================================
DWORD WINAPI StopWatchFlush(VOID)
{
PSTOPWATCH psp;
PSTOPWATCH psp1 = NULL;
BOOL fWroteStartData;
DWORD dwRC = ERROR_SUCCESS;
DWORD dwWritten;
DWORD dwDelta;
DWORD dwPrevCount;
DWORD dwCummDelta;
DWORD dwLen = 0;
HANDLE hFile;
SYSTEMTIME st;
TCHAR szBuf[STOPWATCH_MAX_BUF];
TCHAR szFileName[MAX_PATH];
#ifdef STOPWATCH_DEBUG
TCHAR szDbg[512];
#endif
if((!g_pswi->dwStopWatchMode) || (g_pswi->pStopWatchList == NULL))
{
SetLastError(ERROR_INVALID_DATA);
return(ERROR_INVALID_DATA);
}
GetSystemTime(&st);
if(g_pswi->dwStopWatchListIndex > 0)
{
ENTERCRITICAL;
if(g_pswi->dwStopWatchListIndex > 0)
{
g_pswi->dwStopWatchListIndex = 0;
if(g_pswi->dwStopWatchMode & SPMODES)
{
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
OutputDebugString(TEXT("Flushing shell perf data to shperf.log\r\n"));
}
#endif
// Used below as well to create msg trace log file
dwLen = GetWindowsDirectory(szFileName, ARRAYSIZE(szFileName) - 1);
szFileName[dwLen] = 0;
if (dwLen && szFileName[dwLen-1] == TEXT('\\'))
{
// See if windows is installed in the root
szFileName[dwLen-1] = TEXT('\0');
}
StringCchCat(szFileName, ARRAYSIZE(szFileName), TEXT("\\shperf.log"));
if((hFile = CreateFile(szFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) != INVALID_HANDLE_VALUE)
{
SetFilePointer(hFile, 0, NULL, FILE_END);
psp = g_pswi->pStopWatchList;
while(psp->dwType != EMPTY_NODE)
{
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
wnsprintf(szDbg, ARRAYSIZE(szDbg), TEXT("ID:%d TID:0x%x Type:%d Flgs:%d %s\r\n"),
psp->dwId, psp->dwTID, psp->dwType, psp->dwFlags, psp->szDesc);
OutputDebugString(szDbg);
}
#endif
if(psp->dwType == START_NODE)
{
wnsprintf(szBuf, ARRAYSIZE(szBuf), TEXT("%02d%02d%02d%02d%02d%02d\t0x%x\t%s\t%lu\t"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond,
psp->dwId, psp->szDesc, psp->dwCount);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(TEXT("Found Start Node\r\n"));
#endif
dwDelta = dwCummDelta = 0;
dwPrevCount = psp->dwCount;
psp1 = psp + 1;
fWroteStartData = FALSE;
while(psp1->dwType != EMPTY_NODE)
{
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
wnsprintf(szDbg, ARRAYSIZE(szDbg), TEXT(" ID:%d TID:0x%x Type:%d Flgs:%d %s\r\n"),
psp1->dwId, psp1->dwTID, psp1->dwType, psp1->dwFlags, psp1->szDesc);
OutputDebugString(szDbg);
}
#endif
if((SWID(psp1->dwId) == SWID(psp->dwId)) &&
(psp1->dwTID == psp->dwTID)) // Found a matching LAP or STOP node
{
if(psp1->dwType != START_NODE)
{
dwDelta = psp1->dwCount - dwPrevCount;
dwCummDelta += dwDelta;
if(!fWroteStartData)
{
fWroteStartData = TRUE;
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL); // Write out start node data
}
wnsprintf(szBuf, ARRAYSIZE(szBuf), TEXT("%s\t%lu,%lu,%lu\t"), psp1->szDesc, psp1->dwCount, dwDelta, dwCummDelta);
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(TEXT(" Found Lap/Stop Node\r\n"));
#endif
dwPrevCount = psp1->dwCount;
if(psp1->dwType == STOP_NODE && !(g_pswi->dwStopWatchMode & SPMODE_MARS))
break;
}
else // We have another start node that matches our Id/TID and we haven't had a stop. Log as a missing stop.
{
if(!fWroteStartData)
{
fWroteStartData = TRUE;
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL); // Write out start node data
}
wnsprintf(szBuf, ARRAYSIZE(szBuf), TEXT("ERROR: missing stop time"), psp1->szDesc, psp1->dwCount, dwDelta, dwCummDelta);
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
break;
}
}
psp1++;
}
WriteFile(hFile, TEXT("\r\n"), 2, &dwWritten, NULL);
}
else if(psp->dwType == OUT_OF_NODES)
{
wnsprintf(szBuf, ARRAYSIZE(szBuf), TEXT("%02d%02d%02d%02d%02d%02d\t0x%x\t%s\n"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond,
psp->dwId, psp->szDesc);
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
}
psp->dwType = EMPTY_NODE;
psp++;
}
FlushFileBuffers(hFile);
CloseHandle(hFile);
}
else
{
#ifdef STOPWATCH_DEBUG
wnsprintf(szBuf, ARRAYSIZE(szBuf) - 1, TEXT("CreateFile failed on '%s'. GLE=%d\n"), szFileName, GetLastError());
OutputDebugString(szBuf);
#endif
dwRC = ERROR_NO_DATA;
}
}
else // !(g_pswi->dwStopWatchMode)
{
psp = g_pswi->pStopWatchList;
while(psp->dwType != EMPTY_NODE)
{
psp->dwType = EMPTY_NODE;
psp++;
}
}
} // (g_pswi->dwStopWatchListIndex > 0)
LEAVECRITICAL;
}
if(g_pswi->dwStopWatchMode & SPMODE_MSGTRACE)
{
int i;
StringCchCopy(&szFileName[dwLen], ARRAYSIZE(szFileName) - dwLen, TEXT("\\msgtrace.log"));
if((hFile = CreateFile(szFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) != INVALID_HANDLE_VALUE)
{
SetFilePointer(hFile, 0, NULL, FILE_END);
for (i = 0; i < (int)(g_pswi->dwStopWatchMaxMsgTime / g_pswi->dwStopWatchMsgInterval); ++i)
{
wnsprintf(szBuf, ARRAYSIZE(szBuf) - 1, TEXT("%02d%02d%02d%02d%02d%02d\tMsgTrace\t%4d - %4dms\t%d\r\n"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond,
i * g_pswi->dwStopWatchMsgInterval, (i+1)*g_pswi->dwStopWatchMsgInterval-1, *(g_pswi->pdwStopWatchMsgTime + i));
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(szBuf);
#endif
}
wnsprintf(szBuf, ARRAYSIZE(szBuf) - 1, TEXT("%02d%02d%02d%02d%02d%02d\tMsgTrace\tmsgs >= %dms\t%d\r\n"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond,
g_pswi->dwStopWatchMaxMsgTime, g_pswi->dwcStopWatchOverflow);
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(szBuf);
#endif
if(g_pswi->dwStopWatchTraceMsg > 0)
{
wnsprintf(szBuf, ARRAYSIZE(szBuf) - 1, TEXT("%02d%02d%02d%02d%02d%02d\tMsgTrace\tmsg 0x%x occured %d times.\r\n"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond,
g_pswi->dwStopWatchTraceMsg, g_pswi->dwStopWatchTraceMsgCnt);
WriteFile(hFile, szBuf, lstrlen(szBuf), &dwWritten, NULL);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
OutputDebugString(szBuf);
#endif
}
FlushFileBuffers(hFile);
CloseHandle(hFile);
}
else
{
#ifdef STOPWATCH_DEBUG
wnsprintf(szBuf, ARRAYSIZE(szBuf) - 1, TEXT("CreateFile failed on '%s'. GLE=%d\n"), szFileName, GetLastError());
OutputDebugString(szBuf);
#endif
dwRC = ERROR_NO_DATA;
}
}
return(dwRC);
}
//===========================================================================================
// The following StopWatch messages are used to drive the timer msg handler. The timer proc is used
// as a means of delaying while watching paint messages. If the defined number of timer ticks has
// passed without getting any paint messages, then we mark the time of the last paint message we've
// saved as the stop time.
//===========================================================================================
VOID CALLBACK StopWatch_TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
StopWatch_TimerHandler(hwnd, 1, SWMSG_TIMER, NULL);
}
//===========================================================================================
//===========================================================================================
BOOL WINAPI StopWatch_TimerHandler(HWND hwnd, UINT uInc, DWORD dwFlag, MSG* pmsg)
{
static INT iNumTimersRcvd = 0;
static DWORD dwCnt = 0;
static BOOL bActive = FALSE;
static BOOL bHaveFirstPaintMsg = FALSE;
switch(dwFlag)
{
case SWMSG_PAINT:
if(bActive)
{
dwCnt = GetPerfTime(); // Save tick for last paint message
iNumTimersRcvd = 0; // Reset timers received count
if(!bHaveFirstPaintMsg)
{
TCHAR szClassName[40]; // If the class matches and its the first paint msg mark a lap time
LPCTSTR ptr;
GetClassName(pmsg->hwnd, szClassName, ARRAYSIZE(szClassName)-1);
ptr = g_pswi->pszClassNames;
while(*ptr)
{
if(lstrcmpi(szClassName, ptr) == 0)
{
bHaveFirstPaintMsg = TRUE;
StopWatch_LapTimed(SWID_FRAME, TEXT("Shell Frame 1st Paint"), SPMODE_SHELL | SPMODE_DEBUGOUT, dwCnt);
break;
}
ptr = ptr + (lstrlen(ptr) + 1);
}
}
}
break;
case SWMSG_TIMER:
iNumTimersRcvd += uInc;
if(iNumTimersRcvd >= 3) // If we've received this arbitrary # of timer msgs, mark stop time using the saved last paint tick count
{
const TCHAR c_szFmtShellStop[] = TEXT("Shell Frame Stop (%s)");
TCHAR szTitle[STOPWATCH_MAX_TITLE];
TCHAR szText[ARRAYSIZE(c_szFmtShellStop) + STOPWATCH_MAX_TITLE + 1];
KillTimer(hwnd, ID_STOPWATCH_TIMER);
GetWindowText(hwnd, szTitle, ARRAYSIZE(szTitle)-1);
wnsprintf(szText, ARRAYSIZE(szText), c_szFmtShellStop, szTitle);
StopWatch_StopTimed(SWID_FRAME, szText, SPMODE_SHELL | SPMODE_DEBUGOUT, dwCnt);
bHaveFirstPaintMsg = FALSE;
bActive = FALSE; // Done timing
if((g_pswi->dwStopWatchMode & (SPMODE_EVENT | SPMODE_SHELL)) == (SPMODE_EVENT | SPMODE_SHELL))
{
StopWatch_SignalEvent();
}
}
break;
case SWMSG_CREATE:
dwCnt = GetPerfTime(); // Save initial tick in case we don't have a paint when we exceed the # of SWMSG_TIMER above
iNumTimersRcvd = 0;
bHaveFirstPaintMsg = FALSE;
bActive = (BOOL)SetTimer(hwnd, ID_STOPWATCH_TIMER, g_pswi->dwStopWatchPaintInterval, StopWatch_TimerProc); // Use timer to determine when painting is done
break;
case SWMSG_STATUS:
break;
}
return(bActive); // Timing status active or not
}
//===========================================================================================
// This function is used to key off of WM_KEYDOWN to start timing when navigating inplace
//===========================================================================================
VOID WINAPI StopWatch_CheckMsg(HWND hwnd, MSG msg, LPCSTR lpStr)
{
TCHAR szText[80];
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_TEST) // Used to verify message assumptions
{
wnsprintf((LPTSTR)szText, ARRAYSIZE(szText), TEXT("Hwnd=0x%08x Msg=0x%x\r\n"), msg.hwnd, msg.message);
OutputDebugString(szText);
}
#endif
if(g_pswi->dwStopWatchMode & SPMODE_SHELL)
{
if(!StopWatch_TimerHandler(hwnd, 0, SWMSG_STATUS, &msg) &&
(((msg.message == WM_KEYDOWN) && (msg.wParam == VK_RETURN)) ||
((msg.message == WM_KEYDOWN) && (msg.wParam == VK_BACK)))
) // Navigating within the same window
{
wnsprintf(szText, ARRAYSIZE(szText), TEXT("Shell Frame Same%s"), lpStr);
StopWatch_TimerHandler(hwnd, 0, SWMSG_CREATE, &msg);
StopWatch_Start(SWID_FRAME, szText, SPMODE_SHELL | SPMODE_DEBUGOUT);
}
}
// Compute the time it took to get the message. Then increment approp MsgTime bucket
if(g_pswi->dwStopWatchMode & SPMODE_MSGTRACE)
{
DWORD dwTick = GetTickCount();
DWORD dwElapsed;
#ifdef STOPWATCH_DEBUG
TCHAR szMsg[256];
#endif
g_pswi->dwStopWatchLastLocation = 0;
if(dwTick > msg.time)
{
dwElapsed = dwTick - msg.time;
if(dwElapsed >= g_pswi->dwStopWatchMaxMsgTime)
{
++g_pswi->dwcStopWatchOverflow;
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
TCHAR szClassName[40];
TCHAR szMsgName[20];
GetClassName(msg.hwnd, szClassName, ARRAYSIZE(szClassName) - 1);
if(g_pswi->pfnDecodeMessage != NULL)
StrCpyN(szMsgName, g_pswi->pfnDecodeMessage(msg.message), ARRAYSIZE(szMsgName) - 1);
else
wnsprintf(szMsgName, ARRAYSIZE(szMsgName) - 1, "0x%x", msg.message);
wnsprintf(szMsg, ARRAYSIZE(szMsg) - 1, TEXT("MsgTrace (%s) loc=%d, ms=%d >= %d, hwnd=%x, wndproc=%x, msg=%s, w=%x, l=%x\r\n"),
szClassName, g_pswi->dwStopWatchLastLocation, dwElapsed, g_pswi->dwStopWatchMaxMsgTime, msg.hwnd, GetClassLongPtr(msg.hwnd, GCLP_WNDPROC), szMsgName, msg.wParam, msg.lParam);
OutputDebugString(szMsg);
}
#endif
}
else
{
++(*(g_pswi->pdwStopWatchMsgTime + (dwElapsed / g_pswi->dwStopWatchMsgInterval)));
}
}
if(g_pswi->dwStopWatchTraceMsg == msg.message)
++g_pswi->dwStopWatchTraceMsgCnt;
g_pswi->dwStopWatchLastLocation = 0;
}
}
//===========================================================================================
//===========================================================================================
VOID WINAPI StopWatch_SetMsgLastLocation(DWORD dwLast)
{
g_pswi->dwStopWatchLastLocation = dwLast;
}
//===========================================================================================
// Logs messages that took longer than g_pswi->dwStopWatchMaxDispatchTime to be dispatched
//===========================================================================================
DWORD WINAPI StopWatch_DispatchTime(BOOL fStartTime, MSG msg, DWORD dwStart)
{
DWORD dwTime = 0;
TCHAR szMsg[256];
if(fStartTime)
{
if(g_pswi->dwStopWatchTraceMsg == msg.message)
CapBreak(TRUE);
StopWatch(SWID_MSGDISPATCH, TEXT("+Dispatch"), START_NODE, SPMODE_MSGTRACE | SPMODE_DEBUGOUT, dwStart);
dwTime = GetPerfTime();
}
else
{
dwTime = GetPerfTime();
if(g_pswi->dwStopWatchTraceMsg == msg.message)
CapBreak(FALSE);
if((dwTime - dwStart) >= g_pswi->dwStopWatchMaxDispatchTime)
{
TCHAR szClassName[40];
TCHAR szMsgName[20];
GetClassName(msg.hwnd, szClassName, ARRAYSIZE(szClassName) - 1);
if(g_pswi->pfnDecodeMessage != NULL)
StrCpyN(szMsgName, g_pswi->pfnDecodeMessage(msg.message), ARRAYSIZE(szMsgName) - 1);
else
wnsprintf(szMsgName, ARRAYSIZE(szMsgName) - 1, "0x%x", msg.message);
wnsprintf(szMsg, ARRAYSIZE(szMsg) - 1, TEXT("-Dispatch (%s) ms=%d > %d, hwnd=%x, wndproc=%x, msg=%s(%x), w=%x, l=%x"),
szClassName, dwTime - dwStart, g_pswi->dwStopWatchMaxDispatchTime, msg.hwnd, GetClassLongPtr(msg.hwnd, GCLP_WNDPROC), szMsgName, msg.message, msg.wParam, msg.lParam);
StopWatch(SWID_MSGDISPATCH, szMsg, STOP_NODE, SPMODE_MSGTRACE | SPMODE_DEBUGOUT, dwTime);
#ifdef STOPWATCH_DEBUG
if(g_pswi->dwStopWatchMode & SPMODE_DEBUGOUT)
{
lstrcat(szMsg, "\n");
OutputDebugString(szMsg);
}
#endif
}
}
return(dwTime);
}
//===========================================================================================
// Mark shell/browser frame creation start time
//===========================================================================================
VOID WINAPI StopWatch_MarkFrameStart(LPCSTR lpExplStr)
{
TCHAR szText[80];
DWORD dwTime = GetPerfTime();
if(g_pswi->dwStopWatchMode & SPMODE_SHELL)
{
wnsprintf(szText, ARRAYSIZE(szText), TEXT("Shell Frame Start%s"), lpExplStr);
StopWatch_StartTimed(SWID_FRAME, szText, SPMODE_SHELL | SPMODE_DEBUGOUT, dwTime);
}
if(g_pswi->dwStopWatchMode & SPMODE_BROWSER) // Used to get the start of browser total download time
{
StopWatch_LapTimed(SWID_BROWSER_FRAME, TEXT("Thread Start"), SPMODE_BROWSER | SPMODE_DEBUGOUT, dwTime);
}
if(g_pswi->dwStopWatchMode & SPMODE_JAVA) // Used to get the start of java applet load time
{
StopWatch_StartTimed(SWID_JAVA_APP, TEXT("Java Applet Start"), SPMODE_JAVA | SPMODE_DEBUGOUT, dwTime);
}
}
//===========================================================================================
// Mark shell/browser navigate in same frame start time
//===========================================================================================
VOID WINAPI StopWatch_MarkSameFrameStart(HWND hwnd)
{
DWORD dwTime = GetPerfTime();
if(g_pswi->dwStopWatchMode & SPMODE_SHELL)
{
StopWatch_TimerHandler(hwnd, 0, SWMSG_CREATE, NULL);
StopWatch_StartTimed(SWID_FRAME, TEXT("Shell Frame Same"), SPMODE_SHELL | SPMODE_DEBUGOUT, dwTime);
}
if(g_pswi->dwStopWatchMode & SPMODE_BROWSER) // Used to get browser total download time
{
StopWatch_StartTimed(SWID_BROWSER_FRAME, TEXT("Browser Frame Same"), SPMODE_BROWSER | SPMODE_DEBUGOUT, dwTime);
}
if(g_pswi->dwStopWatchMode & SPMODE_JAVA) // Used to get java applet load time
{
StopWatch_StartTimed(SWID_JAVA_APP, TEXT("Java Applet Same"), SPMODE_JAVA | SPMODE_DEBUGOUT, dwTime);
}
}
//===========================================================================================
// When browser or java perf timing mode is enabled, use "Done" or "Applet Started"
// in the status bar to get load time.
//===========================================================================================
VOID WINAPI StopWatch_MarkJavaStop(LPCSTR lpStringToSend, HWND hwnd, BOOL fChType)
{
const TCHAR c_szFmtJavaStop[] = TEXT("Java Applet Stop (%s)");
TCHAR szTitle[STOPWATCH_MAX_TITLE];
TCHAR szText[STOPWATCH_MAX_TITLE + ARRAYSIZE(c_szFmtJavaStop) + 1];
if(g_pswi->dwStopWatchMode & SPMODE_JAVA)
{
if((lpStringToSend != NULL) && (lstrncmpW((LPWSTR)lpStringToSend, TEXTW("Applet started"), ARRAYSIZE(TEXTW("Applet started"))) == 0))
{
GetWindowText(hwnd, szTitle, ARRAYSIZE(szTitle)-1);
wnsprintf(szText, ARRAYSIZE(szText), c_szFmtJavaStop, szTitle);
StopWatch_Stop(SWID_JAVA_APP, szText, SPMODE_SHELL | SPMODE_DEBUGOUT);
}
}
}
//===========================================================================================
//===========================================================================================
DWORD WINAPI GetPerfTime(VOID)
{
static __int64 freq;
__int64 curtime;
if (!freq)
QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
QueryPerformanceCounter((LARGE_INTEGER *)&curtime);
ASSERT((((curtime * 1000) / freq) >> 32) == 0);
return (DWORD)((curtime * 1000) / freq);
}