WindowsXP-SP1/admin/snapin/dsadmin/profile.h

/*********************************************************************************
/* File:
/* 		PROFILE.H
/* Author:
/*		Max-H. Windisch, SDE-T
/* Date:
/*		October 1996
/* Macros:
/*		BEGIN_PROFILING_BLOCK
/*		END_PROFILING_BLOCK
/*		DUMP_PROFILING_RESULTS
/*		IMPLEMENT_PROFILING
/*		IMPLEMENT_PROFILING_CONDITIONAL
/* Classes:
/*		CMaxLargeInteger
/*		CMaxTimerAbstraction
/*		CMaxMiniProfiler_Node_Base
/*		CMaxMiniProfiler_Node_Standard
/*		CMaxMiniProfiler_Node_NoHistory
/*		CMaxMiniProfiler_Base
/*		CMaxMiniProfiler_Standard
/*		CMaxMiniProfiler_NoHistory
/*		CMaxMultithreadProfiler
/*		CMaxProfilingDLLWrapper
/*		CMaxProfilingObject
/*		CMaxProfilingBlockWrapper
/* Summary:
/*		This mini profiler allows you to place BEGIN_PROFILING_BLOCK and
/*		END_PROFILING_BLOCK directives in your code, or use the
/*		CMaxProfilingBlockWrapper object, and collect results
/*		in a logfile on termination of the profiled application (or by
/*		using the DUMP_PROFILING_RESULTS macro).  The
/*		profiling blocks can be nested.  Each module (DLL/EXE) using
/*		the profiler must use IMPLEMENT_PROFILING or 
/*		IMPLEMENT_PROFILING_CONDITIONAL exactly once (defines
/*		static variables for the profiler)
/* More details:
/*		The default result file is c:/result.txt.  It is not erased
/*		automatically.  For each completed instance of a profiler, it
/*		contains: 1) a header, 2) the history of all profiled blocks (optional),
/*		3) merged results.  For merging, results are sorted by {level, name}, 
/*		merged, then sorted again by {full name}.  Therefore, block names 
/*		must be unique.  In any case, absolute results are always
/*		given (in seconds)
/* How to enable in your code:
/*		To enable the profiler, define MAX_PROFILING_ENABLED before including
/*		this file.  To use the profiler through s:/ds/util/maxprof.dll 
/*		(built in release), define MAX_PROFILING_ENABLED_DLL instead.  This
/*		allows to use one single instance of a profiler from multiple
/*		modules
/* Other comments:
/*		At runtime, you can disable history output by defining the following
/*		environment variable to YES: MAX_DISABLE_PROFILING_HISTORY.
/*		In DLL mode, if you define MAX_PROFILING_CONDITIONAL before including
/*		this file, the profiler will work only if the following environment
/*		variable is defined to YES: MAX_ENABLE_PROFILING
/* Note:
/*		It's on purpose that I avoid using virtual methods here
/*		
/* (c) Copyright 1996 Microsoft-Softimage Inc.
/********************************************************************************/
#ifndef __MAX_PROFILING_H // {
#define __MAX_PROFILING_H

#include <afx.h> // for CTime and CString
#include <assert.h> // for asserts
#include <fstream.h> // for streams
#include <iomanip.h>

//#pragma warning( disable : 4786 ) // stl antivirus ;-)
//#include <dsstlmfc.h> // for STL

#define MAX_ENV_ENABLE_PROFILING _T( "MAX_ENABLE_PROFILING" )
#define MAX_ENV_DISABLE_PROFILING_HISTORY _T( "MAX_DISABLE_PROFILING_HISTORY" )
#define MAX_ENV_YES _T( "YES" )
#define MAX_ENV_ALL _T( "ALL" )

#if !defined( DS_ON_AXP ) && !defined( _NO_THROW )
#define MAXPROFNOTHROW __declspec( nothrow )
#else
#define MAXPROFNOTHROW
#endif

#define MAX_PROFTAGNODE_TOP "PROFILER: ALL"
#define MAX_PROFTAGNODE_HEAPALLOCATION "PROFILER: HEAPALLOCATION"
#define MAX_PROFTAGNODE_BIAS "PROFILER: BIAS"
#define MAX_PROFTAGNODE_NOTHINGNESS "PROFILER: NOTHINGNESS"

// Note: disable profiling in _SHIP (unless specified otherwise by DS_PROFILE_SHIP),
//		 and in unix (not sure why)
#if ( defined _SHIP && !defined DS_PROFILE_SHIP ) || defined unix
#undef MAX_PROFILING_ENABLED_DLL
#undef MAX_PROFILING_ENABLED
#endif





/*********************************************************************************
/* Macros:
/*		BEGIN_PROFILING_BLOCK
/*		END_PROFILING_BLOCK
/*		DUMP_PROFILING_RESULTS
/*		IMPLEMENT_PROFILING
/*		IMPLEMENT_PROFILING_CONDITIONAL
/* Comments:
/*		. For simplified use of CMaxMiniProfiler's.
/*		. For the comment parameter, use a non-unicode string, without "return"
/*		  character
/*		. For the enabler parameter, use a unicode string (the name of your
/*		  environment variable)
/*		. Use unique comments, since the profiler might use them as sorting keys
/*		. The use of DUMP_PROFILING_RESULTS is not compulsory, since profilings
/*		  are always dumped at the end of a profiling session
/********************************************************************************/
#ifndef unix
	#define __MAX_RESULTFILE_NAME "c:\\result.txt"
#else
	#define __MAX_RESULTFILE_NAME "result.txt"
#endif

#ifdef MAX_PROFILING_ENABLED_DLL
	#define __MAX_MINIPROFILER_IMPLEMENTATION ;
#else
	#define __MAX_MINIPROFILER_IMPLEMENTATION \
		const char *CMaxMiniProfiler_Base::s_poDefaultFileName = __MAX_RESULTFILE_NAME; \
		CMaxTimerAbstraction CMaxMiniProfiler_Base::s_oOutOfBraceBiasApproximation; \
		CMaxTimerAbstraction CMaxMiniProfiler_Base::s_oInOfBraceBiasApproximation; \
		bool CMaxMiniProfiler_Base::s_bBiasIsKnown = false; \
		unsigned long CMaxMiniProfiler_Base::s_lHeapBlockSize = 5000;
#endif

#if defined MAX_PROFILING_ENABLED || defined MAX_PROFILING_ENABLED_DLL // {{
	#define BEGIN_PROFILING_BLOCK( comment ) \
		CMaxProfilingObject::SCreateNewNode( comment );
	#define END_PROFILING_BLOCK \
		CMaxProfilingObject::SCloseCurrentNode();
	#define DUMP_PROFILING_RESULTS \
		CMaxProfilingObject::SDumpResults();
	#define IMPLEMENT_PROFILING \
		__MAX_MINIPROFILER_IMPLEMENTATION \
		CMaxProfilingObject::MPOProfiler CMaxProfilingObject::s_oProfiler; \
		CMaxProfilingObject::__CBiasApproximation CMaxProfilingObject::s_oBiasApproximation;
	#define IMPLEMENT_PROFILING_CONDITIONAL( enabler ) \
		__MAX_MINIPROFILER_IMPLEMENTATION \
		CMaxProfilingObject::MPOProfiler CMaxProfilingObject::s_oProfiler( enabler ); \
		CMaxProfilingObject::__CBiasApproximation CMaxProfilingObject::s_oBiasApproximation;
#else // }{
	#define BEGIN_PROFILING_BLOCK( comment ) ( void )( comment );
	#define END_PROFILING_BLOCK ;
	#define DUMP_PROFILING_RESULTS ;
	#define IMPLEMENT_PROFILING ;
	#define IMPLEMENT_PROFILING_CONDITIONAL( enabler ) ;
#endif // }}





#if defined MAX_PROFILING_ENABLED || defined MAX_PROFILING_ENABLED_DLL || defined MAX_PROFILING_DLL_IMPLEMENTATION // {
/*********************************************************************************
/* Helper function:
/*		bGIsEnabledEnvVar
/* Comments:
/********************************************************************************/
MAXPROFNOTHROW static inline bool bGIsEnabledEnvVar( 
	const TCHAR *pszEnvironmentVariableName,
	const TCHAR *pszCriteria = MAX_ENV_YES )
{
const int nLength = 80;
TCHAR szBuffer[ nLength ];
DWORD dwValue;

	// NULL string means enabled (default)
	if ( NULL == pszEnvironmentVariableName )
		return true;

	dwValue = ::GetEnvironmentVariable( 
		pszEnvironmentVariableName, szBuffer, nLength );
	if ( dwValue > 0 && _tcsicmp( szBuffer, pszCriteria ) == 0 )
		return true;

	return false;
};
#endif // }





#if defined MAX_PROFILING_ENABLED || defined MAX_PROFILING_DLL_IMPLEMENTATION // {
/*********************************************************************************
/* Class:
/*		CMaxLargeInteger
/* Comments:
/*		Minimal encapsulation of LARGE_INTEGER, considered as a time value
/********************************************************************************/
class CMaxLargeInteger
{
	protected:
		LARGE_INTEGER m_oValue;

	public:
		MAXPROFNOTHROW CMaxLargeInteger( LONG lHighPart = 0, DWORD dwLowPart = 0 )
		{
			m_oValue.u.HighPart = lHighPart;
			m_oValue.u.LowPart = dwLowPart;
		}

		MAXPROFNOTHROW CMaxLargeInteger( LONGLONG llQuadPart )
		{
			m_oValue.QuadPart = llQuadPart;
		}

		MAXPROFNOTHROW CMaxLargeInteger operator +( const CMaxLargeInteger &roAdded ) const
		{
			return CMaxLargeInteger( m_oValue.QuadPart + roAdded.m_oValue.QuadPart );
		}

		MAXPROFNOTHROW CMaxLargeInteger operator -( const CMaxLargeInteger &roSubstracted ) const
		{
			return CMaxLargeInteger( m_oValue.QuadPart - roSubstracted.m_oValue.QuadPart );
		}

		MAXPROFNOTHROW CMaxLargeInteger operator /( unsigned long lDivisor ) const
		{
			return CMaxLargeInteger( m_oValue.QuadPart / ( LONGLONG )lDivisor );
		}

		MAXPROFNOTHROW bool operator <( const CMaxLargeInteger &roCompared ) const
		{
			return m_oValue.QuadPart < roCompared.m_oValue.QuadPart;
		}

		MAXPROFNOTHROW operator LARGE_INTEGER*()
		{
			return &m_oValue;
		}

		MAXPROFNOTHROW LONG lFGetHighPart() const
		{
			return m_oValue.u.HighPart;
		}

		MAXPROFNOTHROW DWORD dwFGetLowPart() const
		{
			return m_oValue.u.LowPart;
		}

		MAXPROFNOTHROW double dFInSecondsF( const CMaxLargeInteger &roFreq ) const
		{
		const DWORD dwMaxDword = 0xffffffff;
		double highunit;
		
			assert( 0 == roFreq.m_oValue.u.HighPart && 0 != roFreq.m_oValue.u.LowPart );

			highunit = ( ( double )dwMaxDword + 1.0 ) / ( double )roFreq.m_oValue.u.LowPart;
			return ( ( ( double )m_oValue.u.HighPart * highunit ) + ( ( double )m_oValue.u.LowPart / roFreq.m_oValue.u.LowPart ) );
		}
};

MAXPROFNOTHROW inline ostream& operator<<( ostream &os, const CMaxLargeInteger &val )
{
	return os << "(" << ( unsigned long )val.lFGetHighPart() << ";" << ( unsigned long )val.dwFGetLowPart() << ")";
};





/*********************************************************************************
/* Class:
/*		CMaxTimerAbstraction
/* Comments:
/*		Defines the interface CMaxMiniProfiler's expect from any timer
/*		implementation
/********************************************************************************/
class CMaxTimerAbstraction
{
	protected:
		CMaxLargeInteger m_oTime;
		static const CMaxLargeInteger s_oFrequency;

	public:
		MAXPROFNOTHROW CMaxTimerAbstraction(){ /* assumed to zero its internal value */ }
		MAXPROFNOTHROW CMaxTimerAbstraction( int ){ ::QueryPerformanceCounter( m_oTime ); }
		MAXPROFNOTHROW CMaxTimerAbstraction( const CMaxTimerAbstraction &roSrc ) : m_oTime( roSrc.m_oTime ){}
		MAXPROFNOTHROW const CMaxTimerAbstraction& operator =( const CMaxTimerAbstraction &roSrc ){ m_oTime = roSrc.m_oTime; return *this; }

	protected:
		// Note: not part of the interface; for internal use only
		MAXPROFNOTHROW CMaxTimerAbstraction( const CMaxLargeInteger &roSrc ) : m_oTime( roSrc ){};

	public:
		MAXPROFNOTHROW void FLog()
		{
			::QueryPerformanceCounter( m_oTime );
		}

		MAXPROFNOTHROW double dFInSeconds() const
		{
			return m_oTime.dFInSecondsF( s_oFrequency );
		}

	public:
		MAXPROFNOTHROW void FAdd( const CMaxTimerAbstraction &roAdded )
		{
			m_oTime = m_oTime + roAdded.m_oTime;
		}

		MAXPROFNOTHROW void FSubstract( const CMaxTimerAbstraction &roSubstracted )
		{
#if 0
			// special case for negative differences - hide them
			if ( m_oTime < roSubstracted.m_oTime )
			{
				m_oTime = CMaxLargeInteger( 0, 1 );
				return;
			}
#endif

			m_oTime = m_oTime - roSubstracted.m_oTime;
		}

		MAXPROFNOTHROW void FDivide( unsigned long lDivisor )
		{
			m_oTime = m_oTime / lDivisor;
		}

	public:
		MAXPROFNOTHROW static CMaxTimerAbstraction oSSum( const CMaxTimerAbstraction &roArg1, const CMaxTimerAbstraction &roArg2 )
		{
		CMaxTimerAbstraction sum;

			sum.m_oTime = roArg1.m_oTime + roArg2.m_oTime;
			return sum;
		}

		MAXPROFNOTHROW static CMaxTimerAbstraction oSDifference( const CMaxTimerAbstraction &roArg1, const CMaxTimerAbstraction &roArg2 )
		{
		CMaxTimerAbstraction difference;

#if 0
			// special case for negative differences - hide them
			if ( roArg1.m_oTime < roArg2.m_oTime )
				return CMaxTimerAbstraction( CMaxLargeInteger( 0, 1 ) );
#endif

			difference.m_oTime = roArg1.m_oTime - roArg2.m_oTime;
			return difference;
		}

		MAXPROFNOTHROW static bool bSLess( const CMaxTimerAbstraction &roArg1, const CMaxTimerAbstraction &roArg2 )
		{
			return roArg1.m_oTime < roArg2.m_oTime;
		}

		MAXPROFNOTHROW static CMaxTimerAbstraction oSFrequency()
		{
			return CMaxTimerAbstraction( s_oFrequency );
		}

	private:
		MAXPROFNOTHROW static CMaxLargeInteger oSCentralFrequency()
		{
		CMaxLargeInteger frequency;

			::QueryPerformanceFrequency( frequency );
			return frequency;
		}

	friend ostream& operator<<( ostream &os, const CMaxTimerAbstraction &val );
};

MAXPROFNOTHROW inline ostream& operator<<( ostream &os, const CMaxTimerAbstraction &val )
{
	return os << val.m_oTime;
};






/*********************************************************************************
/* Class:
/*		CMaxMiniProfiler_Node_Base
/* Comments:
/*		Basic profiling node that behaves like a chronometer, and provides
/*		standard logging services.  Both the Standard and NoHistory profilers
/*		use this basic implementation
/********************************************************************************/
class CMaxMiniProfiler_Node_Base
{
	public:
		typedef CString MMPNBString;

	public:

		// comparison by index
		// -------------------

		class CCompareIndexes
		{
			public:
				MAXPROFNOTHROW bool operator()( const CMaxMiniProfiler_Node_Base &o1, const CMaxMiniProfiler_Node_Base &o2 ) const
				{
					assert( &o1 != &o2 );
					return ( o1.m_lIndex < o2.m_lIndex );
				};
		};
		friend CCompareIndexes;

	protected:

		// acquired at initialization
		// --------------------------

		unsigned long m_lLevel;
		const char *m_pszTitle;

		unsigned long m_lIndex;
		
		// internal time counting mechanism
		// --------------------------------

		CMaxTimerAbstraction m_taOrigin;
		CMaxTimerAbstraction m_taDelta;
		unsigned int m_nCount;
#ifdef _DEBUG
		bool m_bIsCounting;
#endif
		
		// for final output
		// ----------------

		double m_dDelta;

	public:

		// constructor etc.
		// ----------------
		// Note: uses default assignment and copy constructor
		// Note: it doesn't cost anything to initialize lots of things here - this
		//		 is not done within profiling braces

		MAXPROFNOTHROW CMaxMiniProfiler_Node_Base()
			: m_lLevel( 0 )
			, m_pszTitle( NULL )
			, m_lIndex( 0 )
			, m_nCount( 0 )
			, m_dDelta( 0 )
#ifdef _DEBUG
			, m_bIsCounting( false )
#endif
		{
		};

		// chrono
		// ------

		MAXPROFNOTHROW void FStart()
		{
#ifdef _DEBUG
			assert( !m_bIsCounting );
			m_taOrigin.FLog();
			m_nCount++;
			m_bIsCounting = true;
#else
			m_taOrigin.FLog();
			m_nCount++;
#endif
		};

		MAXPROFNOTHROW void FStop()
		{
		CMaxTimerAbstraction destination( 1 );

#ifdef _DEBUG
			assert( m_bIsCounting );
			m_taDelta.FAdd( CMaxTimerAbstraction::oSDifference( destination, m_taOrigin ) );
			m_bIsCounting = false;
#else
			m_taDelta.FAdd( CMaxTimerAbstraction::oSDifference( destination, m_taOrigin ) );
#endif
		};

		// access to members
		// -----------------

		MAXPROFNOTHROW unsigned long lFGetLevel() const { return m_lLevel; };
		MAXPROFNOTHROW const char *pszFGetTitle() const { return m_pszTitle; };
		MAXPROFNOTHROW unsigned long lFGetIndex() const { return m_lIndex; };
		MAXPROFNOTHROW const CMaxTimerAbstraction &roFGetOrigin() const { return m_taOrigin; };
		MAXPROFNOTHROW CMaxTimerAbstraction &roFGetDelta() { return m_taDelta; };
		MAXPROFNOTHROW unsigned int nFGetCount() const { return m_nCount; };

		MAXPROFNOTHROW double dFGetDelta()
		{
			if ( 0 == m_dDelta )
				FComputeDelta();
			return m_dDelta;
		};

		// misc. services
		// --------------

		MAXPROFNOTHROW bool bFIsIn( const CMaxMiniProfiler_Node_Base &roNode ) const
		{
			// Note: times cannot be equal, so we don't need to worry about that
			if ( CMaxTimerAbstraction::bSLess( m_taOrigin, roNode.m_taOrigin ) )
			{
			CMaxTimerAbstraction d1 = m_taOrigin;
			CMaxTimerAbstraction d2 = roNode.m_taOrigin;

				d1.FAdd( m_taDelta );
				d2.FAdd( roNode.m_taDelta );
				if ( CMaxTimerAbstraction::bSLess( d2, d1 ) )
					return true;
			}
			return false;
		};

		MAXPROFNOTHROW void FConditionalRemove( const CMaxMiniProfiler_Node_Base &roNode, const CMaxTimerAbstraction &roBias )
		{
			if ( bFIsIn( roNode ) )
			{
				CMaxTimerAbstraction d = roNode.m_taDelta;
				d.FAdd( roBias );
				m_taDelta.FSubstract( d );
			}
		};

		// output to file
		// --------------

		void FOutput( ostream &os )
		{
			// don't output dead (merged) nodes
			if ( 0 == m_nCount )
				return;

			// output our index
			os << setw( 10 ) << m_lIndex << ": ";

			// indent
			STab( os, m_lLevel );

			// output our title
			os << "@@Name=";
			if ( NULL != m_pszTitle )
				os << m_pszTitle;

			// output our block count
			os << " @@Count=" << m_nCount;

			// output our delta t
			os << " @@Duration=";
			SStampDeltaInSeconds( os, dFGetDelta() );
		};

		void FStampAbsoluteRange( ostream &os ) const
		{
			SStampAbsoluteRange( os, m_taOrigin, m_taDelta );
		};

	protected:

		// computations at output time (outside of profiling)
		// --------------------------------------------------

		MAXPROFNOTHROW void FComputeDelta()
		{
			m_dDelta = m_taDelta.dFInSeconds();
		};

	public:

		// mini helpers for facilitated and standardized output of results
		// ---------------------------------------------------------------

		static ostream& STab( ostream &os, int level )
		{
			for ( int i = 0; i < level; i++ )
				os << " ";
			return os;
		};

		static ostream& SStampDeltaInSeconds( ostream &os, double delta )
		{
			os << delta << "s";
			return os;
		};

		static ostream& SStampAbsoluteRange( ostream &os, const CMaxTimerAbstraction &rO, const CMaxTimerAbstraction &rD )
		{
			os << "[origin" << rO;
			os << ",duration" << rD << "]";
			return os;
		};
};





/*********************************************************************************
/* Classes:
/*		CMaxMiniProfiler_Node_Standard
/* Comments:
/********************************************************************************/
class CMaxMiniProfiler_Node_Standard
	: public CMaxMiniProfiler_Node_Base
{
	public:

		// comparison by full titles
		// -------------------------

		class CCompareFullTitles
		{
			public:
				MAXPROFNOTHROW bool operator()( const CMaxMiniProfiler_Node_Standard &o1, const CMaxMiniProfiler_Node_Standard &o2 ) const
				{
					assert( &o1 != &o2 );
					return ( o1.m_oFullTitle < o2.m_oFullTitle );
				};
		};
		friend CCompareFullTitles;

		// comparison for node merging (a) level, b) full title, c) index)
		// ---------------------------------------------------------------

		class CCompareForNodeMerging
		{
			public:
				MAXPROFNOTHROW bool operator()( const CMaxMiniProfiler_Node_Standard &o1, const CMaxMiniProfiler_Node_Standard &o2 ) const
				{
					assert( &o1 != &o2 );

					if ( o1.m_lLevel < o2.m_lLevel )
						return true;
					else if ( o1.m_lLevel == o2.m_lLevel )
					{
						if ( o1.m_oFullTitle < o2.m_oFullTitle )
							return true;
						else if ( o1.m_oFullTitle == o2.m_oFullTitle )
						{
							if ( o1.m_lIndex < o2.m_lIndex )
								return true;
						}
					}

					return false;
				};
		};
		friend CCompareForNodeMerging;

		// for the unique algorithm; modifies the parameters
		// -------------------------------------------------

		class CMergeSimilarNodes
		{
			public:
				MAXPROFNOTHROW bool operator()( CMaxMiniProfiler_Node_Standard &o1, CMaxMiniProfiler_Node_Standard &o2 )
				{
					assert( &o1 != &o2 );

					if ( ( o1.m_lLevel == o2.m_lLevel ) && 
						( o1.m_oFullTitle == o2.m_oFullTitle ) )
					{
						if ( o1.m_nCount > 0 && o2.m_nCount > 0 )
						{
						CMaxMiniProfiler_Node_Standard &kept = ( o1.m_lIndex < o2.m_lIndex ) ? o1 : o2;
						CMaxMiniProfiler_Node_Standard &thrown = ( o1.m_lIndex < o2.m_lIndex ) ? o2 : o1;

							kept.m_nCount++;
							kept.m_taDelta.FAdd( thrown.m_taDelta );
							kept.m_dDelta = 0;
		
							thrown.m_nCount = 0;
							thrown.m_taDelta = CMaxTimerAbstraction();
							thrown.m_dDelta = 0;
						}

						return true;
					}

					return false;
				};
		};
		friend CMergeSimilarNodes;

	protected:

		MMPNBString m_oFullTitle;

	public:

		// initialization
		// --------------

		MAXPROFNOTHROW void FInitialize( unsigned long lLevel, const char *pszTitle )
		{
			m_lLevel = lLevel;
			m_pszTitle = pszTitle;
		};

		MAXPROFNOTHROW void FIndex( unsigned long lIndex )
		{
			m_lIndex = lIndex;
		};

		MAXPROFNOTHROW void FSetFullTitle( const MMPNBString &roFullTitle )
		{
			m_oFullTitle = roFullTitle;
		};

		// access to members
		// -----------------

		MAXPROFNOTHROW const MMPNBString &roFGetFullTitle() const { return m_oFullTitle; };
};





/*********************************************************************************
/* Class:
/*		CMaxMiniProfiler_Node_NoHistory
/* Comments:
/********************************************************************************/
class CMaxMiniProfiler_Node_NoHistory
	: public CMaxMiniProfiler_Node_Base
{
	public:

		// unique key to a profiler node
		// -----------------------------

		class CKey
		{
			public:
				unsigned long m_lLevel;
				ULONG_PTR m_lCheckSum;
				const char *m_pszTitle;

			public:
				MAXPROFNOTHROW CKey(
					unsigned long lLevel = 0,
					const char *pszTitle = NULL,
					ULONG_PTR lCheckSum = 0 )
					: m_lLevel( lLevel )
					, m_lCheckSum( lCheckSum )
					, m_pszTitle( pszTitle )
				{
				};
		};

		// comparison of unique keys
		// -------------------------

		class CCompareKeys
		{
			public:
				MAXPROFNOTHROW bool operator()( const CKey &o1, const CKey &o2 ) const
				{
					assert( &o1 != &o2 );
					if ( o1.m_lLevel < o2.m_lLevel )
						return true;
					else if ( o1.m_lLevel == o2.m_lLevel )
					{
						if ( o1.m_pszTitle < o2.m_pszTitle )
							return true;
						else if ( o1.m_pszTitle == o2.m_pszTitle )
						{
							if ( o1.m_lCheckSum < o2.m_lCheckSum )
								return true;
						}
					}

					return false;
				};
		};

	protected:

		CMaxTimerAbstraction m_oInternalOverhead;
		ULONG_PTR m_lCheckSum;

	public:

		MAXPROFNOTHROW CMaxMiniProfiler_Node_NoHistory()
			: CMaxMiniProfiler_Node_Base()
			, m_lCheckSum( 0 )
		{
		};

		// initialization
		// --------------

		MAXPROFNOTHROW void FInitialize( 
			unsigned long lLevel, 
			const char *pszTitle, 
			unsigned long lIndex, 
			const CMaxTimerAbstraction oInternalOverhead )
		{
			if ( 0 == m_lIndex )
			{
				m_lLevel = lLevel;
				m_pszTitle = pszTitle;
				m_lIndex = lIndex;
			}
#ifdef _DEBUG
			else
			{
				assert( lLevel == m_lLevel );
				assert( pszTitle == m_pszTitle );
			}
#endif
			m_oInternalOverhead.FAdd( oInternalOverhead );
		};

		MAXPROFNOTHROW void FSetCheckSum( 
			ULONG_PTR lCheckSum )
		{
			m_lCheckSum = lCheckSum;
		};

		// access to members
		// -----------------

		MAXPROFNOTHROW const CMaxTimerAbstraction &roFGetInternalOverhead() const { return m_oInternalOverhead; };
		MAXPROFNOTHROW ULONG_PTR lFGetCheckSum() const { return m_lCheckSum; };
};





/*********************************************************************************
/* Class:
/*		CMaxMiniProfiler_Base
/* Comments:
/********************************************************************************/
class CMaxMiniProfiler_Base
{
	protected:
		// output file name
		const char *m_poFileName;

		// internal info
		DWORD m_dwThreadId;
		CTime m_oStartTimeOfProfilings;

	protected:
		// Note: the lock in CMaxMultithreadProfiler takes care of protecting
		//		 the static data below in multithread mode

		// default values for initialization
		static const char *s_poDefaultFileName;
		static unsigned long s_lHeapBlockSize;

		// BIAS values
		static CMaxTimerAbstraction s_oOutOfBraceBiasApproximation;
		static CMaxTimerAbstraction s_oInOfBraceBiasApproximation;
		static bool s_bBiasIsKnown;

	public:

		// constructor / destructor
		// ------------------------
		
		CMaxMiniProfiler_Base(
			const TCHAR * = NULL )
			: m_poFileName( s_poDefaultFileName )
			, m_dwThreadId( ::GetCurrentThreadId() )
			, m_oStartTimeOfProfilings( CTime::GetCurrentTime() )
		{
		};

		~CMaxMiniProfiler_Base()
		{
		};

		// locking - public interface
		// --------------------------

		void FLockProfiler(){};
		void FUnlockProfiler(){};

		// bias approximation
		// ------------------
		// Note: the result of this operation is used at output time uniquely

		bool bFIsBiasKnown() const { return s_bBiasIsKnown; };

	protected:

		// for final output
		// ----------------

		void FOutputEmptySession()
		{
			// open the output file
			ofstream os( m_poFileName, ios::out | ios::ate );

			// just stamp a message saying that there was nothing to profile
			CTime t = CTime::GetCurrentTime();
			os << endl;
			os << "PROFILER INSTANTIATED THE ";
			os << t.GetYear() << "/" << t.GetMonth() << "/" << t.GetDay() << " BETWEEN ";
			SStampCTime( os, m_oStartTimeOfProfilings ) << " AND ";
			SStampCTime( os, t ) << " WAS NOT USED." << endl;
		};

		void FOutputHeaderCore( 
			ostream &os, 
			unsigned long lNumberOfOpenNodes,
			const CMaxMiniProfiler_Node_Base &roRootNode,
			unsigned long lTotalNumberOfNodes )
		{
			// stamp the current time in our logfile
			CTime t = CTime::GetCurrentTime();
			os << endl;
			os << "***************************" << endl;
			os << "*** @@ProfilingDate=" << t.GetYear() << "/" << t.GetMonth() << "/" << t.GetDay() << endl;
			os << "*** @@ProfilingStartTime=";
			SStampCTime( os, m_oStartTimeOfProfilings ) << endl;
			os << "*** @@ProfilingEndTime=";
			SStampCTime( os, t ) << endl;
			os << "*** @@ProfilingRange=";
			roRootNode.FStampAbsoluteRange( os );
			os << endl;
			if ( 0 != lNumberOfOpenNodes )
				os << "*** "<< lNumberOfOpenNodes << " NODES WERE NOT CLOSED BY THE USER" << endl;
			os << "***************************" << endl;

			// output the counter's frequency and thread id
			os << "*** @@CounterFrequency=" << CMaxTimerAbstraction::oSFrequency() << endl;
			os << "*** @@ThreadId=" << ( unsigned long )m_dwThreadId << endl;

			// output the profiler's finest possible unit of measurement
			CMaxTimerAbstraction origin( 1 ), destination( 1 );
			CMaxTimerAbstraction delta( CMaxTimerAbstraction::oSDifference( destination, origin ) );
			os << "*** @@FinestMeasurement=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, delta.dFInSeconds() ) << "=" << delta << endl;

			// output the profiler's approximated bias
			assert( s_bBiasIsKnown );
			os << "*** @@OutsideBias=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, s_oOutOfBraceBiasApproximation.dFInSeconds() ) << endl;
			os << "*** @@InsideBias=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, s_oInOfBraceBiasApproximation.dFInSeconds() ) << endl;

			// output the total number of blocks
			os << "*** @@TotalNumberOfBlocks=" << lTotalNumberOfNodes << endl;
		};

		void FOutputMergedSectionHeader( ostream &os ) const
		{
			os << "*** @@MergedResults=" << endl;
		};

		bool bFHistoryOutputDisabled() const
		{
			return bGIsEnabledEnvVar( MAX_ENV_DISABLE_PROFILING_HISTORY );
		};

	public:
		static ostream& SStampCTime( ostream &os, const CTime &roTime )
		{
			os << roTime.GetHour() << ":" << roTime.GetMinute() << ":" << roTime.GetSecond();
			return os;
		};

	private:
		CMaxMiniProfiler_Base( const CMaxMiniProfiler_Base &o );
		const CMaxMiniProfiler_Base& operator =( const CMaxMiniProfiler_Base & );
};





/*********************************************************************************
/* Functions:
/*		GOutputProfilings
/*		lGGetNumberOfProfilingSubNodes
/*		lGDetermineMaxLevelOfProfilings
/*		GRemoveInAndOutBiasFromProfilingNodes
/* Comments:
/*		Done this way to avoid virtuals at node level (and to have common
/*		output code for Standard and NoHistory profilers)
/********************************************************************************/
template <class TVectorItem>
void GOutputProfilings( 
	ostream &os, 
	std::vector<TVectorItem> &roProfilings,
	unsigned long lMaxLevel,
	double dPrecisionThreshold,
	bool bOutputAbsoluteTimeRange )
{
std::vector<TVectorItem>::iterator i;
std::vector<TVectorItem>::size_type n;
std::vector<std::vector<TVectorItem>::size_type> parents( 1 + lMaxLevel );

	parents[ 0 ] = 0;
	
	for ( i = roProfilings.begin(), n = 0; roProfilings.end() != i; i++, n++ )
	{
		// signal the validity of the node
		assert( 0 != ( *i ).nFGetCount() );
		os << ( ( ( ( *i ).dFGetDelta() / ( *i ).nFGetCount() ) < dPrecisionThreshold ) ? "X" : " " );

		// output the node
		( *i ).FOutput( os );

		// register it as the last parent of its level
		long currentlevel = ( *i ).lFGetLevel();
		parents[ currentlevel ] = n;

		// output the % for all parents of the node
		os << " @@PERCENT=";
		double deltat = ( *i ).dFGetDelta();
		for ( long j = currentlevel - 1; j >= 0; j-- )
			os << 100.0 * deltat / roProfilings[ parents[ j ] ].dFGetDelta() << "% ";

		// output the time range in units
		if ( bOutputAbsoluteTimeRange )
		{
			os << " @@Range=";
			( *i ).FStampAbsoluteRange( os );
		}

		// finish output for this node
		os << endl;
	}
};

template <class TVectorItem, class TVectorIterator>
unsigned long lGGetNumberOfProfilingSubNodes( 
	const std::vector<TVectorItem> &roProfilings,
	TVectorIterator &roOrg )
{
unsigned long level = ( *roOrg ).lFGetLevel();
unsigned long n;
TVectorIterator i = roOrg;
	
	i++;
	for ( n = 0; roProfilings.end() != i; i++, n++ )
		if ( ( *i ).lFGetLevel() <= level )
			break;

	return n;
};

template <class TVectorItem>
unsigned long lGDetermineMaxLevelOfProfilings(
	const std::vector<TVectorItem> &roProfilings )
{
unsigned long l = 0;
std::vector<TVectorItem>::const_iterator i;

	for ( i = roProfilings.begin(); roProfilings.end() != i; i++ )
		if ( ( *i ).lFGetLevel() > l )
			l = ( *i ).lFGetLevel();

	return l;
};

template <class TVectorItem>
void GRemoveInAndOutBiasFromProfilingNodes(
	std::vector<TVectorItem> &roProfilings,
	const CMaxTimerAbstraction &roOutOfBraceBiasApproximation,
	const CMaxTimerAbstraction &roInOfBraceBiasApproximation )
{
std::vector<TVectorItem>::iterator i;
unsigned long t, k;

	for ( i = roProfilings.begin(); roProfilings.end() != i; i++ )
	{
		CMaxTimerAbstraction &rtaDelta = ( *i ).roFGetDelta();
		t = ::lGGetNumberOfProfilingSubNodes( roProfilings, i );
		for ( k = 0; k < t; k++ )
			rtaDelta.FSubstract( roOutOfBraceBiasApproximation );
		for ( k = 0; k < t + 1; k++ )
			rtaDelta.FSubstract( roInOfBraceBiasApproximation );
	}
};





/*********************************************************************************
/* Class:
/*		CMaxMiniProfiler_Standard
/* Comments:
/********************************************************************************/
class CMaxMiniProfiler_Standard
	: public CMaxMiniProfiler_Base
{
	protected:
		typedef std::vector<CMaxMiniProfiler_Node_Standard> MMPNodes;
		typedef MMPNodes::size_type MMPNodesRandomAccess;
		typedef std::vector<MMPNodesRandomAccess> MMPNodesReferences;
		typedef std::stack<MMPNodesRandomAccess, MMPNodesReferences> MMPStack;
		typedef MMPStack::size_type MMPStackSizeType;

	protected:
		// profiling nodes
		MMPNodes m_oProfilings;
		MMPNodesRandomAccess m_oLastNode;
		
		// stack for nested blocks
		MMPStack m_oStack;

		// heap acquisition timings
		MMPNodes m_oHeapAcquisitionTimings;

	public:

		// constructor / destructor
		// ------------------------
		
		CMaxMiniProfiler_Standard(
			const TCHAR *pszSpecificEnabler = NULL )
			: CMaxMiniProfiler_Base( pszSpecificEnabler )
			, m_oProfilings( 0 )
			, m_oLastNode( 0 )
			, m_oHeapAcquisitionTimings( 0 )
		{
			FInitDumpingSession();
		};

		~CMaxMiniProfiler_Standard()
		{
			FDumpSession();
			FTermDumpingSession();
		};

		// dumping results - public interface
		// ----------------------------------

		void FDumpResults( bool bForced = false, bool = true )
		{
			if ( !bForced )
			{
				// can dump results only when all profiling nodes are closed
				// (except the main one); we don't want to artificially close the nodes 
				// here at this point
				if ( 1 != m_oStack.size() )
				{
					assert( false );
					return;
				}
			}

			// dump
			FDumpSession();
			FTermDumpingSession();

			// prepare for next dump
			FInitDumpingSession();
		};

		// profiling nodes generation
		// --------------------------
		// Note: FCreateNewNode and FCloseCurrentNode are meant to be as fast as possible;
		//		 also, the bracket between FStart and FStop is as small as possible

		void FCreateNewNode( const char *pszTitle )
		{
			assert( ( 0 == m_oStack.size() ) || ( ::GetCurrentThreadId() == m_dwThreadId ) );

			if ( m_oProfilings.size() == m_oLastNode )
				FReserveMoreHeap();

			// Note: this is time constant
			m_oStack.push( m_oLastNode );
			CMaxMiniProfiler_Node_Standard &roNode = m_oProfilings[ m_oLastNode++ ];
			roNode.FInitialize( static_cast<ULONG>(m_oStack.size()) - 1, pszTitle );
			roNode.FStart();
		};

		void FCloseCurrentNode()
		{
			assert( ( 1 == m_oStack.size() ) || ( ::GetCurrentThreadId() == m_dwThreadId ) );

			// Note: this is time constant
			if ( m_oStack.size() > 0 )
			{
				m_oProfilings[ m_oStack.top() ].FStop();
				m_oStack.pop();
			}
			else
				assert( false );
		};

		// bias approximation
		// ------------------
		// Note: the result of this operation is used at output time uniquely

		void FSetBiasApproximationFrom( unsigned long lBiasSample )
		{
		unsigned int i;

			assert( !s_bBiasIsKnown );

			// Note: this function should be called immediately after having created 
			//		 1 BIAS (b) node
			//		 and x NOTHINGNESS (N) subnodes (n1 ... nx),
			//		 where x = lBiasSample
			assert( m_oLastNode > 1 + lBiasSample );
			
			// our out of brace bias is equal to (b - (n1 + n2 + ... + nx)) / x
			s_oOutOfBraceBiasApproximation = m_oProfilings[ m_oLastNode - ( 1 + lBiasSample ) ].roFGetDelta();
			for ( i = lBiasSample; i > 0; i-- )
				s_oOutOfBraceBiasApproximation.FSubstract( m_oProfilings[ m_oLastNode - i ].roFGetDelta() );
			s_oOutOfBraceBiasApproximation.FDivide( lBiasSample );

			// our in of brace bias is equal to ((n1 + n2 + ... + nx) - N.x) / x
			// Note: on purpose, we re-evaluate N as many times as there are samples
			s_oInOfBraceBiasApproximation = CMaxTimerAbstraction();
			CMaxTimerAbstraction delta;
			for ( i = lBiasSample; i > 0; i-- )
			{
				CMaxTimerAbstraction origin( 1 ), destination( 1 );
				delta.FAdd( CMaxTimerAbstraction::oSDifference( destination, origin ) );
				s_oInOfBraceBiasApproximation.FAdd( m_oProfilings[ m_oLastNode - i ].roFGetDelta() );
			}
			s_oInOfBraceBiasApproximation.FSubstract( delta );
			s_oInOfBraceBiasApproximation.FDivide( lBiasSample );

#if 1
			// remove those BIAS and NOTHINGNESS nodes from the profiler's output nodes
			MMPNodes::iterator iter;
			MMPNodesRandomAccess n;
			for ( iter = m_oProfilings.begin(), n = 0; ( m_oProfilings.end() != iter ) && ( n < m_oLastNode - ( 1 + lBiasSample ) ); iter++, n++ );
			std::fill( iter, m_oProfilings.end(), CMaxMiniProfiler_Node_Standard() );
			m_oLastNode -= ( 1 + lBiasSample );
#endif

			s_bBiasIsKnown = true;
		};

	protected:

		// dumping session management
		// --------------------------

		void FInitDumpingSession()
		{
			// prepare some heap
			FReserveMoreHeap();

			// put a main node
			FCreateNewNode( MAX_PROFTAGNODE_TOP );

			// verify that we start cleanly
			assert( 1 == m_oStack.size() );
			assert( 0 == m_oStack.top() );
		};

		void FDumpSession()
		{
		MMPStackSizeType lNumberOfOpenNodes;

			// terminate our main node
			FCloseCurrentNode();

			// make sure all nodes are closed
			lNumberOfOpenNodes = m_oStack.size();
			while ( !m_oStack.empty() )
				FCloseCurrentNode();

			if ( m_oLastNode > 1 )
			{
			unsigned long lMaxLevel;

				// final trimming and initializations
				FTrimProfilings();
				FIndexProfilings();
				lMaxLevel = ::lGDetermineMaxLevelOfProfilings( m_oProfilings );
				FComputeFullTitles( lMaxLevel );

				// open the output file
				ofstream os( m_poFileName, ios::out | ios::ate );

				// output the raw profilings
				FOutputHeader( os, lNumberOfOpenNodes );
				if ( !bFHistoryOutputDisabled() )
					FOutputProfilings( os, true, lMaxLevel );

				// merge nodes and output merged results
				FMergeProfilings();
				FOutputMergedSectionHeader( os );
				FOutputProfilings( os, false, lMaxLevel );
			}
			else
				FOutputEmptySession();
		};

		void FTermDumpingSession()
		{
			while ( !m_oStack.empty() )
				m_oStack.pop();

			m_oLastNode = 0;
			
			m_oProfilings.erase( m_oProfilings.begin(), m_oProfilings.end() );
			m_oHeapAcquisitionTimings.erase( m_oHeapAcquisitionTimings.begin(), m_oHeapAcquisitionTimings.end() );
		};

	protected:

		// for final output
		// ----------------

		void FOutputHeader( ostream &os, MMPStackSizeType lNumberOfOpenNodes )
		{
			FOutputHeaderCore( os, static_cast<ULONG>(lNumberOfOpenNodes), m_oProfilings[ 0 ], static_cast<ULONG>(m_oLastNode) );
			
			// output the total number of heap allocations
			double dTotalTimeInAllocations = m_oHeapAcquisitionTimings[ 0 ].dFGetDelta();
			for ( MMPNodes::iterator i = m_oHeapAcquisitionTimings.begin(); m_oHeapAcquisitionTimings.end() != i; i++ )
				dTotalTimeInAllocations += ( *i ).dFGetDelta();
			os << "*** @@TotalNumberOfHeapAllocations=" << static_cast<ULONG>(m_oHeapAcquisitionTimings.size()) << "=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, dTotalTimeInAllocations ) << endl;

			// output the total profiling overhead
			double dTotalOverhead = 
				( ( double )( m_oLastNode - 1.0 ) * s_oOutOfBraceBiasApproximation.dFInSeconds() ) + 
				( ( double )m_oLastNode * s_oInOfBraceBiasApproximation.dFInSeconds() );
			double dTotalOverheadPercent = 
				100.0 * ( dTotalOverhead / ( dTotalOverhead + m_oProfilings[ 0 ].dFGetDelta() ) );
			os << "*** @@TotalProfilerOverhead=" << dTotalOverheadPercent << "%=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, dTotalOverhead ) << endl;

			// that's it
			os << "***************************" << endl;
			os << "*** @@History=" << endl;
		};

		void FOutputProfilings( ostream &os, bool bOutputAbsoluteTimeRange, unsigned long lMaxLevel )
		{
		double dPrecisionThreshold = 2.0 * ( s_oOutOfBraceBiasApproximation.dFInSeconds() + s_oInOfBraceBiasApproximation.dFInSeconds() );

			::GOutputProfilings( os, m_oProfilings, lMaxLevel, dPrecisionThreshold, bOutputAbsoluteTimeRange );
		};

		// final management of profiling nodes
		// -----------------------------------

		void FTrimProfilings()
		{
		MMPNodes::iterator i, j;
		MMPNodesRandomAccess n;

			// find the iterator that corresponds to the last node
			for ( i = m_oProfilings.begin(), n = 0; ( m_oProfilings.end() != i ) && ( n < m_oLastNode ); i++, n++ );

			// remove uninitialized nodes
			m_oProfilings.erase( i, m_oProfilings.end() );

			// remove heap allocation timings from affected nodes
			for ( i = m_oHeapAcquisitionTimings.begin(); m_oHeapAcquisitionTimings.end() != i; i++ )
				for ( j = m_oProfilings.begin(); m_oProfilings.end() != j; j++ )
					( *j ).FConditionalRemove( *i, s_oOutOfBraceBiasApproximation );

			// remove from nodes the profiling bias
			::GRemoveInAndOutBiasFromProfilingNodes( 
				m_oProfilings, s_oOutOfBraceBiasApproximation, s_oInOfBraceBiasApproximation );
		};

		void FIndexProfilings()
		{
		MMPNodes::iterator i;
		unsigned long n;

			for ( i = m_oProfilings.begin(), n = 1; m_oProfilings.end() != i; i++, n++ )
				( *i ).FIndex( n );
		};

		void FComputeFullTitles( unsigned long lMaxLevel )
		{
		MMPNodes::iterator i;
		MMPNodesRandomAccess j, n;
		MMPNodesReferences parents( 1 + lMaxLevel );

			parents[ 0 ] = 0;
			
			for ( i = m_oProfilings.begin(), n = 0; m_oProfilings.end() != i; i++, n++ )
			{
				// register the node as the last parent of its level
				unsigned long currentlevel = ( *i ).lFGetLevel();
				parents[ currentlevel ] = n;

				// compute the iterated node's full title
				CMaxMiniProfiler_Node_Base::MMPNBString fulltitle;
				for ( j = 0; j <= currentlevel; j++ )				
					fulltitle += CMaxMiniProfiler_Node_Base::MMPNBString( m_oProfilings[ parents[ j ] ].pszFGetTitle() );
				( *i ).FSetFullTitle( fulltitle );
			}
		};

		void FMergeProfilings()
		{
		MMPNodes::iterator i;

			// sort by level/name/index
			std::sort( m_oProfilings.begin(), m_oProfilings.end(), CMaxMiniProfiler_Node_Standard::CCompareForNodeMerging() );

			// merge the nodes that have same level/name
			i = std::unique( m_oProfilings.begin(), m_oProfilings.end(), CMaxMiniProfiler_Node_Standard::CMergeSimilarNodes() );
			m_oProfilings.erase( i, m_oProfilings.end() );

			// sort by full name
			std::sort( m_oProfilings.begin(), m_oProfilings.end(), CMaxMiniProfiler_Node_Standard::CCompareFullTitles() );
		};

	protected:

		// heap management
		// ---------------

		void FReserveMoreHeap()
		{
		CMaxMiniProfiler_Node_Standard node;

			// log the time we used to generate new heap
			node.FStart();
			node.FInitialize( 0, MAX_PROFTAGNODE_HEAPALLOCATION );

			// reserve a new chunk of nodes
			m_oProfilings.reserve( m_oProfilings.size() + s_lHeapBlockSize );
			m_oProfilings.insert( m_oProfilings.end(), 
				m_oProfilings.capacity() - m_oProfilings.size(), 
				CMaxMiniProfiler_Node_Standard() );

			// that's it
			m_oHeapAcquisitionTimings.push_back( node );
			m_oHeapAcquisitionTimings.back().FStop();
		};

	private:
		CMaxMiniProfiler_Standard( const CMaxMiniProfiler_Standard &o );
		const CMaxMiniProfiler_Standard& operator =( const CMaxMiniProfiler_Standard & );
};





/*********************************************************************************
/* Class:
/*		CMaxMiniProfiler_NoHistory
/* Comments:
/*		This implementation is targetted for massive amounts of nodes
/********************************************************************************/
class CMaxMiniProfiler_NoHistory
	: public CMaxMiniProfiler_Base
{
	protected:
		typedef CMaxMiniProfiler_Node_NoHistory::CKey MMPNHKey;
		typedef CMaxMiniProfiler_Node_NoHistory::CCompareKeys MMPNHKeyCompare;
		typedef std::map<MMPNHKey, CMaxMiniProfiler_Node_NoHistory, MMPNHKeyCompare> MMPNHNodes;
		typedef MMPNHNodes::iterator MMPNHNodesIterator;
		typedef std::vector<MMPNHNodesIterator> MMPNHNodesReferences;
		typedef std::stack<MMPNHNodesIterator, MMPNHNodesReferences> MMPNHStack;
		typedef MMPNHStack::size_type MMPNHStackSizeType;

	protected:
		typedef std::vector<CMaxMiniProfiler_Node_NoHistory> MMPNHFinalNodes;
		typedef MMPNHFinalNodes::iterator MMPNHFinalNodesIterator;

	protected:
		// profiling nodes
		MMPNHNodes m_oProfilings;
		unsigned long m_lLastNode;
		
		// stack for nested blocks
		MMPNHStack m_oStack;

	public:

		// constructor / destructor
		// ------------------------
		
		CMaxMiniProfiler_NoHistory(
			const TCHAR *pszSpecificEnabler = NULL )
			: CMaxMiniProfiler_Base( pszSpecificEnabler )
			, m_lLastNode( 0 )
		{
			FInitDumpingSession();
		};

		~CMaxMiniProfiler_NoHistory()
		{
			FDumpSession();
			FTermDumpingSession();
		};

		// dumping results - public interface
		// ----------------------------------

		void FDumpResults( bool bForced = false, bool = true )
		{
			if ( !bForced )
			{
				// can dump results only when all profiling nodes are closed
				// (except the main one); we don't want to artificially close the nodes 
				// here at this point
				if ( 1 != m_oStack.size() )
				{
					assert( false );
					return;
				}
			}

			// dump
			FDumpSession();
			FTermDumpingSession();

			// prepare for next dump
			FInitDumpingSession();
		};

		// profiling nodes generation
		// --------------------------
		// Note: FCreateNewNode and FCloseCurrentNode are meant to be as fast as possible;
		//		 also, the bracket between FStart and FStop is as small as possible

		void FCreateNewNode( const char *pszTitle )
		{
		MMPNHNodesIterator i;

			assert( ( 0 == m_oStack.size() ) || ( ::GetCurrentThreadId() == m_dwThreadId ) );

			// A) this is not time constant
			// ----------------------------
			// Note: therefore we measure how much time we spend here

			CMaxTimerAbstraction before( 1 );
			{
				// compute the checksum
				ULONG_PTR lCheckSum = ( ULONG_PTR )pszTitle;
				if ( !m_oStack.empty() )
					lCheckSum += ( *m_oStack.top() ).first.m_lCheckSum;

				// compute the key
				MMPNHKey oKey( static_cast<unsigned long>(m_oStack.size()), pszTitle, lCheckSum );

				// get the corresponding node, if any
				i = m_oProfilings.find( oKey );

				// otherwise, create a new node
				if ( m_oProfilings.end() == i )
					i = m_oProfilings.insert( MMPNHNodes::value_type( oKey, CMaxMiniProfiler_Node_NoHistory() ) ).first;
			}
			CMaxTimerAbstraction after( 1 );

			// B) this is time constant
			// ------------------------
			// Note: therefore taken care of by bias computation

			CMaxTimerAbstraction oInternalOverhead( CMaxTimerAbstraction::oSDifference( after, before ) );

			m_lLastNode++;
			( *i ).second.FInitialize( static_cast<unsigned long>(m_oStack.size()), pszTitle, m_lLastNode, oInternalOverhead );
			m_oStack.push( i );
			( *i ).second.FStart();
		};

		void FCloseCurrentNode()
		{
			assert( ( 1 == m_oStack.size() ) || ( ::GetCurrentThreadId() == m_dwThreadId ) );

			// Note: this is time constant
			if ( m_oStack.size() > 0 )
			{
				( *m_oStack.top() ).second.FStop();
				m_oStack.pop();
			}
			else
				assert( false );
		};

		// bias approximation
		// ------------------
		// Note: the result of this operation is used at output time uniquely

		void FSetBiasApproximationFrom( unsigned long lBiasSample )
		{
		unsigned int i;
		MMPNHNodes::iterator j, j1, j2;
		CMaxTimerAbstraction b, n, ib;

			assert( !s_bBiasIsKnown );

			// Note: this function should be called immediately after having created 
			//		 1 BIAS (b) node
			//		 and x NOTHINGNESS (N) subnodes (n1 ... nx),
			//		 where x = lBiasSample
			assert( m_lLastNode > 1 + lBiasSample );
			
			// find bias and nothingness nodes
			// Note: here we search by name, because it's not time critical and
			//		 we don't know the checksum
			CMaxMiniProfiler_Node_Base::MMPNBString id_bias( MAX_PROFTAGNODE_BIAS );
			CMaxMiniProfiler_Node_Base::MMPNBString id_nothingness( MAX_PROFTAGNODE_NOTHINGNESS );
			char cDone = 0;
			for ( j = m_oProfilings.begin(); ( m_oProfilings.end() != j ) && ( ( 1 | 2 ) != cDone ); j++ )
			{
			CMaxMiniProfiler_Node_Base::MMPNBString id_iterated( ( *j ).second.pszFGetTitle() );

				if ( id_iterated == id_bias )
				{
					assert( !( cDone & 1 ) );
					b = ( *j ).second.roFGetDelta();
					j1 = j;
					cDone |= 1;
				}
				else if ( id_iterated == id_nothingness )
				{
					assert( !( cDone & 2 ) );
					n = ( *j ).second.roFGetDelta();
					ib = ( *j ).second.roFGetInternalOverhead();
					j2 = j;
					cDone |= 2;
				}
			}
			assert( ( 1 | 2 ) == cDone );
			if ( cDone & 1 )
				m_oProfilings.erase( j1 );
			if ( cDone & 2 )
				m_oProfilings.erase( j2 );

			// our out of brace bias is equal to (b - (n1 + n2 + ... + nx) - (ib1 + ib2 + ... + ibx)) / x
			// Note: ib is the internal bias (or overhead), and is taken care of separately
			s_oOutOfBraceBiasApproximation = b;
			s_oOutOfBraceBiasApproximation.FSubstract( n );
			s_oOutOfBraceBiasApproximation.FSubstract( ib );
			s_oOutOfBraceBiasApproximation.FDivide( lBiasSample );

			// our in of brace bias is equal to ((n1 + n2 + ... + nx) - N.x) / x
			// Note: on purpose, we re-evaluate N as many times as there are samples
			CMaxTimerAbstraction delta;
			for ( i = lBiasSample; i > 0; i-- )
			{
				CMaxTimerAbstraction origin( 1 ), destination( 1 );
				delta.FAdd( CMaxTimerAbstraction::oSDifference( destination, origin ) );
			}
			s_oInOfBraceBiasApproximation = n;
			s_oInOfBraceBiasApproximation.FSubstract( delta );
			s_oInOfBraceBiasApproximation.FDivide( lBiasSample );

			s_bBiasIsKnown = true;
		};

	protected:

		// dumping session management
		// --------------------------

		void FInitDumpingSession()
		{
			// put a main node
			FCreateNewNode( MAX_PROFTAGNODE_TOP );

			// verify that we start cleanly
			assert( 1 == m_oStack.size() );
		};

		void FDumpSession()
		{
		MMPNHStackSizeType lNumberOfOpenNodes;
		MMPNHFinalNodes oFinalNodes;
		unsigned long lMaxLevel;

			// terminate our main node
			FCloseCurrentNode();

			// make sure all nodes are closed
			lNumberOfOpenNodes = m_oStack.size();
			while ( !m_oStack.empty() )
				FCloseCurrentNode();

			// get the final list of nodes, sorted by index
			FGetFinalNodes( oFinalNodes );

			if ( oFinalNodes.size() > 1 )
			{
				// final trimming and initializations
				::GRemoveInAndOutBiasFromProfilingNodes( 
					oFinalNodes, s_oOutOfBraceBiasApproximation, s_oInOfBraceBiasApproximation );
				lMaxLevel = ::lGDetermineMaxLevelOfProfilings( oFinalNodes );
				CMaxTimerAbstraction oTotalInternalOverhead = oFRemoveInternalOverheadFromFinalNodes( oFinalNodes );

				// open the output file
				ofstream os( m_poFileName, ios::out | ios::ate );

				// output the raw profilings
				FOutputHeader( oFinalNodes, os, lNumberOfOpenNodes, oTotalInternalOverhead );
				FOutputFinalNodes( oFinalNodes, os, lMaxLevel );
			}
			else
				FOutputEmptySession();
		};

		void FTermDumpingSession()
		{
			while ( !m_oStack.empty() )
				m_oStack.pop();

			m_oProfilings.erase( m_oProfilings.begin(), m_oProfilings.end() );
		};

	protected:

		// for final output
		// ----------------

		void FOutputHeader( 
			MMPNHFinalNodes &roFinalNodes,
			ostream &os, 
			MMPNHStackSizeType lNumberOfOpenNodes,
			const CMaxTimerAbstraction &roTotalInternalOverhead )
		{
			FOutputHeaderCore( os, static_cast<unsigned long>(lNumberOfOpenNodes), roFinalNodes[ 0 ], m_lLastNode );

			// output the total profiling overhead
			double dTotalOverhead = 
				( ( double )( m_lLastNode - 1.0 ) * s_oOutOfBraceBiasApproximation.dFInSeconds() ) + 
				( ( double )m_lLastNode * s_oInOfBraceBiasApproximation.dFInSeconds() ) +
				roTotalInternalOverhead.dFInSeconds();
			double dTotalOverheadPercent = 
				100.0 * ( dTotalOverhead / ( dTotalOverhead + roFinalNodes[ 0 ].dFGetDelta() ) );
			os << "*** @@TotalProfilerOverhead=" << dTotalOverheadPercent << "%=";
			CMaxMiniProfiler_Node_Base::SStampDeltaInSeconds( os, dTotalOverhead ) << endl;

			// that's it
			os << "***************************" << endl;
			FOutputMergedSectionHeader( os );
		};

		// final management of profiling nodes
		// -----------------------------------

		void FGetFinalNodes( MMPNHFinalNodes &roFinalNodes )
		{
			assert( !m_oProfilings.empty() );

			// copy the map of profiling nodes into a simple vector
			for ( MMPNHNodes::iterator i = m_oProfilings.begin(); m_oProfilings.end() != i; i++ )
			{
				( *i ).second.FSetCheckSum( ( *i ).first.m_lCheckSum );
				roFinalNodes.push_back( ( *i ).second );
			}

			// sort the vector by nodes indexes
			std::sort( roFinalNodes.begin(), roFinalNodes.end(), CMaxMiniProfiler_Node_Base::CCompareIndexes() );

			// reparent the lost nodes
			// Note: sorting by nodes indexes is not good enough when the profiled code has some
			//		 conditional branches; suppose a new node appears in a branch, its index might
			//		 be greater than nodes that don't belong to that branch; therefore reparenting
			//		 those lost nodes is necessary
			// Note: top node doesn't have a parent, so skip it
			// Note: this algorithm is O(n2) right now, and could be improved, but since it is
			//		 executed at output time only, I don't care
			MMPNHFinalNodesIterator j = roFinalNodes.begin();
			j++;
			while ( roFinalNodes.end() != j )
			{
			const MMPNHFinalNodesIterator oldj = j;
			bool bWrongParent = false;
			unsigned long lTargetLevel = ( *j ).lFGetLevel() - 1;
			ULONG_PTR lTargetCheckSum = ( *j ).lFGetCheckSum() - ( ULONG_PTR )( *j ).pszFGetTitle();

				// find the real parent of j (must appear before j in the sorted vector)
				for ( MMPNHFinalNodesIterator k = j; roFinalNodes.end() != k; k-- )
				{
				unsigned long lIteratedLevel = ( *k ).lFGetLevel();

					// the real parent must have a level equal to lTargetLevel
					if ( lIteratedLevel != lTargetLevel )
					{
						// maybe j didn't even have an immediate wrong parent
						if ( lIteratedLevel < lTargetLevel )
							bWrongParent = true;
						continue;
					}

					// the parent must have a checksum equal to lTargetCheckSum, 
					// otherwise it is a wrong parent
					if ( ( *k ).lFGetCheckSum() != lTargetCheckSum )
						bWrongParent = true;

					// we found the real parent
					else
					{
						// if no wrong parent was encountered, nothing to do
						if ( !bWrongParent )
						{
							j++;
							break;
						}

						// otherwise, we must move the node below its real parent
						else
						{
						CMaxMiniProfiler_Node_NoHistory nodecopy = *j;

							j++;
							k++;
							roFinalNodes.erase( oldj );
							roFinalNodes.insert( k, nodecopy );

							bWrongParent = false;
							break;
						}
					}
				}

				assert( !bWrongParent );
				assert( oldj != j );
			}
		}

		CMaxTimerAbstraction oFRemoveInternalOverheadFromFinalNodes( MMPNHFinalNodes &roFinalNodes )
		{
		CMaxTimerAbstraction oTotalOverhead;
		MMPNHFinalNodes::iterator i;
		std::vector<MMPNHFinalNodesIterator> parents;
		std::vector<MMPNHFinalNodesIterator>::iterator j;
		unsigned long l, s;

			for ( i = roFinalNodes.begin(); roFinalNodes.end() != i; i++ )
			{
				// get the current node level (l) and stack of parents size (s)
				l = ( *i ).lFGetLevel();
				s = static_cast<unsigned long>(parents.size());

				// get the iterated node's internal overhead
				const CMaxTimerAbstraction &roOverhead = ( *i ).roFGetInternalOverhead();
				oTotalOverhead.FAdd( roOverhead );

				// update the stack of parents
				if ( s > 0 )
				{
					while ( s > l )
					{
						parents.pop_back();
						s--;
					}
				}
				assert( l == s );

				// remove internal overhead from all parents
				for ( j = parents.begin(); parents.end() != j; j++ )
				{
					assert( ( *j ) != i );
					CMaxTimerAbstraction &rtaDelta = ( *( *j ) ).roFGetDelta();
					rtaDelta.FSubstract( roOverhead );
				}

				// insert the current node in the stack of parents
				parents.push_back( i );
			}

			return oTotalOverhead;
		};

		void FOutputFinalNodes( MMPNHFinalNodes &roFinalNodes, ostream &os, unsigned long lMaxLevel )
		{
		double dPrecisionThreshold = 2.0 * ( s_oOutOfBraceBiasApproximation.dFInSeconds() + s_oInOfBraceBiasApproximation.dFInSeconds() );

			::GOutputProfilings( os, roFinalNodes, lMaxLevel, dPrecisionThreshold, false );
		};

	private:
		CMaxMiniProfiler_NoHistory( const CMaxMiniProfiler_NoHistory &o );
		const CMaxMiniProfiler_NoHistory& operator =( const CMaxMiniProfiler_NoHistory & );
};





/*********************************************************************************
/* Class:
/*		CMaxMultithreadProfiler
/* Comments:
/*		Instantiates and manages one CMaxMiniProfiler per calling thread
/********************************************************************************/
template <class TMiniProfiler>
class CMaxMultithreadProfiler
{
	protected:
		typedef std::less<DWORD> MTPThreadIdsCompare;
		typedef std::map<DWORD, TMiniProfiler*, MTPThreadIdsCompare> MTPMap;

	protected:
		class __CMaxCriticalSection
		{
			protected:
				CRITICAL_SECTION m_oNTCriticalSection;

			public:
				__CMaxCriticalSection(){ ::InitializeCriticalSection( &m_oNTCriticalSection ); };
				~__CMaxCriticalSection(){ ::DeleteCriticalSection( &m_oNTCriticalSection ); };

				bool Lock() const { ::EnterCriticalSection( &( ( __CMaxCriticalSection * )this )->m_oNTCriticalSection ); return true; };
				bool Unlock() const { ::LeaveCriticalSection( &( ( __CMaxCriticalSection * )this )->m_oNTCriticalSection ); return true; };
			
				operator CRITICAL_SECTION*() const { return ( CRITICAL_SECTION* )&m_oNTCriticalSection; };
		};

	protected:
		MTPMap m_oProfilers;
		__CMaxCriticalSection m_oLockProfilers;

	public:
		CMaxMultithreadProfiler(
			const TCHAR * = NULL )
		{
			m_oProfilers[ ::GetCurrentThreadId() ] = new TMiniProfiler();
		};

		~CMaxMultithreadProfiler()
		{
			if ( !m_oProfilers.empty() )
				FFlushProfilers();
		};

		void FLockProfiler()
		{
			m_oLockProfilers.Lock();
		};

		void FUnlockProfiler()
		{
			m_oLockProfilers.Unlock();
		};

		void FDumpResults( bool bForced = false, bool bCurrentThreadOnly = true )
		{
			m_oLockProfilers.Lock();
			{
			DWORD id = ::GetCurrentThreadId();
			MTPMap::iterator i;

				if ( m_oProfilers.empty() )
				{
					m_oLockProfilers.Unlock();
					return;
				}

				for ( i = m_oProfilers.begin(); m_oProfilers.end() != i; i++ )
					if ( !bCurrentThreadOnly || ( ( *i ).first == id ) )
						( *i ).second->FDumpResults( bForced ); 

				if ( bForced )
					FFlushProfilers();
			}
			m_oLockProfilers.Unlock();
		};

		void FCreateNewNode( const char *pszTitle )
		{ 
			m_oLockProfilers.Lock();
			{
			DWORD id = ::GetCurrentThreadId();
			MTPMap::iterator i = m_oProfilers.find( id );

				if ( m_oProfilers.end() != i )
					( *i ).second->FCreateNewNode( pszTitle ); 
				else
				{
				TMiniProfiler *pNewProfiler = new TMiniProfiler();
					
					m_oProfilers[ id ] = pNewProfiler;
					pNewProfiler->FCreateNewNode( pszTitle ); 
				}
			}
			m_oLockProfilers.Unlock();
		};
		
		void FCloseCurrentNode()
		{ 
			m_oLockProfilers.Lock();
			{
			DWORD id = ::GetCurrentThreadId();
			MTPMap::iterator i = m_oProfilers.find( id );

				assert( m_oProfilers.end() != i );
				( *i ).second->FCloseCurrentNode(); 
			}
			m_oLockProfilers.Unlock();
		};

		bool bFIsBiasKnown() const 
		{ 
		bool b;

			m_oLockProfilers.Lock();
			assert( !m_oProfilers.empty() );
			b = ( *m_oProfilers.begin() ).second->bFIsBiasKnown();
			m_oLockProfilers.Unlock();

			return b;
		};

		void FSetBiasApproximationFrom( unsigned long lBiasSample )
		{
			m_oLockProfilers.Lock();
			assert( !m_oProfilers.empty() );
			( *m_oProfilers.begin() ).second->FSetBiasApproximationFrom( lBiasSample );
			m_oLockProfilers.Unlock();
		};

	protected:
		void FFlushProfilers()
		{
			m_oLockProfilers.Lock();
			assert( !m_oProfilers.empty() );
			for ( MTPMap::iterator i = m_oProfilers.begin(); m_oProfilers.end() != i; i++ )
				delete ( *i ).second;
			m_oProfilers.erase( m_oProfilers.begin(), m_oProfilers.end() );
			m_oLockProfilers.Unlock();
		};

	private:
		CMaxMultithreadProfiler( const CMaxMultithreadProfiler &o );
		const CMaxMultithreadProfiler& operator =( const CMaxMultithreadProfiler & );
};
#endif // }





#ifdef MAX_PROFILING_ENABLED_DLL // {
/*********************************************************************************
/* Class:
/*		CMaxProfilingDLLWrapper
/* Comments:
/*		For simplified use through the macros defined above
/********************************************************************************/
class CMaxProfilingDLLWrapper
{
	protected:
		class __CMaxLoadLibrary
		{
			protected:
				HINSTANCE m_hLibrary;

			public:
				__CMaxLoadLibrary( LPCTSTR pszLibraryFileName )
					: m_hLibrary( NULL )
				{
					if ( NULL != pszLibraryFileName )
						m_hLibrary = ::LoadLibrary( pszLibraryFileName );
				};

				~__CMaxLoadLibrary()
				{
					if ( NULL != m_hLibrary )
						::FreeLibrary( m_hLibrary );
				};

				operator HINSTANCE() const
				{ 
					return m_hLibrary; 
				};
		};

	protected:
		__CMaxLoadLibrary m_oLibrary;

	protected:
		void ( *m_pfn_LockProfiler )();
		void ( *m_pfn_UnlockProfiler )();
		void ( *m_pfn_DumpResults )( bool, bool );
		void ( *m_pfn_CreateNewNode )( const char * );
		void ( *m_pfn_CloseCurrentNode )();
		bool ( *m_pfn_IsBiasKnown )();
		void ( *m_pfn_SetBiasApproximationFrom )( unsigned long );

	protected:
		static void SLockProfiler_Bogus(){};
		static void SUnlockProfiler_Bogus(){};
		static void SDumpResults_Bogus( bool, bool ){};
		static void SCreateNewNode_Bogus( const char * ){};
		static void SCloseCurrentNode_Bogus(){};
		static bool bSIsBiasKnown_Bogus(){ return true; };
		static void SSetBiasApproximationFrom_Bogus( unsigned long ){};

	public:
		CMaxProfilingDLLWrapper(
			const TCHAR *pszSpecificEnabler = NULL )
#ifndef unix
			: m_oLibrary( _T( "s:\\ds\\util\\maxprof.dll" ) )
#else
			: m_oLibrary( NULL )
#endif
			, m_pfn_LockProfiler( NULL )
			, m_pfn_UnlockProfiler( NULL )
			, m_pfn_DumpResults( NULL )
			, m_pfn_CreateNewNode( NULL )
			, m_pfn_CloseCurrentNode( NULL )
			, m_pfn_IsBiasKnown( NULL )
			, m_pfn_SetBiasApproximationFrom( NULL )
		{
			// if the profiler is enabled, get the dll's entry points for profiling
			// (if possible)
			if ( bFProfilerEnabled( pszSpecificEnabler ) &&
				( NULL != ( HINSTANCE )m_oLibrary ) )
			{
				m_pfn_LockProfiler = ( void ( * )() )::GetProcAddress( m_oLibrary, "LockProfiler" );
				assert( NULL != m_pfn_LockProfiler );

				m_pfn_UnlockProfiler = ( void ( * )() )::GetProcAddress( m_oLibrary, "UnlockProfiler" );
				assert( NULL != m_pfn_UnlockProfiler );
				
				m_pfn_DumpResults = ( void ( * )( bool, bool ) )::GetProcAddress( m_oLibrary, "DumpResults" );
				assert( NULL != m_pfn_DumpResults );

				m_pfn_CreateNewNode = ( void ( * )( const char * ) )::GetProcAddress( m_oLibrary, "CreateNewNode" );
				assert( NULL != m_pfn_CreateNewNode );

				m_pfn_CloseCurrentNode = ( void ( * )() )::GetProcAddress( m_oLibrary, "CloseCurrentNode" );
				assert( NULL != m_pfn_CloseCurrentNode );

				m_pfn_IsBiasKnown = ( bool ( * )() )::GetProcAddress( m_oLibrary, "IsBiasKnown" );
				assert( NULL != m_pfn_IsBiasKnown );

				m_pfn_SetBiasApproximationFrom = ( void ( * )( unsigned long ) )::GetProcAddress( m_oLibrary, "SetBiasApproximationFrom" );
				assert( NULL != m_pfn_SetBiasApproximationFrom );
			}

			// otherwise, create bogus entry points
			// Note: this technique is preferred to using "if"s on each call, so this
			//		 switch does not affect the profiling mode at all
			else
			{
				m_pfn_LockProfiler = SLockProfiler_Bogus;
				m_pfn_UnlockProfiler = SUnlockProfiler_Bogus;
				m_pfn_DumpResults = SDumpResults_Bogus;
				m_pfn_CreateNewNode = SCreateNewNode_Bogus;
				m_pfn_CloseCurrentNode = SCloseCurrentNode_Bogus;
				m_pfn_IsBiasKnown = bSIsBiasKnown_Bogus;
				m_pfn_SetBiasApproximationFrom = SSetBiasApproximationFrom_Bogus;
			}
		};

		// Note: this is the easiest way to avoid a severe bug in the DLL version of the
		//		 profiler; basically, if a client DLL detaches the profiled process, the 
		//		 "titles" maintained by address by the profiling nodes become invalid, and 
		//		 can no longer be dereferenced; therefore, to avoid this problem, I make 
		//		 sure all profiling nodes are dumped when a client DLL detaches.  This
		//		 may affect results in some circumstances, but should be OK in most cases
		~CMaxProfilingDLLWrapper()
			{ FDumpResults( true, false ); };

		void FLockProfiler()
			{ ( *m_pfn_LockProfiler )(); };
		void FUnlockProfiler()
			{ ( *m_pfn_UnlockProfiler )(); };
		void FDumpResults( bool bForced = false, bool bCurrentThreadOnly = true )
			{ ( *m_pfn_DumpResults )( bForced, bCurrentThreadOnly ); };
		void FCreateNewNode( const char *pszTitle )
			{ ( *m_pfn_CreateNewNode )( pszTitle ); };
		void FCloseCurrentNode()
			{ ( *m_pfn_CloseCurrentNode )(); };
		bool bFIsBiasKnown() const
			{ return ( *m_pfn_IsBiasKnown )(); };
		void FSetBiasApproximationFrom( unsigned long lBiasSample )
			{ ( *m_pfn_SetBiasApproximationFrom )( lBiasSample ); };

	protected:
#ifdef MAX_PROFILING_CONDITIONAL
		bool bFProfilerEnabled( 
			const TCHAR *pszSpecificEnabler ) const
		{
			// Note: the global enabler allows you to enable/disable
			//		 all "subsystems" at once
			// Note: the specific enabler allows you to enable/disable
			//		 specific "subsystems", given that the global
			//		 enabler is set
			return ( bGIsEnabledEnvVar( MAX_ENV_ENABLE_PROFILING, MAX_ENV_ALL ) ||
				( bGIsEnabledEnvVar( pszSpecificEnabler ) && bGIsEnabledEnvVar( MAX_ENV_ENABLE_PROFILING ) ) );
		}
#else
		bool bFProfilerEnabled( const TCHAR * ) const
		{
			return true;
		}
#endif
};
#endif // }





#if defined MAX_PROFILING_ENABLED || defined MAX_PROFILING_ENABLED_DLL // {
//#ifdef _DEBUG
//	#pragma message( "MAXPROFILER Warning: beware of profilings generated with a DEBUG build." )
//#endif
/*********************************************************************************
/* Class:
/*		CMaxProfilingObject
/* Comments:
/*		For simplified use through the macros defined above.  The typedef
/*		allows easy substitution between multi-threaded (default) and 
/*		single-threaded profilers
/********************************************************************************/
class CMaxProfilingObject
{
	public:
#ifdef MAX_PROFILING_ENABLED_DLL
		typedef CMaxProfilingDLLWrapper MPOProfiler;
#else
		typedef CMaxMultithreadProfiler<CMaxMiniProfiler_Standard> MPOProfiler;
#endif

	protected:
		static MPOProfiler s_oProfiler;

	protected:
		class __CBiasApproximation
		{
			public:
				__CBiasApproximation()
				{
				const unsigned long lBiasSample = 20;

					// if bias has already been computed once, do nothing
					if ( CMaxProfilingObject::s_oProfiler.bFIsBiasKnown() )
						return;

					// compute bias through the used profiler
					CMaxProfilingObject::s_oProfiler.FLockProfiler();
					{
						CMaxProfilingObject::SCreateNewNode( MAX_PROFTAGNODE_BIAS );
						for ( int i = 0; i < lBiasSample; i++ )
						{
							CMaxProfilingObject::SCreateNewNode( MAX_PROFTAGNODE_NOTHINGNESS );
							CMaxProfilingObject::SCloseCurrentNode();
						}
						CMaxProfilingObject::SCloseCurrentNode();

						CMaxProfilingObject::s_oProfiler.FSetBiasApproximationFrom( lBiasSample );
					}
					CMaxProfilingObject::s_oProfiler.FUnlockProfiler();
				};
		};
		friend __CBiasApproximation;

	protected:
		static __CBiasApproximation s_oBiasApproximation;

	public:
		static void SDumpResults( bool bForced = false, bool bCurrentThreadOnly = true )
			{ s_oProfiler.FDumpResults( bForced, bCurrentThreadOnly ); };
		static void SCreateNewNode( const char *pszTitle )
			{ s_oProfiler.FCreateNewNode( pszTitle ); };
		static void SCloseCurrentNode()
			{ s_oProfiler.FCloseCurrentNode(); };
};
#endif // }





#ifndef MAX_PROFILING_DLL_IMPLEMENTATION // {
/*********************************************************************************
/* Class:
/*		CMaxProfilingBlockWrapper
/* Comments:
/*		As a substitute to the macros (Ray's request).  Hoping that those inlines
/*		disappear completely when profiling is turned off.  The alternative
/*		would have been to define a new set of macros taking an additional
/*		parameter (a unique name for each instance of the wrapper within the
/*		same scope)
/* Note:
/*		I use nothrow here, but the current implementations don't guaranty
/*		that no exception will be thrown
/********************************************************************************/
class CMaxProfilingBlockWrapper
{
	public:
		MAXPROFNOTHROW CMaxProfilingBlockWrapper( const char *pszTitle )
			{ BEGIN_PROFILING_BLOCK( pszTitle ); };
		MAXPROFNOTHROW ~CMaxProfilingBlockWrapper()
			{ END_PROFILING_BLOCK; };

	public:
		MAXPROFNOTHROW static void SDump()
			{ DUMP_PROFILING_RESULTS; };
};
#endif // }





/*********************************************************************************
/* Comments:
/*		Here is the code used to generate maxprof.dll
/*********************************************************************************
#define MAX_PROFILING_DLL_IMPLEMENTATION
#include <iomanip.h>
#include <profile.h>
#pragma warning( disable : 4786 )
__MAX_MINIPROFILER_IMPLEMENTATION
typedef CMaxMultithreadProfiler<CMaxMiniProfiler_NoHistory> GDllProfiler_Type1;
typedef CMaxMultithreadProfiler<CMaxMiniProfiler_Standard> GDllProfiler_Type2;
GDllProfiler_Type1 g_oProfiler;
__declspec(dllexport) void LockProfiler()
	{ g_oProfiler.FLockProfiler(); }
__declspec(dllexport) void UnlockProfiler()
	{ g_oProfiler.FUnlockProfiler(); }
__declspec(dllexport) void DumpResults( bool bForced, bool bCurrentThreadOnly )
	{ g_oProfiler.FDumpResults( bForced, bCurrentThreadOnly ); }
__declspec(dllexport) void CreateNewNode( const char *pszTitle )
	{ g_oProfiler.FCreateNewNode( pszTitle ); }
__declspec(dllexport) void CloseCurrentNode()
	{ g_oProfiler.FCloseCurrentNode(); }
__declspec(dllexport) bool IsBiasKnown()
	{ return g_oProfiler.bFIsBiasKnown(); }
__declspec(dllexport) void SetBiasApproximationFrom( unsigned long lBiasSample )
	{ g_oProfiler.FSetBiasApproximationFrom( lBiasSample ); }
#pragma warning( default : 4786 )
/*********************************************************************************
/* Comments:
/*		Here is the DEF file used to generate maxprof.dll
/*********************************************************************************
EXPORTS
	LockProfiler @1
	UnlockProfiler @2
	DumpResults @3
	CreateNewNode @4
	CloseCurrentNode @5
	IsBiasKnown @6
	SetBiasApproximationFrom @7
/********************************************************************************/

// Note: I don't reenable C4786, and I know it...

#endif // }