windows-xp/Source/XPSP1/NT/com/ole32/ih/lockperf.hxx

//+-----------------------------------------------------------------------------
//
//  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_