2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Real-Time Hierarchical Profiling
//
// $NoKeywords: $
//=============================================================================//
# ifndef VPROF_H
# define VPROF_H
# include "tier0/dbg.h"
# include "tier0/fasttimer.h"
# include "tier0/l2cache.h"
# include "tier0/threadtools.h"
# include "tier0/vprof_telemetry.h"
// VProf is enabled by default in all configurations -except- X360 Retail.
2022-05-13 09:16:34 +00:00
//#if !( defined( _X360 ) && defined( _CERT ) )
//#define VPROF_ENABLED
//#endif
2020-04-22 16:56:21 +00:00
# if defined(_X360) && defined(VPROF_ENABLED)
# include "tier0/pmc360.h"
# ifndef USE_PIX
# define VPROF_UNDO_PIX
# undef _PIX_H_
# undef PIXBeginNamedEvent
# undef PIXEndNamedEvent
# undef PIXSetMarker
# undef PIXNameThread
# define USE_PIX
# include <pix.h>
# undef USE_PIX
# else
# include <pix.h>
# endif
# endif
# ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4251)
# endif
// enable this to get detailed nodes beneath budget
// #define VPROF_LEVEL 1
// enable this to use pix (360 only)
// #define VPROF_PIX 1
# if defined(VPROF_PIX)
# pragma comment( lib, "Xapilibi" )
# endif
//-----------------------------------------------------------------------------
//
// Profiling instrumentation macros
//
# define MAXCOUNTERS 256
# ifdef VPROF_ENABLED
# define VPROF_VTUNE_GROUP
# define VPROF( name ) VPROF_(name, 1, VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, false, 0)
# define VPROF_ASSERT_ACCOUNTED( name ) VPROF_(name, 1, VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, true, 0)
# define VPROF_( name, detail, group, bAssertAccounted, budgetFlags ) VPROF_##detail(name,group, bAssertAccounted, budgetFlags)
# define VPROF_BUDGET( name, group ) VPROF_BUDGET_FLAGS(name, group, BUDGETFLAG_OTHER)
# define VPROF_BUDGET_FLAGS( name, group, flags ) VPROF_(name, 0, group, false, flags)
# define VPROF_SCOPE_BEGIN( tag ) do { VPROF( tag )
# define VPROF_SCOPE_END() } while (0)
# define VPROF_ONLY( expression ) expression
# define VPROF_ENTER_SCOPE( name ) g_VProfCurrentProfile.EnterScope( name, 1, VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, false, 0 )
# define VPROF_EXIT_SCOPE() g_VProfCurrentProfile.ExitScope()
# define VPROF_BUDGET_GROUP_ID_UNACCOUNTED 0
// Budgetgroup flags. These are used with VPROF_BUDGET_FLAGS.
// These control which budget panels the groups show up in.
// If a budget group uses VPROF_BUDGET, it gets the default
// which is BUDGETFLAG_OTHER.
# define BUDGETFLAG_CLIENT (1<<0) // Shows up in the client panel.
# define BUDGETFLAG_SERVER (1<<1) // Shows up in the server panel.
# define BUDGETFLAG_OTHER (1<<2) // Unclassified (the client shows these but the dedicated server doesn't).
# define BUDGETFLAG_HIDDEN (1<<15)
# define BUDGETFLAG_ALL 0xFFFF
// NOTE: You can use strings instead of these defines. . they are defined here and added
// in vprof.cpp so that they are always in the same order.
# define VPROF_BUDGETGROUP_OTHER_UNACCOUNTED _T("Unaccounted")
# define VPROF_BUDGETGROUP_WORLD_RENDERING _T("World Rendering")
# define VPROF_BUDGETGROUP_DISPLACEMENT_RENDERING _T("Displacement_Rendering")
# define VPROF_BUDGETGROUP_GAME _T("Game")
# define VPROF_BUDGETGROUP_NPCS _T("NPCs")
# define VPROF_BUDGETGROUP_SERVER_ANIM _T("Server Animation")
# define VPROF_BUDGETGROUP_PHYSICS _T("Physics")
# define VPROF_BUDGETGROUP_STATICPROP_RENDERING _T("Static_Prop_Rendering")
# define VPROF_BUDGETGROUP_MODEL_RENDERING _T("Other_Model_Rendering")
# define VPROF_BUDGETGROUP_MODEL_FAST_PATH_RENDERING _T("Fast Path Model Rendering")
# define VPROF_BUDGETGROUP_BRUSHMODEL_RENDERING _T("Brush_Model_Rendering")
# define VPROF_BUDGETGROUP_SHADOW_RENDERING _T("Shadow_Rendering")
# define VPROF_BUDGETGROUP_DETAILPROP_RENDERING _T("Detail_Prop_Rendering")
# define VPROF_BUDGETGROUP_PARTICLE_RENDERING _T("Particle / Effect_Rendering")
# define VPROF_BUDGETGROUP_ROPES _T("Ropes")
# define VPROF_BUDGETGROUP_DLIGHT_RENDERING _T("Dynamic_Light_Rendering")
# define VPROF_BUDGETGROUP_OTHER_NETWORKING _T("Networking")
# define VPROF_BUDGETGROUP_CLIENT_ANIMATION _T("Client_Animation")
# define VPROF_BUDGETGROUP_OTHER_SOUND _T("Sound")
# define VPROF_BUDGETGROUP_OTHER_VGUI _T("VGUI")
# define VPROF_BUDGETGROUP_OTHER_FILESYSTEM _T("FileSystem")
# define VPROF_BUDGETGROUP_PREDICTION _T("Prediction")
# define VPROF_BUDGETGROUP_INTERPOLATION _T("Interpolation")
# define VPROF_BUDGETGROUP_SWAP_BUFFERS _T("Swap_Buffers")
# define VPROF_BUDGETGROUP_PLAYER _T("Player")
# define VPROF_BUDGETGROUP_OCCLUSION _T("Occlusion")
# define VPROF_BUDGETGROUP_OVERLAYS _T("Overlays")
# define VPROF_BUDGETGROUP_TOOLS _T("Tools")
# define VPROF_BUDGETGROUP_LIGHTCACHE _T("Light_Cache")
# define VPROF_BUDGETGROUP_DISP_HULLTRACES _T("Displacement_Hull_Traces")
# define VPROF_BUDGETGROUP_TEXTURE_CACHE _T("Texture_Cache")
# define VPROF_BUDGETGROUP_REPLAY _T("Replay")
# define VPROF_BUDGETGROUP_PARTICLE_SIMULATION _T("Particle Simulation")
# define VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING _T("Flashlight Shadows")
# define VPROF_BUDGETGROUP_CLIENT_SIM _T("Client Simulation") // think functions, tempents, etc.
# define VPROF_BUDGETGROUP_STEAM _T("Steam")
# define VPROF_BUDGETGROUP_CVAR_FIND _T("Cvar_Find")
# define VPROF_BUDGETGROUP_CLIENTLEAFSYSTEM _T("ClientLeafSystem")
# define VPROF_BUDGETGROUP_JOBS_COROUTINES _T("Jobs / Coroutines")
# define VPROF_BUDGETGROUP_SLEEPING _T("Sleeping")
# define VPROF_BUDGETGROUP_THREADINGMAIN _T("ThreadingMain")
# define VPROF_BUDGETGROUP_HTMLSURFACE _T("HTMLSurface")
# define VPROF_BUDGETGROUP_VGUI VPROF_BUDGETGROUP_HTMLSURFACE
# define VPROF_BUDGETGROUP_TENFOOT VPROF_BUDGETGROUP_HTMLSURFACE
# define VPROF_BUDGETGROUP_STEAMUI VPROF_BUDGETGROUP_HTMLSURFACE
# define VPROF_BUDGETGROUP_ATTRIBUTES _T("Attributes")
# define VPROF_BUDGETGROUP_FINDATTRIBUTE _T("FindAttribute")
# define VPROF_BUDGETGROUP_FINDATTRIBUTEUNSAFE _T("FindAttributeUnsafe")
# ifdef _X360
// update flags
# define VPROF_UPDATE_BUDGET 0x01 // send budget data every frame
# define VPROF_UPDATE_TEXTURE_GLOBAL 0x02 // send global texture data every frame
# define VPROF_UPDATE_TEXTURE_PERFRAME 0x04 // send perframe texture data every frame
# endif
//-------------------------------------
# ifndef VPROF_LEVEL
# define VPROF_LEVEL 0
# endif
//these macros exist to create VProf_<line number> variables. This is important because it avoids /analyze warnings about variable aliasing when VPROF's are nested within each other, and allows
//for multiple VPROF's to exist within the same scope. Three macros must be used to force the __LINE__ to be resolved prior to the token concatenation, but just ignore the _INTERNAL macros and use
//the VPROF_VAR_NAME
# define VPROF_VAR_NAME_INTERNAL_CAT(a, b) a##b
# define VPROF_VAR_NAME_INTERNAL( a, b ) VPROF_VAR_NAME_INTERNAL_CAT( a, b )
# define VPROF_VAR_NAME( a ) VPROF_VAR_NAME_INTERNAL( a, __LINE__ )
# define VPROF_0(name,group,assertAccounted,budgetFlags) tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "(%s)%s", group, name ); CVProfScope VPROF_VAR_NAME( VProf_ )(name, 0, group, assertAccounted, budgetFlags);
# if VPROF_LEVEL > 0
# define VPROF_1(name,group,assertAccounted,budgetFlags) tmZone( TELEMETRY_LEVEL3, TMZF_NONE, "(%s)%s", group, name ); CVProfScope VPROF_VAR_NAME( VProf_ )(name, 1, group, assertAccounted, budgetFlags);
# else
# define VPROF_1(name,group,assertAccounted,budgetFlags) ((void)0)
# endif
# if VPROF_LEVEL > 1
# define VPROF_2(name,group,assertAccounted,budgetFlags) CVProfScope VPROF_VAR_NAME( VProf_ )(name, 2, group, assertAccounted, budgetFlags);
# else
# define VPROF_2(name,group,assertAccounted,budgetFlags) ((void)0)
# endif
# if VPROF_LEVEL > 2
# define VPROF_3(name,group,assertAccounted,budgetFlags) CVProfScope VPROF_VAR_NAME( VProf_ )(name, 3, group, assertAccounted, budgetFlags);
# else
# define VPROF_3(name,group,assertAccounted,budgetFlags) ((void)0)
# endif
# if VPROF_LEVEL > 3
# define VPROF_4(name,group,assertAccounted,budgetFlags) CVProfScope VPROF_VAR_NAME( VProf_ )(name, 4, group, assertAccounted, budgetFlags);
# else
# define VPROF_4(name,group,assertAccounted,budgetFlags) ((void)0)
# endif
//-------------------------------------
# ifdef _MSC_VER
# define VProfCode( code ) \
if ( 0 ) \
; \
else \
{ \
VPROF ( __FUNCTION__ " : " # code ) ; \
code ; \
}
# else
# define VProfCode( code ) \
if ( 0 ) \
; \
else \
{ \
VPROF ( # code ) ; \
code ; \
}
# endif
//-------------------------------------
# define VPROF_INCREMENT_COUNTER(name,amount) do { static CVProfCounter _counter( name ); _counter.Increment( amount ); } while( 0 )
# define VPROF_INCREMENT_GROUP_COUNTER(name,group,amount) do { static CVProfCounter _counter( name, group ); _counter.Increment( amount ); } while( 0 )
# else
# define VPROF( name ) ((void)0)
# define VPROF_ASSERT_ACCOUNTED( name ) ((void)0)
# define VPROF_( name, detail, group, bAssertAccounted, budgetFlags ) ((void)0)
# define VPROF_BUDGET( name, group ) ((void)0)
# define VPROF_BUDGET_FLAGS( name, group, flags ) ((void)0)
# define VPROF_SCOPE_BEGIN( tag ) do {
# define VPROF_SCOPE_END() } while (0)
# define VPROF_ONLY( expression ) ((void)0)
# define VPROF_ENTER_SCOPE( name )
# define VPROF_EXIT_SCOPE()
# define VPROF_INCREMENT_COUNTER(name,amount) ((void)0)
# define VPROF_INCREMENT_GROUP_COUNTER(name,group,amount) ((void)0)
# define VPROF_TEST_SPIKE( msec ) ((void)0)
# define VProfCode( code ) code
# endif
//-----------------------------------------------------------------------------
# ifdef VPROF_ENABLED
//-----------------------------------------------------------------------------
//
// A node in the call graph hierarchy
//
class DBG_CLASS CVProfNode
{
friend class CVProfRecorder ;
friend class CVProfile ;
public :
CVProfNode ( const tchar * pszName , int detailLevel , CVProfNode * pParent , const tchar * pBudgetGroupName , int budgetFlags ) ;
~ CVProfNode ( ) ;
CVProfNode * GetSubNode ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , int budgetFlags ) ;
CVProfNode * GetSubNode ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName ) ;
CVProfNode * GetParent ( ) ;
CVProfNode * GetSibling ( ) ;
CVProfNode * GetPrevSibling ( ) ;
CVProfNode * GetChild ( ) ;
void MarkFrame ( ) ;
void ResetPeak ( ) ;
void Pause ( ) ;
void Resume ( ) ;
void Reset ( ) ;
void EnterScope ( ) ;
bool ExitScope ( ) ;
const tchar * GetName ( ) ;
int GetBudgetGroupID ( )
{
return m_BudgetGroupID ;
}
// Only used by the record/playback stuff.
void SetBudgetGroupID ( int id )
{
m_BudgetGroupID = id ;
}
int GetCurCalls ( ) ;
double GetCurTime ( ) ;
int GetPrevCalls ( ) ;
double GetPrevTime ( ) ;
int GetTotalCalls ( ) ;
double GetTotalTime ( ) ;
double GetPeakTime ( ) ;
double GetCurTimeLessChildren ( ) ;
double GetPrevTimeLessChildren ( ) ;
double GetTotalTimeLessChildren ( ) ;
int GetPrevL2CacheMissLessChildren ( ) ;
int GetPrevLoadHitStoreLessChildren ( ) ;
void ClearPrevTime ( ) ;
int GetL2CacheMisses ( ) ;
// Not used in the common case...
void SetCurFrameTime ( unsigned long milliseconds ) ;
void SetClientData ( int iClientData ) { m_iClientData = iClientData ; }
int GetClientData ( ) const { return m_iClientData ; }
# ifdef DBGFLAG_VALIDATE
void Validate ( CValidator & validator , tchar * pchName ) ; // Validate our internal structures
# endif // DBGFLAG_VALIDATE
// Used by vprof record/playback.
private :
void SetUniqueNodeID ( int id )
{
m_iUniqueNodeID = id ;
}
int GetUniqueNodeID ( ) const
{
return m_iUniqueNodeID ;
}
static int s_iCurrentUniqueNodeID ;
private :
const tchar * m_pszName ;
CFastTimer m_Timer ;
// L2 Cache data.
int m_iPrevL2CacheMiss ;
int m_iCurL2CacheMiss ;
int m_iTotalL2CacheMiss ;
# ifndef _X360
// L2 Cache data.
CL2Cache m_L2Cache ;
# else // 360:
unsigned int m_iBitFlags ; // see enum below for settings
CPMCData m_PMCData ;
int m_iPrevLoadHitStores ;
int m_iCurLoadHitStores ;
int m_iTotalLoadHitStores ;
public :
enum FlagBits
{
kRecordL2 = 0x01 ,
kCPUTrace = 0x02 , ///< cause a PIX trace inside this node.
} ;
// call w/ true to enable L2 and LHS recording; false to turn it off
inline void EnableL2andLHS ( bool enable )
{
if ( enable )
m_iBitFlags | = kRecordL2 ;
else
m_iBitFlags & = ( ~ kRecordL2 ) ;
}
inline bool IsL2andLHSEnabled ( void )
{
return ( m_iBitFlags & kRecordL2 ) ! = 0 ;
}
int GetLoadHitStores ( ) ;
private :
# endif
2021-11-16 20:46:29 +00:00
unsigned m_nCurFrameCalls ;
unsigned m_nPrevFrameCalls ;
2020-04-22 16:56:21 +00:00
int m_nRecursions ;
CCycleCount m_CurFrameTime ;
CCycleCount m_PrevFrameTime ;
unsigned m_nTotalCalls ;
CCycleCount m_TotalTime ;
CCycleCount m_PeakTime ;
CVProfNode * m_pParent ;
CVProfNode * m_pChild ;
CVProfNode * m_pSibling ;
int m_BudgetGroupID ;
int m_iClientData ;
int m_iUniqueNodeID ;
} ;
//-----------------------------------------------------------------------------
//
// Coordinator and root node of the profile hierarchy tree
//
enum VProfReportType_t
{
VPRT_SUMMARY = ( 1 < < 0 ) ,
VPRT_HIERARCHY = ( 1 < < 1 ) ,
VPRT_HIERARCHY_TIME_PER_FRAME_AND_COUNT_ONLY = ( 1 < < 2 ) ,
VPRT_LIST_BY_TIME = ( 1 < < 3 ) ,
VPRT_LIST_BY_TIME_LESS_CHILDREN = ( 1 < < 4 ) ,
VPRT_LIST_BY_AVG_TIME = ( 1 < < 5 ) ,
VPRT_LIST_BY_AVG_TIME_LESS_CHILDREN = ( 1 < < 6 ) ,
VPRT_LIST_BY_PEAK_TIME = ( 1 < < 7 ) ,
VPRT_LIST_BY_PEAK_OVER_AVERAGE = ( 1 < < 8 ) ,
VPRT_LIST_TOP_ITEMS_ONLY = ( 1 < < 9 ) ,
VPRT_FULL = ( 0xffffffff & ~ ( VPRT_HIERARCHY_TIME_PER_FRAME_AND_COUNT_ONLY | VPRT_LIST_TOP_ITEMS_ONLY ) ) ,
} ;
enum CounterGroup_t
{
COUNTER_GROUP_DEFAULT = 0 ,
COUNTER_GROUP_NO_RESET , // The engine doesn't reset these counters. Usually, they are used
// like global variables that can be accessed across modules.
COUNTER_GROUP_TEXTURE_GLOBAL , // Global texture usage counters (totals for what is currently in memory).
COUNTER_GROUP_TEXTURE_PER_FRAME , // Per-frame texture usage counters.
COUNTER_GROUP_TELEMETRY ,
} ;
class DBG_CLASS CVProfile
{
public :
CVProfile ( ) ;
~ CVProfile ( ) ;
void Term ( ) ;
//
// Runtime operations
//
void Start ( ) ;
void Stop ( ) ;
void SetTargetThreadId ( unsigned id ) { m_TargetThreadId = id ; }
unsigned GetTargetThreadId ( ) { return m_TargetThreadId ; }
bool InTargetThread ( ) { return ( m_TargetThreadId = = ThreadGetCurrentId ( ) ) ; }
# ifdef _X360
enum VXConsoleReportMode_t
{
VXCONSOLE_REPORT_TIME = 0 ,
VXCONSOLE_REPORT_L2CACHE_MISSES ,
VXCONSOLE_REPORT_LOAD_HIT_STORE ,
VXCONSOLE_REPORT_COUNT ,
} ;
void VXProfileStart ( ) ;
void VXProfileUpdate ( ) ;
void VXEnableUpdateMode ( int event , bool bEnable ) ;
void VXSendNodes ( void ) ;
void PMCDisableAllNodes ( CVProfNode * pStartNode = NULL ) ; ///< turn off l2 and lhs recording for everywhere
bool PMCEnableL2Upon ( const tchar * pszNodeName , bool bRecursive = false ) ; ///< enable l2 and lhs recording for one given node
bool PMCDisableL2Upon ( const tchar * pszNodeName , bool bRecursive = false ) ; ///< enable l2 and lhs recording for one given node
void DumpEnabledPMCNodes ( void ) ;
void VXConsoleReportMode ( VXConsoleReportMode_t mode ) ;
void VXConsoleReportScale ( VXConsoleReportMode_t mode , float flScale ) ;
// the CPU trace mode is actually a small state machine; it can be off, primed for
// single capture, primed for everything-in-a-frame capture, or currently in everything-in-a-frame
// capture.
enum CPUTraceState
{
kDisabled ,
kFirstHitNode , // record from the first time we hit the node until that node ends
kAllNodesInFrame_WaitingForMark , // we're going to record all the times a node is hit in a frame, but are waiting for the frame to start
kAllNodesInFrame_Recording , // we're recording all hits on a node this frame.
// Same as above, but going to record for > 1 frame
kAllNodesInFrame_WaitingForMarkMultiFrame , // we're going to record all the times a node is hit in a frame, but are waiting for the frame to start
kAllNodesInFrame_RecordingMultiFrame ,
} ;
// Global switch to turn CPU tracing on or off at all. The idea is you set up a node first,
// then trigger tracing by throwing this to true. It'll reset back to false after the trace
// happens.
inline CPUTraceState GetCPUTraceMode ( ) ;
inline void SetCPUTraceEnabled ( CPUTraceState enabled , bool bTraceCompleteEvent = false , int nNumFrames = - 1 ) ;
inline void IncrementMultiTraceIndex ( ) ; // tick up the counter that gets appended to the multi-per-frame traces
inline unsigned int GetMultiTraceIndex ( ) ; // return the counter
void CPUTraceDisableAllNodes ( CVProfNode * pStartNode = NULL ) ; // disable the cpu trace flag wherever it may be
CVProfNode * CPUTraceEnableForNode ( const tchar * pszNodeName ) ; // enable cpu trace on this node only, disabling it wherever else it may be on.
CVProfNode * CPUTraceGetEnabledNode ( CVProfNode * pStartNode = NULL ) ; // return the node enabled for CPU tracing, or NULL.
const char * GetCPUTraceFilename ( ) ; // get the filename the trace should write into.
const char * SetCPUTraceFilename ( const char * filename ) ; // set the filename the trace should write into. (don't specify the extension; I'll do that.)
inline bool TraceCompleteEvent ( void ) ;
# ifdef _X360
void LatchMultiFrame ( int64 cycles ) ;
void SpewWorstMultiFrame ( ) ;
# endif
# endif
void EnterScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted ) ;
void EnterScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted , int budgetFlags ) ;
void ExitScope ( ) ;
void MarkFrame ( ) ;
void ResetPeaks ( ) ;
void Pause ( ) ;
void Resume ( ) ;
void Reset ( ) ;
bool IsEnabled ( ) const ;
int GetDetailLevel ( ) const ;
bool AtRoot ( ) const ;
//
// Queries
//
# ifdef VPROF_VTUNE_GROUP
# define MAX_GROUP_STACK_DEPTH 1024
void EnableVTuneGroup ( const tchar * pGroupName )
{
m_nVTuneGroupID = BudgetGroupNameToBudgetGroupID ( pGroupName ) ;
m_bVTuneGroupEnabled = true ;
}
void DisableVTuneGroup ( void )
{
m_bVTuneGroupEnabled = false ;
}
inline void PushGroup ( int nGroupID ) ;
inline void PopGroup ( void ) ;
# endif
int NumFramesSampled ( ) { return m_nFrames ; }
double GetPeakFrameTime ( ) ;
double GetTotalTimeSampled ( ) ;
double GetTimeLastFrame ( ) ;
CVProfNode * GetRoot ( ) ;
CVProfNode * FindNode ( CVProfNode * pStartNode , const tchar * pszNode ) ;
CVProfNode * GetCurrentNode ( ) ;
typedef void ( __cdecl * StreamOut_t ) ( const char * pszFormat , . . . ) ;
// Set the output function used for all vprof reports. Call this with NULL
// to set it to the default output function.
void SetOutputStream ( StreamOut_t outputStream ) ;
void OutputReport ( int type = VPRT_FULL , const tchar * pszStartNode = NULL , int budgetGroupID = - 1 ) ;
const tchar * GetBudgetGroupName ( int budgetGroupID ) ;
int GetBudgetGroupFlags ( int budgetGroupID ) const ; // Returns a combination of BUDGETFLAG_ defines.
int GetNumBudgetGroups ( void ) ;
void GetBudgetGroupColor ( int budgetGroupID , int & r , int & g , int & b , int & a ) ;
int BudgetGroupNameToBudgetGroupID ( const tchar * pBudgetGroupName ) ;
int BudgetGroupNameToBudgetGroupID ( const tchar * pBudgetGroupName , int budgetFlagsToORIn ) ;
void RegisterNumBudgetGroupsChangedCallBack ( void ( * pCallBack ) ( void ) ) ;
int BudgetGroupNameToBudgetGroupIDNoCreate ( const tchar * pBudgetGroupName ) { return FindBudgetGroupName ( pBudgetGroupName ) ; }
void HideBudgetGroup ( int budgetGroupID , bool bHide = true ) ;
void HideBudgetGroup ( const char * pszName , bool bHide = true ) { HideBudgetGroup ( BudgetGroupNameToBudgetGroupID ( pszName ) , bHide ) ; }
int * FindOrCreateCounter ( const tchar * pName , CounterGroup_t eCounterGroup = COUNTER_GROUP_DEFAULT ) ;
void ResetCounters ( CounterGroup_t eCounterGroup ) ;
int GetNumCounters ( void ) const ;
const tchar * GetCounterName ( int index ) const ;
int GetCounterValue ( int index ) const ;
const tchar * GetCounterNameAndValue ( int index , int & val ) const ;
CounterGroup_t GetCounterGroup ( int index ) const ;
// Performance monitoring events.
void PMEInitialized ( bool bInit ) { m_bPMEInit = bInit ; }
void PMEEnable ( bool bEnable ) { m_bPMEEnabled = bEnable ; }
# ifndef _X360
bool UsePME ( void ) { return ( m_bPMEInit & & m_bPMEEnabled ) ; }
# else
bool UsePME ( void ) { return ( CPMCData : : IsInitialized ( ) & & m_bPMEEnabled ) ; }
# endif
# ifdef DBGFLAG_VALIDATE
void Validate ( CValidator & validator , tchar * pchName ) ; // Validate our internal structures
# endif // DBGFLAG_VALIDATE
protected :
void FreeNodes_R ( CVProfNode * pNode ) ;
# ifdef VPROF_VTUNE_GROUP
bool VTuneGroupEnabled ( )
{
return m_bVTuneGroupEnabled ;
}
int VTuneGroupID ( )
{
return m_nVTuneGroupID ;
}
# endif
void SumTimes ( const tchar * pszStartNode , int budgetGroupID ) ;
void SumTimes ( CVProfNode * pNode , int budgetGroupID ) ;
void DumpNodes ( CVProfNode * pNode , int indent , bool bAverageAndCountOnly ) ;
int FindBudgetGroupName ( const tchar * pBudgetGroupName ) ;
int AddBudgetGroupName ( const tchar * pBudgetGroupName , int budgetFlags ) ;
# ifdef VPROF_VTUNE_GROUP
bool m_bVTuneGroupEnabled ;
int m_nVTuneGroupID ;
int m_GroupIDStack [ MAX_GROUP_STACK_DEPTH ] ;
int m_GroupIDStackDepth ;
# endif
CVProfNode m_Root ;
2021-11-16 20:46:29 +00:00
CVProfNode * m_pCurNode ;
2020-04-22 16:56:21 +00:00
int m_nFrames ;
2021-11-16 20:46:29 +00:00
int m_enabled ;
2020-04-22 16:56:21 +00:00
int m_pausedEnabledDepth ;
2021-11-16 20:46:29 +00:00
bool m_fAtRoot ; // tracked for efficiency of the "not profiling" case
int m_ProfileDetailLevel ;
2020-04-22 16:56:21 +00:00
class CBudgetGroup
{
public :
tchar * m_pName ;
int m_BudgetFlags ;
} ;
CBudgetGroup * m_pBudgetGroups ;
int m_nBudgetGroupNamesAllocated ;
int m_nBudgetGroupNames ;
void ( * m_pNumBudgetGroupsChangedCallBack ) ( void ) ;
// Performance monitoring events.
bool m_bPMEInit ;
bool m_bPMEEnabled ;
int m_Counters [ MAXCOUNTERS ] ;
char m_CounterGroups [ MAXCOUNTERS ] ; // (These are CounterGroup_t's).
tchar * m_CounterNames [ MAXCOUNTERS ] ;
int m_NumCounters ;
# ifdef _X360
int m_UpdateMode ;
CPUTraceState m_iCPUTraceEnabled ;
int m_nFramesRemaining ;
int m_nFrameCount ;
int64 m_WorstCycles ;
char m_WorstTraceFilename [ 128 ] ;
char m_CPUTraceFilename [ 128 ] ;
unsigned int m_iSuccessiveTraceIndex ;
VXConsoleReportMode_t m_ReportMode ;
float m_pReportScale [ VXCONSOLE_REPORT_COUNT ] ;
bool m_bTraceCompleteEvent ;
# endif
unsigned m_TargetThreadId ;
StreamOut_t m_pOutputStream ;
} ;
//-------------------------------------
DBG_INTERFACE CVProfile g_VProfCurrentProfile ;
//-----------------------------------------------------------------------------
DBG_INTERFACE bool g_VProfSignalSpike ;
class CVProfSpikeDetector
{
public :
CVProfSpikeDetector ( float spike ) :
m_timeLast ( GetTimeLast ( ) )
{
m_spike = spike ;
m_Timer . Start ( ) ;
}
~ CVProfSpikeDetector ( )
{
m_Timer . End ( ) ;
if ( Plat_FloatTime ( ) - m_timeLast > 2.0 )
{
m_timeLast = Plat_FloatTime ( ) ;
if ( m_Timer . GetDuration ( ) . GetMillisecondsF ( ) > m_spike )
{
g_VProfSignalSpike = true ;
}
}
}
private :
static float & GetTimeLast ( ) { static float timeLast = 0 ; return timeLast ; }
CFastTimer m_Timer ;
float m_spike ;
float & m_timeLast ;
} ;
// Macro to signal a local spike. Meant as temporary instrumentation, do not leave in code
# define VPROF_TEST_SPIKE( msec ) CVProfSpikeDetector UNIQUE_ID( msec )
//-----------------------------------------------------------------------------
# ifdef VPROF_VTUNE_GROUP
inline void CVProfile : : PushGroup ( int nGroupID )
{
// There is always at least one item on the stack since we force
// the first element to be VPROF_BUDGETGROUP_OTHER_UNACCOUNTED.
Assert ( m_GroupIDStackDepth > 0 ) ;
Assert ( m_GroupIDStackDepth < MAX_GROUP_STACK_DEPTH ) ;
m_GroupIDStack [ m_GroupIDStackDepth ] = nGroupID ;
m_GroupIDStackDepth + + ;
if ( m_GroupIDStack [ m_GroupIDStackDepth - 2 ] ! = nGroupID & &
VTuneGroupEnabled ( ) & &
nGroupID = = VTuneGroupID ( ) )
{
vtune ( true ) ;
}
}
# endif // VPROF_VTUNE_GROUP
# ifdef VPROF_VTUNE_GROUP
inline void CVProfile : : PopGroup ( void )
{
m_GroupIDStackDepth - - ;
// There is always at least one item on the stack since we force
// the first element to be VPROF_BUDGETGROUP_OTHER_UNACCOUNTED.
Assert ( m_GroupIDStackDepth > 0 ) ;
if ( m_GroupIDStack [ m_GroupIDStackDepth ] ! = m_GroupIDStack [ m_GroupIDStackDepth + 1 ] & &
VTuneGroupEnabled ( ) & &
m_GroupIDStack [ m_GroupIDStackDepth + 1 ] = = VTuneGroupID ( ) )
{
vtune ( false ) ;
}
}
# endif // VPROF_VTUNE_GROUP
//-----------------------------------------------------------------------------
class CVProfScope
{
public :
CVProfScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted , int budgetFlags ) ;
~ CVProfScope ( ) ;
private :
bool m_bEnabled ;
} ;
//-----------------------------------------------------------------------------
//
// CVProfNode, inline methods
//
inline CVProfNode : : CVProfNode ( const tchar * pszName , int detailLevel , CVProfNode * pParent , const tchar * pBudgetGroupName , int budgetFlags )
: m_pszName ( pszName ) ,
m_nCurFrameCalls ( 0 ) ,
m_nPrevFrameCalls ( 0 ) ,
m_nRecursions ( 0 ) ,
m_pParent ( pParent ) ,
m_pChild ( NULL ) ,
m_pSibling ( NULL ) ,
m_iClientData ( - 1 )
# ifdef _X360
, m_iBitFlags ( 0 )
# endif
{
m_iUniqueNodeID = s_iCurrentUniqueNodeID + + ;
if ( m_iUniqueNodeID > 0 )
{
m_BudgetGroupID = g_VProfCurrentProfile . BudgetGroupNameToBudgetGroupID ( pBudgetGroupName , budgetFlags ) ;
}
else
{
m_BudgetGroupID = 0 ; // "m_Root" can't call BudgetGroupNameToBudgetGroupID because g_VProfCurrentProfile not yet initialized
}
Reset ( ) ;
if ( m_pParent & & ( m_BudgetGroupID = = VPROF_BUDGET_GROUP_ID_UNACCOUNTED ) )
{
m_BudgetGroupID = m_pParent - > GetBudgetGroupID ( ) ;
}
}
//-------------------------------------
inline CVProfNode * CVProfNode : : GetParent ( )
{
Assert ( m_pParent ) ;
return m_pParent ;
}
//-------------------------------------
inline CVProfNode * CVProfNode : : GetSibling ( )
{
return m_pSibling ;
}
//-------------------------------------
// Hacky way to the previous sibling, only used from vprof panel at the moment,
// so it didn't seem like it was worth the memory waste to add the reverse
// link per node.
inline CVProfNode * CVProfNode : : GetPrevSibling ( )
{
CVProfNode * p = GetParent ( ) ;
if ( ! p )
return NULL ;
CVProfNode * s ;
for ( s = p - > GetChild ( ) ;
s & & ( s - > GetSibling ( ) ! = this ) ;
s = s - > GetSibling ( ) )
;
return s ;
}
//-------------------------------------
inline CVProfNode * CVProfNode : : GetChild ( )
{
return m_pChild ;
}
//-------------------------------------
inline const tchar * CVProfNode : : GetName ( )
{
Assert ( m_pszName ) ;
return m_pszName ;
}
//-------------------------------------
inline int CVProfNode : : GetTotalCalls ( )
{
return m_nTotalCalls ;
}
//-------------------------------------
inline double CVProfNode : : GetTotalTime ( )
{
return m_TotalTime . GetMillisecondsF ( ) ;
}
//-------------------------------------
inline int CVProfNode : : GetCurCalls ( )
{
return m_nCurFrameCalls ;
}
//-------------------------------------
inline double CVProfNode : : GetCurTime ( )
{
return m_CurFrameTime . GetMillisecondsF ( ) ;
}
//-------------------------------------
inline int CVProfNode : : GetPrevCalls ( )
{
return m_nPrevFrameCalls ;
}
//-------------------------------------
inline double CVProfNode : : GetPrevTime ( )
{
return m_PrevFrameTime . GetMillisecondsF ( ) ;
}
//-------------------------------------
inline double CVProfNode : : GetPeakTime ( )
{
return m_PeakTime . GetMillisecondsF ( ) ;
}
//-------------------------------------
inline double CVProfNode : : GetTotalTimeLessChildren ( )
{
double result = GetTotalTime ( ) ;
CVProfNode * pChild = GetChild ( ) ;
while ( pChild )
{
result - = pChild - > GetTotalTime ( ) ;
pChild = pChild - > GetSibling ( ) ;
}
return result ;
}
//-------------------------------------
inline double CVProfNode : : GetCurTimeLessChildren ( )
{
double result = GetCurTime ( ) ;
CVProfNode * pChild = GetChild ( ) ;
while ( pChild )
{
result - = pChild - > GetCurTime ( ) ;
pChild = pChild - > GetSibling ( ) ;
}
return result ;
}
inline double CVProfNode : : GetPrevTimeLessChildren ( )
{
double result = GetPrevTime ( ) ;
CVProfNode * pChild = GetChild ( ) ;
while ( pChild )
{
result - = pChild - > GetPrevTime ( ) ;
pChild = pChild - > GetSibling ( ) ;
}
return result ;
}
//-----------------------------------------------------------------------------
inline int CVProfNode : : GetPrevL2CacheMissLessChildren ( )
{
int result = m_iPrevL2CacheMiss ;
CVProfNode * pChild = GetChild ( ) ;
while ( pChild )
{
result - = pChild - > m_iPrevL2CacheMiss ;
pChild = pChild - > GetSibling ( ) ;
}
return result ;
}
//-----------------------------------------------------------------------------
inline int CVProfNode : : GetPrevLoadHitStoreLessChildren ( )
{
# ifndef _X360
return 0 ;
# else
int result = m_iPrevLoadHitStores ;
CVProfNode * pChild = GetChild ( ) ;
while ( pChild )
{
result - = pChild - > m_iPrevLoadHitStores ;
pChild = pChild - > GetSibling ( ) ;
}
return result ;
# endif
}
//-----------------------------------------------------------------------------
inline void CVProfNode : : ClearPrevTime ( )
{
m_PrevFrameTime . Init ( ) ;
}
//-----------------------------------------------------------------------------
inline int CVProfNode : : GetL2CacheMisses ( void )
{
# ifndef _X360
return m_L2Cache . GetL2CacheMisses ( ) ;
# else
return m_iTotalL2CacheMiss ;
# endif
}
# ifdef _X360
inline int CVProfNode : : GetLoadHitStores ( void )
{
return m_iTotalLoadHitStores ;
}
# endif
//-----------------------------------------------------------------------------
//
// CVProfile, inline methods
//
//-------------------------------------
inline bool CVProfile : : IsEnabled ( ) const
{
return ( m_enabled ! = 0 ) ;
}
//-------------------------------------
inline int CVProfile : : GetDetailLevel ( ) const
{
return m_ProfileDetailLevel ;
}
//-------------------------------------
inline bool CVProfile : : AtRoot ( ) const
{
return m_fAtRoot ;
}
//-------------------------------------
inline void CVProfile : : Start ( )
{
if ( + + m_enabled = = 1 )
{
m_Root . EnterScope ( ) ;
# ifdef _X360
VXProfileStart ( ) ;
CPMCData : : InitializeOnceProgramWide ( ) ;
# endif
}
}
//-------------------------------------
inline void CVProfile : : Stop ( )
{
if ( - - m_enabled = = 0 )
m_Root . ExitScope ( ) ;
}
//-------------------------------------
inline void CVProfile : : EnterScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted , int budgetFlags )
{
if ( ( m_enabled ! = 0 | | ! m_fAtRoot ) & & InTargetThread ( ) ) // if became disabled, need to unwind back to root before stopping
{
// Only account for vprof stuff on the primary thread.
//if( !Plat_IsPrimaryThread() )
// return;
if ( pszName ! = m_pCurNode - > GetName ( ) )
{
m_pCurNode = m_pCurNode - > GetSubNode ( pszName , detailLevel , pBudgetGroupName , budgetFlags ) ;
}
m_pBudgetGroups [ m_pCurNode - > GetBudgetGroupID ( ) ] . m_BudgetFlags | = budgetFlags ;
# if defined( _DEBUG ) && !defined( _X360 )
// 360 doesn't want this to allow tier0 debug/release .def files to match
if ( bAssertAccounted )
{
// FIXME
AssertOnce ( m_pCurNode - > GetBudgetGroupID ( ) ! = 0 ) ;
}
# endif
m_pCurNode - > EnterScope ( ) ;
m_fAtRoot = false ;
}
# if defined(_X360) && defined(VPROF_PIX)
if ( m_pCurNode - > GetBudgetGroupID ( ) ! = VPROF_BUDGET_GROUP_ID_UNACCOUNTED )
PIXBeginNamedEvent ( 0 , pszName ) ;
# endif
}
inline void CVProfile : : EnterScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted )
{
EnterScope ( pszName , detailLevel , pBudgetGroupName , bAssertAccounted , BUDGETFLAG_OTHER ) ;
}
//-------------------------------------
inline void CVProfile : : ExitScope ( )
{
# if defined(_X360) && defined(VPROF_PIX)
# ifdef PIXBeginNamedEvent
# error
# endif
if ( m_pCurNode - > GetBudgetGroupID ( ) ! = VPROF_BUDGET_GROUP_ID_UNACCOUNTED )
PIXEndNamedEvent ( ) ;
# endif
if ( ( ! m_fAtRoot | | m_enabled ! = 0 ) & & InTargetThread ( ) )
{
// Only account for vprof stuff on the primary thread.
//if( !Plat_IsPrimaryThread() )
// return;
// ExitScope will indicate whether we should back up to our parent (we may
// be profiling a recursive function)
if ( m_pCurNode - > ExitScope ( ) )
{
m_pCurNode = m_pCurNode - > GetParent ( ) ;
}
m_fAtRoot = ( m_pCurNode = = & m_Root ) ;
}
}
//-------------------------------------
inline void CVProfile : : Pause ( )
{
m_pausedEnabledDepth = m_enabled ;
m_enabled = 0 ;
if ( ! AtRoot ( ) )
m_Root . Pause ( ) ;
}
//-------------------------------------
inline void CVProfile : : Resume ( )
{
m_enabled = m_pausedEnabledDepth ;
if ( ! AtRoot ( ) )
m_Root . Resume ( ) ;
}
//-------------------------------------
inline void CVProfile : : Reset ( )
{
m_Root . Reset ( ) ;
m_nFrames = 0 ;
}
//-------------------------------------
inline void CVProfile : : ResetPeaks ( )
{
m_Root . ResetPeak ( ) ;
}
//-------------------------------------
inline void CVProfile : : MarkFrame ( )
{
if ( m_enabled )
{
+ + m_nFrames ;
m_Root . ExitScope ( ) ;
m_Root . MarkFrame ( ) ;
m_Root . EnterScope ( ) ;
# ifdef _X360
// update the CPU trace state machine if enabled
switch ( GetCPUTraceMode ( ) )
{
case kAllNodesInFrame_WaitingForMark :
// mark! Start recording a zillion traces.
m_iCPUTraceEnabled = kAllNodesInFrame_Recording ;
break ;
case kAllNodesInFrame_WaitingForMarkMultiFrame :
m_iCPUTraceEnabled = kAllNodesInFrame_RecordingMultiFrame ;
break ;
case kAllNodesInFrame_Recording :
// end of frame. stop recording if no more frames needed
m_iCPUTraceEnabled = kDisabled ;
Msg ( " Frame ended. Recording no more CPU traces \n " ) ;
break ;
case kAllNodesInFrame_RecordingMultiFrame :
// end of frame. stop recording if no more frames needed
if ( - - m_nFramesRemaining = = 0 )
{
m_iCPUTraceEnabled = kDisabled ;
Msg ( " Frames ended. Recording no more CPU traces \n " ) ;
SpewWorstMultiFrame ( ) ;
}
+ + m_nFrameCount ;
break ;
default :
// no default
break ;
}
# endif
}
}
//-------------------------------------
inline double CVProfile : : GetTotalTimeSampled ( )
{
return m_Root . GetTotalTime ( ) ;
}
//-------------------------------------
inline double CVProfile : : GetPeakFrameTime ( )
{
return m_Root . GetPeakTime ( ) ;
}
//-------------------------------------
inline double CVProfile : : GetTimeLastFrame ( )
{
return m_Root . GetCurTime ( ) ;
}
//-------------------------------------
inline CVProfNode * CVProfile : : GetRoot ( )
{
return & m_Root ;
}
//-------------------------------------
inline CVProfNode * CVProfile : : GetCurrentNode ( )
{
return m_pCurNode ;
}
inline const tchar * CVProfile : : GetBudgetGroupName ( int budgetGroupID )
{
Assert ( budgetGroupID > = 0 & & budgetGroupID < m_nBudgetGroupNames ) ;
return m_pBudgetGroups [ budgetGroupID ] . m_pName ;
}
inline int CVProfile : : GetBudgetGroupFlags ( int budgetGroupID ) const
{
Assert ( budgetGroupID > = 0 & & budgetGroupID < m_nBudgetGroupNames ) ;
return m_pBudgetGroups [ budgetGroupID ] . m_BudgetFlags ;
}
# ifdef _X360
inline CVProfile : : CPUTraceState CVProfile : : GetCPUTraceMode ( )
{
return m_iCPUTraceEnabled ;
}
inline void CVProfile : : SetCPUTraceEnabled ( CPUTraceState enabled , bool bTraceCompleteEvent /*=true*/ , int nNumFrames /*= -1*/ )
{
m_iCPUTraceEnabled = enabled ;
m_bTraceCompleteEvent = bTraceCompleteEvent ;
if ( nNumFrames ! = - 1 )
{
m_nFramesRemaining = nNumFrames ;
m_nFrameCount = 0 ;
m_WorstCycles = 0 ;
m_WorstTraceFilename [ 0 ] = 0 ;
}
}
inline void CVProfile : : IncrementMultiTraceIndex ( )
{
+ + m_iSuccessiveTraceIndex ;
}
inline unsigned int CVProfile : : GetMultiTraceIndex ( )
{
return m_iSuccessiveTraceIndex ;
}
# endif
//-----------------------------------------------------------------------------
inline CVProfScope : : CVProfScope ( const tchar * pszName , int detailLevel , const tchar * pBudgetGroupName , bool bAssertAccounted , int budgetFlags )
: m_bEnabled ( g_VProfCurrentProfile . IsEnabled ( ) )
{
if ( m_bEnabled )
{
g_VProfCurrentProfile . EnterScope ( pszName , detailLevel , pBudgetGroupName , bAssertAccounted , budgetFlags ) ;
}
}
//-------------------------------------
inline CVProfScope : : ~ CVProfScope ( )
{
if ( m_bEnabled )
{
g_VProfCurrentProfile . ExitScope ( ) ;
}
}
class CVProfCounter
{
public :
CVProfCounter ( const tchar * pName , CounterGroup_t group = COUNTER_GROUP_DEFAULT )
{
m_pCounter = g_VProfCurrentProfile . FindOrCreateCounter ( pName , group ) ;
Assert ( m_pCounter ) ;
}
~ CVProfCounter ( )
{
}
void Increment ( int val )
{
Assert ( m_pCounter ) ;
* m_pCounter + = val ;
}
private :
int * m_pCounter ;
} ;
# endif
# ifdef _X360
# include "xbox/xbox_console.h"
# include "tracerecording.h"
# include "tier1/fmtstr.h"
# pragma comment( lib, "tracerecording.lib" )
# pragma comment( lib, "xbdm.lib" )
class CPIXRecorder
{
public :
CPIXRecorder ( ) : m_bActive ( false ) { }
~ CPIXRecorder ( ) { Stop ( ) ; }
void Start ( const char * pszFilename = " capture " )
{
if ( ! m_bActive )
{
if ( ! XTraceStartRecording ( CFmtStr ( " e: \\ %s.pix2 " , pszFilename ) ) )
{
Msg ( " XTraceStartRecording failed, error code %d \n " , GetLastError ( ) ) ;
}
else
{
m_bActive = true ;
}
}
}
void Stop ( )
{
if ( m_bActive )
{
m_bActive = false ;
if ( XTraceStopRecording ( ) )
{
Msg ( " CPU trace finished. \n " ) ;
// signal VXConsole that trace is completed
XBX_rTraceComplete ( ) ;
}
}
}
private :
bool m_bActive ;
} ;
# define VPROF_BEGIN_PIX_BLOCK( convar ) \
{ \
bool bRunPix = 0 ; \
static CFastTimer PIXTimer ; \
extern ConVar convar ; \
ConVar & PIXConvar = convar ; \
CPIXRecorder PIXRecorder ; \
{ \
PIXLabel : \
if ( bRunPix ) \
{ \
PIXRecorder . Start ( ) ; \
} \
else \
{ \
if ( PIXConvar . GetBool ( ) ) \
{ \
PIXTimer . Start ( ) ; \
} \
} \
{
# define VPROF_END_PIX_BLOCK() \
} \
\
if ( ! bRunPix ) \
{ \
if ( PIXConvar . GetBool ( ) ) \
{ \
PIXTimer . End ( ) ; \
if ( PIXTimer . GetDuration ( ) . GetMillisecondsF ( ) > PIXConvar . GetFloat ( ) ) \
{ \
PIXConvar . SetValue ( 0 ) ; \
bRunPix = true ; \
goto PIXLabel ; \
} \
} \
} \
else \
{ \
PIXRecorder . Stop ( ) ; \
} \
} \
}
# else
# define VPROF_BEGIN_PIX_BLOCK( PIXConvar ) {
# define VPROF_END_PIX_BLOCK() }
# endif
# ifdef VPROF_UNDO_PIX
# undef USE_PIX
# undef _PIX_H_
# undef PIXBeginNamedEvent
# undef PIXEndNamedEvent
# undef PIXSetMarker
# undef PIXNameThread
# include <pix.h>
# endif
# ifdef _MSC_VER
# pragma warning(pop)
# endif
# endif
//=============================================================================