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.
196 lines
8.0 KiB
196 lines
8.0 KiB
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// File: lockperf.hxx
|
|
//
|
|
// Contents: class for lock monitoring for locks used by ole32.dll
|
|
//
|
|
// Classes: CLockPerfTracker
|
|
//
|
|
// History: 20-Dec-98 mprabhu Created
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
#ifndef _LOCKPERF_HXX_
|
|
#define _LOCKPERF_HXX_
|
|
|
|
#if LOCK_PERF==1
|
|
|
|
// Max entries in the file-line table
|
|
#define MAX_LOCKPERF_FILEENTRY 512
|
|
|
|
// Max # of (different) locks tracked
|
|
#define MAX_LOCKS 64
|
|
|
|
|
|
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// Structure: CTlsLockPerf
|
|
//
|
|
// Synopsis: TlsEntry used when a lock is requested/held
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
struct CTlsLockPerf {
|
|
void *_lpLockPtr;
|
|
DWORD _dwFlags;
|
|
ULONG _loc;
|
|
ULONG _idx;
|
|
DWORD _dwRecursion;
|
|
LARGE_INTEGER _liRequest;
|
|
LARGE_INTEGER _liEntered;
|
|
};
|
|
|
|
// Flags for TLS entries used when a lock is requested/held by a thread
|
|
#define TLS_LOCKPERF_INUSE 0x00000001
|
|
#define TLS_LOCKPERF_WAITING 0x00000010
|
|
#define TLS_LOCKPERF_ENTERED 0x00000020
|
|
|
|
// Max # of Tls Entries (== max # different locks a thread can hold at a time)
|
|
#define TLS_LOCKPERF_MAX 8
|
|
|
|
// LockPerf does not use OleTls, it allocates its own data during
|
|
// Thread_Attach and frees it during Thread_Detach.
|
|
// These two functions are used for the purpose.
|
|
HRESULT AllocLockPerfPvtTlsData();
|
|
void FreeLockPerfPvtTlsData();
|
|
|
|
// TlsIndex allocated during Process_Attach (DllMain)
|
|
extern DWORD gTlsLockPerfIndex;
|
|
|
|
|
|
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// Structure: CTlsLockPerf
|
|
//
|
|
// Synopsis: Represents a critical section guarded by a lock at a {file, line}
|
|
// in the code.
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
class CFileLineEntry {
|
|
public:
|
|
DWORD dwNext; // wsed to chain data by LockName (i.e. by lpLockPtr).
|
|
BOOL bWriteCritSec; // are we writing to shared data at this location?
|
|
ULONG ulLockTableIdx; // index in the lock table for lpLockPtr
|
|
DWORD dwLine; // Line number, eg. 2345
|
|
const char *pszFile; // File name, eg. d:\nt\private\ole32\com\dcomrem\marshal.cxx
|
|
const char *pszLockName; // Name of the lock, eg. gComLock
|
|
void *lpLockPtr; // Critical section used by the lock.
|
|
DWORD dwNumEntrys; // Count of visits to this {file,line} by all threads.
|
|
DWORD dwWaitTime; // cumulative waiting time at this {file,line} entry point
|
|
DWORD dwLockedTime; // cumulative locked time.
|
|
DWORD dwContentionCount; // obtained from the lock.
|
|
DWORD dwAvgTime; // average time spent in this critical section.
|
|
};
|
|
|
|
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// Structure: CLockEntry
|
|
//
|
|
// Synopsis: Stores data for each individual lock object
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
|
|
// This is used for cumulative data and for reader-writer locks when different
|
|
// reader threads could be at different locations in the code at a time.
|
|
// We keep track of the time when the first thread entered and the time the last
|
|
// thread left (possibly at different code locations) so as to calculate
|
|
// a shared lock time.
|
|
|
|
class CLockEntry {
|
|
public:
|
|
void *lpLockPtr; // the lock this entry represents
|
|
const char *pszLockName; // name of the lock
|
|
|
|
DWORD dwHead; // these two are used to chain the data by
|
|
DWORD dwTail; // LockName in the _LockPerfData array.
|
|
|
|
DWORD dwTotalWriteWaitTime; // total write wait time.
|
|
DWORD dwTotalWriteLockTime; // overall time spent holding this lock for Writes.
|
|
DWORD dwTotalWriteEntrys; // total write entry count for this lock.
|
|
|
|
DWORD dwTotalReadWaitTime; // total read wait time.
|
|
DWORD dwTotalReadLockTime; // overall time spent holding this lock for Reads.
|
|
DWORD dwTotalReadEntrys; // total read entry count for this lock.
|
|
|
|
DWORD dwWriterContentionCount; // overall write contention for this lock.
|
|
DWORD dwReaderContentionCount; // overall read contention for this lock.
|
|
|
|
DWORD dwSharedTime; // cumulative shared time
|
|
DWORD dwNumReaders; // count of simultaneous readers in the lock
|
|
LARGE_INTEGER liEntered; // time when the first reader entered this lock.
|
|
};
|
|
|
|
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// Class: CLockPerfTracker
|
|
//
|
|
// Synopsis: Exposes lock monitoring functionality.
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
// This is the main lock tracking class. We just have one object called gLockTracker
|
|
// of this class. All locks interested in timing data must Register themselves before
|
|
// use and call appropriate methods eg. gLockTrack.ReaderWaiting ... etc.
|
|
// A lock is responsible for maintaining Contention counts (and optionally entry counts).
|
|
// These must be reported before the lock is destroyed.
|
|
//
|
|
|
|
class CLockPerfTracker {
|
|
public:
|
|
// called by the lock instance creation function.
|
|
void RegisterLock(void *lpLockPtr, BOOL bReadWrite);
|
|
|
|
// called by the lock code as its state changes depending upon the request
|
|
// bWriter argument of WriterWaiting and WriterEntered is only used internally.
|
|
void ReaderWaiting(const char*pszFile, DWORD dwLine, const char* pszLockName, void *lpLockPtr);
|
|
void WriterWaiting(const char*pszFile, DWORD dwLine, const char* pszLockName, void *lpLockPtr, BOOL bWriter=TRUE);
|
|
void ReaderEntered(const char*pszFile, DWORD dwLine, const char* pszLockName, void *lpLockPtr);
|
|
void WriterEntered(const char*pszFile, DWORD dwLine, const char* pszLockName, void *lpLockPtr, BOOL bWriter=TRUE);
|
|
void ReaderLeaving(void *lpLockPtr);
|
|
void WriterLeaving(void *lpLockPtr);
|
|
|
|
// called by the lock instance prior to destruction/cleanup
|
|
void ReportContention(void *lpLockPtr, DWORD dwWriteEntrys, DWORD dwWriteContention, DWORD dwReadEntrys, DWORD dwReadContention);
|
|
|
|
// called during Process_Attach to initialize statics
|
|
HRESULT Init();
|
|
|
|
// called during Process_Detach to report the timing information
|
|
void OutputPerfData();
|
|
|
|
private:
|
|
// internal functions used by the tracker
|
|
ULONG FindOrCreateFileTableEntry(const char*pszFile, DWORD dwLine, const char* pszLockName, void *lpLockPtr, BOOL bWriter, ULONG *lpIdx);
|
|
ULONG FindLockTableEntry(void *lpLockPtr);
|
|
|
|
void ProcessPerfData();
|
|
|
|
void UpdateFileTableEntry(CTlsLockPerf *pTlsEntry, LARGE_INTEGER *pLiUnlock);
|
|
void OutputFileTableEntry(ULONG index, ULONG bByName, ULONG percent);
|
|
|
|
void UpdateHoggers(ULONG* hogList, ULONG index, ULONG listType);
|
|
void OutputHoggers(ULONG *list);
|
|
|
|
// These are the tables that lock data is collected in.
|
|
|
|
// Each entry in _FileLineData corresponds to a code critical section.
|
|
// ({File, line} where the lock is entered).
|
|
static CFileLineEntry _FileLineData[MAX_LOCKPERF_FILEENTRY];
|
|
|
|
// Each entry in _LockData corresponds to a lock eg. gIPIDLock
|
|
static CLockEntry _LockData[MAX_LOCKS];
|
|
|
|
static LARGE_INTEGER _liFreq; // Performance Frequency on the system
|
|
static ULONG _numCritSecs; // count of {file,line} critical sections monitored
|
|
static ULONG _numLocks; // count of distinct locks being monitored
|
|
};
|
|
|
|
// single global object
|
|
extern CLockPerfTracker gLockTracker;
|
|
|
|
#endif //LOCK_PERF==1
|
|
|
|
#endif //_LOCKPERF_HXX_
|