diff options
Diffstat (limited to 'external/vpc/tier0')
34 files changed, 20527 insertions, 0 deletions
diff --git a/external/vpc/tier0/assert_dialog.cpp b/external/vpc/tier0/assert_dialog.cpp new file mode 100644 index 0000000..8df5e02 --- /dev/null +++ b/external/vpc/tier0/assert_dialog.cpp @@ -0,0 +1,573 @@ +//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//===========================================================================// + +#include "tier0/platform.h" + +#include "tier0/valve_off.h" +#ifdef _X360 +#include "xbox/xbox_console.h" +#include "xbox/xbox_vxconsole.h" +#elif defined( _PS3 ) +#include "ps3/ps3_console.h" +#elif defined( _WIN32 ) +#include <windows.h> +#elif POSIX +char *GetCommandLine(); +#endif +#include "resource.h" +#include "tier0/valve_on.h" +#include "tier0/threadtools.h" +#include "tier0/icommandline.h" + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +class CDialogInitInfo +{ +public: + const tchar *m_pFilename; + int m_iLine; + const tchar *m_pExpression; +}; + + +class CAssertDisable +{ +public: + tchar m_Filename[512]; + + // If these are not -1, then this CAssertDisable only disables asserts on lines between + // these values (inclusive). + int m_LineMin; + int m_LineMax; + + // Decremented each time we hit this assert and ignore it, until it's 0. + // Then the CAssertDisable is removed. + // If this is -1, then we always ignore this assert. + int m_nIgnoreTimes; + + CAssertDisable *m_pNext; +}; + +#ifdef _WIN32 +static HINSTANCE g_hTier0Instance = 0; +#endif + +static bool g_bAssertsEnabled = true; + +static CAssertDisable *g_pAssertDisables = NULL; + +#if ( defined( _WIN32 ) && !defined( _X360 ) ) +static int g_iLastLineRange = 5; +static int g_nLastIgnoreNumTimes = 1; +#endif +#if defined( _X360 ) || defined( _PS3 ) + static int g_VXConsoleAssertReturnValue = -1; +#endif + +// Set to true if they want to break in the debugger. +static bool g_bBreak = false; + +static CDialogInitInfo g_Info; + +static bool g_bDisableAsserts = false; + + +// -------------------------------------------------------------------------------- // +// Internal functions. +// -------------------------------------------------------------------------------- // + +#if defined(_WIN32) && !defined(STATIC_TIER0) +BOOL WINAPI DllMain( + HINSTANCE hinstDLL, // handle to the DLL module + DWORD fdwReason, // reason for calling function + LPVOID lpvReserved // reserved +) +{ + g_hTier0Instance = hinstDLL; + return true; +} +#endif + +static bool IsDebugBreakEnabled() +{ + static bool bResult = ( _tcsstr( Plat_GetCommandLine(), _T("-debugbreak") ) != NULL ); + return bResult; +} + +static bool AssertStack() +{ + static bool bResult = ( _tcsstr( Plat_GetCommandLine(), _T("-assertstack") ) != NULL ); + return bResult; +} + +static bool AreAssertsDisabled() +{ + static bool bResult = ( _tcsstr( Plat_GetCommandLine(), _T("-noassert") ) != NULL ); + return bResult || g_bDisableAsserts; +} + +static bool AllAssertOnce() +{ + static bool bResult = ( _tcsstr( Plat_GetCommandLine(), _T("-assertonce") ) != NULL ); + return bResult; +} + +static bool AreAssertsEnabledInFileLine( const tchar *pFilename, int iLine ) +{ + CAssertDisable **pPrev = &g_pAssertDisables; + CAssertDisable *pNext; + for ( CAssertDisable *pCur=g_pAssertDisables; pCur; pCur=pNext ) + { + pNext = pCur->m_pNext; + + if ( _tcsicmp( pFilename, pCur->m_Filename ) == 0 ) + { + // Are asserts disabled in the whole file? + bool bAssertsEnabled = true; + if ( pCur->m_LineMin == -1 && pCur->m_LineMax == -1 ) + bAssertsEnabled = false; + + // Are asserts disabled on the specified line? + if ( iLine >= pCur->m_LineMin && iLine <= pCur->m_LineMax ) + bAssertsEnabled = false; + + if ( !bAssertsEnabled ) + { + // If this assert is only disabled for the next N times, then countdown.. + if ( pCur->m_nIgnoreTimes > 0 ) + { + --pCur->m_nIgnoreTimes; + if ( pCur->m_nIgnoreTimes == 0 ) + { + // Remove this one from the list. + *pPrev = pNext; + delete pCur; + continue; + } + } + + return false; + } + } + + pPrev = &pCur->m_pNext; + } + + return true; +} + + +CAssertDisable* CreateNewAssertDisable( const tchar *pFilename ) +{ + CAssertDisable *pDisable = new CAssertDisable; + pDisable->m_pNext = g_pAssertDisables; + g_pAssertDisables = pDisable; + + pDisable->m_LineMin = pDisable->m_LineMax = -1; + pDisable->m_nIgnoreTimes = -1; + + _tcsncpy( pDisable->m_Filename, g_Info.m_pFilename, sizeof( pDisable->m_Filename ) - 1 ); + pDisable->m_Filename[ sizeof( pDisable->m_Filename ) - 1 ] = 0; + + return pDisable; +} + + +void IgnoreAssertsInCurrentFile() +{ + CreateNewAssertDisable( g_Info.m_pFilename ); +} + + +CAssertDisable* IgnoreAssertsNearby( int nRange ) +{ + CAssertDisable *pDisable = CreateNewAssertDisable( g_Info.m_pFilename ); + pDisable->m_LineMin = g_Info.m_iLine - nRange; + pDisable->m_LineMax = g_Info.m_iLine - nRange; + return pDisable; +} + + +#if ( defined( _WIN32 ) && !defined( _X360 ) ) +INT_PTR CALLBACK AssertDialogProc( + HWND hDlg, // handle to dialog box + UINT uMsg, // message + WPARAM wParam, // first message parameter + LPARAM lParam // second message parameter +) +{ + switch( uMsg ) + { + case WM_INITDIALOG: + { +#ifdef TCHAR_IS_WCHAR + SetDlgItemTextW( hDlg, IDC_ASSERT_MSG_CTRL, g_Info.m_pExpression ); + SetDlgItemTextW( hDlg, IDC_FILENAME_CONTROL, g_Info.m_pFilename ); +#else + SetDlgItemText( hDlg, IDC_ASSERT_MSG_CTRL, g_Info.m_pExpression ); + SetDlgItemText( hDlg, IDC_FILENAME_CONTROL, g_Info.m_pFilename ); +#endif + SetDlgItemInt( hDlg, IDC_LINE_CONTROL, g_Info.m_iLine, false ); + SetDlgItemInt( hDlg, IDC_IGNORE_NUMLINES, g_iLastLineRange, false ); + SetDlgItemInt( hDlg, IDC_IGNORE_NUMTIMES, g_nLastIgnoreNumTimes, false ); + + // Center the dialog. + RECT rcDlg, rcDesktop; + GetWindowRect( hDlg, &rcDlg ); + GetWindowRect( GetDesktopWindow(), &rcDesktop ); + SetWindowPos( + hDlg, + HWND_TOP, + ((rcDesktop.right-rcDesktop.left) - (rcDlg.right-rcDlg.left)) / 2, + ((rcDesktop.bottom-rcDesktop.top) - (rcDlg.bottom-rcDlg.top)) / 2, + 0, + 0, + SWP_NOSIZE ); + } + return true; + + case WM_COMMAND: + { + switch( LOWORD( wParam ) ) + { + case IDC_IGNORE_FILE: + { + IgnoreAssertsInCurrentFile(); + EndDialog( hDlg, 0 ); + return true; + } + + // Ignore this assert N times. + case IDC_IGNORE_THIS: + { + BOOL bTranslated = false; + UINT value = GetDlgItemInt( hDlg, IDC_IGNORE_NUMTIMES, &bTranslated, false ); + if ( bTranslated && value > 1 ) + { + CAssertDisable *pDisable = IgnoreAssertsNearby( 0 ); + pDisable->m_nIgnoreTimes = value - 1; + g_nLastIgnoreNumTimes = value; + } + + EndDialog( hDlg, 0 ); + return true; + } + + // Always ignore this assert. + case IDC_IGNORE_ALWAYS: + { + IgnoreAssertsNearby( 0 ); + EndDialog( hDlg, 0 ); + return true; + } + + case IDC_IGNORE_NEARBY: + { + BOOL bTranslated = false; + UINT value = GetDlgItemInt( hDlg, IDC_IGNORE_NUMLINES, &bTranslated, false ); + if ( !bTranslated || value < 1 ) + return true; + + IgnoreAssertsNearby( value ); + EndDialog( hDlg, 0 ); + return true; + } + + case IDC_IGNORE_ALL: + { + g_bAssertsEnabled = false; + EndDialog( hDlg, 0 ); + return true; + } + + case IDC_BREAK: + { + g_bBreak = true; + EndDialog( hDlg, 0 ); + return true; + } + } + + case WM_KEYDOWN: + { + // Escape? + if ( wParam == 2 ) + { + // Ignore this assert. + EndDialog( hDlg, 0 ); + return true; + } + } + + } + return true; + } + + return FALSE; +} + + +static HWND g_hBestParentWindow; + + +static BOOL CALLBACK ParentWindowEnumProc( + HWND hWnd, // handle to parent window + LPARAM lParam // application-defined value +) +{ + if ( IsWindowVisible( hWnd ) ) + { + DWORD procID; + GetWindowThreadProcessId( hWnd, &procID ); + if ( procID == (DWORD)lParam ) + { + g_hBestParentWindow = hWnd; + return FALSE; // don't iterate any more. + } + } + return TRUE; +} + + +static HWND FindLikelyParentWindow() +{ + // Enumerate top-level windows and take the first visible one with our processID. + g_hBestParentWindow = NULL; + EnumWindows( ParentWindowEnumProc, GetCurrentProcessId() ); + return g_hBestParentWindow; +} +#endif + +// -------------------------------------------------------------------------------- // +// Interface functions. +// -------------------------------------------------------------------------------- // + +// provides access to the global that turns asserts on and off +PLATFORM_INTERFACE bool AreAllAssertsDisabled() +{ + return !g_bAssertsEnabled; +} + +PLATFORM_INTERFACE void SetAllAssertsDisabled( bool bAssertsDisabled ) +{ + g_bAssertsEnabled = !bAssertsDisabled; +} + + +PLATFORM_INTERFACE bool ShouldUseNewAssertDialog() +{ + static bool bMPIWorker = ( _tcsstr( Plat_GetCommandLine(), _T("-mpi_worker") ) != NULL ); + if ( bMPIWorker ) + { + return false; + } + +#ifdef DBGFLAG_ASSERTDLG + return true; // always show an assert dialog +#else + return Plat_IsInDebugSession(); // only show an assert dialog if the process is being debugged +#endif // DBGFLAG_ASSERTDLG +} + + +PLATFORM_INTERFACE bool DoNewAssertDialog( const tchar *pFilename, int line, const tchar *pExpression ) +{ + LOCAL_THREAD_LOCK(); + + if ( AreAssertsDisabled() ) + return false; + + // If they have the old mode enabled (always break immediately), then just break right into + // the debugger like we used to do. + if ( IsDebugBreakEnabled() ) + return true; + + // Have ALL Asserts been disabled? + if ( !g_bAssertsEnabled ) + return false; + + // Has this specific Assert been disabled? + if ( !AreAssertsEnabledInFileLine( pFilename, line ) ) + return false; + + // Now create the dialog. + g_Info.m_pFilename = pFilename; + g_Info.m_iLine = line; + g_Info.m_pExpression = pExpression; + + if ( AssertStack() ) + { + IgnoreAssertsNearby( 0 ); + // @TODO: add-back callstack spew support + Warning( "%s (%d) : Assertion callstack...(NOT IMPLEMENTED IN NEW LOGGING SYSTEM.)\n", pFilename, line ); + // Warning_SpewCallStack( 10, "%s (%d) : Assertion callstack...\n", pFilename, line ); + return false; + } + + if( AllAssertOnce() ) + { + IgnoreAssertsNearby( 0 ); + } + + g_bBreak = false; + +#if defined( _X360 ) + + char cmdString[XBX_MAX_RCMDLENGTH]; + + // Before calling VXConsole, init the global variable that receives the result + g_VXConsoleAssertReturnValue = -1; + + // Message VXConsole to pop up a PC-side Assert dialog + _snprintf( cmdString, sizeof(cmdString), "Assert() 0x%.8x File: %s\tLine: %d\t%s", + &g_VXConsoleAssertReturnValue, pFilename, line, pExpression ); + XBX_SendRemoteCommand( cmdString, false ); + + // We sent a synchronous message, so g_xbx_dbgVXConsoleAssertReturnValue should have been overwritten by now + if ( g_VXConsoleAssertReturnValue == -1 ) + { + // VXConsole isn't connected/running - default to the old behaviour (break) + g_bBreak = true; + } + else + { + // Respond to what the user selected + switch( g_VXConsoleAssertReturnValue ) + { + case ASSERT_ACTION_IGNORE_FILE: + IgnoreAssertsInCurrentFile(); + break; + case ASSERT_ACTION_IGNORE_THIS: + // Ignore this Assert once + break; + case ASSERT_ACTION_BREAK: + // Break on this Assert + g_bBreak = true; + break; + case ASSERT_ACTION_IGNORE_ALL: + // Ignore all Asserts from now on + g_bAssertsEnabled = false; + break; + case ASSERT_ACTION_IGNORE_ALWAYS: + // Ignore this Assert from now on + IgnoreAssertsNearby( 0 ); + break; + case ASSERT_ACTION_OTHER: + default: + // Error... just break + XBX_Error( "DoNewAssertDialog: invalid Assert response returned from VXConsole - breaking to debugger" ); + g_bBreak = true; + break; + } + } +#elif defined( _PS3 ) + // There are a few ways to handle this sort of assert behavior with the PS3 / Target Manager API. + // One is to use a DebuggerBreak per usual, and then SNProcessContinue in the TMAPI to make + // the game resume after a breakpoint. (You can use snIsDebuggerPresent() to determine if + // the debugger is attached, although really it doesn't matter here.) + // This doesn't work because the DebuggerBreak() is actually an interrupt op, and so Continue() + // won't continue past it -- you need to do that from inside the ProDG debugger itself. + // Another is to wait on a mutex here and then trip it from the TMAPI, but there isn't + // a clean way to trip sync primitives from TMAPI. + // Another way is to suspend the thread here and have TMAPI resume it. + // The simplest way is to spin-wait on a shared variable that you expect the + // TMAPI to poke into memory. I'm trying that. + + char cmdString[XBX_MAX_RCMDLENGTH]; + + // Before calling VXConsole, init the global variable that receives the result + g_VXConsoleAssertReturnValue = -1; + + // Message VXConsole to pop up a PC-side Assert dialog + _snprintf( cmdString, sizeof(cmdString), "Assert() 0x%.8x File: %s\tLine: %d\t%s", + &g_VXConsoleAssertReturnValue, pFilename, line, pExpression ); + XBX_SendRemoteCommand( cmdString, false ); + + if ( g_pValvePS3Console->IsConsoleConnected() ) + { + // DebuggerBreak(); + + while ( g_VXConsoleAssertReturnValue == -1 ) + { + ThreadSleep( 1000 ); + } + + // assume that the VX has poked the return value + // Respond to what the user selected + switch( g_VXConsoleAssertReturnValue ) + { + case ASSERT_ACTION_IGNORE_FILE: + IgnoreAssertsInCurrentFile(); + break; + case ASSERT_ACTION_IGNORE_THIS: + // Ignore this Assert once + break; + case ASSERT_ACTION_BREAK: + // Break on this Assert + g_bBreak = true; + break; + case ASSERT_ACTION_IGNORE_ALL: + // Ignore all Asserts from now on + g_bAssertsEnabled = false; + break; + case ASSERT_ACTION_IGNORE_ALWAYS: + // Ignore this Assert from now on + IgnoreAssertsNearby( 0 ); + break; + case ASSERT_ACTION_OTHER: + default: + // nothing. + break; + } + } + else if ( g_pValvePS3Console->IsDebuggerPresent() ) + { + g_bBreak = true; + } + else + { + // ignore the assert + } + + +#elif defined( POSIX ) + + fprintf(stderr, "%s %i %s\n", pFilename, line, pExpression); + if ( getenv( "RAISE_ON_ASSERT" ) ) + { + DebuggerBreak(); + g_bBreak = true; + } + +#elif defined( _WIN32 ) + + if ( !g_hTier0Instance || !ThreadInMainThread() ) + { + int result = MessageBox( NULL, pExpression, "Assertion Failed", MB_SYSTEMMODAL | MB_CANCELTRYCONTINUE ); + + if ( result == IDCANCEL ) + { + IgnoreAssertsNearby( 0 ); + } + else if ( result == IDCONTINUE ) + { + g_bBreak = true; + } + } + else + { + HWND hParentWindow = FindLikelyParentWindow(); + + DialogBox( g_hTier0Instance, MAKEINTRESOURCE( IDD_ASSERT_DIALOG ), hParentWindow, AssertDialogProc ); + } + +#endif + + return g_bBreak; +} + diff --git a/external/vpc/tier0/commandline.cpp b/external/vpc/tier0/commandline.cpp new file mode 100644 index 0000000..2620b2e --- /dev/null +++ b/external/vpc/tier0/commandline.cpp @@ -0,0 +1,676 @@ +//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $Workfile: $ +// $NoKeywords: $ +//===========================================================================// + +#include "pch_tier0.h" +#include "tier0/icommandline.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include "tier0/dbg.h" +#include "tier0_strtools.h" +#include "tier1/strtools.h" // this is included for the definition of V_isspace() + +#ifdef PLATFORM_POSIX +#include <limits.h> +#define _MAX_PATH PATH_MAX +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + + +static const int MAX_PARAMETER_LEN = 128; + +//----------------------------------------------------------------------------- +// Purpose: Implements ICommandLine +//----------------------------------------------------------------------------- +class CCommandLine : public ICommandLine +{ +public: + // Construction + CCommandLine( void ); + virtual ~CCommandLine( void ); + + // Implements ICommandLine + virtual void CreateCmdLine( const char *commandline ); + virtual void CreateCmdLine( int argc, char **argv ); + virtual const char *GetCmdLine( void ) const; + virtual const char *CheckParm( const char *psz, const char **ppszValue = 0 ) const; + + virtual void RemoveParm( const char *parm ); + virtual void AppendParm( const char *pszParm, const char *pszValues ); + + virtual int ParmCount() const; + virtual int FindParm( const char *psz ) const; + virtual const char* GetParm( int nIndex ) const; + + virtual const char *ParmValue( const char *psz, const char *pDefaultVal = NULL ) const; + virtual int ParmValue( const char *psz, int nDefaultVal ) const; + virtual float ParmValue( const char *psz, float flDefaultVal ) const; + virtual void SetParm( int nIndex, char const *pParm ); + +private: + enum + { + MAX_PARAMETER_LEN = 128, + MAX_PARAMETERS = 256, + }; + + // When the commandline contains @name, it reads the parameters from that file + void LoadParametersFromFile( const char *&pSrc, char *&pDst, intp maxDestLen, bool bInQuotes ); + + // Parse command line... + void ParseCommandLine(); + + // Frees the command line arguments + void CleanUpParms(); + + // Adds an argument.. + void AddArgument( const char *pFirst, const char *pLast ); + + // Copy of actual command line + char *m_pszCmdLine; + + // Pointers to each argument... + int m_nParmCount; + char *m_ppParms[MAX_PARAMETERS]; +}; + + +//----------------------------------------------------------------------------- +// Instance singleton and expose interface to rest of code +//----------------------------------------------------------------------------- +static CCommandLine g_CmdLine; +ICommandLine *CommandLine() +{ + return &g_CmdLine; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CCommandLine::CCommandLine( void ) +{ + m_pszCmdLine = NULL; + m_nParmCount = 0; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CCommandLine::~CCommandLine( void ) +{ + CleanUpParms(); + delete[] m_pszCmdLine; +} + + +//----------------------------------------------------------------------------- +// Read commandline from file instead... +//----------------------------------------------------------------------------- +void CCommandLine::LoadParametersFromFile( const char *&pSrc, char *&pDst, intp maxDestLen, bool bInQuotes ) +{ + // Suck out the file name + char szFileName[ MAX_PATH ]; + char *pOut; + char *pDestStart = pDst; + + if ( maxDestLen < 3 ) + return; + + // Skip the @ sign + pSrc++; + + pOut = szFileName; + + char terminatingChar = ' '; + if ( bInQuotes ) + terminatingChar = '\"'; + + while ( *pSrc && *pSrc != terminatingChar ) + { + *pOut++ = *pSrc++; + if ( (pOut - szFileName) >= (MAX_PATH-1) ) + break; + } + + *pOut = '\0'; + + // Skip the space after the file name + if ( *pSrc ) + pSrc++; + + // Now read in parameters from file + FILE *fp = fopen( szFileName, "r" ); + if ( fp ) + { + char c; + c = (char)fgetc( fp ); + while ( c != EOF ) + { + // Turn return characters into spaces + if ( c == '\n' ) + c = ' '; + + *pDst++ = c; + + // Don't go past the end, and allow for our terminating space character AND a terminating null character. + if ( (pDst - pDestStart) >= (maxDestLen-2) ) + break; + + // Get the next character, if there are more + c = (char)fgetc( fp ); + } + + // Add a terminating space character + *pDst++ = ' '; + + fclose( fp ); + } + else + { + printf( "Parameter file '%s' not found, skipping...", szFileName ); + } +} + + +//----------------------------------------------------------------------------- +// Creates a command line from the arguments passed in +//----------------------------------------------------------------------------- +void CCommandLine::CreateCmdLine( int argc, char **argv ) +{ + char cmdline[2048]; + cmdline[0] = 0; + const int MAX_CHARS = sizeof(cmdline) - 1; + cmdline[MAX_CHARS] = 0; + for ( int i = 0; i < argc; ++i ) + { + strncat( cmdline, "\"", MAX_CHARS ); + strncat( cmdline, argv[i], MAX_CHARS ); + strncat( cmdline, "\"", MAX_CHARS ); + strncat( cmdline, " ", MAX_CHARS ); + } + + CreateCmdLine( cmdline ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Create a command line from the passed in string +// Note that if you pass in a @filename, then the routine will read settings +// from a file instead of the command line +//----------------------------------------------------------------------------- +void CCommandLine::CreateCmdLine( const char *commandline ) +{ + if ( m_pszCmdLine ) + { + delete[] m_pszCmdLine; + } + + char szFull[ 4096 ]; + + char *pDst = szFull; + const char *pSrc = commandline; + + bool bInQuotes = false; + const char *pInQuotesStart = 0; + while ( *pSrc ) + { + // Is this an unslashed quote? + if ( *pSrc == '"' ) + { + if ( pSrc == commandline || ( pSrc[-1] != '/' && pSrc[-1] != '\\' ) ) + { + bInQuotes = !bInQuotes; + pInQuotesStart = pSrc + 1; + } + } + + if ( *pSrc == '@' ) + { + if ( pSrc == commandline || (!bInQuotes && V_isspace( pSrc[-1] )) || (bInQuotes && pSrc == pInQuotesStart) ) + { + LoadParametersFromFile( pSrc, pDst, sizeof( szFull ) - (pDst - szFull), bInQuotes ); + if ( bInQuotes ) + { + // Back up over the opening quote which has already been copied to pDst. + // Otherwise we end up with an orphaned single quote which causes later + // parsing problems. + --pDst; + Assert( *pDst == '\"' ); + } + // The opening quote, if any, is now gone. + bInQuotes = false; + continue; + } + } + + // Don't go past the end. + if ( (pDst - szFull) >= (sizeof( szFull ) - 1) ) + break; + + *pDst++ = *pSrc++; + } + + *pDst = '\0'; + + size_t len = strlen( szFull ) + 1; + m_pszCmdLine = new char[len]; + memcpy( m_pszCmdLine, szFull, len ); + +#if defined( PLATFORM_PS3 ) + Plat_SetCommandLine( m_pszCmdLine ); +#endif + + ParseCommandLine(); +} + + +//----------------------------------------------------------------------------- +// Finds a string in another string with a case insensitive test +//----------------------------------------------------------------------------- +static char * _stristr( char * pStr, const char * pSearch ) +{ + AssertValidStringPtr(pStr); + AssertValidStringPtr(pSearch); + + if (!pStr || !pSearch) + return 0; + + char* pLetter = pStr; + + // Check the entire string + while (*pLetter != 0) + { + // Skip over non-matches + if (tolower((unsigned char)*pLetter) == tolower((unsigned char)*pSearch)) + { + // Check for match + char const* pMatch = pLetter + 1; + char const* pTest = pSearch + 1; + while (*pTest != 0) + { + // We've run off the end; don't bother. + if (*pMatch == 0) + return 0; + + if (tolower((unsigned char)*pMatch) != tolower((unsigned char)*pTest)) + break; + + ++pMatch; + ++pTest; + } + + // Found a match! + if (*pTest == 0) + return pLetter; + } + + ++pLetter; + } + + return 0; +} + + +//----------------------------------------------------------------------------- +// Purpose: Remove specified string ( and any args attached to it ) from command line +// Input : *pszParm - +//----------------------------------------------------------------------------- +void CCommandLine::RemoveParm( const char *pszParm ) +{ + if ( !m_pszCmdLine ) + return; + + // Search for first occurrence of pszParm + char *p, *found; + char *pnextparam; + intp n; + size_t curlen; + + p = m_pszCmdLine; + while ( *p ) + { + curlen = strlen( p ); + + found = _stristr( p, pszParm ); + if ( !found ) + break; + + pnextparam = found + 1; + bool bHadQuote = false; + if ( found > m_pszCmdLine && found[-1] == '\"' ) + bHadQuote = true; + + while ( pnextparam && *pnextparam && (*pnextparam != ' ') && (*pnextparam != '\"') ) + pnextparam++; + + if ( pnextparam && ( static_cast<size_t>( pnextparam - found ) > strlen( pszParm ) ) ) + { + p = pnextparam; + continue; + } + + while ( pnextparam && *pnextparam && (*pnextparam != '-') && (*pnextparam != '+') ) + pnextparam++; + + if ( bHadQuote ) + { + found--; + } + + if ( pnextparam && *pnextparam ) + { + // We are either at the end of the string, or at the next param. Just chop out the current param. + n = curlen - ( pnextparam - p ); // # of characters after this param. + memmove( found, pnextparam, n ); + + found[n] = '\0'; + } + else + { + // Clear out rest of string. + n = pnextparam - found; + memset( found, 0, n ); + } + } + + // Strip and trailing ' ' characters left over. + while ( 1 ) + { + intp len = strlen( m_pszCmdLine ); + if ( len == 0 || m_pszCmdLine[ len - 1 ] != ' ' ) + break; + + m_pszCmdLine[len - 1] = '\0'; + } + + ParseCommandLine(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Append parameter and argument values to command line +// Input : *pszParm - +// *pszValues - +//----------------------------------------------------------------------------- +void CCommandLine::AppendParm( const char *pszParm, const char *pszValues ) +{ + intp nNewLength = 0; + char *pCmdString; + + nNewLength = strlen( pszParm ); // Parameter. + if ( pszValues ) + nNewLength += strlen( pszValues ) + 1; // Values + leading space character. + nNewLength++; // Terminal 0; + + if ( !m_pszCmdLine ) + { + m_pszCmdLine = new char[ nNewLength ]; + strcpy( m_pszCmdLine, pszParm ); + if ( pszValues ) + { + strcat( m_pszCmdLine, " " ); + strcat( m_pszCmdLine, pszValues ); + } + + ParseCommandLine(); + return; + } + + // Remove any remnants from the current Cmd Line. + RemoveParm( pszParm ); + + nNewLength += strlen( m_pszCmdLine ) + 1 + 1; + + pCmdString = new char[ nNewLength ]; + memset( pCmdString, 0, nNewLength ); + + strcpy ( pCmdString, m_pszCmdLine ); // Copy old command line. + strcat ( pCmdString, " " ); // Put in a space + strcat ( pCmdString, pszParm ); + if ( pszValues ) + { + strcat( pCmdString, " " ); + strcat( pCmdString, pszValues ); + } + + // Kill off the old one + delete[] m_pszCmdLine; + + // Point at the new command line. + m_pszCmdLine = pCmdString; + + ParseCommandLine(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Return current command line +// Output : const char +//----------------------------------------------------------------------------- +const char *CCommandLine::GetCmdLine( void ) const +{ + return m_pszCmdLine; +} + + +//----------------------------------------------------------------------------- +// Purpose: Search for the parameter in the current commandline +// Input : *psz - +// **ppszValue - +// Output : char +//----------------------------------------------------------------------------- +const char *CCommandLine::CheckParm( const char *psz, const char **ppszValue ) const +{ + if ( ppszValue ) + *ppszValue = NULL; + + int i = FindParm( psz ); + if ( i == 0 ) + return NULL; + + if ( ppszValue ) + { + if ( (i+1) >= m_nParmCount ) + { + *ppszValue = NULL; + } + else + { + *ppszValue = m_ppParms[i+1]; + } + } + + return m_ppParms[i]; +} + + +//----------------------------------------------------------------------------- +// Adds an argument.. +//----------------------------------------------------------------------------- +void CCommandLine::AddArgument( const char *pFirst, const char *pLast ) +{ + if ( pLast == pFirst ) + return; + + if ( m_nParmCount >= MAX_PARAMETERS ) + Error( "CCommandLine::AddArgument: exceeded %d parameters", MAX_PARAMETERS ); + + size_t nLen = ( pLast - pFirst ) + 1; + m_ppParms[m_nParmCount] = new char[nLen]; + memcpy( m_ppParms[m_nParmCount], pFirst, nLen - 1 ); + m_ppParms[m_nParmCount][nLen - 1] = 0; + + ++m_nParmCount; +} + + +//----------------------------------------------------------------------------- +// Parse command line... +//----------------------------------------------------------------------------- +void CCommandLine::ParseCommandLine() +{ + CleanUpParms(); + if (!m_pszCmdLine) + return; + + const char *pChar = m_pszCmdLine; + while ( *pChar && V_isspace(*pChar) ) + { + ++pChar; + } + + bool bInQuotes = false; + const char *pFirstLetter = NULL; + for ( ; *pChar; ++pChar ) + { + if ( bInQuotes ) + { + if ( *pChar != '\"' ) + continue; + + AddArgument( pFirstLetter, pChar ); + pFirstLetter = NULL; + bInQuotes = false; + continue; + } + + // Haven't started a word yet... + if ( !pFirstLetter ) + { + if ( *pChar == '\"' ) + { + bInQuotes = true; + pFirstLetter = pChar + 1; + continue; + } + + if ( V_isspace( *pChar ) ) + continue; + + pFirstLetter = pChar; + continue; + } + + // Here, we're in the middle of a word. Look for the end of it. + if ( V_isspace( *pChar ) ) + { + AddArgument( pFirstLetter, pChar ); + pFirstLetter = NULL; + } + } + + if ( pFirstLetter ) + { + AddArgument( pFirstLetter, pChar ); + } +} + + +//----------------------------------------------------------------------------- +// Individual command line arguments +//----------------------------------------------------------------------------- +void CCommandLine::CleanUpParms() +{ + for ( int i = 0; i < m_nParmCount; ++i ) + { + delete [] m_ppParms[i]; + m_ppParms[i] = NULL; + } + m_nParmCount = 0; +} + + +//----------------------------------------------------------------------------- +// Returns individual command line arguments +//----------------------------------------------------------------------------- +int CCommandLine::ParmCount() const +{ + return m_nParmCount; +} + +int CCommandLine::FindParm( const char *psz ) const +{ + // Start at 1 so as to not search the exe name + for ( int i = 1; i < m_nParmCount; ++i ) + { + if ( !V_tier0_stricmp( psz, m_ppParms[i] ) ) + return i; + } + return 0; +} + +const char* CCommandLine::GetParm( int nIndex ) const +{ + Assert( (nIndex >= 0) && (nIndex < m_nParmCount) ); + if ( (nIndex < 0) || (nIndex >= m_nParmCount) ) + return ""; + return m_ppParms[nIndex]; +} +void CCommandLine::SetParm( int nIndex, char const *pParm ) +{ + if ( pParm ) + { + Assert( (nIndex >= 0) && (nIndex < m_nParmCount) ); + if ( (nIndex >= 0) && (nIndex < m_nParmCount) ) + { + if ( m_ppParms[nIndex] ) + delete[] m_ppParms[nIndex]; + m_ppParms[nIndex] = strdup( pParm ); + } + + } + +} + + +//----------------------------------------------------------------------------- +// Returns the argument after the one specified, or the default if not found +//----------------------------------------------------------------------------- +const char *CCommandLine::ParmValue( const char *psz, const char *pDefaultVal ) const +{ + int nIndex = FindParm( psz ); + if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1)) + return pDefaultVal; + + // Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-' + if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' ) + return pDefaultVal; + + return m_ppParms[nIndex + 1]; +} + +int CCommandLine::ParmValue( const char *psz, int nDefaultVal ) const +{ + int nIndex = FindParm( psz ); + if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1)) + return nDefaultVal; + + // Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-' + if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' ) + return nDefaultVal; + + return atoi( m_ppParms[nIndex + 1] ); +} + +float CCommandLine::ParmValue( const char *psz, float flDefaultVal ) const +{ + int nIndex = FindParm( psz ); + if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1)) + return flDefaultVal; + + // Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-' + if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' ) + return flDefaultVal; + + return atof( m_ppParms[nIndex + 1] ); +} diff --git a/external/vpc/tier0/cpu.cpp b/external/vpc/tier0/cpu.cpp new file mode 100644 index 0000000..420e1a1 --- /dev/null +++ b/external/vpc/tier0/cpu.cpp @@ -0,0 +1,697 @@ +//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// +#include "pch_tier0.h" + +#if defined(_WIN32) && !defined(_X360) +#define WINDOWS_LEAN_AND_MEAN +#include <windows.h> +#include "cputopology.h" +#elif defined( PLATFORM_OSX ) +#include <sys/sysctl.h> +#endif + +#ifndef _PS3 +#include "tier0_strtools.h" +#endif + +//#include "tier1/strtools.h" // this is included for the definition of V_isspace() +#ifdef PLATFORM_WINDOWS_PC +#include <intrin.h> +#endif + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + +const tchar* GetProcessorVendorId(); + +static bool cpuid(uint32 function, uint32& out_eax, uint32& out_ebx, uint32& out_ecx, uint32& out_edx) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#elif defined(GNUC) + asm("mov %%ebx, %%esi\n\t" + "cpuid\n\t" + "xchg %%esi, %%ebx" + : "=a" (out_eax), + "=S" (out_ebx), + "=c" (out_ecx), + "=d" (out_edx) + : "a" (function) + ); + return true; +#elif defined(_WIN64) + int pCPUInfo[4]; + __cpuid( pCPUInfo, (int)function ); + out_eax = pCPUInfo[0]; + out_ebx = pCPUInfo[1]; + out_ecx = pCPUInfo[2]; + out_edx = pCPUInfo[3]; + return false; +#else + bool retval = true; + uint32 local_eax, local_ebx, local_ecx, local_edx; + _asm pushad; + + __try + { + _asm + { + xor edx, edx // Clue the compiler that EDX & others is about to be used. + xor ecx, ecx + xor ebx, ebx // <Sergiy> Note: if I don't zero these out, cpuid sometimes won't work, I didn't find out why yet + mov eax, function // set up CPUID to return processor version and features + // 0 = vendor string, 1 = version info, 2 = cache info + cpuid // code bytes = 0fh, 0a2h + mov local_eax, eax // features returned in eax + mov local_ebx, ebx // features returned in ebx + mov local_ecx, ecx // features returned in ecx + mov local_edx, edx // features returned in edx + } + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + retval = false; + } + + out_eax = local_eax; + out_ebx = local_ebx; + out_ecx = local_ecx; + out_edx = local_edx; + + _asm popad + + return retval; +#endif +} + +static bool CheckMMXTechnology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return true; +#else + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + return false; + + return ( edx & 0x800000 ) != 0; +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: This is a bit of a hack because it appears +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +static bool IsWin98OrOlder() +{ +#if defined( _X360 ) || defined( _PS3 ) || defined( POSIX ) + return false; +#else + bool retval = false; + + OSVERSIONINFOEX osvi; + ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); + osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); + + BOOL bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi); + if( !bOsVersionInfoEx ) + { + // If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO. + + osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO); + if ( !GetVersionEx ( (OSVERSIONINFO *) &osvi) ) + { + Error( _T("IsWin98OrOlder: Unable to get OS version information") ); + } + } + + switch (osvi.dwPlatformId) + { + case VER_PLATFORM_WIN32_NT: + // NT, XP, Win2K, etc. all OK for SSE + break; + case VER_PLATFORM_WIN32_WINDOWS: + // Win95, 98, Me can't do SSE + retval = true; + break; + case VER_PLATFORM_WIN32s: + // Can't really run this way I don't think... + retval = true; + break; + default: + break; + } + + return retval; +#endif +} + + +static bool CheckSSETechnology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return true; +#else + if ( IsWin98OrOlder() ) + { + return false; + } + + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + { + return false; + } + + return ( edx & 0x2000000L ) != 0; +#endif +} + +static bool CheckSSE2Technology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + return false; + + return ( edx & 0x04000000 ) != 0; +#endif +} + +bool CheckSSE3Technology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax,ebx,edx,ecx; + if( !cpuid(1,eax,ebx,ecx,edx) ) + return false; + + return ( ecx & 0x00000001 ) != 0; // bit 1 of ECX +#endif +} + +bool CheckSSSE3Technology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + // SSSE 3 is implemented by both Intel and AMD + // detection is done the same way for both vendors + uint32 eax,ebx,edx,ecx; + if( !cpuid(1,eax,ebx,ecx,edx) ) + return false; + + return ( ecx & ( 1 << 9 ) ) != 0; // bit 9 of ECX +#endif +} + +bool CheckSSE41Technology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + // SSE 4.1 is implemented by both Intel and AMD + // detection is done the same way for both vendors + + uint32 eax,ebx,edx,ecx; + if( !cpuid(1,eax,ebx,ecx,edx) ) + return false; + + return ( ecx & ( 1 << 19 ) ) != 0; // bit 19 of ECX +#endif +} + +bool CheckSSE42Technology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + // SSE4.2 is an Intel-only feature + + const char *pchVendor = GetProcessorVendorId(); + if ( 0 != V_tier0_stricmp( pchVendor, "GenuineIntel" ) ) + return false; + + uint32 eax,ebx,edx,ecx; + if( !cpuid(1,eax,ebx,ecx,edx) ) + return false; + + return ( ecx & ( 1 << 20 ) ) != 0; // bit 20 of ECX +#endif +} + + +bool CheckSSE4aTechnology( void ) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + // SSE 4a is an AMD-only feature + + const char *pchVendor = GetProcessorVendorId(); + if ( 0 != V_tier0_stricmp( pchVendor, "AuthenticAMD" ) ) + return false; + + uint32 eax,ebx,edx,ecx; + if( !cpuid( 0x80000001,eax,ebx,ecx,edx) ) + return false; + + return ( ecx & ( 1 << 6 ) ) != 0; // bit 6 of ECX +#endif +} + + +static bool Check3DNowTechnology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax, unused; + if ( !cpuid(0x80000000,eax,unused,unused,unused) ) + return false; + + if ( eax > 0x80000000L ) + { + if ( !cpuid(0x80000001,unused,unused,unused,eax) ) + return false; + + return ( eax & 1<<31 ) != 0; + } + return false; +#endif +} + +static bool CheckCMOVTechnology() +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + return false; + + return ( edx & (1<<15) ) != 0; +#endif +} + +static bool CheckFCMOVTechnology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + return false; + + return ( edx & (1<<16) ) != 0; +#endif +} + +static bool CheckRDTSCTechnology(void) +{ +#if defined( _X360 ) || defined( _PS3 ) + return false; +#else + uint32 eax,ebx,edx,unused; + if ( !cpuid(1,eax,ebx,unused,edx) ) + return false; + + return ( edx & 0x10 ) != 0; +#endif +} + +// Return the Processor's vendor identification string, or "Generic_x86" if it doesn't exist on this CPU +const tchar* GetProcessorVendorId() +{ +#if defined( _X360 ) || defined( _PS3 ) + return "PPC"; +#else + uint32 unused, VendorIDRegisters[3]; + + static tchar VendorID[13]; + + memset( VendorID, 0, sizeof(VendorID) ); + if ( !cpuid(0,unused, VendorIDRegisters[0], VendorIDRegisters[2], VendorIDRegisters[1] ) ) + { + if ( IsPC() ) + { + _tcscpy( VendorID, _T( "Generic_x86" ) ); + } + else if ( IsX360() ) + { + _tcscpy( VendorID, _T( "PowerPC" ) ); + } + } + else + { + memcpy( VendorID+0, &(VendorIDRegisters[0]), sizeof( VendorIDRegisters[0] ) ); + memcpy( VendorID+4, &(VendorIDRegisters[1]), sizeof( VendorIDRegisters[1] ) ); + memcpy( VendorID+8, &(VendorIDRegisters[2]), sizeof( VendorIDRegisters[2] ) ); + } + + return VendorID; +#endif +} + +// Returns non-zero if Hyper-Threading Technology is supported on the processors and zero if not. +// If it's supported, it does not mean that it's been enabled. So we test another flag to see if it's enabled +// See Intel Processor Identification and the CPUID instruction Application Note 485 +// http://www.intel.com/Assets/PDF/appnote/241618.pdf +static bool HTSupported(void) +{ +#if ( defined( _X360 ) || defined( _PS3 ) ) + // not entirtely sure about the semantic of HT support, it being an intel name + // are we asking about HW threads or HT? + return true; +#else + enum { + HT_BIT = 0x10000000, // EDX[28] - Bit 28 set indicates Hyper-Threading Technology is supported in hardware. + FAMILY_ID = 0x0f00, // EAX[11:8] - Bit 11 thru 8 contains family processor id + EXT_FAMILY_ID = 0x0f00000, // EAX[23:20] - Bit 23 thru 20 contains extended family processor id + FAMILY_ID_386 = 0x0300, + FAMILY_ID_486 = 0x0400, // EAX[8:12] - 486, 487 and overdrive + FAMILY_ID_PENTIUM = 0x0500, // Pentium, Pentium OverDrive 60 - 200 + FAMILY_ID_PENTIUM_PRO = 0x0600,// P Pro, P II, P III, P M, Celeron M, Core Duo, Core Solo, Core2 Duo, Core2 Extreme, P D, Xeon model F, + // also 45-nm : Intel Atom, Core i7, Xeon MP ; see Intel Processor Identification and the CPUID instruction pg 20,21 + + FAMILY_ID_EXTENDED = 0x0F00 // P IV, Xeon, Celeron D, P D, + }; + + uint32 unused, + reg_eax = 0, + reg_ebx = 0, + reg_edx = 0, + vendor_id[3] = {0, 0, 0}; + + // verify cpuid instruction is supported + if( !cpuid(0,unused, vendor_id[0],vendor_id[2],vendor_id[1]) + || !cpuid(1,reg_eax,reg_ebx,unused,reg_edx) ) + return false; + + // <Sergiy> Previously, we detected P4 specifically; now, we detect GenuineIntel with HT enabled in general + // if (((reg_eax & FAMILY_ID) == FAMILY_ID_EXTENDED) || (reg_eax & EXT_FAMILY_ID)) + + // Check to see if this is an Intel Processor with HT or CMT capability , and if HT/CMT is enabled + if (vendor_id[0] == 'uneG' && vendor_id[1] == 'Ieni' && vendor_id[2] == 'letn') + return (reg_edx & HT_BIT) != 0 && // Genuine Intel Processor with Hyper-Threading Technology implemented + ((reg_ebx >> 16) & 0xFF) > 1 ; // Hyper-Threading OR Core Multi-Processing has been enabled + + return false; // This is not a genuine Intel processor. +#endif +} + +// See Intel Processor Identification and the CPUID instruction Application Note 485 +// http://www.intel.com/Assets/PDF/appnote/241618.pdf +int LogicalProcessorsPerCore() +{ +#if defined( _X360 ) || defined( _PS3 ) || defined( LINUX ) + return 2; // +#elif defined(_WIN32) + uint32 nMaxStandardFnSupported, nVendorId[3]; + if( !cpuid( 0, nMaxStandardFnSupported,nVendorId[0],nVendorId[2],nVendorId[1] ) ) + { + return 1; + } + + uint32 nFn1_Eax, nFn1_Ebx, nFn1_Ecx, nFn1_Edx; + if( !cpuid( 1, nFn1_Eax, nFn1_Ebx, nFn1_Ecx, nFn1_Edx) ) + { + return 1; + } + + enum CpuidFnMasks + { + HTT = 0x10000000, // Fn0000_0001 EDX[28] + LogicalProcessorCount = 0x00FF0000, // Fn0000_0001 EBX[23:16] + ApicId = 0xFF000000, // Fn0000_0001 EBX[31:24] + NC_Intel = 0xFC000000, // Fn0000_0004 EAX[31:26] + NC_Amd = 0x000000FF, // Fn8000_0008 ECX[7:0] + CmpLegacy_Amd = 0x00000002, // Fn8000_0001 ECX[1] + ApicIdCoreIdSize_Amd = 0x0000F000 // Fn8000_0008 ECX[15:12] + }; + + // Determine if hardware threading is enabled. + if( nFn1_Edx & HTT ) + { + // Determine the total number of logical processors per package. + int nLogProcsPerPkg = ( nFn1_Ebx & LogicalProcessorCount ) >> 16; + int nCoresPerPkg = 1; + + if( ( ( nFn1_Ebx >> 16 ) & 0xFF ) <= 1 ) // Has Hyper-Threading OR Core Multi-Processing not been enabled ? + { + // NOTE: This is only tested on Intel CPUs; I don't know if it's true on AMD, as I have no HT AMD to test on + return 1; // HT was turned off, for all intents and purposes in our engine it means one logical CPU per core + } + + // Determine the total number of cores per package. This info + // is extracted differently dependending on the cpu vendor. + if( nVendorId[0] == 'uneG' && nVendorId[1] == 'Ieni' && nVendorId[2] == 'letn' ) // GenuineIntel + { + if( nMaxStandardFnSupported >= 4 ) + { + uint32 nFn4_Eax, nFn4_Ebx, nFn4_Ecx, nFn4_Edx ; + if( cpuid( 4, nFn4_Eax, nFn4_Ebx, nFn4_Ecx, nFn4_Edx ) ) + { + nCoresPerPkg = ( ( nFn4_Eax & NC_Intel ) >> 26 ) + 1; + + } + } + // <Sergiy> as the DirectX CoreDetection sample goes, the logic is that on old processors where + // the functions aren't supported, we assume one core per package, multiple logical processors per package + // I suspect this may be wrong, especially for AMD processors. + return nLogProcsPerPkg / nCoresPerPkg; + } +#if 0 // <Sergiy> To make as concervative change as possible now, I'll skip AMD hyperthread detection + else + { + if( nVendorId[0] == 'htuA' && nVendorId[1] == 'itne' && nVendorId[2] == 'DMAc' ) // AuthenticAMD + { + uint32 nFnx8_Eax, nFnx8_Ebx, nFnx8_Ecx, nFnx8_Edx ; + if( cpuid( 0x80000008, nFnx8_Eax, nFnx8_Ebx, nFnx8_Ecx, nFnx8_Edx ) ) + { + // AMD reports the msb width of the CORE_ID bit field of the APIC ID + // in ApicIdCoreIdSize_Amd. The maximum value represented by the msb + // width is the theoretical number of cores the processor can support + // and not the actual number of current cores, which is how the msb width + // of the CORE_ID bit field has been traditionally determined. If the + // ApicIdCoreIdSize_Amd value is zero, then you use the traditional method + // to determine the CORE_ID msb width. + DWORD msbWidth = nFnx8_Ecx & ApicIdCoreIdSize_Amd; + if( msbWidth ) + { + // Set nCoresPerPkg to the maximum theortical number of cores + // the processor package can support (2 ^ width) so the APIC + // extractor object can be configured to extract the proper + // values from an APIC. + nCoresPerPkg = 1 << ( msbWidth >> 12 ); + } + else + { + // Set nCoresPerPkg to the actual number of cores being reported + // by the CPUID instruction. + nCoresPerPkg = ( nFnx8_Ecx & NC_Amd ) + 1; + } + } + } + // <Sergiy> as the DirectX CoreDetection sample goes, the logic is that on old processors where + // the functions aren't supported, we assume one core per package, multiple logical processors per package + // I suspect this may be wrong, especially for AMD processors. + return nLogProcsPerPkg / nCoresPerPkg; + } +#endif + } + return 1; +#endif +} + + + +// Measure the processor clock speed by sampling the cycle count, waiting +// for some fraction of a second, then measuring the elapsed number of cycles. +static int64 CalculateClockSpeed() +{ +#if defined( _X360 ) || defined(_PS3) + // Xbox360 and PS3 have the same clock speed and share a lot of characteristics on PPU + return 3200000000LL; +#else +#if defined( _WIN32 ) + LARGE_INTEGER waitTime, startCount, curCount; + CCycleCount start, end; + + // Take 1/32 of a second for the measurement. + QueryPerformanceFrequency( &waitTime ); + int scale = 5; + waitTime.QuadPart >>= scale; + + QueryPerformanceCounter( &startCount ); + start.Sample(); + do + { + QueryPerformanceCounter( &curCount ); + } + while ( curCount.QuadPart - startCount.QuadPart < waitTime.QuadPart ); + end.Sample(); + + return (end.m_Int64 - start.m_Int64) << scale; +#elif defined(POSIX) + uint64 CalculateCPUFreq(); // from cpu_linux.cpp + int64 freq =(int64)CalculateCPUFreq(); + if ( freq == 0 ) // couldn't calculate clock speed + { + Error( "Unable to determine CPU Frequency\n" ); + } + return freq; +#else + #error "Please implement Clock Speed function for this platform" +#endif +#endif +} + +static CPUInformation s_cpuInformation; + +const CPUInformation& GetCPUInformation() +{ + CPUInformation &pi = s_cpuInformation; + // Has the structure already been initialized and filled out? + if ( pi.m_Size == sizeof(pi) ) + return pi; + + // Redundant, but just in case the user somehow messes with the size. + memset(&pi, 0x0, sizeof(pi)); + + // Fill out the structure, and return it: + pi.m_Size = sizeof(pi); + + // Grab the processor frequency: + pi.m_Speed = CalculateClockSpeed(); + + // Get the logical and physical processor counts: + +#if defined( _X360 ) + pi.m_nPhysicalProcessors = 3; + pi.m_nLogicalProcessors = 6; +#elif defined( _PS3 ) + pi.m_nPhysicalProcessors = 1; + pi.m_nLogicalProcessors = 2; +#elif defined(_WIN32) && !defined( _X360 ) + SYSTEM_INFO si; + ZeroMemory( &si, sizeof(si) ); + + GetSystemInfo( &si ); + + // Sergiy: fixing: si.dwNumberOfProcessors is the number of logical processors according to experiments on i7, P4 and a DirectX sample (Aug'09) + // this is contrary to MSDN documentation on GetSystemInfo() + // + pi.m_nLogicalProcessors = si.dwNumberOfProcessors; + if ( 0 == V_tier0_stricmp( GetProcessorVendorId(), "AuthenticAMD" ) ) + { + // quick fix for AMD Phenom: it reports 3 logical cores and 4 physical cores; + // no AMD CPUs by the end of 2009 have HT, so we'll override HT detection here + pi.m_nPhysicalProcessors = pi.m_nLogicalProcessors; + } + else + { + CpuTopology topo; + pi.m_nPhysicalProcessors = topo.NumberOfSystemCores(); + } + + // Make sure I always report at least one, when running WinXP with the /ONECPU switch, + // it likes to report 0 processors for some reason. + if ( pi.m_nPhysicalProcessors == 0 && pi.m_nLogicalProcessors == 0 ) + { + Assert( !"Sergiy: apparently I didn't fix some CPU detection code completely. Let me know and I'll do my best to fix it soon." ); + pi.m_nPhysicalProcessors = 1; + pi.m_nLogicalProcessors = 1; + } +#elif defined(LINUX) + pi.m_nLogicalProcessors = 0; + pi.m_nPhysicalProcessors = 0; + const int k_cMaxProcessors = 256; + bool rgbProcessors[k_cMaxProcessors]; + memset( rgbProcessors, 0, sizeof( rgbProcessors ) ); + int cMaxCoreId = 0; + + FILE *fpCpuInfo = fopen( "/proc/cpuinfo", "r" ); + if ( fpCpuInfo ) + { + char rgchLine[256]; + while ( fgets( rgchLine, sizeof( rgchLine ), fpCpuInfo ) ) + { + if ( !strncasecmp( rgchLine, "processor", strlen( "processor" ) ) ) + { + pi.m_nLogicalProcessors++; + } + if ( !strncasecmp( rgchLine, "core id", strlen( "core id" ) ) ) + { + char *pchValue = strchr( rgchLine, ':' ); + cMaxCoreId = MAX( cMaxCoreId, atoi( pchValue + 1 ) ); + } + if ( !strncasecmp( rgchLine, "physical id", strlen( "physical id" ) ) ) + { + // it seems (based on survey data) that we can see + // processor N (N > 0) when it's the only processor in + // the system. so keep track of each processor + char *pchValue = strchr( rgchLine, ':' ); + int cPhysicalId = atoi( pchValue + 1 ); + if ( cPhysicalId < k_cMaxProcessors ) + rgbProcessors[cPhysicalId] = true; + } + /* this code will tell us how many physical chips are in the machine, but we want + core count, so for the moment, each processor counts as both logical and physical. + if ( !strncasecmp( rgchLine, "physical id ", strlen( "physical id " ) ) ) + { + char *pchValue = strchr( rgchLine, ':' ); + pi.m_nPhysicalProcessors = MAX( pi.m_nPhysicalProcessors, atol( pchValue ) ); + } + */ + } + fclose( fpCpuInfo ); + for ( int i = 0; i < k_cMaxProcessors; i++ ) + if ( rgbProcessors[i] ) + pi.m_nPhysicalProcessors++; + pi.m_nPhysicalProcessors *= ( cMaxCoreId + 1 ); + } + else + { + pi.m_nLogicalProcessors = 1; + pi.m_nPhysicalProcessors = 1; + Assert( !"couldn't read cpu information from /proc/cpuinfo" ); + } + +#elif defined(OSX) + int mib[2], num_cpu = 1; + size_t len; + mib[0] = CTL_HW; + mib[1] = HW_NCPU; + len = sizeof(num_cpu); + sysctl(mib, 2, &num_cpu, &len, NULL, 0); + pi.m_nPhysicalProcessors = num_cpu; + pi.m_nLogicalProcessors = num_cpu; + +#endif + + // Determine Processor Features: + pi.m_bRDTSC = CheckRDTSCTechnology(); + pi.m_bCMOV = CheckCMOVTechnology(); + pi.m_bFCMOV = CheckFCMOVTechnology(); + pi.m_bMMX = CheckMMXTechnology(); + pi.m_bSSE = CheckSSETechnology(); + pi.m_bSSE2 = CheckSSE2Technology(); + pi.m_bSSE3 = CheckSSE3Technology(); + pi.m_bSSSE3 = CheckSSSE3Technology(); + pi.m_bSSE4a = CheckSSE4aTechnology(); + pi.m_bSSE41 = CheckSSE41Technology(); + pi.m_bSSE42 = CheckSSE42Technology(); + pi.m_b3DNow = Check3DNowTechnology(); + pi.m_szProcessorID = (tchar*)GetProcessorVendorId(); + pi.m_bHT = pi.m_nPhysicalProcessors < pi.m_nLogicalProcessors; //HTSupported(); + + return pi; +} + diff --git a/external/vpc/tier0/cpu_posix.cpp b/external/vpc/tier0/cpu_posix.cpp new file mode 100644 index 0000000..4fe2db8 --- /dev/null +++ b/external/vpc/tier0/cpu_posix.cpp @@ -0,0 +1,143 @@ +//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: determine CPU speed under linux +// +// $NoKeywords: $ +//=============================================================================// +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/sysctl.h> +#include <sys/time.h> +#include <unistd.h> +#include <tier0/platform.h> +#include <errno.h> + +#define rdtsc(x) \ + __asm__ __volatile__ ("rdtsc" : "=A" (x)) + +class TimeVal +{ +public: + TimeVal() {} + TimeVal& operator=(const TimeVal &val) { m_TimeVal = val.m_TimeVal; } + inline double operator-(const TimeVal &left) + { + uint64 left_us = (uint64) left.m_TimeVal.tv_sec * 1000000 + left.m_TimeVal.tv_usec; + uint64 right_us = (uint64) m_TimeVal.tv_sec * 1000000 + m_TimeVal.tv_usec; + uint64 diff_us = left_us - right_us; + return diff_us/1000000; + } + + timeval m_TimeVal; +}; + +// Compute the positive difference between two 64 bit numbers. +static inline uint64 diff(uint64 v1, uint64 v2) +{ + uint64 d = v1 - v2; + if (d >= 0) return d; else return -d; +} + +#ifdef OSX +uint64 GetCPUFreqFromPROC() +{ + int mib[2] = {CTL_HW, HW_CPU_FREQ}; + uint64 frequency = 0; + size_t len = sizeof(frequency); + + if (sysctl(mib, 2, &frequency, &len, NULL, 0) == -1) + return 0; + return frequency; +} +#else +uint64 GetCPUFreqFromPROC() +{ + double mhz = 0; + char line[1024], *s, search_str[] = "cpu MHz"; + FILE *fp; + + /* open proc/cpuinfo */ + if ((fp = fopen("/proc/cpuinfo", "r")) == NULL) + { + return 0; + } + + /* ignore all lines until we reach MHz information */ + while (fgets(line, 1024, fp) != NULL) + { + if (strstr(line, search_str) != NULL) + { + /* ignore all characters in line up to : */ + for (s = line; *s && (*s != ':'); ++s); + /* get MHz number */ + if (*s && (sscanf(s+1, "%lf", &mhz) == 1)) + break; + } + } + + if (fp!=NULL) fclose(fp); + + return (uint64)(mhz*1000000); +} +#endif + + +uint64 CalculateCPUFreq() +{ +#ifdef LINUX + char const *pFreq = getenv("CPU_MHZ"); + if ( pFreq ) + { + uint64 retVal = 1000000; + return retVal * atoi( pFreq ); + } +#endif + + // Compute the period. Loop until we get 3 consecutive periods that + // are the same to within a small error. The error is chosen + // to be +/- 0.02% on a P-200. + const uint64 error = 40000; + const int max_iterations = 600; + int count; + uint64 period, period1 = error * 2, period2 = 0, period3 = 0; + + for (count = 0; count < max_iterations; count++) + { + TimeVal start_time, end_time; + uint64 start_tsc, end_tsc; + gettimeofday (&start_time.m_TimeVal, 0); + rdtsc (start_tsc); + usleep (5000); // sleep for 5 msec + gettimeofday (&end_time.m_TimeVal, 0); + rdtsc (end_tsc); + + period3 = (end_tsc - start_tsc) / (end_time - start_time); + + if (diff (period1, period2) <= error && + diff (period2, period3) <= error && + diff (period1, period3) <= error) + break; + + period1 = period2; + period2 = period3; + } + + if (count == max_iterations) + { + return GetCPUFreqFromPROC(); // fall back to /proc + } + + // Set the period to the average period measured. + period = (period1 + period2 + period3) / 3; + + // Some Pentiums have broken TSCs that increment very + // slowly or unevenly. + if (period < 10000000) + { + return GetCPUFreqFromPROC(); // fall back to /proc + } + + return period; +} + diff --git a/external/vpc/tier0/cputopology.cpp b/external/vpc/tier0/cputopology.cpp new file mode 100644 index 0000000..1125cae --- /dev/null +++ b/external/vpc/tier0/cputopology.cpp @@ -0,0 +1,1018 @@ +//------------------------------------------------------------------------------------- +// CpuTopology.cpp +// +// CpuToplogy class implementation. +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------------- +#include "pch_tier0.h" + +#if defined(_WIN32) && !defined(_X360) && !defined( _PS3 ) +#include "cputopology.h" +#include <stdlib.h> +#include <crtdbg.h> + +#undef malloc +#undef free +#ifdef _WIN64 + // Inline assembly is not supported in 64-bit. Ideally, we would prefer to + // use the __cpuid intrinsic to avoid having to drop to assembly altogether. + // However, as of MSVC 9.0, the __cpuid intrinsic does not enable the + // ability to set the ECX register, which is required for obtaining certain + // extended CPU information. To overcome these issues, we must call the + // Cpuid64() external function, which is written in assembly and located in + // the cpuid64.asm file included in this project. This project contains a build + // step that invokes 64-bit MASM on cpuid64.asm when building a 64-bit target. + extern "C" void Cpuid64(void* argsPtr); +#endif + +//--------------------------------------------------------------------------------- +// Name: ICpuToplogy +// Desc: Specifies the interface that each class that provides an implementation +// for extracting cpu topology must conform to. This is the Implementor +// class in the traditional Bridge Pattern. +//--------------------------------------------------------------------------------- +class ICpuTopology +{ +public: + virtual ~ICpuTopology() + { + } + virtual BOOL IsDefaultImpl() const = 0; + virtual DWORD NumberOfProcessCores() const = 0; + virtual DWORD NumberOfSystemCores() const = 0; + virtual DWORD_PTR CoreAffinityMask( DWORD coreIdx ) const = 0; +}; + + +namespace +{ +/////////////////////////////////////////////////////////////////////////////////// +// Local Class Definitions +/////////////////////////////////////////////////////////////////////////////////// + +//--------------------------------------------------------------------------------- +// Name: DefaultImpl +// Desc: Provides a default implementation for the ICpuTopology interface when +// GetLogicalProcessorInformation and CPUID are not supported for whatever +// reason. This is a ConcreteImplementor class in the traditional Bridge +// Pattern. +//--------------------------------------------------------------------------------- +class DefaultImpl : public ICpuTopology +{ +public: + //----------------------------------------------------------------------------- + // DefaultImpl::IsDefaultImpl + //----------------------------------------------------------------------------- + /*virtual*/ BOOL IsDefaultImpl() const + { + return TRUE; + } + + //----------------------------------------------------------------------------- + // DefaultImpl::NumberOfProcessCores + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfProcessCores() const + { + return 1; + } + + //----------------------------------------------------------------------------- + // DefaultImpl::IsNumberOfSystemCores + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfSystemCores() const + { + return 1; + } + + //----------------------------------------------------------------------------- + // DefaultImpl::CoreAffinityMask + //----------------------------------------------------------------------------- + /*virtual*/ DWORD_PTR CoreAffinityMask( DWORD coreIdx ) const + { + DWORD_PTR coreAffinity = 0; + if( 1 == coreIdx ) + { + DWORD_PTR dwSystemAffinity; + GetProcessAffinityMask( GetCurrentProcess(), &coreAffinity, &dwSystemAffinity ); + } + return coreAffinity; + } +}; + +//--------------------------------------------------------------------------------- +// Name: GlpiImpl +// Desc: Provides the GetLogicalProcessorInformation implementation for the +// ICpuTopology interface. This is a ConcreteImplementor class in the +// traditional Bridge Pattern. +//--------------------------------------------------------------------------------- +class GlpiImpl : public ICpuTopology +{ +public: + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::GlpiImpl + // Desc: Initializes the internal structures/data with information retrieved + // from a call to GetLogicalProcessorInformation. + //----------------------------------------------------------------------------- + GlpiImpl() : m_pSlpi( NULL ), + m_nItems( 0 ) + { + _ASSERT( IsSupported() ); + + GlpiFnPtr pGlpi = GetGlpiFn_(); + _ASSERT( pGlpi ); + + DWORD cbBuffer = 0; + pGlpi( 0, &cbBuffer ); + + m_pSlpi = ( SYSTEM_LOGICAL_PROCESSOR_INFORMATION* )malloc( cbBuffer ); + pGlpi( m_pSlpi, &cbBuffer ); + m_nItems = cbBuffer / sizeof( SYSTEM_LOGICAL_PROCESSOR_INFORMATION ); + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::~GlpiImpl + //----------------------------------------------------------------------------- + /*virtual*/ ~GlpiImpl() + { + free( m_pSlpi ); + m_pSlpi = 0; + m_nItems = 0; + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::IsDefaultImpl + //----------------------------------------------------------------------------- + /*virtual*/ BOOL IsDefaultImpl() const + { + return FALSE; + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::NumberOfProcessCores + // Desc: Gets the total number of physical processor cores available to the + // current process. + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfProcessCores() const + { + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + GetProcessAffinityMask( GetCurrentProcess(), &dwProcessAffinity, &dwSystemAffinity ); + + DWORD nCores = 0; + for( DWORD i = 0; i < m_nItems; ++i ) + { + if( ( RelationProcessorCore == m_pSlpi[i].Relationship ) && + ( m_pSlpi[i].ProcessorMask & dwProcessAffinity ) ) + { + ++nCores; + } + } + return nCores; + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::NumberOfSystemCores + // Desc: Gets the total number of physical processor cores enabled on the + // system. + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfSystemCores() const + { + DWORD nCores = 0; + for( DWORD i = 0; i < m_nItems; ++i ) + { + if( RelationProcessorCore == m_pSlpi[i].Relationship ) + ++nCores; + } + return nCores; + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::CoreAffinityMask + // Desc: Gets an affinity mask that corresponds to the requested processor + // core. + //----------------------------------------------------------------------------- + /*virtual*/ DWORD_PTR CoreAffinityMask( DWORD coreIdx ) const + { + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + GetProcessAffinityMask( GetCurrentProcess(), &dwProcessAffinity, &dwSystemAffinity ); + + for( DWORD i = 0; i < m_nItems; ++i ) + { + if( RelationProcessorCore == m_pSlpi[i].Relationship ) + { + if( !coreIdx-- ) + { + return m_pSlpi[i].ProcessorMask & dwProcessAffinity; + } + } + } + return 0; + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::IsSupported + //----------------------------------------------------------------------------- + static BOOL IsSupported() + { + return NULL != GetGlpiFn_(); + } + +private: + // GetLogicalProcessorInformation function pointer + typedef BOOL( WINAPI* GlpiFnPtr )( +SYSTEM_LOGICAL_PROCESSOR_INFORMATION*, +PDWORD +); + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::VerifyGlpiFn_ + // Desc: Gets a pointer to the GetLogicalProcessorInformation function only if + // it is supported on the current platform. + // GetLogicalProcessorInformation is supported on Windows Server 2003 and + // XP64, however there is a bug with the implementation. Therefore, only + // GetLogicalProcessorInformation on Windows Vista is supported in this + // sample. + //----------------------------------------------------------------------------- + static GlpiFnPtr VerifyGlpiFn_() + { + // VerifyVersionInfo function pointer + typedef BOOL ( WINAPI* VviFnPtr )( LPOSVERSIONINFOEX, + DWORD, + DWORDLONG ); + + HMODULE hMod = GetModuleHandle( TEXT( "kernel32" ) ); +#ifdef _UNICODE + VviFnPtr pVvi = (VviFnPtr) GetProcAddress( hMod, "VerifyVersionInfoW" ); + #else + VviFnPtr pVvi = ( VviFnPtr )GetProcAddress( hMod, "VerifyVersionInfoA" ); +#endif + GlpiFnPtr pGlpi = NULL; + + if( pVvi ) + { + // VerSetConditionMask function pointer + typedef ULONGLONG ( WINAPI* VscmFnPtr )( ULONGLONG, + DWORD, + BYTE ); + + VscmFnPtr pVscm = ( VscmFnPtr )GetProcAddress( hMod, "VerSetConditionMask" ); + + _ASSERT( pVscm ); + + // Check for Windows Vista + OSVERSIONINFOEX osvi = { sizeof( OSVERSIONINFOEX ) }; + osvi.dwMajorVersion = 6; + osvi.dwMinorVersion = 0; + osvi.wServicePackMajor = 0; + osvi.wServicePackMinor = 0; + + ULONGLONG dwlMask = 0; + dwlMask = pVscm( dwlMask, VER_MAJORVERSION, VER_GREATER_EQUAL ); + dwlMask = pVscm( dwlMask, VER_MINORVERSION, VER_GREATER_EQUAL ); + dwlMask = pVscm( dwlMask, VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL ); + dwlMask = pVscm( dwlMask, VER_SERVICEPACKMINOR, VER_GREATER_EQUAL ); + + if( pVvi( &osvi, VER_MAJORVERSION + | VER_MINORVERSION + | VER_SERVICEPACKMAJOR + | VER_SERVICEPACKMINOR, + dwlMask ) ) + { + pGlpi = ( GlpiFnPtr )GetProcAddress( hMod, "GetLogicalProcessorInformation" ); + _ASSERT( pGlpi ); + } + } + + return pGlpi; + + } + + //----------------------------------------------------------------------------- + // Name: GlpiImpl::GetGlpiFn_ + // Desc: Gets a cached pointer to the GetLogicalProcessorInformation function. + //----------------------------------------------------------------------------- + static GlpiFnPtr GetGlpiFn_() + { + static GlpiFnPtr pGlpi = VerifyGlpiFn_(); + return pGlpi; + } + + // Private Members + SYSTEM_LOGICAL_PROCESSOR_INFORMATION* m_pSlpi; + DWORD m_nItems; +}; + +//--------------------------------------------------------------------------------- +// Name: ApicExtractor +// Desc: A utility class that provides an interface for decoding a processor +// APIC ID. An APIC ID is an 8-bit identifier given to each logical +// processor on system boot and can be retrieved by the CPUID instruction. +// Each APIC ID is composed of a PACKAGE_ID, CORE_ID and SMT_ID that describe +// the relationship of a logical processor within the processor topology of +// the system. +//--------------------------------------------------------------------------------- +class ApicExtractor +{ +public: + //----------------------------------------------------------------------------- + // Name: ApicExtractor::ApicExtractor + //----------------------------------------------------------------------------- + ApicExtractor( DWORD nLogProcsPerPkg = 1, DWORD nCoresPerPkg = 1 ) + { + SetPackageTopology( nLogProcsPerPkg, nCoresPerPkg ); + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::SmtId + //----------------------------------------------------------------------------- + BYTE SmtId( BYTE apicId ) const + { + return apicId & m_smtIdMask.mask; + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::CoreId + //----------------------------------------------------------------------------- + BYTE CoreId( BYTE apicId ) const + { + return ( apicId & m_coreIdMask.mask ) >> m_smtIdMask.width; + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::PackageId + //----------------------------------------------------------------------------- + BYTE PackageId( BYTE apicId ) const + { + return ( apicId & m_pkgIdMask.mask ) >> + ( m_smtIdMask.width + m_coreIdMask.width ); + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::PackageCoreId + //----------------------------------------------------------------------------- + BYTE PackageCoreId( BYTE apicId ) const + { + return ( apicId & ( m_pkgIdMask.mask | m_coreIdMask.mask ) ) >> + m_smtIdMask.width; + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::GetLogProcsPerPkg + //----------------------------------------------------------------------------- + DWORD GetLogProcsPerPkg() const + { + return m_nLogProcsPerPkg; + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::GetCoresPerPkg + //----------------------------------------------------------------------------- + DWORD GetCoresPerPkg() const + { + return m_nCoresPerPkg; + } + + //----------------------------------------------------------------------------- + // Name: ApicExtractor::SetPackageTopology + // Desc: You should call SetPackageTopology with the number of logical + // processors per package and number of cores per package before calling + // the sub id accessors (SmtId(), CoreId(), PackageId(), PackageCoreId()) + // as this information is required to effectively decode an APIC ID into + // its sub parts. + //----------------------------------------------------------------------------- + void SetPackageTopology( DWORD nLogProcsPerPkg, DWORD nCoresPerPkg ) + { + m_nLogProcsPerPkg = ( BYTE )nLogProcsPerPkg; + m_nCoresPerPkg = ( BYTE )nCoresPerPkg; + + // fix for Phenom x3 and similar CPUs - it reports 3 logical processors per package, and 4 cores per package + // so one core is probably just disabled for yield, but it causes a bug in GetMaskWidth that propagates + if( m_nCoresPerPkg > m_nLogProcsPerPkg ) + { + m_nCoresPerPkg = m_nLogProcsPerPkg; + } + + m_smtIdMask.width = GetMaskWidth_( m_nLogProcsPerPkg / m_nCoresPerPkg ); + m_coreIdMask.width = GetMaskWidth_( m_nCoresPerPkg ); + m_pkgIdMask.width = 8 - ( m_smtIdMask.width + m_coreIdMask.width ); + + m_pkgIdMask.mask = ( BYTE )( 0xFF << ( m_smtIdMask.width + m_coreIdMask.width ) ); + m_coreIdMask.mask = ( BYTE )( ( 0xFF << m_smtIdMask.width ) ^ m_pkgIdMask.mask ); + m_smtIdMask.mask = ( BYTE )~( 0xFF << m_smtIdMask.width ); + + } + +private: + //----------------------------------------------------------------------------- + // Name: ApicExtractor::GetMaskWidth_ + // Desc: Gets the width of a sub id bit field in an APIC ID. The width of a + // sub id (CORE_ID, SMT_ID) is only wide enough to support the maximum + // number of ids that needs to be represented in the topology. + //----------------------------------------------------------------------------- + static BYTE GetMaskWidth_( BYTE maxIds ) + { + --maxIds; + + // find index of msb + BYTE msbIdx = 8; + BYTE msbMask = 0x80; + while( msbMask && !( msbMask & maxIds ) ) + { + --msbIdx; + msbMask >>= 1; + } + return msbIdx; + } + + struct IdMask + { + BYTE width; + BYTE mask; + }; + + // Private Members + BYTE m_nLogProcsPerPkg; + BYTE m_nCoresPerPkg; + IdMask m_smtIdMask; + IdMask m_coreIdMask; + IdMask m_pkgIdMask; +}; + +//--------------------------------------------------------------------------------- +// Name: Cpuid +// Desc: A utility class that wraps the functionality of the CPUID instruction. +// Call the Call() method with the desired CPUID function, and use the +// register accessors to retrieve the register values. +//--------------------------------------------------------------------------------- +class Cpuid +{ +public: + // FnSet values are used to indicate a CPUID function set. + enum FnSet + { + Std = 0x00000000, + Ext = 0x80000000 + }; + + //----------------------------------------------------------------------------- + // Name: Cpuid::Cpuid + //----------------------------------------------------------------------------- + Cpuid() : m_eax( 0 ), + m_ebx( 0 ), + m_ecx( 0 ), + m_edx( 0 ) + { + } + + // Register accessors + DWORD Eax() const + { + return m_eax; + } + DWORD Ebx() const + { + return m_ebx; + } + DWORD Ecx() const + { + return m_ecx; + } + DWORD Edx() const + { + return m_edx; + } + + //----------------------------------------------------------------------------- + // Name: Cpuid::Call + // Desc: Calls the CPUID instruction with the specified function. Returns TRUE + // if the CPUID function was supported, FALSE if it wasn't. + //----------------------------------------------------------------------------- + BOOL Call( FnSet fnSet, DWORD fn ) + { + if( IsFnSupported( fnSet, fn ) ) + { + UncheckedCall_( fnSet, fn ); + return true; + } + return false; + } + + //----------------------------------------------------------------------------- + // Name: Cpuid::IsVendor + // Desc: Compares a string with the vendor string encoded in the CPUID + // instruction. + //----------------------------------------------------------------------------- + static BOOL IsVendor( const char* strVendor ) + { + // Cache the vendor string + static const Cpuid cpu( Std ); + return cpu.Ebx() == *reinterpret_cast<const DWORD*>( strVendor ) + && cpu.Ecx() == *reinterpret_cast<const DWORD*>( strVendor + 8 ) + && cpu.Edx() == *reinterpret_cast<const DWORD*>( strVendor + 4 ); + } + + //----------------------------------------------------------------------------- + // Name: Cpuid::IsFnSupported + // Desc: Checks to see if a CPUID function is supported. Different processors + // support different functions. This method is automatically called from + // the Call() method, so you don't need to call it beforehand. + //----------------------------------------------------------------------------- + static BOOL IsFnSupported( FnSet fnSet, DWORD fn ) + { + // Cache the maximum supported standard function + static const DWORD MaxStdFn = Cpuid( Std ).Eax(); + // Cache the maximum supported extended function + static const DWORD MaxExtFn = Cpuid( Ext ).Eax(); + + bool ret = false; + switch( fnSet ) + { + case Std: + ret = ( fn <= MaxStdFn ); + break; + case Ext: + ret = ( fn <= MaxExtFn ); + break; + default: + _ASSERT( 0 ); // should never get here + break; + } + return ret; + } + +private: + //----------------------------------------------------------------------------- + // Name: Cpuid::Cpuid + // Desc: This constructor is private and is only used to set a Cpuid object to + // initial values retrieved from CPUID functions 0x00000000 and + // 0x80000000. Good for caching values from the CPUID instruction that + // are not variable, like the encoded vendor string and the maximum + // supported CPUID function values. + //----------------------------------------------------------------------------- + explicit Cpuid( FnSet fnSet ) + { + UncheckedCall_( fnSet, 0 ); + } + + //----------------------------------------------------------------------------- + // Name: Cpuid::UncheckedCall_ + // Desc: Calls the CPUID instruction without checking for CPUID function + // support. + //----------------------------------------------------------------------------- + void UncheckedCall_( FnSet fnSet, DWORD fn ) + { +#ifdef _WIN64 + // Inline assembly is not supported in 64-bit. Ideally, we would prefer to + // use the __cpuid intrinsic to avoid having to drop to assembly altogether. + // However, as of MSVC 9.0, the __cpuid intrinsic does not enable the + // ability to set the ECX register, which is required for obtaining certain + // extended CPU information. To overcome these issues, we must call the + // Cpuid64() external function, which is written in assembly and located in + // the cpuid64.asm file included in this project. This project contains a build + // step that invokes 64-bit MASM on cpuid64.asm when building a 64-bit target. + m_eax = fnSet | fn; + m_ecx = 0; + Cpuid64(this); + #else + __asm + { + mov ecx, 0 + mov eax, fn + or eax, fnSet + cpuid + mov edi, this + mov [edi].m_eax, eax + mov [edi].m_ebx, ebx + mov [edi].m_ecx, ecx + mov [edi].m_edx, edx + } +#endif + } + + // Private Members + DWORD m_eax; + DWORD m_ebx; + DWORD m_ecx; + DWORD m_edx; +}; + +//--------------------------------------------------------------------------------- +// Name: CpuidImpl +// Desc: Provides the CPUID instruction implementation for the ICpuTopology +// interface. This is a ConcreteImplementor class in the traditional Bridge +// Pattern. +//--------------------------------------------------------------------------------- +class CpuidImpl : public ICpuTopology +{ +public: + // CpuidFnMasks are used when extracting bit-encoded information retrieved from + // the CPUID instruction + enum CpuidFnMasks + { + HTT = 0x10000000, // Fn0000_0001 EDX[28] + LogicalProcessorCount = 0x00FF0000, // Fn0000_0001 EBX[23:16] + ApicId = 0xFF000000, // Fn0000_0001 EBX[31:24] + NC_Intel = 0xFC000000, // Fn0000_0004 EAX[31:26] + NC_Amd = 0x000000FF, // Fn8000_0008 ECX[7:0] + CmpLegacy_Amd = 0x00000002, // Fn8000_0001 ECX[1] + ApicIdCoreIdSize_Amd = 0x0000F000 // Fn8000_0008 ECX[15:12] + }; + + enum + { + MaxLogicalProcessors = sizeof( DWORD_PTR ) * 8 + }; + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::CpuidImpl + // Desc: Initializes internal structures/data with information retrieved from + // calling the CPUID instruction. + //----------------------------------------------------------------------------- + CpuidImpl() : m_nItems( 0 ) + { + _ASSERT( IsSupported() ); + + DWORD nLogProcsPerPkg = 1; + DWORD nCoresPerPkg = 1; + + Cpuid cpu; + + // Determine if hardware threading is enabled. + cpu.Call( Cpuid::Std, 1 ); + if( cpu.Edx() & HTT ) + { + // Determine the total number of logical processors per package. + nLogProcsPerPkg = ( cpu.Ebx() & LogicalProcessorCount ) >> 16; + + // Determine the total number of cores per package. This info + // is extracted differently dependending on the cpu vendor. + if( Cpuid::IsVendor( GenuineIntel ) ) + { + if( cpu.Call( Cpuid::Std, 4 ) ) + { + nCoresPerPkg = ( ( cpu.Eax() & NC_Intel ) >> 26 ) + 1; + } + } + else + { + _ASSERT( Cpuid::IsVendor( AuthenticAMD ) ); + if( cpu.Call( Cpuid::Ext, 8 ) ) + { + // AMD reports the msb width of the CORE_ID bit field of the APIC ID + // in ApicIdCoreIdSize_Amd. The maximum value represented by the msb + // width is the theoretical number of cores the processor can support + // and not the actual number of current cores, which is how the msb width + // of the CORE_ID bit field has been traditionally determined. If the + // ApicIdCoreIdSize_Amd value is zero, then you use the traditional method + // to determine the CORE_ID msb width. + DWORD msbWidth = cpu.Ecx() & ApicIdCoreIdSize_Amd; + if( msbWidth ) + { + // Set nCoresPerPkg to the maximum theortical number of cores + // the processor package can support (2 ^ width) so the APIC + // extractor object can be configured to extract the proper + // values from an APIC. + nCoresPerPkg = 1 << ( msbWidth >> 12 ); + } + else + { + // Set nCoresPerPkg to the actual number of cores being reported + // by the CPUID instruction. + nCoresPerPkg = ( cpu.Ecx() & NC_Amd ) + 1; + } + } + } + } + + // Configure the APIC extractor object with the information it needs to + // be able to decode the APIC. + m_apicExtractor.SetPackageTopology( nLogProcsPerPkg, nCoresPerPkg ); + + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + HANDLE hProcess = GetCurrentProcess(); + HANDLE hThread = GetCurrentThread(); + GetProcessAffinityMask( hProcess, &dwProcessAffinity, &dwSystemAffinity ); + if( 1 == dwSystemAffinity ) + { + // Since we only have 1 logical processor present on the system, we + // can explicitly set a single APIC ID to zero. + _ASSERT( 1 == nLogProcsPerPkg ); + m_apicIds[m_nItems++] = 0; + } + else + { + // Set the process affinity to the system affinity if they are not + // equal so that all logical processors can be accounted for. + if( dwProcessAffinity != dwSystemAffinity ) + { + SetProcessAffinityMask( hProcess, dwSystemAffinity ); + } + + // Call cpuid on each active logical processor in the system affinity. + DWORD_PTR dwPrevThreadAffinity = 0; + for( DWORD_PTR dwThreadAffinity = 1; + dwThreadAffinity && dwThreadAffinity <= dwSystemAffinity; + dwThreadAffinity <<= 1 ) + { + if( dwSystemAffinity & dwThreadAffinity ) + { + if( 0 == dwPrevThreadAffinity ) + { + // Save the previous thread affinity so we can return + // the executing thread affinity back to this state. + _ASSERT( 0 == m_nItems ); + dwPrevThreadAffinity = SetThreadAffinityMask( hThread, + dwThreadAffinity ); + } + else + { + _ASSERT( m_nItems > 0 ); + SetThreadAffinityMask( hThread, dwThreadAffinity ); + } + + // Allow the thread to switch to masked logical processor. + Sleep( 0 ); + + // Store the APIC ID + cpu.Call( Cpuid::Std, 1 ); + m_apicIds[m_nItems++] = ( BYTE )( ( cpu.Ebx() & ApicId ) >> 24 ); + } + } + + // Restore the previous process and thread affinity state. + SetProcessAffinityMask( hProcess, dwProcessAffinity ); + SetThreadAffinityMask( hThread, dwPrevThreadAffinity ); + Sleep( 0 ); + } + + } + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::IsDefaultImpl + //----------------------------------------------------------------------------- + /*virtual*/ BOOL IsDefaultImpl() const + { + return FALSE; + } + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::NumberOfProcessCores + // Desc: Gets the number of processor cores available to the current process. + // The total accounts for cores that may have been masked out by process + // affinity. + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfProcessCores() const + { + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + GetProcessAffinityMask( GetCurrentProcess(), &dwProcessAffinity, &dwSystemAffinity ); + + BYTE pkgCoreIds[MaxLogicalProcessors] = { 0 }; + DWORD nPkgCoreIds = 0; + + for( DWORD i = 0; i < m_nItems; ++i ) + { + if( dwProcessAffinity & ( ( DWORD_PTR )1 << i ) ) + { + AddUniquePkgCoreId_( i, pkgCoreIds, nPkgCoreIds ); + } + } + return nPkgCoreIds; + } + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::NumberOfSystemCores + // Desc: Gets the number of processor cores on the system. + //----------------------------------------------------------------------------- + /*virtual*/ DWORD NumberOfSystemCores() const + { + BYTE pkgCoreIds[MaxLogicalProcessors] = { 0 }; + DWORD nPkgCoreIds = 0; + for( DWORD i = 0; i < m_nItems; ++i ) + { + AddUniquePkgCoreId_( i, pkgCoreIds, nPkgCoreIds ); + } + return nPkgCoreIds; + } + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::CoreAffinityMask + // Desc: Gets an affinity mask that corresponds to a specific processor core. + // coreIdx must be less than the total number of processor cores + // recognized by the operating system (NumberOfSystemCores()). + //----------------------------------------------------------------------------- + /*virtual*/ DWORD_PTR CoreAffinityMask( DWORD coreIdx ) const + { + BYTE pkgCoreIds[MaxLogicalProcessors] = { 0 }; + DWORD nPkgCoreIds = 0; + for( DWORD i = 0; i < m_nItems; ++i ) + { + AddUniquePkgCoreId_( i, pkgCoreIds, nPkgCoreIds ); + } + + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + GetProcessAffinityMask( GetCurrentProcess(), &dwProcessAffinity, &dwSystemAffinity ); + + DWORD_PTR coreAffinity = 0; + if( coreIdx < nPkgCoreIds ) + { + for( DWORD i = 0; i < m_nItems; ++i ) + { + if( m_apicExtractor.PackageCoreId( m_apicIds[i] ) == pkgCoreIds[coreIdx] ) + { + coreAffinity |= ( dwProcessAffinity & ( ( DWORD_PTR )1 << i ) ); + } + } + } + return coreAffinity; + } + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::IsSupported + // Desc: Indicates if a CpuidImpl object is supported on this platform. + // Support is only granted on Intel and AMD platforms where the current + // calling process has security rights to query process affinity and + // change it if the process and system affinity differ. CpuidImpl is + // also not supported if thread affinity cannot be set on systems with + // more than 1 logical processor. + //----------------------------------------------------------------------------- + static BOOL IsSupported() + { + BOOL bSupported = Cpuid::IsVendor( GenuineIntel ) + || Cpuid::IsVendor( AuthenticAMD ); + + if( bSupported ) + { + DWORD_PTR dwProcessAffinity, dwSystemAffinity; + HANDLE hProcess = GetCurrentProcess(); + + // Query process affinity mask + bSupported = GetProcessAffinityMask( hProcess, &dwProcessAffinity, &dwSystemAffinity ); + if( bSupported ) + { + if( dwProcessAffinity != dwSystemAffinity ) + { + // The process and system affinities differ. Attempt to set + // the process affinity to the system affinity. + bSupported = SetProcessAffinityMask( hProcess, dwSystemAffinity ); + if( bSupported ) + { + // Restore previous process affinity + bSupported = SetProcessAffinityMask( hProcess, dwProcessAffinity ); + } + } + + if( bSupported && ( dwSystemAffinity > 1 ) ) + { + // Attempt to set the thread affinity + HANDLE hThread = GetCurrentThread(); + DWORD_PTR dwThreadAffinity = SetThreadAffinityMask( hThread, dwProcessAffinity ); + if( dwThreadAffinity ) + { + // Restore the previous thread affinity + bSupported = 0 != SetThreadAffinityMask( hThread, dwThreadAffinity ); + } + else + { + bSupported = FALSE; + } + } + } + } + return bSupported; + } + +private: + + //----------------------------------------------------------------------------- + // Name: CpuidImpl::AddUniquePkgCoreId_ + // Desc: Adds the package/core id extracted from the APIC ID at m_apicIds[idx] + // in the if the package/core id is unique to the pkgCoreIds array. + // nPkgCore is an in/out parm that will reflect the total number of items + // in pkgCoreIds array. It will be incrememted if a unique package/core + // id is found and added. + //----------------------------------------------------------------------------- + void AddUniquePkgCoreId_( DWORD idx, BYTE* pkgCoreIds, DWORD& nPkgCoreIds ) const + { + _ASSERT( idx < m_nItems ); + _ASSERT( NULL != pkgCoreIds ); + + DWORD j; + for( j = 0; j < nPkgCoreIds; ++j ) + { + if( pkgCoreIds[j] == m_apicExtractor.PackageCoreId( m_apicIds[idx] ) ) + break; + } + if( j == nPkgCoreIds ) + { + pkgCoreIds[j] = m_apicExtractor.PackageCoreId( m_apicIds[idx] ); + ++nPkgCoreIds; + } + } + + // Private Members + BYTE m_apicIds[MaxLogicalProcessors]; + BYTE m_nItems; + ApicExtractor m_apicExtractor; + + // Supported Vendor Strings + static const char GenuineIntel[]; + static const char AuthenticAMD[]; +}; + +// Static initialization of vendor strings +const char CpuidImpl::GenuineIntel[] = "GenuineIntel"; +const char CpuidImpl::AuthenticAMD[] = "AuthenticAMD"; + +} // unnamed-namespace + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::CpuTopology +// Desc: Initializes this object with the appropriately supported cpu topology +// implementation object. +//------------------------------------------------------------------------------------- +CpuTopology::CpuTopology( BOOL bForceCpuid ) : m_pImpl( NULL ) +{ + ForceCpuid( bForceCpuid ); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::~CpuTopology +//------------------------------------------------------------------------------------- +CpuTopology::~CpuTopology() +{ + Destroy_(); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::NumberOfProcessCores +// Desc: Gets the total number of physical processor cores available to the current +// process. +//------------------------------------------------------------------------------------- +DWORD CpuTopology::NumberOfProcessCores() const +{ + return m_pImpl->NumberOfProcessCores(); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::NumberOfSystemCores +// Desc: Gets the total number of physical processor cores enabled on the system. +//------------------------------------------------------------------------------------- +DWORD CpuTopology::NumberOfSystemCores() const +{ + return m_pImpl->NumberOfSystemCores(); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::CoreAffinityMask +// Desc: Gets an affinity mask that corresponds to the requested processor core. +//------------------------------------------------------------------------------------- +DWORD_PTR CpuTopology::CoreAffinityMask( DWORD coreIdx ) const +{ + return m_pImpl->CoreAffinityMask( coreIdx ); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::IsDefaultImpl +// Desc: Returns TRUE if m_pImpl is a DefaultImpl object, FALSE if not. Used to +// indicate whether or not the prescribed methods (CPUID or +// GetLogicalProcessorInformation) are supported on the system. +//------------------------------------------------------------------------------------- +BOOL CpuTopology::IsDefaultImpl() const +{ + return m_pImpl->IsDefaultImpl(); +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::ForceCpuid +// Desc: Constructs a cpu topology object. If bForce is FALSE, then a GlpiImpl object +// is first attempted, then CpuidImpl, then finally DefaultImpl. If bForce is +// TRUE, then GlpiImpl is never attempted. +//------------------------------------------------------------------------------------- +void CpuTopology::ForceCpuid( BOOL bForce ) +{ + Destroy_(); + + if( !bForce && GlpiImpl::IsSupported() ) + { + m_pImpl = new GlpiImpl(); + } + else if( CpuidImpl::IsSupported() ) + { + m_pImpl = new CpuidImpl(); + } + else + { + m_pImpl = new DefaultImpl(); + } +} + +//------------------------------------------------------------------------------------- +// Name: CpuTopology::Destroy_ +//------------------------------------------------------------------------------------- +void CpuTopology::Destroy_() +{ + delete m_pImpl; + m_pImpl = NULL; +} +#endif
\ No newline at end of file diff --git a/external/vpc/tier0/cputopology.h b/external/vpc/tier0/cputopology.h new file mode 100644 index 0000000..5da2890 --- /dev/null +++ b/external/vpc/tier0/cputopology.h @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------------- +// CpuTopology.h +// +// CpuToplogy class declaration. +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------------- +#pragma once +#ifndef CPU_TOPOLOGY_H +#define CPU_TOPOLOGY_H + +#include "winlite.h" + +class ICpuTopology; + +//--------------------------------------------------------------------------------- +// Name: CpuToplogy +// Desc: This class constructs a supported cpu topology implementation object on +// initialization and forwards calls to it. This is the Abstraction class +// in the traditional Bridge Pattern. +//--------------------------------------------------------------------------------- +class CpuTopology +{ +public: + CpuTopology( BOOL bForceCpuid = FALSE ); + ~CpuTopology(); + + BOOL IsDefaultImpl() const; + DWORD NumberOfProcessCores() const; + DWORD NumberOfSystemCores() const; + DWORD_PTR CoreAffinityMask( DWORD coreIdx ) const; + + void ForceCpuid( BOOL bForce ); +private: + void Destroy_(); + + ICpuTopology* m_pImpl; +}; + +#endif // CPU_TOPOLOGY_H diff --git a/external/vpc/tier0/dbg.cpp b/external/vpc/tier0/dbg.cpp new file mode 100644 index 0000000..8effafb --- /dev/null +++ b/external/vpc/tier0/dbg.cpp @@ -0,0 +1,627 @@ +//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $NoKeywords: $ +// +//===========================================================================// + +#include "tier0/platform.h" + +#if defined( PLATFORM_WINDOWS_PC ) +#define WIN_32_LEAN_AND_MEAN +#include <windows.h> // Currently needed for IsBadReadPtr and IsBadWritePtr +#pragma comment(lib,"user32.lib") // For MessageBox +#endif + +#include "tier0/minidump.h" +#include "tier0/stacktools.h" + +#include <assert.h> +#include <stdio.h> +#include <string.h> +#include <stdarg.h> +#include <stdlib.h> +#include "color.h" +#include "tier0/dbg.h" +#include "tier0/threadtools.h" +#include "tier0/icommandline.h" +#include <math.h> + +#if defined( _X360 ) +#include "xbox/xbox_console.h" +#endif + +#include "tier0/etwprof.h" + +#ifndef STEAM +#define PvRealloc realloc +#define PvAlloc malloc +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) +#pragma optimize( "g", off ) //variable argument functions seem to screw up stack walking unless this optimization is disabled +#pragma warning( disable: 4748 ) // Turn off the warning telling us that optimizations are off if /GS is on +#endif + +DEFINE_LOGGING_CHANNEL_NO_TAGS( LOG_LOADING, "LOADING" ); + +//----------------------------------------------------------------------------- +// Stack attachment management +//----------------------------------------------------------------------------- +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + +static bool s_bCallStacksWithAllWarnings = false; //if true, attach a call stack to every SPEW_WARNING message. Warning()/DevWarning()/... +static int s_iWarningMaxCallStackLength = 5; +#define AutomaticWarningCallStackLength() (s_bCallStacksWithAllWarnings ? s_iWarningMaxCallStackLength : 0) + +void _Warning_AlwaysSpewCallStack_Enable( bool bEnable ) +{ + s_bCallStacksWithAllWarnings = bEnable; +} + +void _Warning_AlwaysSpewCallStack_Length( int iMaxCallStackLength ) +{ + s_iWarningMaxCallStackLength = iMaxCallStackLength; +} + +static bool s_bCallStacksWithAllErrors = false; //if true, attach a call stack to every SPEW_ERROR message. Mostly just Error() +static int s_iErrorMaxCallStackLength = 20; //default to higher output with an error since we're quitting anyways +#define AutomaticErrorCallStackLength() (s_bCallStacksWithAllErrors ? s_iErrorMaxCallStackLength : 0) + +void _Error_AlwaysSpewCallStack_Enable( bool bEnable ) +{ + s_bCallStacksWithAllErrors = bEnable; +} + +void _Error_AlwaysSpewCallStack_Length( int iMaxCallStackLength ) +{ + s_iErrorMaxCallStackLength = iMaxCallStackLength; +} + +#else //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + +#define AutomaticWarningCallStackLength() 0 +#define AutomaticErrorCallStackLength() 0 + +void _Warning_AlwaysSpewCallStack_Enable( bool bEnable ) +{ +} + +void _Warning_AlwaysSpewCallStack_Length( int iMaxCallStackLength ) +{ +} + +void _Error_AlwaysSpewCallStack_Enable( bool bEnable ) +{ +} + +void _Error_AlwaysSpewCallStack_Length( int iMaxCallStackLength ) +{ +} + +#endif //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + +void _ExitOnFatalAssert( const tchar* pFile, int line ) +{ + Log_Msg( LOG_ASSERT, _T("Fatal assert failed: %s, line %d. Application exiting.\n"), pFile, line ); + + // only write out minidumps if we're not in the debugger + if ( !Plat_IsInDebugSession() ) + { + WriteMiniDump(); + } + + Log_Msg( LOG_DEVELOPER, _T("_ExitOnFatalAssert\n") ); + Plat_ExitProcess( EXIT_FAILURE ); +} + + +//----------------------------------------------------------------------------- +// Templates to assist in validating pointers: +//----------------------------------------------------------------------------- +PLATFORM_INTERFACE void _AssertValidReadPtr( void* ptr, int count/* = 1*/ ) +{ +#if defined( _WIN32 ) && !defined( _X360 ) + Assert( !IsBadReadPtr( ptr, count ) ); +#else + Assert( !count || ptr ); +#endif +} + +PLATFORM_INTERFACE void _AssertValidWritePtr( void* ptr, int count/* = 1*/ ) +{ +#if defined( _WIN32 ) && !defined( _X360 ) + Assert( !IsBadWritePtr( ptr, count ) ); +#else + Assert( !count || ptr ); +#endif +} + +PLATFORM_INTERFACE void _AssertValidReadWritePtr( void* ptr, int count/* = 1*/ ) +{ +#if defined( _WIN32 ) && !defined( _X360 ) + Assert(!( IsBadWritePtr(ptr, count) || IsBadReadPtr(ptr,count))); +#else + Assert( !count || ptr ); +#endif +} + +PLATFORM_INTERFACE void _AssertValidStringPtr( const tchar* ptr, int maxchar/* = 0xFFFFFF */ ) +{ +#if defined( _WIN32 ) && !defined( _X360 ) + #ifdef TCHAR_IS_CHAR + Assert( !IsBadStringPtr( ptr, maxchar ) ); + #else + Assert( !IsBadStringPtrW( ptr, maxchar ) ); + #endif +#else + Assert( ptr ); +#endif +} + +void AppendCallStackToLogMessage( tchar *formattedMessage, int iMessageLength, int iAppendCallStackLength ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) +# if defined( TCHAR_IS_CHAR ) //I'm horrible with unicode and I don't plan on testing this with wide characters just yet + if( iAppendCallStackLength > 0 ) + { + int iExistingMessageLength = (int)strlen( formattedMessage ); //no V_strlen in tier 0, plus we're only compiling this for windows and 360. Seems safe + formattedMessage += iExistingMessageLength; + iMessageLength -= iExistingMessageLength; + + if( iMessageLength <= 32 ) + return; //no room for anything useful + + //append directly to the spew message + if( (iExistingMessageLength > 0) && (formattedMessage[-1] == '\n') ) + { + --formattedMessage; + ++iMessageLength; + } + + //append preface + int iAppendedLength = _snprintf( formattedMessage, iMessageLength, _T("\nCall Stack:\n\t") ); + + void **CallStackBuffer = (void **)stackalloc( iAppendCallStackLength * sizeof( void * ) ); + int iCount = GetCallStack( CallStackBuffer, iAppendCallStackLength, 2 ); + if( TranslateStackInfo( CallStackBuffer, iCount, formattedMessage + iAppendedLength, iMessageLength - iAppendedLength, _T("\n\t") ) == 0 ) + { + //failure + formattedMessage[0] = '\0'; //this is pointing at where we wrote "\nCall Stack:\n\t" + } + else + { + iAppendedLength += (int)strlen( formattedMessage + iAppendedLength ); //no V_strlen in tier 0, plus we're only compiling this for windows and 360. Seems safe + + if( iAppendedLength < iMessageLength ) + { + formattedMessage[iAppendedLength] = '\n'; //Add another newline. + ++iAppendedLength; + + formattedMessage[iAppendedLength] = '\0'; + } + } + } +# else + AssertMsg( false, "Fixme" ); +# endif +#endif +} + +// Forward declare for internal use only. +CLoggingSystem *GetGlobalLoggingSystem(); + +#define Log_LegacyHelperColor_Stack( Channel, Severity, Color, MessageFormat, AppendCallStackLength ) \ + do \ +{ \ + CLoggingSystem *pLoggingSystem = GetGlobalLoggingSystem(); \ + if ( pLoggingSystem->IsChannelEnabled( Channel, Severity ) ) \ +{ \ + tchar formattedMessage[MAX_LOGGING_MESSAGE_LENGTH]; \ + va_list args; \ + va_start( args, MessageFormat ); \ + Tier0Internal_vsntprintf( formattedMessage, MAX_LOGGING_MESSAGE_LENGTH, MessageFormat, args ); \ + va_end( args ); \ + AppendCallStackToLogMessage( formattedMessage, MAX_LOGGING_MESSAGE_LENGTH, AppendCallStackLength ); \ + pLoggingSystem->LogDirect( Channel, Severity, Color, formattedMessage ); \ +} \ +} while( 0 ) + +#define Log_LegacyHelperColor( Channel, Severity, Color, MessageFormat ) Log_LegacyHelperColor_Stack( Channel, Severity, Color, MessageFormat, 0 ) + +#define Log_LegacyHelper_Stack( Channel, Severity, MessageFormat, AppendCallStackLength ) Log_LegacyHelperColor_Stack( Channel, Severity, pLoggingSystem->GetChannelColor( Channel ), MessageFormat, AppendCallStackLength ) +#define Log_LegacyHelper( Channel, Severity, MessageFormat ) Log_LegacyHelperColor( Channel, Severity, pLoggingSystem->GetChannelColor( Channel ), MessageFormat ) + + +void Msg( const tchar* pMsgFormat, ... ) +{ + Log_LegacyHelper( LOG_GENERAL, LS_MESSAGE, pMsgFormat ); +} + +void Warning( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper_Stack( LOG_GENERAL, LS_WARNING, pMsgFormat, AutomaticWarningCallStackLength() ); +} + +void Warning_SpewCallStack( int iMaxCallStackLength, const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper_Stack( LOG_GENERAL, LS_WARNING, pMsgFormat, iMaxCallStackLength ); +} + + +void Error( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper_Stack( LOG_GENERAL, LS_ERROR, pMsgFormat, AutomaticErrorCallStackLength() ); +} + +void Error_SpewCallStack( int iMaxCallStackLength, const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper_Stack( LOG_GENERAL, LS_ERROR, pMsgFormat, iMaxCallStackLength ); +} + + +//----------------------------------------------------------------------------- +// A couple of super-common dynamic spew messages, here for convenience +// These looked at the "developer" group, print if it's level 1 or higher +//----------------------------------------------------------------------------- +void DevMsg( int level, const tchar* pMsgFormat, ... ) +{ + LoggingChannelID_t channel = level >= 2 ? LOG_DEVELOPER_VERBOSE : LOG_DEVELOPER; + Log_LegacyHelper( channel, LS_MESSAGE, pMsgFormat ); +} + + +void DevWarning( int level, const tchar *pMsgFormat, ... ) +{ + LoggingChannelID_t channel = level >= 2 ? LOG_DEVELOPER_VERBOSE : LOG_DEVELOPER; + Log_LegacyHelper( channel, LS_WARNING, pMsgFormat ); +} + +void DevMsg( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper( LOG_DEVELOPER, LS_MESSAGE, pMsgFormat ); +} + +void DevWarning( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper( LOG_DEVELOPER, LS_WARNING, pMsgFormat ); +} + +void ConColorMsg( const Color& clr, const tchar* pMsgFormat, ... ) +{ + Log_LegacyHelperColor( LOG_CONSOLE, LS_MESSAGE, clr, pMsgFormat ); +} + +void ConMsg( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper( LOG_CONSOLE, LS_MESSAGE, pMsgFormat ); +} + +void ConDMsg( const tchar *pMsgFormat, ... ) +{ + Log_LegacyHelper( LOG_DEVELOPER_CONSOLE, LS_MESSAGE, pMsgFormat ); +} + +// If we don't have a function from math.h, then it doesn't link certain floating-point +// functions in and printfs with %f cause runtime errors in the C libraries. +PLATFORM_INTERFACE float CrackSmokingCompiler( float a ) +{ + return (float)fabs( a ); +} + +void* Plat_SimpleLog( const tchar* file, int line ) +{ + FILE* f = _tfopen( _T("simple.log"), _T("at+") ); + _ftprintf( f, _T("%s:%i\n"), file, line ); + fclose( f ); + + return NULL; +} + +//----------------------------------------------------------------------------- +// Purpose: For debugging startup times, etc. +// Input : *fmt - +// ... - +//----------------------------------------------------------------------------- +void COM_TimestampedLog( char const *fmt, ... ) +{ + static float s_LastStamp = 0.0; + static bool s_bShouldLog = false; + static bool s_bShouldLogToConsole = false; + static bool s_bShouldLogToETW = false; + static bool s_bChecked = false; + static bool s_bFirstWrite = false; + + if ( !s_bChecked ) + { + s_bShouldLog = ( CommandLine()->CheckParm( "-profile" ) ) ? true : false; + s_bShouldLogToConsole = ( CommandLine()->ParmValue( "-profile", 0.0f ) != 0.0f ) ? true : false; + + s_bShouldLogToETW = ( CommandLine()->CheckParm( "-etwprofile" ) ) ? true : false; + if ( s_bShouldLogToETW ) + { + s_bShouldLog = true; + } + + s_bChecked = true; + } + if ( !s_bShouldLog ) + { + return; + } + + char string[1024]; + va_list argptr; + va_start( argptr, fmt ); + Tier0Internal_vsnprintf( string, sizeof( string ), fmt, argptr ); + va_end( argptr ); + + float curStamp = Plat_FloatTime(); + +#if defined( _X360 ) + XBX_rTimeStampLog( curStamp, string ); +#elif defined( _PS3 ) + Log_Warning( LOG_LOADING, "%8.4f / %8.4f: %s\n", curStamp, curStamp - s_LastStamp, string ); +#endif + + if ( IsPC() ) + { + // If ETW profiling is enabled then do it only. + if ( s_bShouldLogToETW ) + { + ETWMark( string ); + } + else + { + if ( !s_bFirstWrite ) + { + unlink( "timestamped.log" ); + s_bFirstWrite = true; + } + + FILE* fp = fopen( "timestamped.log", "at+" ); + fprintf( fp, "%8.4f / %8.4f: %s\n", curStamp, curStamp - s_LastStamp, string ); + fclose( fp ); + } + + if ( s_bShouldLogToConsole ) + { + Msg( "%8.4f / %8.4f: %s\n", curStamp, curStamp - s_LastStamp, string ); + } + } + + s_LastStamp = curStamp; +} + +#ifdef IS_WINDOWS_PC + +class CHardwareBreakPoint +{ +public: + + enum EOpCode + { + BRK_SET = 0, + BRK_UNSET, + }; + + CHardwareBreakPoint() + { + m_eOperation = BRK_SET; + m_pvAddress = 0; + m_hThread = 0; + m_hThreadEvent = 0; + m_nRegister = 0; + m_bSuccess = false; + } + + const void *m_pvAddress; + HANDLE m_hThread; + EHardwareBreakpointType m_eType; + EHardwareBreakpointSize m_eSize; + HANDLE m_hThreadEvent; + int m_nRegister; + EOpCode m_eOperation; + bool m_bSuccess; + + static void SetBits( DWORD_PTR& dw, int lowBit, int bits, int newValue ); + static DWORD WINAPI ThreadProc( LPVOID lpParameter ); +}; + +void CHardwareBreakPoint::SetBits( DWORD_PTR& dw, int lowBit, int bits, int newValue ) +{ + DWORD_PTR mask = (1 << bits) - 1; + dw = (dw & ~(mask << lowBit)) | (newValue << lowBit); +} + +DWORD WINAPI CHardwareBreakPoint::ThreadProc( LPVOID lpParameter ) +{ + CHardwareBreakPoint *h = reinterpret_cast< CHardwareBreakPoint * >( lpParameter ); + SuspendThread( h->m_hThread ); + + // Get current context + CONTEXT ct = {0}; + ct.ContextFlags = CONTEXT_DEBUG_REGISTERS; + GetThreadContext(h->m_hThread,&ct); + + int FlagBit = 0; + + bool Dr0Busy = false; + bool Dr1Busy = false; + bool Dr2Busy = false; + bool Dr3Busy = false; + if (ct.Dr7 & 1) + Dr0Busy = true; + if (ct.Dr7 & 4) + Dr1Busy = true; + if (ct.Dr7 & 16) + Dr2Busy = true; + if (ct.Dr7 & 64) + Dr3Busy = true; + + if ( h->m_eOperation == CHardwareBreakPoint::BRK_UNSET ) + { + // Remove + if (h->m_nRegister == 0) + { + FlagBit = 0; + ct.Dr0 = 0; + Dr0Busy = false; + } + if (h->m_nRegister == 1) + { + FlagBit = 2; + ct.Dr1 = 0; + Dr1Busy = false; + } + if (h->m_nRegister == 2) + { + FlagBit = 4; + ct.Dr2 = 0; + Dr2Busy = false; + } + if (h->m_nRegister == 3) + { + FlagBit = 6; + ct.Dr3 = 0; + Dr3Busy = false; + } + ct.Dr7 &= ~(1 << FlagBit); + } + else + { + if (!Dr0Busy) + { + h->m_nRegister = 0; + ct.Dr0 = (DWORD_PTR)h->m_pvAddress; + Dr0Busy = true; + } + else if (!Dr1Busy) + { + h->m_nRegister = 1; + ct.Dr1 = (DWORD_PTR)h->m_pvAddress; + Dr1Busy = true; + } + else if (!Dr2Busy) + { + h->m_nRegister = 2; + ct.Dr2 = (DWORD_PTR)h->m_pvAddress; + Dr2Busy = true; + } + else if (!Dr3Busy) + { + h->m_nRegister = 3; + ct.Dr3 = (DWORD_PTR)h->m_pvAddress; + Dr3Busy = true; + } + else + { + h->m_bSuccess = false; + ResumeThread(h->m_hThread); + SetEvent(h->m_hThreadEvent); + return 0; + } + + ct.Dr6 = 0; + int st = 0; + if (h->m_eType == BREAKPOINT_EXECUTE) + st = 0; + if (h->m_eType == BREAKPOINT_READWRITE) + st = 3; + if (h->m_eType == BREAKPOINT_WRITE) + st = 1; + + int le = 0; + if (h->m_eSize == BREAKPOINT_SIZE_1) + le = 0; + if (h->m_eSize == BREAKPOINT_SIZE_2) + le = 1; + if (h->m_eSize == BREAKPOINT_SIZE_4) + le = 3; + if (h->m_eSize == BREAKPOINT_SIZE_8) + le = 2; + + SetBits( ct.Dr7, 16 + h->m_nRegister*4, 2, st ); + SetBits( ct.Dr7, 18 + h->m_nRegister*4, 2, le ); + SetBits( ct.Dr7, h->m_nRegister*2,1,1); + } + + ct.ContextFlags = CONTEXT_DEBUG_REGISTERS; + SetThreadContext(h->m_hThread,&ct); + + ResumeThread( h->m_hThread ); + h->m_bSuccess = true; + SetEvent( h->m_hThreadEvent ); + return 0; +} + +HardwareBreakpointHandle_t SetHardwareBreakpoint( EHardwareBreakpointType eType, EHardwareBreakpointSize eSize, const void *pvLocation ) +{ + CHardwareBreakPoint *h = new CHardwareBreakPoint(); + h->m_pvAddress = pvLocation; + h->m_eSize = eSize; + h->m_eType = eType; + HANDLE hThread = GetCurrentThread(); + h->m_hThread = hThread; + + if ( hThread == GetCurrentThread() ) + { + DWORD nThreadId = GetCurrentThreadId(); + h->m_hThread = OpenThread( THREAD_ALL_ACCESS, 0, nThreadId ); + } + + h->m_hThreadEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); + h->m_eOperation = CHardwareBreakPoint::BRK_SET; // Set Break + CreateThread( 0, 0, CHardwareBreakPoint::ThreadProc, (LPVOID)h, 0, 0 ); + WaitForSingleObject( h->m_hThreadEvent,INFINITE ); + CloseHandle( h->m_hThreadEvent ); + h->m_hThreadEvent = 0; + if ( hThread == GetCurrentThread() ) + { + CloseHandle( h->m_hThread ); + } + h->m_hThread = hThread; + if ( !h->m_bSuccess ) + { + delete h; + return (HardwareBreakpointHandle_t)0; + } + return (HardwareBreakpointHandle_t)h; +} + +bool ClearHardwareBreakpoint( HardwareBreakpointHandle_t handle ) +{ + CHardwareBreakPoint *h = reinterpret_cast< CHardwareBreakPoint* >( handle ); + if ( !h ) + { + return false; + } + + bool bOpened = false; + if ( h->m_hThread == GetCurrentThread() ) + { + DWORD nThreadId = GetCurrentThreadId(); + h->m_hThread = OpenThread( THREAD_ALL_ACCESS, 0, nThreadId ); + bOpened = true; + } + + h->m_hThreadEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); + h->m_eOperation = CHardwareBreakPoint::BRK_UNSET; // Remove Break + CreateThread( 0,0,CHardwareBreakPoint::ThreadProc, (LPVOID)h, 0,0 ); + WaitForSingleObject( h->m_hThreadEvent, INFINITE ); + CloseHandle( h->m_hThreadEvent ); + h->m_hThreadEvent = 0; + if ( bOpened ) + { + CloseHandle( h->m_hThread ); + } + delete h; + return true; +} + +#endif // IS_WINDOWS_PC + diff --git a/external/vpc/tier0/etwprof.cpp b/external/vpc/tier0/etwprof.cpp new file mode 100644 index 0000000..ccd2c76 --- /dev/null +++ b/external/vpc/tier0/etwprof.cpp @@ -0,0 +1,377 @@ +//============ Copyright (c) Valve Corporation, All rights reserved. ============ +// +// ETW (Event Tracing for Windows) profiling helpers. +// This allows easy insertion of Generic Event markers into ETW/xperf tracing +// which then aids in analyzing the traces and finding performance problems. +// +//=============================================================================== + +#include "pch_tier0.h" +#include "tier0/etwprof.h" +#include <memory> + +#ifdef ETW_MARKS_ENABLED + +// After building the DLL if it has never been registered on this machine or +// if the providers have changed you need to go: +// xcopy /y %vgame%\bin\tier0.dll %temp% +// wevtutil um %vgame%\..\src\tier0\ValveETWProvider.man +// wevtutil im %vgame%\..\src\tier0\ValveETWProvider.man + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +// These are defined in evntrace.h but you need a Vista+ Windows +// SDK to have them available, so I define them here. +#define EVENT_CONTROL_CODE_DISABLE_PROVIDER 0 +#define EVENT_CONTROL_CODE_ENABLE_PROVIDER 1 +#define EVENT_CONTROL_CODE_CAPTURE_STATE 2 + +// EVNTAPI is used in evntprov.h which is included by ValveETWProviderEvents.h +// We define EVNTAPI without the DECLSPEC_IMPORT specifier so that +// we can implement these functions locally instead of using the import library, +// and can therefore still run on Windows XP. +#define EVNTAPI __stdcall +// Include the event register/write/unregister macros compiled from the manifest file. +// Note that this includes evntprov.h which requires a Vista+ Windows SDK +// which we don't currently have, so evntprov.h is checked in. +#include "ValveETWProviderEvents.h" + +// Typedefs for use with GetProcAddress +typedef ULONG (__stdcall *tEventRegister)( LPCGUID ProviderId, PENABLECALLBACK EnableCallback, PVOID CallbackContext, PREGHANDLE RegHandle); +typedef ULONG (__stdcall *tEventWrite)( REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData); +typedef ULONG (__stdcall *tEventUnregister)( REGHANDLE RegHandle ); + +// Helper class to dynamically load Advapi32.dll, find the ETW functions, +// register the providers if possible, and get the performance counter frequency. +class CETWRegister +{ +public: + CETWRegister() + { + QueryPerformanceFrequency( &m_frequency ); + + // Find Advapi32.dll. This should always succeed. + HMODULE pAdvapiDLL = LoadLibraryW( L"Advapi32.dll" ); + if ( pAdvapiDLL ) + { + // Try to find the ETW functions. This will fail on XP. + m_pEventRegister = ( tEventRegister )GetProcAddress( pAdvapiDLL, "EventRegister" ); + m_pEventWrite = ( tEventWrite )GetProcAddress( pAdvapiDLL, "EventWrite" ); + m_pEventUnregister = ( tEventUnregister )GetProcAddress( pAdvapiDLL, "EventUnregister" ); + + // Register two ETW providers. If registration fails then the event logging calls will fail. + // On XP these calls will do nothing. + // On Vista and above, if these providers have been enabled by xperf or logman then + // the VALVE_FRAMERATE_Context and VALVE_MAIN_Context globals will be modified + // like this: + // MatchAnyKeyword: 0xffffffffffffffff + // IsEnabled: 1 + // Level: 255 + // In other words, fully enabled. + + EventRegisterValve_FrameRate(); + EventRegisterValve_ServerFrameRate(); + EventRegisterValve_Main(); + EventRegisterValve_Input(); + EventRegisterValve_Network(); + + // Emit the thread ID for the main thread. This also indicates that + // the main provider is initialized. + EventWriteThread_ID( GetCurrentThreadId(), "Main thread" ); + // Emit an input system event so we know that it is active. + EventWriteKey_down( "Valve input provider initialized.", 0, 0 ); + } + } + ~CETWRegister() + { + // Unregister our providers. + EventUnregisterValve_Network(); + EventUnregisterValve_Input(); + EventUnregisterValve_Main(); + EventUnregisterValve_ServerFrameRate(); + EventUnregisterValve_FrameRate(); + } + + tEventRegister m_pEventRegister; + tEventWrite m_pEventWrite; + tEventUnregister m_pEventUnregister; + + // QPC frequency + LARGE_INTEGER m_frequency; + +} g_ETWRegister; + +// Redirector function for EventRegister. Called by macros in ValveETWProviderEvents.h +ULONG EVNTAPI EventRegister( LPCGUID ProviderId, PENABLECALLBACK EnableCallback, PVOID CallbackContext, PREGHANDLE RegHandle ) +{ + if ( g_ETWRegister.m_pEventRegister ) + return g_ETWRegister.m_pEventRegister( ProviderId, EnableCallback, CallbackContext, RegHandle ); + + return 0; +} + +// Redirector function for EventWrite. Called by macros in ValveETWProviderEvents.h +ULONG EVNTAPI EventWrite( REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData ) +{ + if ( g_ETWRegister.m_pEventWrite ) + return g_ETWRegister.m_pEventWrite( RegHandle, EventDescriptor, UserDataCount, UserData ); + return 0; +} + +// Redirector function for EventUnregister. Called by macros in ValveETWProviderEvents.h +ULONG EVNTAPI EventUnregister( REGHANDLE RegHandle ) +{ + if ( g_ETWRegister.m_pEventUnregister ) + return g_ETWRegister.m_pEventUnregister( RegHandle ); + return 0; +} + +// Call QueryPerformanceCounter +static int64 GetQPCTime() +{ + LARGE_INTEGER time; + + QueryPerformanceCounter( &time ); + return time.QuadPart; +} + +// Convert a QueryPerformanceCounter delta into milliseconds +static float QPCToMS( int64 nDelta ) +{ + // Convert from a QPC delta to seconds. + float flSeconds = ( float )( nDelta / double( g_ETWRegister.m_frequency.QuadPart ) ); + + // Convert from seconds to milliseconds + return flSeconds * 1000; +} + +// Public functions for emitting ETW events. + +int64 ETWMark( const char *pMessage ) +{ + int64 nTime = GetQPCTime(); + EventWriteMark( pMessage ); + return nTime; +} + +int64 ETWMarkPrintf( const char *pMessage, ... ) +{ + // If we are running on Windows XP or if our providers have not been enabled + // (by xperf or other) then this will be false and we can early out. + // Be sure to check the appropriate context for the event. This is only + // worth checking if there is some cost beyond the EventWrite that we can + // avoid -- the redirectors in this file guarantee that EventWrite is always + // safe to call. + if ( !VALVE_MAIN_Context.IsEnabled ) + { + return 0; + } + + char buffer[1000]; + va_list args; + va_start( args, pMessage ); + vsprintf_s( buffer, pMessage, args ); + va_end( args ); + + int64 nTime = GetQPCTime(); + EventWriteMark( buffer ); + return nTime; +} + +void ETWMark1F( const char *pMessage, float data1 ) +{ + EventWriteMark1F( pMessage, data1 ); +} + +void ETWMark2F( const char *pMessage, float data1, float data2 ) +{ + EventWriteMark2F( pMessage, data1, data2 ); +} + +void ETWMark3F( const char *pMessage, float data1, float data2, float data3 ) +{ + EventWriteMark3F( pMessage, data1, data2, data3 ); +} + +void ETWMark4F( const char *pMessage, float data1, float data2, float data3, float data4 ) +{ + EventWriteMark4F( pMessage, data1, data2, data3, data4 ); +} + +void ETWMark1I( const char *pMessage, int data1 ) +{ + EventWriteMark1I( pMessage, data1 ); +} + +void ETWMark2I( const char *pMessage, int data1, int data2 ) +{ + EventWriteMark2I( pMessage, data1, data2 ); +} + +void ETWMark3I( const char *pMessage, int data1, int data2, int data3 ) +{ + EventWriteMark3I( pMessage, data1, data2, data3 ); +} + +void ETWMark4I( const char *pMessage, int data1, int data2, int data3, int data4 ) +{ + EventWriteMark4I( pMessage, data1, data2, data3, data4 ); +} + +void ETWMark1S( const char *pMessage, const char* data1 ) +{ + EventWriteMark1S( pMessage, data1 ); +} + +void ETWMark2S( const char *pMessage, const char* data1, const char* data2 ) +{ + EventWriteMark2S( pMessage, data1, data2 ); +} + +// Track the depth of ETW Begin/End pairs. This needs to be per-thread +// if we start emitting marks on multiple threads. Using __declspec(thread) +// has some problems on Windows XP, but since these ETW functions only work +// on Vista+ that doesn't matter. +static __declspec( thread ) int s_nDepth; + +int64 ETWBegin( const char *pMessage ) +{ + // If we are running on Windows XP or if our providers have not been enabled + // (by xperf or other) then this will be false and we can early out. + // Be sure to check the appropriate context for the event. This is only + // worth checking if there is some cost beyond the EventWrite that we can + // avoid -- the redirectors in this file guarantee that EventWrite is always + // safe to call. + // In this case we also avoid the potentially unreliable TLS implementation + // (for dynamically loaded DLLs) on Windows XP. + if ( !VALVE_MAIN_Context.IsEnabled ) + { + return 0; + } + + int64 nTime = GetQPCTime(); + EventWriteStart( pMessage, s_nDepth++ ); + return nTime; +} + +int64 ETWEnd( const char *pMessage, int64 nStartTime ) +{ + // If we are running on Windows XP or if our providers have not been enabled + // (by xperf or other) then this will be false and we can early out. + // Be sure to check the appropriate context for the event. This is only + // worth checking if there is some cost beyond the EventWrite that we can + // avoid -- the redirectors in this file guarantee that EventWrite is always + // safe to call. + // In this case we also avoid the potentially unreliable TLS implementation + // (for dynamically loaded DLLs) on Windows XP. + if ( !VALVE_MAIN_Context.IsEnabled ) + { + return 0; + } + + int64 nTime = GetQPCTime(); + EventWriteStop( pMessage, --s_nDepth, QPCToMS( nTime - nStartTime ) ); + return nTime; +} + +static int s_nRenderFrameCount; + +int ETWGetRenderFrameNumber() +{ + return s_nRenderFrameCount; +} + +// Insert a render frame marker using the Valve-FrameRate provider. Automatically +// count the frame number and frame time. Since the frame count and elapsed time +// are tracked without paying attention to the bIsServerProcess flag the results +// will be 'unexpected' if bIsServerProcess changes value within a process. +void ETWRenderFrameMark( bool bIsServerProcess ) +{ + static int64 s_lastFrameTime; + + int64 nCurrentFrameTime = GetQPCTime(); + float flElapsedFrameTime = 0.0f; + if ( s_nRenderFrameCount ) + { + flElapsedFrameTime = QPCToMS( nCurrentFrameTime - s_lastFrameTime ); + } + + if ( bIsServerProcess ) + { + EventWriteServerRenderFrameMark( s_nRenderFrameCount, flElapsedFrameTime ); + } + else + { + EventWriteRenderFrameMark( s_nRenderFrameCount, flElapsedFrameTime ); + } + + ++s_nRenderFrameCount; + s_lastFrameTime = nCurrentFrameTime; +} + +// Insert a simulation frame marker using the Valve-FrameRate provider. Automatically +// count the frame number and frame time. Since the frame count and elapsed time +// are tracked without paying attention to the bIsServerProcess flag the results +// will be 'unexpected' if bIsServerProcess changes value within a process. +void ETWSimFrameMark( bool bIsServerProcess ) +{ + static int s_nFrameCount; + static int64 s_lastFrameTime; + + int64 nCurrentFrameTime = GetQPCTime(); + float flElapsedFrameTime = 0.0f; + if ( s_nFrameCount ) + { + flElapsedFrameTime = QPCToMS( nCurrentFrameTime - s_lastFrameTime ); + } + + if ( bIsServerProcess ) + { + EventWriteServerSimFrameMark( s_nFrameCount, flElapsedFrameTime ); + } + else + { + EventWriteSimFrameMark( s_nFrameCount, flElapsedFrameTime ); + } + + ++s_nFrameCount; + s_lastFrameTime = nCurrentFrameTime; +} + +void ETWMouseDown( int whichButton, int x, int y ) +{ + EventWriteMouse_down( whichButton, x, y ); +} + +void ETWMouseUp( int whichButton, int x, int y ) +{ + EventWriteMouse_up( whichButton, x, y ); +} + +void ETWKeyDown( int nScanCode, int nVirtualCode, const char *pChar ) +{ + EventWriteKey_down( pChar, nScanCode, nVirtualCode ); +} + +void ETWSendPacket( const char *pTo, int nWireSize, int nOutSequenceNR, int nOutSequenceNrAck ) +{ + static int s_nCumulativeWireSize; + s_nCumulativeWireSize += nWireSize; + + EventWriteSendPacket( pTo, nWireSize, nOutSequenceNR, nOutSequenceNrAck, s_nCumulativeWireSize ); +} + +void ETWThrottled() +{ + EventWriteThrottled(); +} + +void ETWReadPacket( const char *pFrom, int nWireSize, int nInSequenceNR, int nOutSequenceNRAck ) +{ + static int s_nCumulativeWireSize; + s_nCumulativeWireSize += nWireSize; + + EventWriteReadPacket( pFrom, nWireSize, nInSequenceNR, nOutSequenceNRAck, s_nCumulativeWireSize ); +} + +#endif // ETW_MARKS_ENABLED diff --git a/external/vpc/tier0/fasttimer.cpp b/external/vpc/tier0/fasttimer.cpp new file mode 100644 index 0000000..8ea732c --- /dev/null +++ b/external/vpc/tier0/fasttimer.cpp @@ -0,0 +1,23 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "pch_tier0.h" + +#include <stdio.h> +#include "tier0/fasttimer.h" + +// NOTE: This has to be the last file included! +//#include "tier0/memdbgon.h" + +uint64 g_ClockSpeed; // Clocks/sec +unsigned long g_dwClockSpeed; +double g_ClockSpeedMicrosecondsMultiplier; +double g_ClockSpeedMillisecondsMultiplier; +double g_ClockSpeedSecondsMultiplier; + +// Constructor init the clock speed. +CClockSpeedInit g_ClockSpeedInit; diff --git a/external/vpc/tier0/logging.cpp b/external/vpc/tier0/logging.cpp new file mode 100644 index 0000000..9edf7d2 --- /dev/null +++ b/external/vpc/tier0/logging.cpp @@ -0,0 +1,698 @@ +//============ Copyright (c) Valve Corporation, All rights reserved. ============ +// +// Logging system definitions. +// +//=============================================================================== + +#include "pch_tier0.h" +#include "logging.h" + +#include <string.h> +#include "dbg.h" +#include "threadtools.h" +#include "tier0_strtools.h" // this is from tier1, but only included for inline definition of V_isspace + +#ifdef _PS3 +#include <sys/tty.h> +#endif + + +////////////////////////////////////////////////////////////////////////// +// Define commonly used channels here +////////////////////////////////////////////////////////////////////////// +DEFINE_LOGGING_CHANNEL_NO_TAGS( LOG_GENERAL, "General" ); + +DEFINE_LOGGING_CHANNEL_NO_TAGS( LOG_ASSERT, "Assert" ); + +// Corresponds to ConMsg/ConWarning/etc. with a level <= 1. +// Only errors are spewed by default. +BEGIN_DEFINE_LOGGING_CHANNEL( LOG_CONSOLE, "Console", LCF_CONSOLE_ONLY, LS_ERROR ); +ADD_LOGGING_CHANNEL_TAG( "Console" ); +END_DEFINE_LOGGING_CHANNEL(); + +// Corresponds to DevMsg/DevWarning/etc. with a level <= 1. +// Only errors are spewed by default. +BEGIN_DEFINE_LOGGING_CHANNEL( LOG_DEVELOPER, "Developer", LCF_CONSOLE_ONLY, LS_ERROR ); +ADD_LOGGING_CHANNEL_TAG( "Developer" ); +END_DEFINE_LOGGING_CHANNEL(); + +// Corresponds to ConMsg/ConWarning/etc. with a level >= 2. +// Only errors are spewed by default. +BEGIN_DEFINE_LOGGING_CHANNEL( LOG_DEVELOPER_CONSOLE, "DeveloperConsole", LCF_CONSOLE_ONLY, LS_ERROR ); +ADD_LOGGING_CHANNEL_TAG( "DeveloperVerbose" ); +ADD_LOGGING_CHANNEL_TAG( "Console" ); +END_DEFINE_LOGGING_CHANNEL(); + +// Corresponds to DevMsg/DevWarning/etc, with a level >= 2. +// Only errors are spewed by default. +BEGIN_DEFINE_LOGGING_CHANNEL( LOG_DEVELOPER_VERBOSE, "DeveloperVerbose", LCF_CONSOLE_ONLY, LS_ERROR, Color( 192, 128, 192, 255 ) ); +ADD_LOGGING_CHANNEL_TAG( "DeveloperVerbose" ); +END_DEFINE_LOGGING_CHANNEL(); + +////////////////////////////////////////////////////////////////////////// +// Globals +////////////////////////////////////////////////////////////////////////// + +// The index of the logging state used by the current thread. This defaults to 0 across all threads, +// which indicates that the global listener set should be used (CLoggingSystem::m_nGlobalStateIndex). +// +// NOTE: +// Because our linux TLS implementation does not support embedding a thread local +// integer in a class, the logging system must use a global thread-local integer. +// This means that we can only have one instance of CLoggingSystem, although +// we could support additional instances if we are willing to lose support for +// thread-local spew handling. +// There is no other reason why this class must be a singleton, except +// for the fact that there's no reason to have more than one in existence. +bool g_bEnforceLoggingSystemSingleton = false; + +#ifdef _PS3 +#include "tls_ps3.h" +#else // _PS3 +CTHREADLOCALINT g_nThreadLocalStateIndex; +#endif // _PS3 + +////////////////////////////////////////////////////////////////////////// +// Implementation +////////////////////////////////////////////////////////////////////////// + +CLoggingSystem *g_pGlobalLoggingSystem = NULL; + +// This function does not get inlined due to the static variable :( +CLoggingSystem *GetGlobalLoggingSystem_Internal() +{ + static CLoggingSystem globalLoggingSystem; + g_pGlobalLoggingSystem = &globalLoggingSystem; + return &globalLoggingSystem; +} + +// This function can get inlined +CLoggingSystem *GetGlobalLoggingSystem() +{ + return ( g_pGlobalLoggingSystem == NULL ) ? GetGlobalLoggingSystem_Internal() : g_pGlobalLoggingSystem; +} + +CLoggingSystem::CLoggingSystem() : +m_nChannelCount( 0 ), +m_nChannelTagCount( 0 ), +m_nTagNamePoolIndex( 0 ), +m_nGlobalStateIndex( 0 ) +{ + Assert( !g_bEnforceLoggingSystemSingleton ); + g_bEnforceLoggingSystemSingleton = true; +#if !defined( _PS3 ) && !defined(POSIX) && !defined(PLATFORM_WINDOWS) + // Due to uncertain constructor ordering (g_nThreadLocalStateIndex + // may not be constructed yet so TLS index may not be available yet) + // we cannot initialize the state index here without risking + // AppVerifier errors and undefined behavior. Luckily TlsAlloc values + // are guaranteed to be zero-initialized so we don't need to zero-init, + // this, and in fact we can't for all threads. + // TLS on PS3 is zero-initialized in global ELF section + // TLS is also not accessible at this point before PRX entry point runs + g_nThreadLocalStateIndex = 0; +#endif + + m_LoggingStates[0].m_nPreviousStackEntry = -1; + + m_LoggingStates[0].m_nListenerCount = 1; + m_LoggingStates[0].m_RegisteredListeners[0] = &m_DefaultLoggingListener; + m_LoggingStates[0].m_pLoggingResponse = &m_DefaultLoggingResponse; + + // Mark all other logging state blocks as unused. + for ( int i = 1; i < MAX_LOGGING_STATE_COUNT; ++ i ) + { + m_LoggingStates[i].m_nListenerCount = -1; + } + + m_pStateMutex = NULL; +} + +CLoggingSystem::~CLoggingSystem() +{ + g_bEnforceLoggingSystemSingleton = false; + delete m_pStateMutex; +} + +LoggingChannelID_t CLoggingSystem::RegisterLoggingChannel( const char *pChannelName, RegisterTagsFunc registerTagsFunc, int flags, LoggingSeverity_t severity, Color spewColor ) +{ + if ( m_nChannelCount >= MAX_LOGGING_CHANNEL_COUNT ) + { + // Out of logging channels... catastrophic fail! + Log_Error( LOG_GENERAL, "Out of logging channels.\n" ); + Assert( 0 ); + return INVALID_LOGGING_CHANNEL_ID; + } + else + { + // Channels can be multiply defined, in which case return the ID of the existing channel. + for ( int i = 0; i < m_nChannelCount; ++ i ) + { + if ( V_tier0_stricmp( m_RegisteredChannels[i].m_Name, pChannelName ) == 0 ) + { + // OK to call the tag registration callback; duplicates will be culled away. + // This allows multiple people to register a logging channel, and the union of all tags will be registered. + if ( registerTagsFunc != NULL ) + { + registerTagsFunc(); + } + + // If a logging channel is registered multiple times, only one of the registrations should specify flags/severity/color. + if ( m_RegisteredChannels[i].m_Flags == 0 && m_RegisteredChannels[i].m_MinimumSeverity == LS_MESSAGE && m_RegisteredChannels[i].m_SpewColor == UNSPECIFIED_LOGGING_COLOR ) + { + m_RegisteredChannels[i].m_Flags = ( LoggingChannelFlags_t )flags; + m_RegisteredChannels[i].m_MinimumSeverity = severity; + m_RegisteredChannels[i].m_SpewColor = spewColor; + } + else + { + AssertMsg( flags == 0 || flags == m_RegisteredChannels[i].m_Flags, "Non-zero or mismatched flags specified in logging channel re-registration!" ); + AssertMsg( severity == LS_MESSAGE || severity == m_RegisteredChannels[i].m_MinimumSeverity, "Non-default or mismatched severity specified in logging channel re-registration!" ); + AssertMsg( spewColor == UNSPECIFIED_LOGGING_COLOR || spewColor == m_RegisteredChannels[i].m_SpewColor, "Non-default or mismatched color specified in logging channel re-registration!" ); + } + + return m_RegisteredChannels[i].m_ID; + } + } + + m_RegisteredChannels[m_nChannelCount].m_ID = m_nChannelCount; + m_RegisteredChannels[m_nChannelCount].m_Flags = ( LoggingChannelFlags_t )flags; + m_RegisteredChannels[m_nChannelCount].m_MinimumSeverity = severity; + m_RegisteredChannels[m_nChannelCount].m_SpewColor = spewColor; + strncpy( m_RegisteredChannels[m_nChannelCount].m_Name, pChannelName, MAX_LOGGING_IDENTIFIER_LENGTH ); + + if ( registerTagsFunc != NULL ) + { + registerTagsFunc(); + } + return m_nChannelCount ++; + } +} + +LoggingChannelID_t CLoggingSystem::FindChannel( const char *pChannelName ) const +{ + for ( int i = 0; i < m_nChannelCount; ++ i ) + { + if ( V_tier0_stricmp( m_RegisteredChannels[i].m_Name, pChannelName ) == 0 ) + { + return i; + } + } + + return INVALID_LOGGING_CHANNEL_ID; +} + +void CLoggingSystem::AddTagToCurrentChannel( const char *pTagName ) +{ + // Add tags at the head of the tag-list of the most recently added channel. + LoggingChannel_t *pChannel = &m_RegisteredChannels[m_nChannelCount]; + + // First check for duplicates + if ( pChannel->HasTag( pTagName ) ) + { + return; + } + + LoggingTag_t *pTag = AllocTag( pTagName ); + + pTag->m_pNextTag = pChannel->m_pFirstTag; + pChannel->m_pFirstTag = pTag; +} + +void CLoggingSystem::SetChannelSpewLevel( LoggingChannelID_t channelID, LoggingSeverity_t minimumSeverity ) +{ + GetChannel( channelID )->SetSpewLevel( minimumSeverity ); +} + +void CLoggingSystem::SetChannelSpewLevelByName( const char *pName, LoggingSeverity_t minimumSeverity ) +{ + for ( int i = 0; i < m_nChannelCount; ++ i ) + { + if ( V_tier0_stricmp( m_RegisteredChannels[i].m_Name, pName ) == 0 ) + { + m_RegisteredChannels[i].SetSpewLevel( minimumSeverity ); + } + } +} + +void CLoggingSystem::SetChannelSpewLevelByTag( const char *pTag, LoggingSeverity_t minimumSeverity ) +{ + for ( int i = 0; i < m_nChannelCount; ++ i ) + { + if ( m_RegisteredChannels[i].HasTag( pTag ) ) + { + m_RegisteredChannels[i].SetSpewLevel( minimumSeverity ); + } + } +} + +void CLoggingSystem::PushLoggingState( bool bThreadLocal, bool bClearState ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + + int nNewState = FindUnusedStateIndex(); + // Ensure we're not out of state blocks. + Assert( nNewState != -1 ); + + int nCurrentState = bThreadLocal ? (int)g_nThreadLocalStateIndex : m_nGlobalStateIndex; + + if ( bClearState ) + { + m_LoggingStates[nNewState].m_nListenerCount = 0; + m_LoggingStates[nNewState].m_pLoggingResponse = &m_DefaultLoggingResponse; + } + else + { + m_LoggingStates[nNewState] = m_LoggingStates[nCurrentState]; + } + + m_LoggingStates[nNewState].m_nPreviousStackEntry = nCurrentState; + + if ( bThreadLocal ) + { + g_nThreadLocalStateIndex = nNewState; + } + else + { + m_nGlobalStateIndex = nNewState; + } + + m_pStateMutex->Unlock(); +} + +void CLoggingSystem::PopLoggingState( bool bThreadLocal ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + + int nCurrentState = bThreadLocal ? (int)g_nThreadLocalStateIndex : m_nGlobalStateIndex; + + // Shouldn't be less than 0 (implies error during Push()) or 0 (implies that Push() was never called) + Assert( nCurrentState > 0 ); + + // Mark the current state as unused. + m_LoggingStates[nCurrentState].m_nListenerCount = -1; + + if ( bThreadLocal ) + { + g_nThreadLocalStateIndex = m_LoggingStates[nCurrentState].m_nPreviousStackEntry; + } + else + { + m_nGlobalStateIndex = m_LoggingStates[nCurrentState].m_nPreviousStackEntry; + } + + m_pStateMutex->Unlock(); +} + +void CLoggingSystem::RegisterLoggingListener( ILoggingListener *pListener ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + LoggingState_t *pState = GetCurrentState(); + if ( pState->m_nListenerCount > MAX_LOGGING_CHANNEL_COUNT ) + { + // Out of logging listener slots... catastrophic fail! + Assert( 0 ); + } + else + { + pState->m_RegisteredListeners[pState->m_nListenerCount] = pListener; + ++ pState->m_nListenerCount; + } + m_pStateMutex->Unlock(); +} + +void CLoggingSystem::UnregisterLoggingListener( ILoggingListener *pListener ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + LoggingState_t *pState = GetCurrentState(); + for ( int i = 0; i < pState->m_nListenerCount; ++ i ) + { + if ( pState->m_RegisteredListeners[i] == pListener ) + { + // Shuffle all the listeners ahead over these, and reduce the count. + for ( int j = i; j < (pState->m_nListenerCount-1); ++ j ) + { + pState->m_RegisteredListeners[j] = pState->m_RegisteredListeners[j+1]; + } + pState->m_nListenerCount--; + break; + } + } + m_pStateMutex->Unlock(); +} + +bool CLoggingSystem::IsListenerRegistered( ILoggingListener *pListener ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + const LoggingState_t *pState = GetCurrentState(); + bool bFound = false; + for ( int i = 0; i < pState->m_nListenerCount; ++ i ) + { + if ( pState->m_RegisteredListeners[i] == pListener ) + { + bFound = true; + break; + } + } + m_pStateMutex->Unlock(); + return bFound; +} + +void CLoggingSystem::ResetCurrentLoggingState() +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + LoggingState_t *pState = GetCurrentState(); + pState->m_nListenerCount = 0; + pState->m_pLoggingResponse = &m_DefaultLoggingResponse; + m_pStateMutex->Unlock(); +} + +void CLoggingSystem::SetLoggingResponsePolicy( ILoggingResponsePolicy *pLoggingResponse ) +{ + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + LoggingState_t *pState = GetCurrentState(); + if ( pLoggingResponse == NULL ) + { + pState->m_pLoggingResponse = &m_DefaultLoggingResponse; + } + else + { + pState->m_pLoggingResponse = pLoggingResponse; + } + m_pStateMutex->Unlock(); +} + +LoggingResponse_t CLoggingSystem::LogDirect( LoggingChannelID_t channelID, LoggingSeverity_t severity, Color color, const tchar *pMessage ) +{ + Assert( IsValidChannelID( channelID ) ); + if ( !IsValidChannelID( channelID ) ) + return LR_CONTINUE; + + LoggingContext_t context; + context.m_ChannelID = channelID; + context.m_Flags = m_RegisteredChannels[channelID].m_Flags; + context.m_Severity = severity; + context.m_Color = ( color == UNSPECIFIED_LOGGING_COLOR ) ? m_RegisteredChannels[channelID].m_SpewColor : color; + + // It is assumed that the mutex is reentrant safe on all platforms. + if ( !m_pStateMutex ) + m_pStateMutex = new CThreadFastMutex(); + + m_pStateMutex->Lock(); + + LoggingState_t *pState = GetCurrentState(); + + for ( int i = 0; i < pState->m_nListenerCount; ++ i ) + { + pState->m_RegisteredListeners[i]->Log( &context, pMessage ); + } + +#if defined( _PS3 ) && !defined( _CERT ) + if ( !pState->m_nListenerCount ) + { + unsigned int unBytesWritten; + sys_tty_write( SYS_TTYP15, pMessage, strlen( pMessage ), &unBytesWritten ); + } +#endif + + LoggingResponse_t response = pState->m_pLoggingResponse->OnLog( &context ); + + m_pStateMutex->Unlock(); + + switch( response ) + { + case LR_DEBUGGER: + // Asserts put the debug break in the macro itself so the code breaks at the failure point. + if ( severity != LS_ASSERT ) + { + DebuggerBreakIfDebugging(); + } + break; + + case LR_ABORT: + Log_Msg( LOG_DEVELOPER_VERBOSE, "Exiting due to logging LR_ABORT request.\n" ); + Plat_ExitProcess( EXIT_FAILURE ); + break; + } + + return response; +} + +CLoggingSystem::LoggingChannel_t *CLoggingSystem::GetChannel( LoggingChannelID_t channelID ) +{ + Assert( IsValidChannelID( channelID ) ); + return &m_RegisteredChannels[channelID]; +} + +const CLoggingSystem::LoggingChannel_t *CLoggingSystem::GetChannel( LoggingChannelID_t channelID ) const +{ + Assert( IsValidChannelID( channelID ) ); + return &m_RegisteredChannels[channelID]; +} + +CLoggingSystem::LoggingState_t *CLoggingSystem::GetCurrentState() +{ + // Assume the caller grabbed the mutex. + int nState = g_nThreadLocalStateIndex; + if ( nState != 0 ) + { + Assert( nState > 0 && nState < MAX_LOGGING_STATE_COUNT ); + return &m_LoggingStates[nState]; + } + else + { + Assert( m_nGlobalStateIndex >= 0 && m_nGlobalStateIndex < MAX_LOGGING_STATE_COUNT ); + return &m_LoggingStates[m_nGlobalStateIndex]; + } +} + +const CLoggingSystem::LoggingState_t *CLoggingSystem::GetCurrentState() const +{ + // Assume the caller grabbed the mutex. + int nState = g_nThreadLocalStateIndex; + if ( nState != 0 ) + { + Assert( nState > 0 && nState < MAX_LOGGING_STATE_COUNT ); + return &m_LoggingStates[nState]; + } + else + { + Assert( m_nGlobalStateIndex >= 0 && m_nGlobalStateIndex < MAX_LOGGING_STATE_COUNT ); + return &m_LoggingStates[m_nGlobalStateIndex]; + } +} + +int CLoggingSystem::FindUnusedStateIndex() +{ + for ( int i = 0; i < MAX_LOGGING_STATE_COUNT; ++ i ) + { + if ( m_LoggingStates[i].m_nListenerCount < 0 ) + { + return i; + } + } + return -1; +} + +CLoggingSystem::LoggingTag_t *CLoggingSystem::AllocTag( const char *pTagName ) +{ + Assert( m_nChannelTagCount < MAX_LOGGING_TAG_COUNT ); + LoggingTag_t *pTag = &m_ChannelTags[m_nChannelTagCount ++]; + + pTag->m_pNextTag = NULL; + pTag->m_pTagName = m_TagNamePool + m_nTagNamePoolIndex; + + // Copy string into pool. + size_t nTagLength = strlen( pTagName ); + Assert( m_nTagNamePoolIndex + nTagLength + 1 <= MAX_LOGGING_TAG_CHARACTER_COUNT ); + strcpy( m_TagNamePool + m_nTagNamePoolIndex, pTagName ); + m_nTagNamePoolIndex += ( int )nTagLength + 1; + + return pTag; +} + +LoggingChannelID_t LoggingSystem_RegisterLoggingChannel( const char *pName, RegisterTagsFunc registerTagsFunc, int flags, LoggingSeverity_t severity, Color color ) +{ + return GetGlobalLoggingSystem()->RegisterLoggingChannel( pName, registerTagsFunc, flags, severity, color ); +} + +void LoggingSystem_ResetCurrentLoggingState() +{ + GetGlobalLoggingSystem()->ResetCurrentLoggingState(); +} + +void LoggingSystem_RegisterLoggingListener( ILoggingListener *pListener ) +{ + GetGlobalLoggingSystem()->RegisterLoggingListener( pListener ); +} + +void LoggingSystem_UnregisterLoggingListener( ILoggingListener *pListener ) +{ + GetGlobalLoggingSystem()->UnregisterLoggingListener( pListener ); +} + +void LoggingSystem_SetLoggingResponsePolicy( ILoggingResponsePolicy *pResponsePolicy ) +{ + GetGlobalLoggingSystem()->SetLoggingResponsePolicy( pResponsePolicy ); +} + +void LoggingSystem_PushLoggingState( bool bThreadLocal, bool bClearState ) +{ + GetGlobalLoggingSystem()->PushLoggingState( bThreadLocal, bClearState ); +} + +void LoggingSystem_PopLoggingState( bool bThreadLocal ) +{ + GetGlobalLoggingSystem()->PopLoggingState( bThreadLocal ); +} + +void LoggingSystem_AddTagToCurrentChannel( const char *pTagName ) +{ + GetGlobalLoggingSystem()->AddTagToCurrentChannel( pTagName ); +} + +LoggingChannelID_t LoggingSystem_FindChannel( const char *pChannelName ) +{ + return GetGlobalLoggingSystem()->FindChannel( pChannelName ); +} + +int LoggingSystem_GetChannelCount() +{ + return GetGlobalLoggingSystem()->GetChannelCount(); +} + +LoggingChannelID_t LoggingSystem_GetFirstChannelID() +{ + return ( GetGlobalLoggingSystem()->GetChannelCount() > 0 ) ? 0 : INVALID_LOGGING_CHANNEL_ID; +} + +LoggingChannelID_t LoggingSystem_GetNextChannelID( LoggingChannelID_t channelID ) +{ + int nChannelCount = GetGlobalLoggingSystem()->GetChannelCount(); + int nNextChannel = channelID + 1; + return ( nNextChannel < nChannelCount ) ? nNextChannel : INVALID_LOGGING_CHANNEL_ID; +} + +const CLoggingSystem::LoggingChannel_t *LoggingSystem_GetChannel( LoggingChannelID_t channelIndex ) +{ + return GetGlobalLoggingSystem()->GetChannel( channelIndex ); +} + +bool LoggingSystem_HasTag( LoggingChannelID_t channelID, const char *pTag ) +{ + return GetGlobalLoggingSystem()->HasTag( channelID, pTag ); +} + +bool LoggingSystem_IsChannelEnabled( LoggingChannelID_t channelID, LoggingSeverity_t severity ) +{ + return GetGlobalLoggingSystem()->IsChannelEnabled( channelID, severity ); +} + +void LoggingSystem_SetChannelSpewLevel( LoggingChannelID_t channelID, LoggingSeverity_t minimumSeverity ) +{ + GetGlobalLoggingSystem()->SetChannelSpewLevel( channelID, minimumSeverity ); +} + +void LoggingSystem_SetChannelSpewLevelByName( const char *pName, LoggingSeverity_t minimumSeverity ) +{ + GetGlobalLoggingSystem()->SetChannelSpewLevelByName( pName, minimumSeverity ); +} + +void LoggingSystem_SetChannelSpewLevelByTag( const char *pTag, LoggingSeverity_t minimumSeverity ) +{ + GetGlobalLoggingSystem()->SetChannelSpewLevelByTag( pTag, minimumSeverity ); +} + +int32 LoggingSystem_GetChannelColor( LoggingChannelID_t channelID ) +{ + return GetGlobalLoggingSystem()->GetChannelColor( channelID ).GetRawColor(); +} + +void LoggingSystem_SetChannelColor( LoggingChannelID_t channelID, int color ) +{ + Color c; + c.SetRawColor( color ); + GetGlobalLoggingSystem()->SetChannelColor( channelID, c ); +} + +LoggingChannelFlags_t LoggingSystem_GetChannelFlags( LoggingChannelID_t channelID ) +{ + return GetGlobalLoggingSystem()->GetChannelFlags( channelID ); +} + +void LoggingSystem_SetChannelFlags( LoggingChannelID_t channelID, LoggingChannelFlags_t flags ) +{ + GetGlobalLoggingSystem()->SetChannelFlags( channelID, flags ); +} + +LoggingResponse_t LoggingSystem_Log( LoggingChannelID_t channelID, LoggingSeverity_t severity, const char *pMessageFormat, ... ) +{ + if ( !GetGlobalLoggingSystem()->IsChannelEnabled( channelID, severity ) ) + return LR_CONTINUE; + + tchar formattedMessage[MAX_LOGGING_MESSAGE_LENGTH]; + + va_list args; + va_start( args, pMessageFormat ); + Tier0Internal_vsntprintf( formattedMessage, MAX_LOGGING_MESSAGE_LENGTH, pMessageFormat, args ); + va_end( args ); + + return GetGlobalLoggingSystem()->LogDirect( channelID, severity, UNSPECIFIED_LOGGING_COLOR, formattedMessage ); +} + +LoggingResponse_t LoggingSystem_Log( LoggingChannelID_t channelID, LoggingSeverity_t severity, Color spewColor, const char *pMessageFormat, ... ) +{ + if ( !GetGlobalLoggingSystem()->IsChannelEnabled( channelID, severity ) ) + return LR_CONTINUE; + + tchar formattedMessage[MAX_LOGGING_MESSAGE_LENGTH]; + + va_list args; + va_start( args, pMessageFormat ); + Tier0Internal_vsntprintf( formattedMessage, MAX_LOGGING_MESSAGE_LENGTH, pMessageFormat, args ); + va_end( args ); + + return GetGlobalLoggingSystem()->LogDirect( channelID, severity, spewColor, formattedMessage ); +} + +LoggingResponse_t LoggingSystem_LogDirect( LoggingChannelID_t channelID, LoggingSeverity_t severity, Color spewColor, const char *pMessage ) +{ + if ( !GetGlobalLoggingSystem()->IsChannelEnabled( channelID, severity ) ) + return LR_CONTINUE; + return GetGlobalLoggingSystem()->LogDirect( channelID, severity, spewColor, pMessage ); +} + +LoggingResponse_t LoggingSystem_LogAssert( const char *pMessageFormat, ... ) +{ + if ( !GetGlobalLoggingSystem()->IsChannelEnabled( LOG_ASSERT, LS_ASSERT ) ) + return LR_CONTINUE; + + tchar formattedMessage[MAX_LOGGING_MESSAGE_LENGTH]; + + va_list args; + va_start( args, pMessageFormat ); + Tier0Internal_vsntprintf( formattedMessage, MAX_LOGGING_MESSAGE_LENGTH, pMessageFormat, args ); + va_end( args ); + + return GetGlobalLoggingSystem()->LogDirect( LOG_ASSERT, LS_ASSERT, UNSPECIFIED_LOGGING_COLOR, formattedMessage ); +} diff --git a/external/vpc/tier0/mem.cpp b/external/vpc/tier0/mem.cpp new file mode 100644 index 0000000..96468c3 --- /dev/null +++ b/external/vpc/tier0/mem.cpp @@ -0,0 +1,79 @@ +//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: Memory allocation! +// +// $NoKeywords: $ +//=============================================================================// + +#include "pch_tier0.h" +#include "tier0/mem.h" +//#include <malloc.h> +#include "tier0/dbg.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#ifndef STEAM +#define PvRealloc realloc +#define PvAlloc malloc +#define PvExpand _expand +#endif + +enum +{ + MAX_STACK_DEPTH = 32 +}; + +static uint8 *s_pBuf = NULL; +static int s_pBufStackDepth[MAX_STACK_DEPTH]; +static int s_nBufDepth = -1; +static int s_nBufCurSize = 0; +static int s_nBufAllocSize = 0; + +//----------------------------------------------------------------------------- +// Other DLL-exported methods for particular kinds of memory +//----------------------------------------------------------------------------- +void *MemAllocScratch( int nMemSize ) +{ + // Minimally allocate 1M scratch + if (s_nBufAllocSize < s_nBufCurSize + nMemSize) + { + s_nBufAllocSize = s_nBufCurSize + nMemSize; + if (s_nBufAllocSize < 2 * 1024) + { + s_nBufAllocSize = 2 * 1024; + } + + if (s_pBuf) + { + s_pBuf = (uint8*)PvRealloc( s_pBuf, s_nBufAllocSize ); + Assert( s_pBuf ); + } + else + { + s_pBuf = (uint8*)PvAlloc( s_nBufAllocSize ); + } + } + + int nBase = s_nBufCurSize; + s_nBufCurSize += nMemSize; + ++s_nBufDepth; + Assert( s_nBufDepth < MAX_STACK_DEPTH ); + s_pBufStackDepth[s_nBufDepth] = nMemSize; + + return &s_pBuf[nBase]; +} + +void MemFreeScratch() +{ + Assert( s_nBufDepth >= 0 ); + s_nBufCurSize -= s_pBufStackDepth[s_nBufDepth]; + --s_nBufDepth; +} + +#ifdef POSIX +void ZeroMemory( void *mem, size_t length ) +{ + memset( mem, 0x0, length ); +} +#endif diff --git a/external/vpc/tier0/mem_helpers.cpp b/external/vpc/tier0/mem_helpers.cpp new file mode 100644 index 0000000..52f2003 --- /dev/null +++ b/external/vpc/tier0/mem_helpers.cpp @@ -0,0 +1,186 @@ +//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//===========================================================================// + +#include "tier0/platform.h" +#include "tier0/icommandline.h" +#include "tier0/dbg.h" +#include "mem_helpers.h" +#include <string.h> +//#include <malloc.h> + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + +// Needed for debugging +const char *g_pszModule = "tier0"; +bool g_bInitMemory = true; + +#if defined(PLATFORM_POSIX) || defined( PLATFORM_PS3) +void DoApplyMemoryInitializations( void *pMem, size_t nSize ) +{ +} + +size_t CalcHeapUsed() +{ + return 0; +} +#else + +unsigned long g_dwFeeFee = 0xffeeffee; + +// Generated by Mathematica. +unsigned char g_RandomValues[256] = { + 95, 126, 220, 71, 92, 179, 95, 219, 111, 150, 38, 155, 181, 62, 40, 231, 238, + 54, 47, 55, 186, 204, 64, 70, 118, 94, 107, 251, 199, 140, 67, 87, 86, 127, + 210, 41, 21, 90, 208, 24, 167, 204, 32, 254, 38, 51, 9, 11, 38, 33, 188, 104, + 0, 75, 119, 24, 122, 203, 24, 164, 250, 224, 241, 182, 213, 201, 173, 67, + 200, 255, 244, 227, 46, 219, 26, 149, 218, 132, 120, 154, 227, 244, 106, 198, + 109, 87, 150, 40, 16, 99, 169, 193, 100, 156, 78, 171, 246, 47, 84, 119, 10, + 52, 207, 171, 230, 90, 90, 127, 180, 153, 68, 140, 62, 14, 87, 57, 208, 154, + 116, 29, 131, 177, 224, 187, 51, 148, 142, 245, 152, 230, 184, 117, 91, 146, + 235, 153, 35, 104, 187, 177, 215, 131, 17, 49, 211, 244, 60, 152, 103, 248, + 51, 224, 237, 240, 51, 30, 10, 233, 253, 106, 252, 73, 134, 136, 178, 86, + 228, 107, 77, 255, 85, 242, 204, 119, 102, 53, 209, 35, 123, 32, 252, 210, + 43, 12, 136, 167, 155, 210, 71, 254, 178, 172, 3, 230, 93, 208, 196, 68, 235, + 16, 106, 189, 201, 177, 85, 78, 206, 187, 48, 68, 64, 190, 117, 236, 49, 174, + 105, 63, 207, 70, 170, 93, 6, 110, 52, 111, 169, 92, 247, 86, 10, 174, 207, + 240, 104, 209, 81, 177, 123, 189, 175, 212, 101, 219, 114, 243, 44, 91, 51, + 139, 91, 57, 120, 41, 98, 119 }; + +unsigned long g_iCurRandomValueOffset = 0; + + +void InitializeToFeeFee( void *pMem, size_t nSize ) +{ + unsigned long *pCurDWord = (unsigned long*)pMem; + size_t nDWords = nSize >> 2; + while ( nDWords ) + { + *pCurDWord = 0xffeeffee; + ++pCurDWord; + --nDWords; + } + + unsigned char *pCurChar = (unsigned char*)pCurDWord; + size_t nBytes = nSize & 3; + size_t iOffset = 0; + while ( nBytes ) + { + *pCurChar = ((unsigned char*)&g_dwFeeFee)[iOffset]; + ++iOffset; + --nBytes; + ++pCurChar; + } +} + + +void InitializeToRandom( void *pMem, size_t nSize ) +{ + unsigned char *pOut = (unsigned char *)pMem; + for ( size_t i=0; i < nSize; i++ ) + { + pOut[i] = g_RandomValues[(g_iCurRandomValueOffset & 255)]; + ++g_iCurRandomValueOffset; + } +} + + +void DoApplyMemoryInitializations( void *pMem, size_t nSize ) +{ + if ( !pMem ) + return; + + // If they passed -noinitmemory on the command line, don't do anything here. + Assert( g_bInitMemory ); + + // First time we get in here, remember all the settings. + static bool bDebuggerPresent = Plat_IsInDebugSession(); + static bool bCheckedCommandLine = false; + static bool bRandomizeMemory = false; + if ( !bCheckedCommandLine ) + { + bCheckedCommandLine = true; + + //APS + char *pStr = (char*)Plat_GetCommandLineA(); + if ( pStr ) + { + char tempStr[512]; + strncpy( tempStr, pStr, sizeof( tempStr ) - 1 ); + tempStr[ sizeof( tempStr ) - 1 ] = 0; + _strupr( tempStr ); + + if ( strstr( tempStr, "-RANDOMIZEMEMORY" ) ) + bRandomizeMemory = true; + + if ( strstr( tempStr, "-NOINITMEMORY" ) ) + g_bInitMemory = false; + } + } + + if ( bRandomizeMemory ) + { + // They asked for it.. randomize all the memory. + InitializeToRandom( pMem, nSize ); + } + else + { + if ( bDebuggerPresent ) + { + // Ok, it's already set to 0xbaadf00d, but we want something that will make floating-point #'s NANs. + InitializeToFeeFee( pMem, nSize ); + } + else + { +#if defined(_DEBUG) || defined(USE_LIGHT_MEM_DEBUG) +#ifdef LIGHT_MEM_DEBUG_REQUIRES_CMD_LINE_SWITCH + extern bool g_bUsingLMD; + if ( !g_bUsingLMD ) + { + return; + } +#endif + // Ok, it's already set to 0xcdcdcdcd, but we want something that will make floating-point #'s NANs. + InitializeToFeeFee( pMem, nSize ); +#endif + } + } +} + +size_t CalcHeapUsed() +{ +#if defined( _X360 ) + return 0; +#else + _HEAPINFO hinfo; + int heapstatus; + intp nTotal; + + nTotal = 0; + hinfo._pentry = NULL; + while( ( heapstatus = _heapwalk( &hinfo ) ) == _HEAPOK ) + { + nTotal += (hinfo._useflag == _USEDENTRY) ? hinfo._size : 0; + } + + switch (heapstatus) + { + case _HEAPEMPTY: + case _HEAPEND: + // success + break; + + default: + // heap corrupted + nTotal = -1; + } + + return nTotal; +#endif +} + +#endif // not PLATFORM_POSIX + diff --git a/external/vpc/tier0/mem_helpers.h b/external/vpc/tier0/mem_helpers.h new file mode 100644 index 0000000..cdf2bfc --- /dev/null +++ b/external/vpc/tier0/mem_helpers.h @@ -0,0 +1,33 @@ +//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +//===========================================================================// + +#ifndef MEM_HELPERS_H +#define MEM_HELPERS_H +#ifdef _WIN32 +#pragma once +#endif + + +// Normally, the runtime libraries like to mess with the memory returned by malloc(), +// which can create problems trying to repro bugs in debug builds or in the debugger. +// +// If the debugger is present, it initializes data to 0xbaadf00d, which makes floating +// point numbers come out to about 0.1. +// +// If the debugger is not present, and it's a debug build, then you get 0xcdcdcdcd, +// which is about 25 million. +// +// Otherwise, you get uninitialized memory. +// +// In here, we make sure the memory is either random garbage, or it's set to +// 0xffeeffee, which casts to a NAN. +extern bool g_bInitMemory; +#define ApplyMemoryInitializations( pMem, nSize ) if ( !g_bInitMemory ) ; else { DoApplyMemoryInitializations( pMem, nSize ); } +void DoApplyMemoryInitializations( void *pMem, size_t nSize ); + +size_t CalcHeapUsed(); + +#endif // MEM_HELPERS_H diff --git a/external/vpc/tier0/mem_impl_type.h b/external/vpc/tier0/mem_impl_type.h new file mode 100644 index 0000000..f01b653 --- /dev/null +++ b/external/vpc/tier0/mem_impl_type.h @@ -0,0 +1,6 @@ + +#if ( (!defined( POSIX )||defined(_GAMECONSOLE)) && (defined(_DEBUG) || defined(USE_MEM_DEBUG) ) ) +#define MEM_IMPL_TYPE_DBG 1 +#else +#define MEM_IMPL_TYPE_STD 1 +#endif diff --git a/external/vpc/tier0/memdbg.cpp b/external/vpc/tier0/memdbg.cpp new file mode 100644 index 0000000..ad9c153 --- /dev/null +++ b/external/vpc/tier0/memdbg.cpp @@ -0,0 +1,2762 @@ +//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: Memory allocation! +// +// $NoKeywords: $ +//===========================================================================// + + +#include "pch_tier0.h" + +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + +//#include <malloc.h> +#include <string.h> +#include "tier0/dbg.h" +#include "tier0/stackstats.h" +#include "tier0/memalloc.h" +#include "tier0/fasttimer.h" +#include "mem_helpers.h" +#ifdef PLATFORM_WINDOWS_PC +#undef WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <crtdbg.h> +#endif +#ifdef OSX +#include <malloc/malloc.h> +#include <stdlib.h> +#endif + +#include <map> +#include <set> +#include <limits.h> +#include "tier0/threadtools.h" +#ifdef _X360 +#include "xbox/xbox_console.h" +#endif + +#ifdef _PS3 +#include "sys/memory.h" +#include "tls_ps3.h" +#include "ps3/ps3_helpers.h" +#include "memoverride_ps3.h" +#endif + +#ifdef USE_LIGHT_MEM_DEBUG +#undef USE_MEM_DEBUG +#endif + +#if (!defined( POSIX ) && (defined(_DEBUG) || defined(USE_MEM_DEBUG))) +#pragma message ("USE_MEM_DEBUG is enabled in a release build. Don't check this in!") +#endif + +#include "mem_impl_type.h" + +#if MEM_IMPL_TYPE_DBG + +#if defined(_WIN32) && ( !defined(_X360) && !defined(_WIN64) ) +//be sure to disable frame pointer omission for all projects. "vpc /nofpo" when using stack traces +//#define USE_STACK_TRACES +// or: +//#define USE_STACK_TRACES_DETAILED +const size_t STACK_TRACE_LENGTH = 32; +#endif + +//prevent stupid bugs from checking one and not the other +#if defined( USE_STACK_TRACES_DETAILED ) && !defined( USE_STACK_TRACES ) +#define USE_STACK_TRACES //don't comment me. I'm a safety check +#endif + +#if defined( USE_STACK_TRACES ) +#define SORT_STACK_TRACE_DESCRIPTION_DUMPS +#endif + +#if (defined( USE_STACK_TRACES )) && !(defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) +#error Stack traces will not work unless FPO is disabled for every function traced through. Rebuild everything with FPO disabled "vpc /nofpo" +#endif + +//----------------------------------------------------------------------------- + +#ifdef _PS3 +MemOverrideRawCrtFunctions_t *g_pMemOverrideRawCrtFns; +#define DebugAlloc (g_pMemOverrideRawCrtFns->pfn_malloc) +#define DebugFree (g_pMemOverrideRawCrtFns->pfn_free) +#elif defined( _X360 ) +#define DebugAlloc DmAllocatePool +#define DebugFree DmFreePool +#else +#define DebugAlloc malloc +#define DebugFree free +#endif + +#ifdef _WIN32 +int g_DefaultHeapFlags = _CrtSetDbgFlag( _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_ALLOC_MEM_DF ); +#else +int g_DefaultHeapFlags = 0; +#endif // win32 + +#if defined( _MEMTEST ) +static char s_szStatsMapName[32]; +static char s_szStatsComment[256]; +#endif + +#pragma optimize( "", off ) +//----------------------------------------------------------------------------- + +#if defined( USE_STACK_TRACES ) + +bool GetModuleFromAddress( void *address, char *pResult, int iLength ) +{ + return GetModuleNameFromAddress( address, pResult, iLength ); +} + +bool GetCallerModule( char *pDest, int iLength ) +{ + void *pCaller; + GetCallStack_Fast( &pCaller, 1, 2 ); + + return ( pCaller != 0 && GetModuleFromAddress( pCaller, pDest, iLength ) ); +} + +// +// Note: StackDescribe function is non-reentrant: +// Reason: Stack description is stored in a static buffer. +// Solution: Passing caller-allocated buffers would allow the +// function to become reentrant, however the current only client (FindOrCreateFilename) +// is synchronized with a heap mutex, after retrieving stack description the +// heap memory will be allocated to copy the text. +// + +char * StackDescribe( void * const *ppAddresses, int nMaxAddresses ) +{ + static char s_chStackDescription[ 32 * 1024 ]; + char *pchBuffer = s_chStackDescription; + +#if defined( SORT_STACK_TRACE_DESCRIPTION_DUMPS ) //Assuming StackDescribe is called iteratively on a sorted set of stacks (as in DumpStackStats()). We can save work by skipping unchanged parts at the beginning of the string. + static void *LastCallStack[STACK_TRACE_LENGTH] = { NULL }; + static char *pEndPos[STACK_TRACE_LENGTH] = { NULL }; + bool bUseExistingString = true; +#else + s_chStackDescription[ 0 ] = 0; +#endif + + int k; + for ( k = 0; k < nMaxAddresses; ++ k ) + { + if ( !ppAddresses[k] ) + break; + +#if defined( SORT_STACK_TRACE_DESCRIPTION_DUMPS ) + if( bUseExistingString && (k < STACK_TRACE_LENGTH) ) + { + if( ppAddresses[k] == LastCallStack[k] ) + { + pchBuffer = pEndPos[k]; + continue; + } + else + { + //everything from here on is invalidated + bUseExistingString = false; + for( int clearEntries = k; clearEntries < STACK_TRACE_LENGTH; ++clearEntries ) //wipe out unused entries + { + LastCallStack[clearEntries] = NULL; + pEndPos[clearEntries] = NULL; + } + //fall through to existing code + + if( k == 0 ) + *pchBuffer = '\0'; + else + sprintf( pchBuffer, "<--" ); + } + } +#endif + { + pchBuffer += strlen( pchBuffer ); + + char szTemp[MAX_PATH]; + szTemp[0] = '\0'; + uint32 iLine = 0; + uint32 iLineDisplacement = 0; + uint64 iSymbolDisplacement = 0; + if ( GetFileAndLineFromAddress( ppAddresses[k], szTemp, MAX_PATH, iLine, &iLineDisplacement ) ) + { + char const *pchFileName = szTemp + strlen( szTemp ); + for ( size_t numSlashesAllowed = 2; pchFileName > szTemp; --pchFileName ) + { + if ( *pchFileName == '\\' ) + { + if ( numSlashesAllowed-- ) + continue; + else + break; + } + } + sprintf( pchBuffer, iLineDisplacement ? "%s:%d+0x%I32X" : "%s:%d", pchFileName, iLine, iLineDisplacement ); + } + else if ( GetSymbolNameFromAddress( ppAddresses[k], szTemp, MAX_PATH, &iSymbolDisplacement ) ) + { + sprintf( pchBuffer, ( iSymbolDisplacement > 0 && !( iSymbolDisplacement >> 63 ) ) ? "%s+0x%llX" : "%s", szTemp, iSymbolDisplacement ); + } + else + { + sprintf( pchBuffer, "#0x%08p", ppAddresses[k] ); + } + + pchBuffer += strlen( pchBuffer ); + sprintf( pchBuffer, "<--" ); + +#if defined( SORT_STACK_TRACE_DESCRIPTION_DUMPS ) + if( k < STACK_TRACE_LENGTH ) + { + LastCallStack[k] = ppAddresses[k]; + pEndPos[k] = pchBuffer; + } +#endif + } + } + *pchBuffer = 0; + +#if defined( SORT_STACK_TRACE_DESCRIPTION_DUMPS ) + for( ; k < STACK_TRACE_LENGTH; ++k ) //wipe out unused entries + { + LastCallStack[k] = NULL; + pEndPos[k] = NULL; + } +#endif + + return s_chStackDescription; +} + +#else + +#define GetModuleFromAddress( address, pResult, iLength ) ( ( *pResult = 0 ), 0) +#define GetCallerModule( pDest, iLength ) false + +#endif + + +//----------------------------------------------------------------------------- + +// NOTE: This exactly mirrors the dbg header in the MSDEV crt +// eventually when we write our own allocator, we can kill this +struct CrtDbgMemHeader_t +{ + unsigned char m_Reserved[8]; + const char *m_pFileName; + int m_nLineNumber; + unsigned char m_Reserved2[16]; +}; + +struct Sentinal_t +{ + DWORD value[4]; +}; + +Sentinal_t g_HeadSentinelAllocated = +{ + 0xeee1beef, + 0xeee1f00d, + 0xbd122969, + 0xbeefbeef, +}; + +Sentinal_t g_HeadSentinelFree = +{ + 0xdeadbeef, + 0xbaadf00d, + 0xbd122969, + 0xdeadbeef, +}; + +Sentinal_t g_TailSentinel = +{ + 0xbaadf00d, + 0xbd122969, + 0xdeadbeef, + 0xbaadf00d, +}; + +const byte g_FreeFill = 0xdd; + +enum DbgMemHeaderBlockType_t +{ + BLOCKTYPE_FREE, + BLOCKTYPE_ALLOCATED +}; + +struct DbgMemHeader_t +#if !defined( _DEBUG ) || defined( _PS3 ) + : CrtDbgMemHeader_t +#endif +{ + size_t nLogicalSize; +#if defined( USE_STACK_TRACES ) + unsigned int nStatIndex; + byte reserved[16 - (sizeof(unsigned int) * 2)]; // MS allocator always returns mem aligned on 16 bytes, which some of our code depends on +#else + byte reserved[16 - sizeof(unsigned int)]; // MS allocator always returns mem aligned on 16 bytes, which some of our code depends on +#endif + Sentinal_t sentinal; +}; + +const int g_nRecentFrees = ( IsPC() ) ? 8192 : 512; +DbgMemHeader_t ** GetRecentFrees() { static DbgMemHeader_t **g_pRecentFrees = (DbgMemHeader_t**) +#ifdef _PS3 +g_pMemOverrideRawCrtFns->pfn_calloc +#else +calloc +#endif +( g_nRecentFrees, sizeof(DbgMemHeader_t *) ); +return g_pRecentFrees; } +uint32 volatile g_iNextFreeSlot; + +uint32 volatile g_break_BytesFree = 0xffffffff; + +void LMDReportInvalidBlock( DbgMemHeader_t *pHeader, const char *pszMessage ) +{ + char szMsg[256]; + if ( pHeader ) + { + sprintf( szMsg, "HEAP IS CORRUPT: %s (block 0x%x, %d bytes)\n", pszMessage, (size_t)( ((byte*) pHeader) + sizeof( DbgMemHeader_t ) ), pHeader->nLogicalSize ); + } + else + { + sprintf( szMsg, "HEAP IS CORRUPT: %s\n", pszMessage ); + } + Assert( !"HEAP IS CORRUPT!" ); + DebuggerBreak(); +} + +void LMDValidateBlock( DbgMemHeader_t *pHeader, bool bFreeList ) +{ + if ( memcmp( &pHeader->sentinal, bFreeList ? &g_HeadSentinelFree : &g_HeadSentinelAllocated, sizeof(Sentinal_t) ) != 0 ) + { + LMDReportInvalidBlock( pHeader, "Head sentinel corrupt" ); + } + if ( memcmp( ((Sentinal_t *)(( ((byte*) pHeader) + sizeof( DbgMemHeader_t ) + pHeader->nLogicalSize ))), &g_TailSentinel, sizeof(Sentinal_t) ) != 0 ) + { + LMDReportInvalidBlock( pHeader, "Tail sentinel corrupt" ); + } + if ( bFreeList ) + { + byte *pCur = (byte *)pHeader + sizeof(DbgMemHeader_t); + byte *pLimit = pCur + pHeader->nLogicalSize; + while ( pCur != pLimit ) + { + if ( *pCur++ != g_FreeFill ) + { + LMDReportInvalidBlock( pHeader, "Write after free" ); + } + } + } +} + + +//----------------------------------------------------------------------------- + +#if defined( _DEBUG ) && !defined( POSIX ) +#define GetCrtDbgMemHeader( pMem ) ((CrtDbgMemHeader_t*)((DbgMemHeader_t*)pMem - 1) - 1) +#elif defined( OSX ) +DbgMemHeader_t *GetCrtDbgMemHeader( void *pMem ); +#else +#define GetCrtDbgMemHeader( pMem ) ((DbgMemHeader_t*)(pMem) - 1) +#endif + +#if defined( USE_STACK_TRACES ) +#define GetAllocationStatIndex_Internal( pMem ) ( ((DbgMemHeader_t*)pMem - 1)->nStatIndex ) +#endif + +#ifdef OSX +DbgMemHeader_t *GetCrtDbgMemHeader( void *pMem ) +{ + size_t msize = malloc_size( pMem ); + return (DbgMemHeader_t *)( (char *)pMem + msize - sizeof(DbgMemHeader_t) ); +} +#endif + + +inline void *InternalMalloc( size_t nSize, const char *pFileName, int nLine ) +{ +#if defined( POSIX ) || defined( _PS3 ) + void *pAllocedMem = NULL; +#ifdef OSX + pAllocedMem = malloc_zone_malloc( malloc_default_zone(), nSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pAllocedMem ); +#elif defined( _PS3 ) + pAllocedMem = (g_pMemOverrideRawCrtFns->pfn_malloc)( nSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pAllocedMem; + *((void**)pInternalMem->m_Reserved2) = pAllocedMem; +#else + pAllocedMem = malloc( nSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pAllocedMem; +#endif + + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; + pInternalMem->nLogicalSize = nSize; + *((int*)pInternalMem->m_Reserved) = 0xf00df00d; + + pInternalMem->sentinal = g_HeadSentinelAllocated; + *( (Sentinal_t *)( ((byte*)pInternalMem) + sizeof( DbgMemHeader_t ) + nSize ) ) = g_TailSentinel; + LMDValidateBlock( pInternalMem, false ); + +#ifdef OSX + return pAllocedMem; +#else + return pInternalMem + 1; +#endif + +#else // WIN32 + DbgMemHeader_t *pInternalMem; +#if !defined( _DEBUG ) + pInternalMem = (DbgMemHeader_t *)malloc( nSize + sizeof(DbgMemHeader_t) ); + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; +#else + pInternalMem = (DbgMemHeader_t *)_malloc_dbg( nSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine ); +#endif + + pInternalMem->nLogicalSize = nSize; + return pInternalMem + 1; +#endif // WIN32 +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +inline void *InternalMallocAligned( size_t nSize, size_t align, const char *pFileName, int nLine ) +{ +#if defined( POSIX ) || defined( _PS3 ) + void *pAllocedMem = NULL; +#ifdef OSX + pAllocedMem = malloc_zone_malloc( malloc_default_zone(), nSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pAllocedMem ); +#elif defined( _PS3 ) + size_t numWastedAlignPages = ( sizeof( DbgMemHeader_t ) / align ); + if ( align * numWastedAlignPages < sizeof( DbgMemHeader_t ) ) + ++ numWastedAlignPages; + size_t nSizeRequired = nSize + numWastedAlignPages*align + sizeof( Sentinal_t ); + pAllocedMem = (g_pMemOverrideRawCrtFns->pfn_memalign)( align, nSizeRequired ); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( ((char*)pAllocedMem) + numWastedAlignPages*align ); + *((void**)pInternalMem->m_Reserved2) = pAllocedMem; +#else + pAllocedMem = malloc( nSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pAllocedMem; +#endif + + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; + pInternalMem->nLogicalSize = nSize; + *((int*)pInternalMem->m_Reserved) = 0xf00df00d; + + pInternalMem->sentinal = g_HeadSentinelAllocated; + *( (Sentinal_t *)( ((byte*)pInternalMem) + sizeof( DbgMemHeader_t ) + nSize ) ) = g_TailSentinel; + LMDValidateBlock( pInternalMem, false ); + +#ifdef OSX + return pAllocedMem; +#else + return pInternalMem + 1; +#endif + +#else // WIN32 + DbgMemHeader_t *pInternalMem; +#if !defined( _DEBUG ) + pInternalMem = (DbgMemHeader_t *)malloc( nSize + sizeof(DbgMemHeader_t) ); + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; +#else + pInternalMem = (DbgMemHeader_t *)_malloc_dbg( nSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine ); +#endif + + pInternalMem->nLogicalSize = nSize; + return pInternalMem + 1; +#endif // WIN32 +} +#endif + +inline void *InternalRealloc( void *pMem, size_t nNewSize, const char *pFileName, int nLine ) +{ + if ( !pMem ) + return InternalMalloc( nNewSize, pFileName, nLine ); + +#ifdef POSIX + void *pNewAllocedMem = NULL; +#ifdef OSX + pNewAllocedMem = (DbgMemHeader_t *)malloc_zone_realloc( malloc_default_zone(), pMem, nNewSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pNewAllocedMem ); +#elif defined( _PS3 ) + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + pNewAllocedMem = (DbgMemHeader_t *)(g_pMemOverrideRawCrtFns->pfn_realloc)( *((void**)pInternalMem->m_Reserved2), nNewSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + pInternalMem = (DbgMemHeader_t *)pNewAllocedMem; + *((void**)pInternalMem->m_Reserved2) = pNewAllocedMem; +#else + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + pNewAllocedMem = (DbgMemHeader_t *)realloc( pInternalMem, nNewSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + pInternalMem = (DbgMemHeader_t *)pNewAllocedMem; +#endif + + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; + pInternalMem->nLogicalSize = static_cast<unsigned int>( nNewSize ); + *((int*)pInternalMem->m_Reserved) = 0xf00df00d; + + pInternalMem->sentinal = g_HeadSentinelAllocated; + *( (Sentinal_t *)( ((byte*)pInternalMem) + sizeof( DbgMemHeader_t ) + nNewSize ) ) = g_TailSentinel; + LMDValidateBlock( pInternalMem, false ); + +#ifdef OSX + return pNewAllocedMem; +#else + return pInternalMem + 1; +#endif + +#else // WIN32 + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; +#if !defined( _DEBUG ) + pInternalMem = (DbgMemHeader_t *)realloc( pInternalMem, nNewSize + sizeof(DbgMemHeader_t) ); + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; +#else + pInternalMem = (DbgMemHeader_t *)_realloc_dbg( pInternalMem, nNewSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine ); +#endif + + pInternalMem->nLogicalSize = nNewSize; + return pInternalMem + 1; +#endif // WIN32 +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +inline void *InternalReallocAligned( void *pMem, size_t nNewSize, size_t align, const char *pFileName, int nLine ) +{ + if ( !pMem ) + return InternalMallocAligned( nNewSize, align, pFileName, nLine ); + +#ifdef POSIX + void *pNewAllocedMem = NULL; +#ifdef OSX + pNewAllocedMem = (DbgMemHeader_t *)malloc_zone_realloc( malloc_default_zone(), pMem, nNewSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pNewAllocedMem ); +#elif defined( _PS3 ) + size_t numWastedAlignPages = ( sizeof( DbgMemHeader_t ) / align ); + if ( align * numWastedAlignPages < sizeof( DbgMemHeader_t ) ) + ++ numWastedAlignPages; + size_t nSizeRequired = nNewSize + numWastedAlignPages*align + sizeof( Sentinal_t ); + + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + pNewAllocedMem = (DbgMemHeader_t *)(g_pMemOverrideRawCrtFns->pfn_reallocalign)( *((void**)pInternalMem->m_Reserved2), nSizeRequired, align ); + pInternalMem = GetCrtDbgMemHeader( ((char*)pNewAllocedMem) + numWastedAlignPages*align ); + *((void**)pInternalMem->m_Reserved2) = pNewAllocedMem; +#else + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + pNewAllocedMem = (DbgMemHeader_t *)realloc( pInternalMem, nNewSize + sizeof(DbgMemHeader_t) + sizeof( Sentinal_t ) ); + pInternalMem = (DbgMemHeader_t *)pNewAllocedMem; +#endif + + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; + pInternalMem->nLogicalSize = static_cast<unsigned int>( nNewSize ); + *((int*)pInternalMem->m_Reserved) = 0xf00df00d; + + pInternalMem->sentinal = g_HeadSentinelAllocated; + *( (Sentinal_t *)( ((byte*)pInternalMem) + sizeof( DbgMemHeader_t ) + nNewSize ) ) = g_TailSentinel; + LMDValidateBlock( pInternalMem, false ); + +#ifdef OSX + return pNewAllocedMem; +#else + return pInternalMem + 1; +#endif + +#else // WIN32 + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; +#if !defined( _DEBUG ) + pInternalMem = (DbgMemHeader_t *)realloc( pInternalMem, nNewSize + sizeof(DbgMemHeader_t) ); + pInternalMem->m_pFileName = pFileName; + pInternalMem->m_nLineNumber = nLine; +#else + pInternalMem = (DbgMemHeader_t *)_realloc_dbg( pInternalMem, nNewSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine ); +#endif + + pInternalMem->nLogicalSize = nNewSize; + return pInternalMem + 1; +#endif // WIN32 +} +#endif + +inline void InternalFree( void *pMem ) +{ + if ( !pMem ) + return; + + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; + +#if defined( POSIX ) + // Record it in recent free blocks list + DbgMemHeader_t **pRecentFrees = GetRecentFrees(); + uint32 iNextSlot = ThreadInterlockedIncrement( &g_iNextFreeSlot ); + iNextSlot %= g_nRecentFrees; + + if ( memcmp( &pInternalMem->sentinal, &g_HeadSentinelAllocated, sizeof( Sentinal_t ) ) != 0 ) + { + Assert( !"Double Free or Corrupt Block Header!" ); + DebuggerBreak(); + } + LMDValidateBlock( pInternalMem, false ); + if ( g_break_BytesFree == pInternalMem->nLogicalSize ) + { + DebuggerBreak(); + } + pInternalMem->sentinal = g_HeadSentinelFree; + memset( pMem, g_FreeFill, pInternalMem->nLogicalSize ); + + DbgMemHeader_t *pToFree = pInternalMem; + if ( pInternalMem->nLogicalSize < 16*1024 ) + { + pToFree = pRecentFrees[iNextSlot]; + pRecentFrees[iNextSlot] = pInternalMem; + + if ( pToFree ) + { + LMDValidateBlock( pToFree, true ); + } + } + + // Validate several last frees + for ( uint32 k = iNextSlot - 1, iteration = 0; iteration < 10; ++ iteration, -- k ) + { + if ( DbgMemHeader_t *pLastFree = pRecentFrees[ k % g_nRecentFrees ] ) + { + LMDValidateBlock( pLastFree, true ); + } + } + + if ( !pToFree ) + return; + +#ifdef OSX + malloc_zone_free( malloc_default_zone(), pToFree ); +#elif defined( _PS3 ) + (g_pMemOverrideRawCrtFns->pfn_free)( *((void**)pToFree->m_Reserved2) ); +#elif LINUX + free( pToFree ); +#else + free( pToFree ); +#endif +#elif defined( _DEBUG ) + _free_dbg( pInternalMem, _NORMAL_BLOCK ); +#else + free( pInternalMem ); +#endif +} + +inline size_t InternalMSize( void *pMem ) +{ +#if defined( _PS3 ) + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + return pInternalMem->nLogicalSize; +#elif defined(POSIX) + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + return pInternalMem->nLogicalSize; +#elif !defined(_DEBUG) + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); + return _msize( pInternalMem ) - sizeof(DbgMemHeader_t); +#else + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; + return _msize_dbg( pInternalMem, _NORMAL_BLOCK ) - sizeof(DbgMemHeader_t); +#endif +} + +inline size_t InternalLogicalSize( void *pMem ) +{ +#if defined(POSIX) + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem ); +#elif !defined(_DEBUG) + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; +#else + DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1; +#endif + return pInternalMem->nLogicalSize; +} + +#ifndef _DEBUG +#define _CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg ) 0 +#endif + +//----------------------------------------------------------------------------- + + +// Custom allocator protects this module from recursing on operator new +template <class T> +class CNoRecurseAllocator +{ +public: + // type definitions + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + CNoRecurseAllocator() {} + CNoRecurseAllocator(const CNoRecurseAllocator&) {} + template <class U> CNoRecurseAllocator(const CNoRecurseAllocator<U>&) {} + ~CNoRecurseAllocator(){} + + // rebind allocator to type U + template <class U > struct rebind { typedef CNoRecurseAllocator<U> other; }; + + // return address of values + pointer address (reference value) const { return &value; } + + const_pointer address (const_reference value) const { return &value;} + size_type max_size() const { return INT_MAX; } + + pointer allocate(size_type num, const void* = 0) { return (pointer)DebugAlloc(num * sizeof(T)); } + void deallocate (pointer p, size_type num) { DebugFree(p); } + void construct(pointer p, const T& value) { new((void*)p)T(value); } + void destroy (pointer p) { p->~T(); } +}; + +template <class T1, class T2> +bool operator==(const CNoRecurseAllocator<T1>&, const CNoRecurseAllocator<T2>&) +{ + return true; +} + +template <class T1, class T2> +bool operator!=(const CNoRecurseAllocator<T1>&, const CNoRecurseAllocator<T2>&) +{ + return false; +} + +class CStringLess +{ +public: + bool operator()(const char *pszLeft, const char *pszRight ) const + { + return ( V_tier0_stricmp( pszLeft, pszRight ) < 0 ); + } +}; + +//----------------------------------------------------------------------------- + +#pragma warning( disable:4074 ) // warning C4074: initializers put in compiler reserved initialization area +#pragma init_seg( compiler ) + +//----------------------------------------------------------------------------- +// NOTE! This should never be called directly from leaf code +// Just use new,delete,malloc,free etc. They will call into this eventually +//----------------------------------------------------------------------------- +class CDbgMemAlloc : public IMemAlloc +{ +public: + CDbgMemAlloc(); + virtual ~CDbgMemAlloc(); + + // Release versions + virtual void *Alloc( size_t nSize ); + virtual void *Realloc( void *pMem, size_t nSize ); + virtual void Free( void *pMem ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize ); + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + virtual void *AllocAlign( size_t nSize, size_t align ); + virtual void *AllocAlign( size_t nSize, size_t align, const char *pFileName, int nLine ); + virtual void *ReallocAlign( void *pMem, size_t nSize, size_t align ); + virtual void *ReallocAlign( void *pMem, size_t nSize, size_t align, const char *pFileName, int nLine ); +#endif + + // Debug versions + virtual void *Alloc( size_t nSize, const char *pFileName, int nLine ); + virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ); + virtual void Free( void *pMem, const char *pFileName, int nLine ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ); + + virtual void *RegionAlloc( int region, size_t nSize ) { return Alloc( nSize ); } + virtual void *RegionAlloc( int region, size_t nSize, const char *pFileName, int nLine ) { return Alloc( nSize, pFileName, nLine ); } + + // Returns the size of a particular allocation (NOTE: may be larger than the size requested!) + virtual size_t GetSize( void *pMem ); + + // Force file + line information for an allocation + virtual void PushAllocDbgInfo( const char *pFileName, int nLine ); + virtual void PopAllocDbgInfo(); + + virtual int32 CrtSetBreakAlloc( int32 lNewBreakAlloc ); + virtual int CrtSetReportMode( int nReportType, int nReportMode ); + virtual int CrtIsValidHeapPointer( const void *pMem ); + virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access ); + virtual int CrtCheckMemory( void ); + virtual int CrtSetDbgFlag( int nNewFlag ); + virtual void CrtMemCheckpoint( _CrtMemState *pState ); + + // handles storing allocation info for coroutines + virtual uint32 GetDebugInfoSize(); + virtual void SaveDebugInfo( void *pvDebugInfo ); + virtual void RestoreDebugInfo( const void *pvDebugInfo ); + virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ); + + // FIXME: Remove when we have our own allocator + virtual void* CrtSetReportFile( int nRptType, void* hFile ); + virtual void* CrtSetReportHook( void* pfnNewHook ); + virtual int CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * szFormat ); + + virtual int heapchk(); + + virtual bool IsDebugHeap() { return true; } + + virtual int GetVersion() { return MEMALLOC_VERSION; } + + virtual void CompactHeap() + { +#if defined( _X360 ) && defined( _DEBUG ) + HeapCompact( GetProcessHeap(), 0 ); +#endif + } + + virtual void CompactIncremental() {} + virtual void OutOfMemory( size_t nBytesAttempted = 0 ) {} + + virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ) { return NULL; } // debug heap doesn't attempt retries + + void SetStatsExtraInfo( const char *pMapName, const char *pComment ) + { +#if defined( _MEMTEST ) + strncpy( s_szStatsMapName, pMapName, sizeof( s_szStatsMapName ) ); + s_szStatsMapName[sizeof( s_szStatsMapName ) - 1] = '\0'; + + strncpy( s_szStatsComment, pComment, sizeof( s_szStatsComment ) ); + s_szStatsComment[sizeof( s_szStatsComment ) - 1] = '\0'; +#endif + } + + virtual size_t MemoryAllocFailed(); + void SetCRTAllocFailed( size_t nMemSize ); + + enum + { + BYTE_COUNT_16 = 0, + BYTE_COUNT_32, + BYTE_COUNT_128, + BYTE_COUNT_2048, + BYTE_COUNT_GREATER, + + NUM_BYTE_COUNT_BUCKETS + }; + +private: + struct MemInfo_t + { +#if defined( USE_STACK_TRACES ) + DECLARE_CALLSTACKSTATSTRUCT(); + DECLARE_CALLSTACKSTATSTRUCT_FIELDDESCRIPTION(); +#endif + + MemInfo_t() + { + memset( this, 0, sizeof(*this) ); + } + + // Size in bytes + size_t m_nCurrentSize; + size_t m_nPeakSize; + size_t m_nTotalSize; + size_t m_nOverheadSize; + size_t m_nPeakOverheadSize; + + // Count in terms of # of allocations + int m_nCurrentCount; + int m_nPeakCount; + int m_nTotalCount; + + int m_nSumTargetRange; + int m_nCurTargetRange; + int m_nMaxTargetRange; + + // Count in terms of # of allocations of a particular size + int m_pCount[NUM_BYTE_COUNT_BUCKETS]; + + // Time spent allocating + deallocating (microseconds) + int64 m_nTime; + }; + + struct MemInfoKey_FileLine_t + { + MemInfoKey_FileLine_t( const char *pFileName, int line ) : m_pFileName(pFileName), m_nLine(line) {} + bool operator<( const MemInfoKey_FileLine_t &key ) const + { + int iret = V_tier0_stricmp( m_pFileName, key.m_pFileName ); + if ( iret < 0 ) + return true; + + if ( iret > 0 ) + return false; + + return m_nLine < key.m_nLine; + } + + const char *m_pFileName; + int m_nLine; + }; + + // NOTE: Deliberately using STL here because the UTL stuff + // is a client of this library; want to avoid circular dependency + + // Maps file name to info + typedef std::map< MemInfoKey_FileLine_t, MemInfo_t, std::less<MemInfoKey_FileLine_t>, CNoRecurseAllocator<std::pair<const MemInfoKey_FileLine_t, MemInfo_t> > > StatMap_FileLine_t; + typedef StatMap_FileLine_t::iterator StatMapIter_FileLine_t; + typedef StatMap_FileLine_t::value_type StatMapEntry_FileLine_t; + + typedef std::set<const char *, CStringLess, CNoRecurseAllocator<const char *> > Filenames_t; + + // Heap reporting method + typedef void (*HeapReportFunc_t)( char const *pFormat, ... ); + +private: + // Returns the actual debug info + virtual void GetActualDbgInfo( const char *&pFileName, int &nLine ); + + // Finds the file in our map + MemInfo_t &FindOrCreateEntry( const char *pFileName, int line ); + const char *FindOrCreateFilename( const char *pFileName ); + +#if defined( USE_STACK_TRACES ) + int GetCallStackForIndex( unsigned int index, void **pCallStackOut, int iMaxEntriesOut ); + friend int GetAllocationCallStack( void *mem, void **pCallStackOut, int iMaxEntriesOut ); +#endif + + // Updates stats + virtual void RegisterAllocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); + virtual void RegisterDeallocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); +#if defined( USE_STACK_TRACES ) + void RegisterAllocation( unsigned int nStatIndex, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); + void RegisterDeallocation( unsigned int nStatIndex, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); +#endif + void RegisterAllocation( MemInfo_t &info, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); + void RegisterDeallocation( MemInfo_t &info, size_t nLogicalSize, size_t nActualSize, unsigned nTime ); + + // Gets the allocation file name + const char *GetAllocatonFileName( void *pMem ); + int GetAllocatonLineNumber( void *pMem ); + + // FIXME: specify a spew output func for dumping stats + // Stat output + void DumpMemInfo( const char *pAllocationName, int line, const MemInfo_t &info ); + void DumpFileStats(); +#if defined( USE_STACK_TRACES ) + void DumpMemInfo( void * const CallStack[STACK_TRACE_LENGTH], const MemInfo_t &info ); + void DumpCallStackFlow( char const *pchFileBase ); +#endif + virtual void DumpStats(); + virtual void DumpStatsFileBase( char const *pchFileBase ); + virtual void DumpBlockStats( void *p ); + virtual void GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory ); + + virtual size_t ComputeMemoryUsedBy( char const *pchSubStr ); + + virtual IVirtualMemorySection * AllocateVirtualMemorySection( size_t numMaxBytes ) + { +#if defined( _GAMECONSOLE ) || defined( _WIN32 ) + extern IVirtualMemorySection * VirtualMemoryManager_AllocateVirtualMemorySection( size_t numMaxBytes ); + return VirtualMemoryManager_AllocateVirtualMemorySection( numMaxBytes ); +#else + return NULL; +#endif + } + + virtual int GetGenericMemoryStats( GenericMemoryStat_t **ppMemoryStats ) + { + // TODO: reuse code from GlobalMemoryStatus (though this is only really useful when using CStdMemAlloc...) + return 0; + } + +private: + StatMap_FileLine_t m_StatMap_FileLine; +#if defined( USE_STACK_TRACES ) + typedef CCallStackStatsGatherer<MemInfo_t, STACK_TRACE_LENGTH, GetCallStack_Fast, CCallStackStatsGatherer_StatMutexPool<128>, CNoRecurseAllocator> CallStackStatsType_t; + CallStackStatsType_t m_CallStackStats; +#endif + + MemInfo_t m_GlobalInfo; + CFastTimer m_Timer; + bool m_bInitialized; + Filenames_t m_Filenames; + + HeapReportFunc_t m_OutputFunc; + + static size_t s_pCountSizes[NUM_BYTE_COUNT_BUCKETS]; + static const char *s_pCountHeader[NUM_BYTE_COUNT_BUCKETS]; + + size_t m_sMemoryAllocFailed; +}; + +static char const *g_pszUnknown = "unknown"; + +#if defined( USE_STACK_TRACES ) +BEGIN_STATSTRUCTDESCRIPTION( CDbgMemAlloc::MemInfo_t ) + WRITE_STATSTRUCT_FIELDDESCRIPTION(); +END_STATSTRUCTDESCRIPTION() + + +BEGIN_STATSTRUCTFIELDDESCRIPTION( CDbgMemAlloc::MemInfo_t ) + DEFINE_STATSTRUCTFIELD( m_nCurrentSize, BasicStatStructFieldDesc, ( BSSFT_SIZE_T, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nPeakSize, BasicStatStructFieldDesc, ( BSSFT_SIZE_T, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nTotalSize, BasicStatStructFieldDesc, ( BSSFT_SIZE_T, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nOverheadSize, BasicStatStructFieldDesc, ( BSSFT_SIZE_T, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nPeakOverheadSize, BasicStatStructFieldDesc, ( BSSFT_SIZE_T, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nCurrentCount, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nPeakCount, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nTotalCount, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nSumTargetRange, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nCurTargetRange, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nMaxTargetRange, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD_ARRAYENTRY( m_pCount, BYTE_COUNT_16, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD_ARRAYENTRY( m_pCount, BYTE_COUNT_32, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD_ARRAYENTRY( m_pCount, BYTE_COUNT_128, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD_ARRAYENTRY( m_pCount, BYTE_COUNT_2048, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD_ARRAYENTRY( m_pCount, BYTE_COUNT_GREATER, BasicStatStructFieldDesc, ( BSSFT_INT, BSSFCM_ADD ) ) + DEFINE_STATSTRUCTFIELD( m_nTime, BasicStatStructFieldDesc, ( BSSFT_INT64, BSSFCM_ADD ) ) +END_STATSTRUCTFIELDDESCRIPTION() +#endif + + +//----------------------------------------------------------------------------- + +const int DBG_INFO_STACK_DEPTH = 32; + +struct DbgInfoStack_t +{ + const char *m_pFileName; + int m_nLine; +}; + +#ifdef _PS3 +#ifndef _CERT +extern TLSGlobals * ( *g_pfnElfGetTlsGlobals )(); +#define IfDbgInfoIsReady() if ( TLSGlobals *IfDbgInfoIsReady_pTlsGlobals = g_pfnElfGetTlsGlobals ? g_pfnElfGetTlsGlobals() : NULL ) +#else +#define IfDbgInfoIsReady() if ( TLSGlobals *IfDbgInfoIsReady_pTlsGlobals = GetTLSGlobals() ) +#endif +#define g_DbgInfoStack ( ( DbgInfoStack_t *& ) IfDbgInfoIsReady_pTlsGlobals->pMallocDbgInfoStack ) +#define g_nDbgInfoStackDepth ( IfDbgInfoIsReady_pTlsGlobals->nMallocDbgInfoStackDepth ) +#else +CTHREADLOCALPTR( DbgInfoStack_t) g_DbgInfoStack CONSTRUCT_EARLY; +CTHREADLOCALINT g_nDbgInfoStackDepth CONSTRUCT_EARLY; +#define IfDbgInfoIsReady() if (true) +#endif + +#ifdef _PS3 +struct CDbgMemAlloc_GetRawCrtMemOverrideFuncs_Early +{ + CDbgMemAlloc_GetRawCrtMemOverrideFuncs_Early() + { + malloc_managed_size mms; + mms.current_inuse_size = 0x12345678; + mms.current_system_size = 0x09ABCDEF; + mms.max_system_size = 0; + int iResult = malloc_stats( &mms ); + g_pMemOverrideRawCrtFns = reinterpret_cast< MemOverrideRawCrtFunctions_t * >( iResult ); + } +} +g_CDbgMemAlloc_GetRawCrtMemOverrideFuncs_Early CONSTRUCT_EARLY; +#endif + +//----------------------------------------------------------------------------- +// Singleton... +//----------------------------------------------------------------------------- +static CDbgMemAlloc s_DbgMemAlloc CONSTRUCT_EARLY; + +#ifdef _PS3 + +IMemAlloc *g_pMemAllocInternalPS3 = &s_DbgMemAlloc; +PLATFORM_OVERRIDE_MEM_ALLOC_INTERNAL_PS3_IMPL + +#else // !_PS3 + +#ifndef TIER0_VALIDATE_HEAP +IMemAlloc *g_pMemAlloc CONSTRUCT_EARLY = &s_DbgMemAlloc; +#else +IMemAlloc *g_pActualAlloc = &s_DbgMemAlloc; +#endif + +#endif // _PS3 + + +//----------------------------------------------------------------------------- + +CThreadMutex g_DbgMemMutex CONSTRUCT_EARLY; + +#define HEAP_LOCK() AUTO_LOCK( g_DbgMemMutex ) + + +//----------------------------------------------------------------------------- +// Byte count buckets +//----------------------------------------------------------------------------- +size_t CDbgMemAlloc::s_pCountSizes[CDbgMemAlloc::NUM_BYTE_COUNT_BUCKETS] = +{ + 16, 32, 128, 2048, INT_MAX +}; + +const char *CDbgMemAlloc::s_pCountHeader[CDbgMemAlloc::NUM_BYTE_COUNT_BUCKETS] = +{ + "<=16 byte allocations", + "17-32 byte allocations", + "33-128 byte allocations", + "129-2048 byte allocations", + ">2048 byte allocations" +}; + + +size_t g_TargetCountRangeMin = 0, g_TargetCountRangeMax = 0; + +//----------------------------------------------------------------------------- +// Standard output +//----------------------------------------------------------------------------- +static FILE* s_DbgFile; + +static void DefaultHeapReportFunc( char const *pFormat, ... ) +{ + va_list args; + va_start( args, pFormat ); + vfprintf( s_DbgFile, pFormat, args ); + va_end( args ); +} + +//----------------------------------------------------------------------------- +// Constructor +//----------------------------------------------------------------------------- +CDbgMemAlloc::CDbgMemAlloc() : m_sMemoryAllocFailed( (size_t)0 ) +{ + CClockSpeedInit::Init(); + + m_OutputFunc = DefaultHeapReportFunc; + m_bInitialized = true; + + if ( !IsDebug() && !IsX360() ) + { + Plat_DebugString( "USE_MEM_DEBUG is enabled in a release build. Don't check this in!\n" ); + } + +#ifdef _PS3 + g_pMemAllocInternalPS3 = &s_DbgMemAlloc; + PLATFORM_OVERRIDE_MEM_ALLOC_INTERNAL_PS3.m_pMemAllocCached = &s_DbgMemAlloc; + malloc_managed_size mms; + mms.current_inuse_size = 0x12345678; + mms.current_system_size = 0x09ABCDEF; + mms.max_system_size = reinterpret_cast< size_t >( this ); + int iResult = malloc_stats( &mms ); + g_pMemOverrideRawCrtFns = reinterpret_cast< MemOverrideRawCrtFunctions_t * >( iResult ); +#endif +} + +CDbgMemAlloc::~CDbgMemAlloc() +{ + Filenames_t::const_iterator iter = m_Filenames.begin(); + while(iter != m_Filenames.end()) + { + char *pFileName = (char*)(*iter); + free( pFileName ); + iter++; + } + m_bInitialized = false; +} + + +//----------------------------------------------------------------------------- +// Release versions +//----------------------------------------------------------------------------- + +void *CDbgMemAlloc::Alloc( size_t nSize ) +{ +/* + // NOTE: Uncomment this to find unknown allocations + const char *pFileName = g_pszUnknown; + int nLine; + GetActualDbgInfo( pFileName, nLine ); + if (pFileName == g_pszUnknown) + { + int x = 3; + } +*/ + char szModule[MAX_PATH]; + if ( GetCallerModule( szModule, MAX_PATH ) ) + { + return Alloc( nSize, szModule, 0 ); + } + else + { + return Alloc( nSize, g_pszUnknown, 0 ); + } +// return malloc( nSize ); +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void *CDbgMemAlloc::AllocAlign( size_t nSize, size_t align ) +{ +/* + // NOTE: Uncomment this to find unknown allocations + const char *pFileName = g_pszUnknown; + int nLine; + GetActualDbgInfo( pFileName, nLine ); + if (pFileName == g_pszUnknown) + { + int x = 3; + } +*/ + char szModule[MAX_PATH]; + if ( GetCallerModule( szModule, MAX_PATH ) ) + { + return AllocAlign( nSize, align, szModule, 0 ); + } + else + { + return AllocAlign( nSize, align, g_pszUnknown, 0 ); + } +// return malloc( nSize ); +} +#endif + +void *CDbgMemAlloc::Realloc( void *pMem, size_t nSize ) +{ +/* + // NOTE: Uncomment this to find unknown allocations + const char *pFileName = g_pszUnknown; + int nLine; + GetActualDbgInfo( pFileName, nLine ); + if (pFileName == g_pszUnknown) + { + int x = 3; + } +*/ + // FIXME: Should these gather stats? + char szModule[MAX_PATH]; + if ( GetCallerModule( szModule, MAX_PATH ) ) + { + return Realloc( pMem, nSize, szModule, 0 ); + } + else + { + return Realloc( pMem, nSize, g_pszUnknown, 0 ); + } +// return realloc( pMem, nSize ); +} + +void CDbgMemAlloc::Free( void *pMem ) +{ + // FIXME: Should these gather stats? + Free( pMem, g_pszUnknown, 0 ); +// free( pMem ); +} + +void *CDbgMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize ) +{ + return NULL; +} + + +//----------------------------------------------------------------------------- +// Force file + line information for an allocation +//----------------------------------------------------------------------------- +void CDbgMemAlloc::PushAllocDbgInfo( const char *pFileName, int nLine ) +{ + IfDbgInfoIsReady() + { + + if ( g_DbgInfoStack == NULL ) + { + g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH ); + g_nDbgInfoStackDepth = -1; + } + + ++g_nDbgInfoStackDepth; + Assert( g_nDbgInfoStackDepth < DBG_INFO_STACK_DEPTH ); + g_DbgInfoStack[g_nDbgInfoStackDepth].m_pFileName = FindOrCreateFilename( pFileName ); + g_DbgInfoStack[g_nDbgInfoStackDepth].m_nLine = nLine; + + } +} + +void CDbgMemAlloc::PopAllocDbgInfo() +{ + IfDbgInfoIsReady() + { + + if ( g_DbgInfoStack == NULL ) + { + g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH ); + g_nDbgInfoStackDepth = -1; + } + + --g_nDbgInfoStackDepth; + Assert( g_nDbgInfoStackDepth >= -1 ); + + } +} + + +//----------------------------------------------------------------------------- +// handles storing allocation info for coroutines +//----------------------------------------------------------------------------- +uint32 CDbgMemAlloc::GetDebugInfoSize() +{ + return sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH + sizeof( int32 ); +} + +void CDbgMemAlloc::SaveDebugInfo( void *pvDebugInfo ) +{ + IfDbgInfoIsReady() + { + if ( g_DbgInfoStack == NULL ) + { + g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH ); + g_nDbgInfoStackDepth = -1; + } + + int32 *pnStackDepth = (int32*) pvDebugInfo; + *pnStackDepth = g_nDbgInfoStackDepth; + memcpy( pnStackDepth+1, &g_DbgInfoStack[0], sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH ); + } +} + +void CDbgMemAlloc::RestoreDebugInfo( const void *pvDebugInfo ) +{ + IfDbgInfoIsReady() + { + if ( g_DbgInfoStack == NULL ) + { + g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH ); + g_nDbgInfoStackDepth = -1; + } + + const int32 *pnStackDepth = (const int32*) pvDebugInfo; + g_nDbgInfoStackDepth = *pnStackDepth; + memcpy( &g_DbgInfoStack[0], pnStackDepth+1, sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH ); + } +} + +void CDbgMemAlloc::InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ) +{ + int32 *pnStackDepth = (int32*) pvDebugInfo; + + if( pchRootFileName ) + { + *pnStackDepth = 0; + + DbgInfoStack_t *pStackRoot = (DbgInfoStack_t *)(pnStackDepth + 1); + pStackRoot->m_pFileName = FindOrCreateFilename( pchRootFileName ); + pStackRoot->m_nLine = nLine; + } + else + { + *pnStackDepth = -1; + } + +} + + +//----------------------------------------------------------------------------- +// Returns the actual debug info +//----------------------------------------------------------------------------- +void CDbgMemAlloc::GetActualDbgInfo( const char *&pFileName, int &nLine ) +{ +#if defined( USE_STACK_TRACES_DETAILED ) + return; +#endif + + IfDbgInfoIsReady() + { + + if ( g_DbgInfoStack == NULL ) + { + g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH ); + g_nDbgInfoStackDepth = -1; + } + + if ( g_nDbgInfoStackDepth >= 0 && g_DbgInfoStack[0].m_pFileName) + { + pFileName = g_DbgInfoStack[0].m_pFileName; + nLine = g_DbgInfoStack[0].m_nLine; + } + + } +} + + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +const char *CDbgMemAlloc::FindOrCreateFilename( const char *pFileName ) +{ + // If we created it for the first time, actually *allocate* the filename memory + HEAP_LOCK(); + // This is necessary for shutdown conditions: the file name is stored + // in some piece of memory in a DLL; if that DLL becomes unloaded, + // we'll have a pointer to crap memory + + if ( !pFileName ) + { + pFileName = g_pszUnknown; + } + +#if defined( USE_STACK_TRACES_DETAILED ) +{ + + // Walk the stack to determine what's causing the allocation + void *arrStackAddresses[ 10 ] = { 0 }; + int numStackAddrRetrieved = GetCallStack_Fast( arrStackAddresses, 10, 2 ); //Skip this function, and either CDbgMemAlloc::Alloc() or CDbgMemAlloc::Realloc() + char *szStack = StackDescribe( arrStackAddresses, numStackAddrRetrieved ); + if ( szStack && *szStack ) + { + pFileName = szStack; // Use the stack description for the allocation + } + +} +#endif // #if defined( USE_STACK_TRACES_DETAILED ) + + char *pszFilenameCopy; + Filenames_t::const_iterator iter = m_Filenames.find( pFileName ); + if ( iter == m_Filenames.end() ) + { + size_t nLen = strlen(pFileName) + 1; + pszFilenameCopy = (char *)DebugAlloc( nLen ); + memcpy( pszFilenameCopy, pFileName, nLen ); + m_Filenames.insert( pszFilenameCopy ); + } + else + { + pszFilenameCopy = (char *)(*iter); + } + + return pszFilenameCopy; +} + +//----------------------------------------------------------------------------- +// Finds the file in our map +//----------------------------------------------------------------------------- +CDbgMemAlloc::MemInfo_t &CDbgMemAlloc::FindOrCreateEntry( const char *pFileName, int line ) +{ + // Oh how I love crazy STL. retval.first == the StatMapIter_t in the std::pair + // retval.first->second == the MemInfo_t that's part of the StatMapIter_t + std::pair<StatMapIter_FileLine_t, bool> retval; + retval = m_StatMap_FileLine.insert( StatMapEntry_FileLine_t( MemInfoKey_FileLine_t( pFileName, line ), MemInfo_t() ) ); + return retval.first->second; +} + +#if defined( USE_STACK_TRACES ) +int CDbgMemAlloc::GetCallStackForIndex( unsigned int index, void **pCallStackOut, int iMaxEntriesOut ) +{ + if( iMaxEntriesOut > STACK_TRACE_LENGTH ) + iMaxEntriesOut = STACK_TRACE_LENGTH; + + CallStackStatsType_t::StackReference stackRef = m_CallStackStats.GetCallStackForIndex( index ); + + memcpy( pCallStackOut, stackRef, iMaxEntriesOut * sizeof( void * ) ); + for( int i = 0; i != iMaxEntriesOut; ++i ) + { + if( pCallStackOut[i] == NULL ) + return i; + } + return iMaxEntriesOut; +} +#endif + + +//----------------------------------------------------------------------------- +// Updates stats +//----------------------------------------------------------------------------- +void CDbgMemAlloc::RegisterAllocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + HEAP_LOCK(); + RegisterAllocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime ); + RegisterAllocation( FindOrCreateEntry( pFileName, nLine ), nLogicalSize, nActualSize, nTime ); +} + +void CDbgMemAlloc::RegisterDeallocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + HEAP_LOCK(); + RegisterDeallocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime ); + RegisterDeallocation( FindOrCreateEntry( pFileName, nLine ), nLogicalSize, nActualSize, nTime ); +} + +#if defined( USE_STACK_TRACES ) +void CDbgMemAlloc::RegisterAllocation( unsigned int nStatIndex, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + HEAP_LOCK(); + RegisterAllocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime ); + CCallStackStatsGatherer_StructAccessor_AutoLock<MemInfo_t> entryAccessor = m_CallStackStats.GetEntry( nStatIndex ); + RegisterAllocation( *entryAccessor.GetStruct(), nLogicalSize, nActualSize, nTime ); +} + +void CDbgMemAlloc::RegisterDeallocation( unsigned int nStatIndex, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + HEAP_LOCK(); + RegisterDeallocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime ); + CCallStackStatsGatherer_StructAccessor_AutoLock<MemInfo_t> entryAccessor = m_CallStackStats.GetEntry( nStatIndex ); + RegisterDeallocation( *entryAccessor.GetStruct(), nLogicalSize, nActualSize, nTime ); +} +#endif + +void CDbgMemAlloc::RegisterAllocation( MemInfo_t &info, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + ++info.m_nCurrentCount; + ++info.m_nTotalCount; + if (info.m_nCurrentCount > info.m_nPeakCount) + { + info.m_nPeakCount = info.m_nCurrentCount; + } + + info.m_nCurrentSize += nLogicalSize; + info.m_nTotalSize += nLogicalSize; + if (info.m_nCurrentSize > info.m_nPeakSize) + { + info.m_nPeakSize = info.m_nCurrentSize; + } + + if ( nLogicalSize > g_TargetCountRangeMin && nLogicalSize <= g_TargetCountRangeMax ) + { + info.m_nSumTargetRange++; + info.m_nCurTargetRange++; + if ( info.m_nCurTargetRange > info.m_nMaxTargetRange ) + { + info.m_nMaxTargetRange = info.m_nCurTargetRange; + } + } + + for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i) + { + if (nLogicalSize <= s_pCountSizes[i]) + { + ++info.m_pCount[i]; + break; + } + } + + Assert( info.m_nPeakCount >= info.m_nCurrentCount ); + Assert( info.m_nPeakSize >= info.m_nCurrentSize ); + + info.m_nOverheadSize += (nActualSize - nLogicalSize); + if (info.m_nOverheadSize > info.m_nPeakOverheadSize) + { + info.m_nPeakOverheadSize = info.m_nOverheadSize; + } + + info.m_nTime += nTime; +} + +void CDbgMemAlloc::RegisterDeallocation( MemInfo_t &info, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) +{ + --info.m_nCurrentCount; + info.m_nCurrentSize -= nLogicalSize; + + for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i) + { + if (nLogicalSize <= s_pCountSizes[i]) + { + --info.m_pCount[i]; + break; + } + } + + if ( nLogicalSize > g_TargetCountRangeMin && nLogicalSize <= g_TargetCountRangeMax ) + { + info.m_nCurTargetRange--; + } + + Assert( info.m_nPeakCount >= info.m_nCurrentCount ); + Assert( info.m_nPeakSize >= info.m_nCurrentSize ); + Assert( info.m_nCurrentCount >= 0 ); + Assert( info.m_nCurrentSize >= 0 ); + + info.m_nOverheadSize -= (nActualSize - nLogicalSize); + + info.m_nTime += nTime; +} + + +//----------------------------------------------------------------------------- +// Gets the allocation file name +//----------------------------------------------------------------------------- + +const char *CDbgMemAlloc::GetAllocatonFileName( void *pMem ) +{ + if (!pMem) + return ""; + + CrtDbgMemHeader_t *pHeader = GetCrtDbgMemHeader( pMem ); + if ( pHeader->m_pFileName ) + return pHeader->m_pFileName; + else + return g_pszUnknown; +} + +//----------------------------------------------------------------------------- +// Gets the allocation file name +//----------------------------------------------------------------------------- +int CDbgMemAlloc::GetAllocatonLineNumber( void *pMem ) +{ + if ( !pMem ) + return 0; + + CrtDbgMemHeader_t *pHeader = GetCrtDbgMemHeader( pMem ); + return pHeader->m_nLineNumber; +} + +//----------------------------------------------------------------------------- +// Debug versions of the main allocation methods +//----------------------------------------------------------------------------- +void *CDbgMemAlloc::Alloc( size_t nSize, const char *pFileName, int nLine ) +{ + HEAP_LOCK(); + +#if defined( USE_STACK_TRACES ) + unsigned int iStatEntryIndex = m_CallStackStats.GetEntryIndex( CCallStackStorage( m_CallStackStats.StackFunction, 1 ) ); +#endif + + if ( !m_bInitialized ) + { + void *pRetval = InternalMalloc( nSize, pFileName, nLine ); + +#if defined( USE_STACK_TRACES ) + if( pRetval ) + { + GetAllocationStatIndex_Internal( pRetval ) = iStatEntryIndex; + } +#endif + + return pRetval; + } + + + + if ( pFileName != g_pszUnknown ) + pFileName = FindOrCreateFilename( pFileName ); + + GetActualDbgInfo( pFileName, nLine ); + + /* + if ( strcmp( pFileName, "class CUtlVector<int,class CUtlMemory<int> >" ) == 0) + { + GetActualDbgInfo( pFileName, nLine ); + } + */ + + m_Timer.Start(); + void *pMem = InternalMalloc( nSize, pFileName, nLine ); + m_Timer.End(); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + + ApplyMemoryInitializations( pMem, nSize ); + +#if defined( USE_STACK_TRACES ) + RegisterAllocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#else + RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#endif + + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + } + return pMem; +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void *CDbgMemAlloc::AllocAlign( size_t nSize, size_t align, const char *pFileName, int nLine ) +{ + HEAP_LOCK(); + +#if defined( USE_STACK_TRACES ) + unsigned int iStatEntryIndex = m_CallStackStats.GetEntryIndexForCurrentCallStack( 1 ); +#endif + + if ( !m_bInitialized ) + { + void *pRetval = InternalMalloc( nSize, pFileName, nLine ); + +#if defined( USE_STACK_TRACES ) + if( pRetval ) + { + GetAllocationStatIndex_Internal( pRetval ) = iStatEntryIndex; + } +#endif + + return pRetval; + } + + + + if ( pFileName != g_pszUnknown ) + pFileName = FindOrCreateFilename( pFileName ); + + GetActualDbgInfo( pFileName, nLine ); + + /* + if ( strcmp( pFileName, "class CUtlVector<int,class CUtlMemory<int> >" ) == 0) + { + GetActualDbgInfo( pFileName, nLine ); + } + */ + + m_Timer.Start(); + void *pMem = InternalMallocAligned( nSize, align, pFileName, nLine ); + m_Timer.End(); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + + ApplyMemoryInitializations( pMem, nSize ); + +#if defined( USE_STACK_TRACES ) + RegisterAllocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#else + RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#endif + + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + } + return pMem; +} +#endif + +void *CDbgMemAlloc::Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + HEAP_LOCK(); + + pFileName = FindOrCreateFilename( pFileName ); + +#if defined( USE_STACK_TRACES ) + unsigned int iStatEntryIndex = m_CallStackStats.GetEntryIndex( CCallStackStorage( m_CallStackStats.StackFunction, 1 ) ); +#endif + + if ( !m_bInitialized ) + { + pMem = InternalRealloc( pMem, nSize, pFileName, nLine ); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + return pMem; + } + + if ( pMem != 0 ) + { +#if defined( USE_STACK_TRACES ) + RegisterDeallocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), 0 ); +#else + RegisterDeallocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), 0 ); +#endif + } + + GetActualDbgInfo( pFileName, nLine ); + + m_Timer.Start(); + pMem = InternalRealloc( pMem, nSize, pFileName, nLine ); + m_Timer.End(); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + +#if defined( USE_STACK_TRACES ) + RegisterAllocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#else + RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#endif + + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + } + return pMem; +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void *CDbgMemAlloc::ReallocAlign( void *pMem, size_t nSize, size_t align ) +{ +/* + // NOTE: Uncomment this to find unknown allocations + const char *pFileName = g_pszUnknown; + int nLine; + GetActualDbgInfo( pFileName, nLine ); + if (pFileName == g_pszUnknown) + { + int x = 3; + } +*/ + char szModule[MAX_PATH]; + if ( GetCallerModule( szModule, MAX_PATH ) ) + { + return ReallocAlign( pMem, nSize, align, szModule, 0 ); + } + else + { + return ReallocAlign( pMem, nSize, align, g_pszUnknown, 0 ); + } +// return malloc( nSize ); +} +void *CDbgMemAlloc::ReallocAlign( void *pMem, size_t nSize, size_t align, const char *pFileName, int nLine ) +{ + HEAP_LOCK(); + + pFileName = FindOrCreateFilename( pFileName ); + +#if defined( USE_STACK_TRACES ) + unsigned int iStatEntryIndex = m_CallStackStats.GetEntryIndexForCurrentCallStack( 1 ); +#endif + + if ( !m_bInitialized ) + { + pMem = InternalReallocAligned( pMem, nSize, align, pFileName, nLine ); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + return pMem; + } + + if ( pMem != 0 ) + { +#if defined( USE_STACK_TRACES ) + RegisterDeallocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), 0 ); +#else + RegisterDeallocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), 0 ); +#endif + } + + GetActualDbgInfo( pFileName, nLine ); + + m_Timer.Start(); + pMem = InternalReallocAligned( pMem, nSize, align, pFileName, nLine ); + m_Timer.End(); + +#if defined( USE_STACK_TRACES ) + if( pMem ) + { + GetAllocationStatIndex_Internal( pMem ) = iStatEntryIndex; + } +#endif + +#if defined( USE_STACK_TRACES ) + RegisterAllocation( GetAllocationStatIndex_Internal( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#else + RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() ); +#endif + + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + } + return pMem; +} +#endif + +void CDbgMemAlloc::Free( void *pMem, const char * /*pFileName*/, int nLine ) +{ + if ( !pMem ) + return; + + HEAP_LOCK(); + + if ( !m_bInitialized ) + { + InternalFree( pMem ); + return; + } + + size_t nOldLogicalSize = InternalLogicalSize( pMem ); + size_t nOldSize = InternalMSize( pMem ); + +#if defined( USE_STACK_TRACES ) + unsigned int oldStatIndex = GetAllocationStatIndex_Internal( pMem ); +#else + const char *pOldFileName = GetAllocatonFileName( pMem ); + int oldLine = GetAllocatonLineNumber( pMem ); +#endif + + + m_Timer.Start(); + InternalFree( pMem ); + m_Timer.End(); + +#if defined( USE_STACK_TRACES ) + RegisterDeallocation( oldStatIndex, nOldLogicalSize, nOldSize, m_Timer.GetDuration().GetMicroseconds() ); +#else + RegisterDeallocation( pOldFileName, oldLine, nOldLogicalSize, nOldSize, m_Timer.GetDuration().GetMicroseconds() ); +#endif +} + +void *CDbgMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + return NULL; +} + + +//----------------------------------------------------------------------------- +// Returns the size of a particular allocation (NOTE: may be larger than the size requested!) +//----------------------------------------------------------------------------- +size_t CDbgMemAlloc::GetSize( void *pMem ) +{ + HEAP_LOCK(); + + if ( !pMem ) + return m_GlobalInfo.m_nCurrentSize; + + return InternalMSize( pMem ); +} + + +//----------------------------------------------------------------------------- +// FIXME: Remove when we make our own heap! Crt stuff we're currently using +//----------------------------------------------------------------------------- +int32 CDbgMemAlloc::CrtSetBreakAlloc( int32 lNewBreakAlloc ) +{ +#ifdef POSIX + return 0; +#else + return _CrtSetBreakAlloc( lNewBreakAlloc ); +#endif +} + +int CDbgMemAlloc::CrtSetReportMode( int nReportType, int nReportMode ) +{ +#ifdef POSIX + return 0; +#else + return _CrtSetReportMode( nReportType, nReportMode ); +#endif +} + +int CDbgMemAlloc::CrtIsValidHeapPointer( const void *pMem ) +{ +#ifdef POSIX + return 0; +#else + return _CrtIsValidHeapPointer( pMem ); +#endif +} + +int CDbgMemAlloc::CrtIsValidPointer( const void *pMem, unsigned int size, int access ) +{ +#ifdef POSIX + return 0; +#else + return _CrtIsValidPointer( pMem, size, access ); +#endif +} + +#define DBGMEM_CHECKMEMORY 1 + +int CDbgMemAlloc::CrtCheckMemory( void ) +{ +#if !defined( DBGMEM_CHECKMEMORY ) || defined( POSIX ) + return 1; +#elif defined( _WIN32 ) + if ( !_CrtCheckMemory()) + { + Msg( "Memory check failed!\n" ); + return 0; + } + return 1; +#else + return 1; +#endif +} + +int CDbgMemAlloc::CrtSetDbgFlag( int nNewFlag ) +{ +#ifdef POSIX + return 0; +#else + return _CrtSetDbgFlag( nNewFlag ); +#endif +} + +void CDbgMemAlloc::CrtMemCheckpoint( _CrtMemState *pState ) +{ +#ifndef POSIX + _CrtMemCheckpoint( pState ); +#endif +} + +// FIXME: Remove when we have our own allocator +void* CDbgMemAlloc::CrtSetReportFile( int nRptType, void* hFile ) +{ +#ifdef POSIX + return 0; +#else + return (void*)_CrtSetReportFile( nRptType, (_HFILE)hFile ); +#endif +} + +void* CDbgMemAlloc::CrtSetReportHook( void* pfnNewHook ) +{ +#ifdef POSIX + return 0; +#else + return (void*)_CrtSetReportHook( (_CRT_REPORT_HOOK)pfnNewHook ); +#endif +} + +int CDbgMemAlloc::CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ) +{ +#ifdef POSIX + return 0; +#else + return _CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg ); +#endif +} + +int CDbgMemAlloc::heapchk() +{ +#ifdef POSIX + return 0; +#else + if ( CrtCheckMemory() ) + return _HEAPOK; + else + return _HEAPBADPTR; +#endif +} + +void CDbgMemAlloc::DumpBlockStats( void *p ) +{ + DbgMemHeader_t *pBlock = (DbgMemHeader_t *)p - 1; + if ( !CrtIsValidHeapPointer( pBlock ) ) + { + Msg( "0x%x is not valid heap pointer\n", p ); + return; + } + + const char *pFileName = GetAllocatonFileName( p ); + int line = GetAllocatonLineNumber( p ); + + Msg( "0x%x allocated by %s line %d, %d bytes\n", p, pFileName, line, GetSize( p ) ); +} + +//----------------------------------------------------------------------------- +// Stat output +//----------------------------------------------------------------------------- +void CDbgMemAlloc::DumpMemInfo( const char *pAllocationName, int line, const MemInfo_t &info ) +{ + m_OutputFunc("%s, line %i\t%.1f\t%.1f\t%.1f\t%.1f\t%.1f\t%d\t%d\t%d\t%d\t%d\t%d\t%d", + pAllocationName, + line, + info.m_nCurrentSize / 1024.0f, + info.m_nPeakSize / 1024.0f, + info.m_nTotalSize / 1024.0f, + info.m_nOverheadSize / 1024.0f, + info.m_nPeakOverheadSize / 1024.0f, + (int)(info.m_nTime / 1000), + info.m_nCurrentCount, + info.m_nPeakCount, + info.m_nTotalCount, + info.m_nSumTargetRange, + info.m_nCurTargetRange, + info.m_nMaxTargetRange + ); + + for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i) + { + m_OutputFunc( "\t%d", info.m_pCount[i] ); + } + + m_OutputFunc("\n"); +} + + +//----------------------------------------------------------------------------- +// Stat output +//----------------------------------------------------------------------------- +size_t CDbgMemAlloc::ComputeMemoryUsedBy( char const *pchSubStr) +{ + size_t total = 0; + StatMapIter_FileLine_t iter = m_StatMap_FileLine.begin(); + while(iter != m_StatMap_FileLine.end()) + { + if(!pchSubStr || strstr(iter->first.m_pFileName,pchSubStr)) + { + total += iter->second.m_nCurrentSize; + } + iter++; + } + return total; +} + +void CDbgMemAlloc::DumpFileStats() +{ + StatMapIter_FileLine_t iter = m_StatMap_FileLine.begin(); + while(iter != m_StatMap_FileLine.end()) + { + DumpMemInfo( iter->first.m_pFileName, iter->first.m_nLine, iter->second ); + iter++; + } +} + +void CDbgMemAlloc::DumpStatsFileBase( char const *pchFileBase ) +{ + char szFileName[MAX_PATH]; + static int s_FileCount = 0; + if (m_OutputFunc == DefaultHeapReportFunc) + { + char *pPath = ""; +#ifdef _X360 + pPath = "D:\\"; +#elif defined( _PS3 ) + pPath = "/app_home/"; +#endif + + +#if defined( _MEMTEST ) && defined( _WIN32 ) + char szXboxName[32]; + strcpy( szXboxName, "xbox" ); + DWORD numChars = sizeof( szXboxName ); + DmGetXboxName( szXboxName, &numChars ); + char *pXboxName = strstr( szXboxName, "_360" ); + if ( pXboxName ) + { + *pXboxName = '\0'; + } + + SYSTEMTIME systemTime; + GetLocalTime( &systemTime ); + //_snprintf( szFileName, sizeof( szFileName ), "%s%s_%2.2d%2.2d_%2.2d%2.2d%2.2d_%d.txt", pPath, s_szStatsMapName, systemTime.wMonth, systemTime.wDay, systemTime.wHour, systemTime.wMinute, systemTime.wSecond, s_FileCount ); + _snprintf( szFileName, sizeof( szFileName ), "%s%s_%d.txt", pPath, s_szStatsMapName, s_FileCount ); +#else + _snprintf( szFileName, sizeof( szFileName ), "%s%s_%d.txt", pPath, pchFileBase, s_FileCount ); +#endif + + ++s_FileCount; + + s_DbgFile = fopen(szFileName, "wt"); + if (!s_DbgFile) + return; + } + + { + HEAP_LOCK(); + + m_OutputFunc("Allocation type\tCurrent Size(k)\tPeak Size(k)\tTotal Allocations(k)\tOverhead Size(k)\tPeak Overhead Size(k)\tTime(ms)\tCurrent Count\tPeak Count\tTotal Count\tTNum\tTCur\tTMax"); + + for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i) + { + m_OutputFunc( "\t%s", s_pCountHeader[i] ); + } + + m_OutputFunc("\n"); + + MemInfo_t totals = m_GlobalInfo; +#ifdef _PS3 + { + // Add a line for system heap stats + static malloc_managed_size mms; + (g_pMemOverrideRawCrtFns->pfn_malloc_stats)( &mms ); + + MemInfo_t info; + info.m_nCurrentSize = mms.current_inuse_size; + info.m_nPeakSize = mms.max_system_size; + info.m_nOverheadSize = mms.current_system_size - mms.current_inuse_size; + DumpMemInfo( "||PS3 malloc_stats||", 0, info ); + + // Add a line for PRXs + char prxFilename[256]; + sys_prx_id_t prxIDs[256]; + sys_prx_segment_info_t prxSegments[32]; + sys_prx_get_module_list_t prxList = { sizeof( sys_prx_get_module_list_t ), ARRAYSIZE( prxIDs ), 0, prxIDs, NULL }; + sys_prx_get_module_list( 0, &prxList ); + Assert( prxList.count < ARRAYSIZE( prxIDs ) ); + memset( &info, 0, sizeof( info ) ); + for ( int i = 0; i < prxList.count; i++ ) + { + sys_prx_module_info_t prxInfo; + prxInfo.size = sizeof( sys_prx_module_info_t ); + prxInfo.filename = prxFilename; + prxInfo.filename_size = sizeof( prxFilename ); + prxInfo.segments = prxSegments; + prxInfo.segments_num = ARRAYSIZE( prxSegments ); + sys_prx_get_module_info( prxList.idlist[i], 0, &prxInfo ); + Assert( prxInfo.segments_num < ARRAYSIZE( prxSegments ) ); + for ( int j = 0; j < prxInfo.segments_num; j++ ) + { + info.m_nCurrentSize += prxInfo.segments[j].memsz; + } + } + DumpMemInfo( "PS3 PRXs", 0, info ); + + // Add PRX sizes to our global tracked total: + totals.m_nCurrentSize += info.m_nCurrentSize; + } +#endif // _PS3 + + // The total of all memory usage we know about: + DumpMemInfo( "||Totals||", 0, totals ); + + if ( IsGameConsole() ) + { + // Add a line showing total system memory usage from the OS (if this is more than + // "||Totals||", then there is unknown memory usage that we need to track down): + size_t usedMemory, freeMemory; + GlobalMemoryStatus( &usedMemory, &freeMemory ); + MemInfo_t info; + info.m_nCurrentSize = usedMemory; + DumpMemInfo( "||Used Memory||", 0, info ); + } + +#ifdef _MEMTEST + { + // Add lines for GPU allocations + int nGPUMemSize, nGPUMemFree, nTextureSize, nRTSize, nVBSize, nIBSize, nUnknown; + if ( 7 == sscanf( s_szStatsComment, "%d %d %d %d %d %d %d", &nGPUMemSize, &nGPUMemFree, &nTextureSize, &nRTSize, &nVBSize, &nIBSize, &nUnknown ) ) + { + int nTotalUsed = nTextureSize + nRTSize + nVBSize + nIBSize + nUnknown; + int nOverhead = ( nGPUMemSize - nTotalUsed ) - nGPUMemFree; + m_OutputFunc( "||PS3 RSX: total used||, line 0\t%.1f\n", nTotalUsed / 1024.0f ); + m_OutputFunc( "PS3 RSX: textures, line 0\t%.1f\n", nTextureSize / 1024.0f ); + m_OutputFunc( "PS3 RSX: render targets, line 0\t%.1f\n", nRTSize / 1024.0f ); + m_OutputFunc( "PS3 RSX: vertex buffers, line 0\t%.1f\n", nVBSize / 1024.0f ); + m_OutputFunc( "PS3 RSX: index buffers, line 0\t%.1f\n", nIBSize / 1024.0f ); + m_OutputFunc( "PS3 RSX: unknown, line 0\t%.1f\n", nUnknown / 1024.0f ); + m_OutputFunc( "PS3 RSX: overhead, line 0\t%.1f\n", nOverhead / 1024.0f ); + } + } +#endif + + //m_OutputFunc("File/Line Based\n"); + DumpFileStats(); + } + + if (m_OutputFunc == DefaultHeapReportFunc) + { + fclose(s_DbgFile); + +#if defined( _X360 ) + XBX_rMemDump( szFileName ); +#endif + } +} + +void CDbgMemAlloc::GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory ) +{ + if ( !pUsedMemory || !pFreeMemory ) + return; + +#if defined ( _X360 ) + + // GlobalMemoryStatus tells us how much physical memory is free + MEMORYSTATUS stat; + ::GlobalMemoryStatus( &stat ); + *pFreeMemory = stat.dwAvailPhys; + + // Used is total minus free (discount the 32MB system reservation) + *pUsedMemory = ( stat.dwTotalPhys - 32*1024*1024 ) - *pFreeMemory; + +#elif defined( _PS3 ) + + // need to factor in how much empty space there is in the heap + // (since it NEVER returns pages back to the OS after hitting a high-watermark) + static malloc_managed_size mms; + (g_pMemOverrideRawCrtFns->pfn_malloc_stats)( &mms ); + int heapFree = mms.current_system_size - mms.current_inuse_size; + Assert( heapFree >= 0 ); + + // sys_memory_get_user_memory_size tells us how much PPU memory is used/free + static sys_memory_info stat; + sys_memory_get_user_memory_size( &stat ); + *pFreeMemory = stat.available_user_memory; + *pFreeMemory += heapFree; + *pUsedMemory = stat.total_user_memory - *pFreeMemory; + // 213MB are available in retail mode, so adjust free mem to reflect that even if we're in devkit mode + const size_t RETAIL_SIZE = 213*1024*1024; + if ( stat.total_user_memory > RETAIL_SIZE ) + *pFreeMemory -= stat.total_user_memory - RETAIL_SIZE; + +#else + + // no data + *pFreeMemory = 0; + *pUsedMemory = 0; + +#endif +} + +#ifdef USE_STACK_TRACES +void CDbgMemAlloc::DumpCallStackFlow( char const *pchFileBase ) +{ + HEAP_LOCK(); + + char szFileName[MAX_PATH]; + static int s_FileCount = 0; + + char *pPath = ""; + if ( IsX360() ) + { + pPath = "D:\\"; + } + +#if defined( _MEMTEST ) && defined( _WIN32 ) + char szXboxName[32]; + strcpy( szXboxName, "xbox" ); + DWORD numChars = sizeof( szXboxName ); + DmGetXboxName( szXboxName, &numChars ); + char *pXboxName = strstr( szXboxName, "_360" ); + if ( pXboxName ) + { + *pXboxName = '\0'; + } + + SYSTEMTIME systemTime; + GetLocalTime( &systemTime ); + _snprintf( szFileName, sizeof( szFileName ), "%s%s_%2.2d%2.2d_%2.2d%2.2d%2.2d_%d.csf", pPath, s_szStatsMapName, systemTime.wMonth, systemTime.wDay, systemTime.wHour, systemTime.wMinute, systemTime.wSecond, s_FileCount ); +#else + _snprintf( szFileName, sizeof( szFileName ), "%s%s%d.vcsf", pPath, pchFileBase, s_FileCount ); +#endif + + ++s_FileCount; + m_CallStackStats.DumpToFile( szFileName, false ); +} +#endif + +//----------------------------------------------------------------------------- +// Stat output +//----------------------------------------------------------------------------- +void CDbgMemAlloc::DumpStats() +{ + DumpStatsFileBase( "memstats" ); +#ifdef USE_STACK_TRACES + DumpCallStackFlow( "memflow" ); +#endif +} + +void CDbgMemAlloc::SetCRTAllocFailed( size_t nSize ) +{ + m_sMemoryAllocFailed = nSize; + DebuggerBreakIfDebugging(); + char buffer[256]; + _snprintf( buffer, sizeof( buffer ), "***** OUT OF MEMORY! attempted allocation size: %u ****\n", nSize ); +#if defined( _PS3 ) && defined( _DEBUG ) + DebuggerBreak(); +#endif // _PS3 + +#ifdef _X360 + XBX_OutputDebugString( buffer ); + if ( !Plat_IsInDebugSession() ) + { + XBX_CrashDump( true ); +#if defined( _DEMO ) + XLaunchNewImage( XLAUNCH_KEYWORD_DEFAULT_APP, 0 ); +#else + XLaunchNewImage( "default.xex", 0 ); +#endif + } +#elif defined(_WIN32 ) + OutputDebugString( buffer ); + if ( !Plat_IsInDebugSession() ) + { + AssertFatalMsg( false, buffer ); + abort(); + } +#else + printf( "%s\n", buffer ); + if ( !Plat_IsInDebugSession() ) + { + AssertFatalMsg( false, buffer ); + exit( 0 ); + } +#endif +} + +size_t CDbgMemAlloc::MemoryAllocFailed() +{ + return m_sMemoryAllocFailed; +} + + + +#ifdef LINUX +// +// Under linux we can ask GLIBC to override malloc for us +// Base on code from Ryan, http://hg.icculus.org/icculus/mallocmonitor/file/29c4b0d049f7/monitor_client/malloc_hook_glibc.c +// +// +static void *glibc_malloc_hook = NULL; +static void *glibc_realloc_hook = NULL; +static void *glibc_memalign_hook = NULL; +static void *glibc_free_hook = NULL; + +/* convenience functions for setting the hooks... */ +static inline void save_glibc_hooks(void); +static inline void set_glibc_hooks(void); +static inline void set_override_hooks(void); + +CThreadMutex g_HookMutex; +/* + * Our overriding hooks...they call through to the original C runtime + * implementations and report to the monitoring daemon. + */ + +static void *override_malloc_hook(size_t s, const void *caller) +{ + void *retval; + AUTO_LOCK( g_HookMutex ); + set_glibc_hooks(); /* put glibc back in control. */ + retval = InternalMalloc( s, NULL, 0 ); + save_glibc_hooks(); /* update in case glibc changed them. */ + + set_override_hooks(); /* only restore hooks if daemon is listening */ + + return(retval); +} /* override_malloc_hook */ + + +static void *override_realloc_hook(void *ptr, size_t s, const void *caller) +{ + void *retval; + AUTO_LOCK( g_HookMutex ); + + set_glibc_hooks(); /* put glibc back in control. */ + retval = InternalRealloc(ptr, s, NULL, 0); /* call glibc version. */ + save_glibc_hooks(); /* update in case glibc changed them. */ + + set_override_hooks(); /* only restore hooks if daemon is listening */ + + return(retval); +} /* override_realloc_hook */ + + +static void *override_memalign_hook(size_t a, size_t s, const void *caller) +{ + void *retval; + AUTO_LOCK( g_HookMutex ); + + set_glibc_hooks(); /* put glibc back in control. */ + retval = memalign(a, s); /* call glibc version. */ + save_glibc_hooks(); /* update in case glibc changed them. */ + + set_override_hooks(); /* only restore hooks if daemon is listening */ + + return(retval); +} /* override_memalign_hook */ + + +static void override_free_hook(void *ptr, const void *caller) +{ + AUTO_LOCK( g_HookMutex ); + + set_glibc_hooks(); /* put glibc back in control. */ + InternalFree(ptr); /* call glibc version. */ + save_glibc_hooks(); /* update in case glibc changed them. */ + + set_override_hooks(); /* only restore hooks if daemon is listening */ +} /* override_free_hook */ + + + +/* + * Convenience functions for swapping the hooks around... + */ + +/* + * Save a copy of the original allocation hooks, so we can call into them + * from our overriding functions. It's possible that glibc might change + * these hooks under various conditions (so the manual's examples seem + * to suggest), so we update them whenever we finish calling into the + * the originals. + */ +static inline void save_glibc_hooks(void) +{ + glibc_malloc_hook = (void *)__malloc_hook; + glibc_realloc_hook = (void *)__realloc_hook; + glibc_memalign_hook = (void *)__memalign_hook; + glibc_free_hook = (void *)__free_hook; +} /* save_glibc_hooks */ + +/* + * Restore the hooks to the glibc versions. This is needed since, say, + * their realloc() might call malloc() or free() under the hood, etc, so + * it's safer to let them have complete control over the subsystem, which + * also makes our logging saner, too. + */ +static inline void set_glibc_hooks(void) +{ + __malloc_hook = (void* (*)(size_t, const void*))glibc_malloc_hook; + __realloc_hook = (void* (*)(void*, size_t, const void*))glibc_realloc_hook; + __memalign_hook = (void* (*)(size_t, size_t, const void*))glibc_memalign_hook; + __free_hook = (void (*)(void*, const void*))glibc_free_hook; +} /* set_glibc_hooks */ + + +/* + * Put our hooks back in place. This should be done after the original + * glibc version has been called and we've finished any logging (which + * may call glibc functions, too). This sets us up for the next calls from + * the application. + */ +static inline void set_override_hooks(void) +{ + __malloc_hook = override_malloc_hook; + __realloc_hook = override_realloc_hook; + __memalign_hook = override_memalign_hook; + __free_hook = override_free_hook; +} /* set_override_hooks */ + + + +/* + * The Hook Of All Hooks...how we get in there in the first place. + */ + +/* + * glibc will call this when the malloc subsystem is initializing, giving + * us a chance to install hooks that override the functions. + */ +static void override_init_hook(void) +{ + AUTO_LOCK( g_HookMutex ); + + /* install our hooks. Will connect to daemon on first malloc, etc. */ + save_glibc_hooks(); + set_override_hooks(); +} /* override_init_hook */ + + +/* + * __malloc_initialize_hook is apparently a "weak variable", so you can + * define and assign it here even though it's in glibc, too. This lets + * us hook into malloc as soon as the runtime initializes, and before + * main() is called. Basically, this whole trick depends on this. + */ +void (*__malloc_initialize_hook)(void) __attribute__((visibility("default")))= override_init_hook; + +#elif defined( OSX ) +// +// pointers to the osx versions of these functions +static void *osx_malloc_hook = NULL; +static void *osx_realloc_hook = NULL; +static void *osx_free_hook = NULL; + +// convenience functions for setting the hooks... +static inline void save_osx_hooks(void); +static inline void set_osx_hooks(void); +static inline void set_override_hooks(void); + +CThreadMutex g_HookMutex; +// +// Our overriding hooks...they call through to the original C runtime +// implementations and report to the monitoring daemon. +// + +static void *override_malloc_hook(struct _malloc_zone_t *zone, size_t s) +{ + void *retval; + set_osx_hooks(); + retval = InternalMalloc( s, NULL, 0 ); + set_override_hooks(); + + return(retval); +} + + +static void *override_realloc_hook(struct _malloc_zone_t *zone, void *ptr, size_t s) +{ + void *retval; + + set_osx_hooks(); + retval = InternalRealloc(ptr, s, NULL, 0); + set_override_hooks(); + + return(retval); +} + + +static void override_free_hook(struct _malloc_zone_t *zone, void *ptr) +{ + // sometime they pass in a null pointer from higher level calls, just ignore it + if ( !ptr ) + return; + + set_osx_hooks(); + + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( ptr ); + if ( *((int*)pInternalMem->m_Reserved) == 0xf00df00d ) + { + InternalFree( ptr ); + } + + set_override_hooks(); +} + + +/* + + These are func's we could optionally override right now on OSX but don't need to + + static size_t override_size_hook(struct _malloc_zone_t *zone, const void *ptr) + { + set_osx_hooks(); + DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( (void *)ptr ); + set_override_hooks(); + if ( *((int*)pInternalMem->m_Reserved) == 0xf00df00d ) + { + return pInternalMem->nLogicalSize; + } + return 0; + } + + + static void *override_calloc_hook(struct _malloc_zone_t *zone, size_t num_items, size_t size ) + { + void *ans = override_malloc_hook( zone, num_items*size ); + if ( !ans ) + return 0; + memset( ans, 0x0, num_items*size ); + return ans; + } + + static void *override_valloc_hook(struct _malloc_zone_t *zone, size_t size ) + { + return override_calloc_hook( zone, 1, size ); + } + + static void override_destroy_hook(struct _malloc_zone_t *zone) + { + } + */ + + + +// +// Save a copy of the original allocation hooks, so we can call into them +// from our overriding functions. It's possible that osx might change +// these hooks under various conditions (so the manual's examples seem +// to suggest), so we update them whenever we finish calling into the +// the originals. +// +static inline void save_osx_hooks(void) +{ + malloc_zone_t *malloc_zone = malloc_default_zone(); + + osx_malloc_hook = (void *)malloc_zone->malloc; + osx_realloc_hook = (void *)malloc_zone->realloc; + osx_free_hook = (void *)malloc_zone->free; + + // These are func's we could optionally override right now on OSX but don't need to + // osx_size_hook = (void *)malloc_zone->size; + // osx_calloc_hook = (void *)malloc_zone->calloc; + // osx_valloc_hook = (void *)malloc_zone->valloc; + // osx_destroy_hook = (void *)malloc_zone->destroy; +} + +// +// Restore the hooks to the osx versions. This is needed since, say, +// their realloc() might call malloc() or free() under the hood, etc, so +// it's safer to let them have complete control over the subsystem, which +// also makes our logging saner, too. +// +static inline void set_osx_hooks(void) +{ + malloc_zone_t *malloc_zone = malloc_default_zone(); + malloc_zone->malloc = (void* (*)(_malloc_zone_t*, size_t))osx_malloc_hook; + malloc_zone->realloc = (void* (*)(_malloc_zone_t*, void*, size_t))osx_realloc_hook; + malloc_zone->free = (void (*)(_malloc_zone_t*, void*))osx_free_hook; + + // These are func's we could optionally override right now on OSX but don't need to + + //malloc_zone->size = (size_t (*)(_malloc_zone_t*, const void *))osx_size_hook; + //malloc_zone->calloc = (void* (*)(_malloc_zone_t*, size_t, size_t))osx_calloc_hook; + //malloc_zone->valloc = (void* (*)(_malloc_zone_t*, size_t))osx_valloc_hook; + //malloc_zone->destroy = (void (*)(_malloc_zone_t*))osx_destroy_hook; +} + + +/* + * Put our hooks back in place. This should be done after the original + * osx version has been called and we've finished any logging (which + * may call osx functions, too). This sets us up for the next calls from + * the application. + */ +static inline void set_override_hooks(void) +{ + malloc_zone_t *malloc_zone = malloc_default_zone(); + + malloc_zone->malloc = override_malloc_hook; + malloc_zone->realloc = override_realloc_hook; + malloc_zone->free = override_free_hook; + + // These are func's we could optionally override right now on OSX but don't need to + //malloc_zone->size = override_size_hook; + //malloc_zone->calloc = override_calloc_hook; + // malloc_zone->valloc = override_valloc_hook; + //malloc_zone->destroy = override_destroy_hook; +} + + +// +// The Hook Of All Hooks...how we get in there in the first place. +// +// osx will call this when the malloc subsystem is initializing, giving +// us a chance to install hooks that override the functions. +// + +void __attribute__ ((constructor)) mem_init(void) +{ + AUTO_LOCK( g_HookMutex ); + save_osx_hooks(); + set_override_hooks(); +} + +void *operator new( size_t nSize, int nBlockUse, const char *pFileName, int nLine ) +{ + set_osx_hooks(); + void *pMem = g_pMemAlloc->Alloc(nSize, pFileName, nLine); + set_override_hooks(); + return pMem; +} + +void *operator new[] ( size_t nSize, int nBlockUse, const char *pFileName, int nLine ) +{ + set_osx_hooks(); + void *pMem = g_pMemAlloc->Alloc(nSize, pFileName, nLine); + set_override_hooks(); + return pMem; +} + +#endif // OSX + +int GetAllocationCallStack( void *mem, void **pCallStackOut, int iMaxEntriesOut ) +{ +#if defined( USE_MEM_DEBUG ) && (defined( USE_STACK_TRACES )) + return s_DbgMemAlloc.GetCallStackForIndex( GetAllocationStatIndex_Internal( mem ), pCallStackOut, iMaxEntriesOut ); +#else + return 0; +#endif +} + + +#endif // MEM_IMPL_TYPE_DBG + +#endif // !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) diff --git a/external/vpc/tier0/memstd.cpp b/external/vpc/tier0/memstd.cpp new file mode 100644 index 0000000..20a8aec --- /dev/null +++ b/external/vpc/tier0/memstd.cpp @@ -0,0 +1,2493 @@ +//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: Memory allocation! +// +// $NoKeywords: $ +//=============================================================================// + +#include "tier0/platform.h" + + +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + + +//#include <malloc.h> + +#include <algorithm> + +#include "tier0/dbg.h" +#include "tier0/memalloc.h" +#include "tier0/threadtools.h" +#include "mem_helpers.h" +#include "memstd.h" +#include "tier0/stacktools.h" +#include "tier0/minidump.h" +#ifdef _X360 +#include "xbox/xbox_console.h" +#endif + +#ifdef _PS3 +#include "memoverride_ps3.h" +#endif + +#ifndef _WIN32 +#define IsDebuggerPresent() false +#endif + +#ifdef USE_LIGHT_MEM_DEBUG +#undef USE_MEM_DEBUG +#pragma message("*** USE_LIGHT_MEM_DEBUG is ON ***") +#pragma optimize( "", off ) +#endif + +#define DEF_REGION 0 + +#if defined( _WIN32 ) || defined( _PS3 ) +#define USE_DLMALLOC +#define MEMALLOC_SEGMENT_MIXED +#define MBH_SIZE_MB ( 45 + MBYTES_STEAM_MBH_USAGE ) +//#define MEMALLOC_REGIONS +#endif // _WIN32 || _PS3 + +#ifndef USE_DLMALLOC +#ifdef _PS3 +#define malloc_internal( region, bytes ) (g_pMemOverrideRawCrtFns->pfn_malloc)(bytes) +#define malloc_aligned_internal( region, bytes, align ) (g_pMemOverrideRawCrtFns->pfn_memalign)(align, bytes) +#define realloc_internal (g_pMemOverrideRawCrtFns->pfn_realloc) +#define realloc_aligned_internal (g_pMemOverrideRawCrtFns->pfn_reallocalign) +#define free_internal (g_pMemOverrideRawCrtFns->pfn_free) +#define msize_internal (g_pMemOverrideRawCrtFns->pfn_malloc_usable_size) +#define compact_internal() (0) +#define heapstats_internal(p) (void)(0) +#else // _PS3 +#define malloc_internal( region, bytes) malloc(bytes) +#define malloc_aligned_internal( region, bytes, align ) memalign(align, bytes) +#define realloc_internal realloc +#define realloc_aligned_internal realloc +#define free_internal free +#ifdef POSIX +#define msize_internal malloc_usable_size +#else // POSIX +#define msize_internal _msize +#endif // POSIX +#define compact_internal() (0) +#define heapstats_internal(p) (void)(0) +#endif // _PS3 +#else // USE_DLMALLOC +#define MSPACES 1 +#include "dlmalloc/malloc-2.8.3.h" + +void *g_AllocRegions[] = +{ +#ifndef MEMALLOC_REGIONS +#ifdef MEMALLOC_SEGMENT_MIXED + create_mspace( 0, 1 ), // unified + create_mspace( MBH_SIZE_MB*1024*1024, 1 ), +#else + create_mspace( 100*1024*1024, 1 ), +#endif +#else // MEMALLOC_REGIONS + // @TODO: per DLL regions didn't work out very well. flux of usage left too much overhead. need to try lifetime-based management [6/9/2009 tom] + create_mspace( 82*1024*1024, 1 ), // unified +#endif // MEMALLOC_REGIONS +}; + +#ifndef MEMALLOC_REGIONS +#ifndef MEMALLOC_SEGMENT_MIXED +#define SelectRegion( region, bytes ) 0 +#else +// NOTE: this split is designed to force the 'large block' heap to ONLY perform virtual allocs (see +// DEFAULT_MMAP_THRESHOLD in malloc.cpp), to avoid ANY fragmentation or waste in an internal arena +#define REGION_SPLIT (256*1024) +#define SelectRegion( region, bytes ) g_AllocRegions[bytes < REGION_SPLIT] +#endif +#else // MEMALLOC_REGIONS +#define SelectRegion( region, bytes ) g_AllocRegions[region] +#endif // MEMALLOC_REGIONS + +#define malloc_internal( region, bytes ) mspace_malloc(SelectRegion(region,bytes), bytes) +#define malloc_aligned_internal( region, bytes, align ) mspace_memalign(SelectRegion(region,bytes), align, bytes) +FORCEINLINE void *realloc_aligned_internal( void *mem, size_t bytes, size_t align ) +{ + // TODO: implement realloc_aligned inside dlmalloc (requires splitting realloc's existing + // 'grow in-place' code into a new function, then call that w/ alloc_align/copy/free on failure) + byte *newMem = (byte *)dlrealloc( mem, bytes ); + if ( ((size_t)newMem&(align-1)) == 0 ) + return newMem; + // realloc broke alignment... + byte *fallback = (byte *)malloc_aligned_internal( DEF_REGION, bytes, align ); + if ( !fallback ) + return NULL; + memcpy( fallback, newMem, bytes ); + dlfree( newMem ); + return fallback; +} + +inline size_t compact_internal() +{ + size_t start = 0, end = 0; + + for ( int i = 0; i < ARRAYSIZE(g_AllocRegions); i++ ) + { + start += mspace_footprint( g_AllocRegions[i] ); + mspace_trim( g_AllocRegions[i], 0 ); + end += mspace_footprint( g_AllocRegions[i] ); + } + + return ( start - end ); +} + +inline void heapstats_internal( FILE *pFile ) +{ + // @TODO: improve this presentation, as a table [6/1/2009 tom] + char buf[1024]; + for ( int i = 0; i < ARRAYSIZE( g_AllocRegions ); i++ ) + { + struct mallinfo info = mspace_mallinfo( g_AllocRegions[ i ] ); + size_t footPrint = mspace_footprint( g_AllocRegions[ i ] ); + size_t maxFootPrint = mspace_max_footprint( g_AllocRegions[ i ] ); + _snprintf( buf, sizeof(buf), + "\ndlmalloc mspace %d (%s)\n" + " %d:footprint -%10d (total space used by the mspace)\n" + " %d:footprint_max -%10d (maximum total space used by the mspace)\n" + " %d:arena -%10d (non-mmapped space allocated from system)\n" + " %d:ordblks -%10d (number of free chunks)\n" + " %d:hblkhd -%10d (space in mmapped regions)\n" + " %d:usmblks -%10d (maximum total allocated space)\n" + " %d:uordblks -%10d (total allocated space)\n" + " %d:fordblks -%10d (total free space)\n" + " %d:keepcost -%10d (releasable (via malloc_trim) space)\n", + i, i?"medium-block":"large-block", i,footPrint, i,maxFootPrint, i,info.arena, i,info.ordblks, i,info.hblkhd, i,info.usmblks, i,info.uordblks, i,info.fordblks, i,info.keepcost ); + if ( pFile ) + fprintf( pFile, "%s", buf ); + else + Msg( "%s", buf ); + } +} + +#define realloc_internal dlrealloc +#define free_internal dlfree +#define msize_internal dlmalloc_usable_size +#endif // USE_DLMALLOC + +#ifdef TIME_ALLOC +CAverageCycleCounter g_MallocCounter; +CAverageCycleCounter g_ReallocCounter; +CAverageCycleCounter g_FreeCounter; + +#define PrintOne( name ) \ + Msg("%-48s: %6.4f avg (%8.1f total, %7.3f peak, %5d iters)\n", \ + #name, \ + g_##name##Counter.GetAverageMilliseconds(), \ + g_##name##Counter.GetTotalMilliseconds(), \ + g_##name##Counter.GetPeakMilliseconds(), \ + g_##name##Counter.GetIters() ); \ + memset( &g_##name##Counter, 0, sizeof(g_##name##Counter) ) + +void PrintAllocTimes() +{ + PrintOne( Malloc ); + PrintOne( Realloc ); + PrintOne( Free ); +} + +#define PROFILE_ALLOC(name) CAverageTimeMarker name##_ATM( &g_##name##Counter ) + +#else // TIME_ALLOC +#define PROFILE_ALLOC( name ) ((void)0) +#define PrintAllocTimes() ((void)0) +#endif // TIME_ALLOC + +#if _MSC_VER < 1400 && defined( MSVC ) && !defined(_STATIC_LINKED) && (defined(_DEBUG) || defined(USE_MEM_DEBUG)) +void *operator new( unsigned int nSize, int nBlockUse, const char *pFileName, int nLine ) +{ + return ::operator new( nSize ); +} + +void *operator new[] ( unsigned int nSize, int nBlockUse, const char *pFileName, int nLine ) +{ + return ::operator new[]( nSize ); +} +#endif + +#include "mem_impl_type.h" +#if MEM_IMPL_TYPE_STD + +//----------------------------------------------------------------------------- +// Singleton... +//----------------------------------------------------------------------------- +#pragma warning( disable:4074 ) // warning C4074: initializers put in compiler reserved initialization area +#pragma init_seg( compiler ) + +#if MEM_SBH_ENABLED +CSmallBlockPool< CStdMemAlloc::CFixedAllocator< MBYTES_PRIMARY_SBH, true> >::SharedData_t CSmallBlockPool< CStdMemAlloc::CFixedAllocator< MBYTES_PRIMARY_SBH, true> >::gm_SharedData CONSTRUCT_EARLY; +#ifdef MEMALLOC_USE_SECONDARY_SBH +CSmallBlockPool< CStdMemAlloc::CFixedAllocator< MBYTES_SECONDARY_SBH, false> >::SharedData_t CSmallBlockPool< CStdMemAlloc::CFixedAllocator< MBYTES_SECONDARY_SBH, false> >::gm_SharedData CONSTRUCT_EARLY; +#endif +#ifndef MEMALLOC_NO_FALLBACK +CSmallBlockPool< CStdMemAlloc::CVirtualAllocator >::SharedData_t CSmallBlockPool< CStdMemAlloc::CVirtualAllocator >::gm_SharedData CONSTRUCT_EARLY; +#endif +#endif // MEM_SBH_ENABLED + +static CStdMemAlloc s_StdMemAlloc CONSTRUCT_EARLY; + +#ifdef _PS3 + +MemOverrideRawCrtFunctions_t *g_pMemOverrideRawCrtFns; +IMemAlloc *g_pMemAllocInternalPS3 = &s_StdMemAlloc; +PLATFORM_OVERRIDE_MEM_ALLOC_INTERNAL_PS3_IMPL + +#else // !_PS3 + +#ifndef TIER0_VALIDATE_HEAP +IMemAlloc *g_pMemAlloc = &s_StdMemAlloc; +#else +IMemAlloc *g_pActualAlloc = &s_StdMemAlloc; +#endif + +#endif // _PS3 + +CStdMemAlloc::CStdMemAlloc() +: m_pfnFailHandler( DefaultFailHandler ), + m_sMemoryAllocFailed( (size_t)0 ), + m_bInCompact( false ) +{ +#ifdef _PS3 + g_pMemAllocInternalPS3 = &s_StdMemAlloc; + PLATFORM_OVERRIDE_MEM_ALLOC_INTERNAL_PS3.m_pMemAllocCached = &s_StdMemAlloc; + malloc_managed_size mms; + mms.current_inuse_size = 0x12345678; + mms.current_system_size = 0x09ABCDEF; + mms.max_system_size = reinterpret_cast< size_t >( this ); + int iResult = malloc_stats( &mms ); + g_pMemOverrideRawCrtFns = reinterpret_cast< MemOverrideRawCrtFunctions_t * >( iResult ); +#endif +} + +#if MEM_SBH_ENABLED +//----------------------------------------------------------------------------- +// Small block heap (multi-pool) +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +template <typename T> +inline T MemAlign( T val, unsigned alignment ) +{ + return (T)( ( (unsigned)val + alignment - 1 ) & ~( alignment - 1 ) ); +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +template <typename CAllocator> +void CSmallBlockPool<CAllocator>::Init( unsigned nBlockSize ) +{ + SharedData_t *pSharedData = GetSharedData(); + if ( !pSharedData->m_pBase ) + { + pSharedData->m_pBase = pSharedData->m_Allocator.AllocatePoolMemory(); + pSharedData->m_pLimit = pSharedData->m_pBase + CAllocator::TOTAL_BYTES; + pSharedData->m_pNextBlock = pSharedData->m_pBase; + } + + if ( !( nBlockSize % MIN_SBH_ALIGN == 0 && nBlockSize >= MIN_SBH_BLOCK && nBlockSize >= sizeof(TSLNodeBase_t) ) ) + DebuggerBreak(); + + m_nBlockSize = nBlockSize; + m_pNextAlloc = NULL; + m_nCommittedPages = 0; +} + +template <typename CAllocator> +size_t CSmallBlockPool<CAllocator>::GetBlockSize() +{ + return m_nBlockSize; +} + +// Define VALIDATE_SBH_FREE_LIST to a given block size to validate that pool's freelist (it'll crash on the next alloc/free after the list is corrupted) +// NOTE: this may affect perf more than USE_LIGHT_MEM_DEBUG +//#define VALIDATE_SBH_FREE_LIST 320 +template <typename CAllocator> +void CSmallBlockPool<CAllocator>::ValidateFreelist( SharedData_t *pSharedData ) +{ +#ifdef VALIDATE_SBH_FREE_LIST + if ( m_nBlockSize != VALIDATE_SBH_FREE_LIST ) + return; + static int count = 0; + count++; // Track when the corruption occurs, if repeatable + pSharedData->m_Lock.LockForWrite(); +#ifdef USE_NATIVE_SLIST + TSLNodeBase_t *pNode = (TSLNodeBase_t *)(m_FreeList.AccessUnprotected()->Next.Next); +#else + TSLNodeBase_t *pNode = (TSLNodeBase_t *)(m_FreeList.AccessUnprotected()->value.Next); +#endif + while( pNode ) + pNode = pNode->Next; + pSharedData->m_Lock.UnlockWrite(); +#endif // VALIDATE_SBH_FREE_LIST +} + +template <typename CAllocator> +void *CSmallBlockPool<CAllocator>::Alloc() +{ + SharedData_t *pSharedData = GetSharedData(); + + ValidateFreelist( pSharedData ); + + CThreadSpinRWLock &sharedLock = pSharedData->m_Lock; + if ( !sharedLock.TryLockForRead() ) + { + sharedLock.LockForRead(); + } + byte *pResult; + intp iPage = -1; + int iThreadPriority = INT_MAX; + + while (1) + { + pResult = m_FreeList.Pop(); + if ( !pResult ) + { + int nBlockSize = m_nBlockSize; + byte *pNextAlloc; + while (1) + { + pResult = m_pNextAlloc; + if ( pResult ) + { + pNextAlloc = pResult + nBlockSize; + if ( ( ( (uintp)(pNextAlloc) - 1 ) % BYTES_PAGE ) + nBlockSize > BYTES_PAGE ) + { + // Crossed a page boundary + pNextAlloc = 0; + } + if ( m_pNextAlloc.AssignIf( pResult, pNextAlloc ) ) + { + iPage = (size_t)((byte *)pResult - pSharedData->m_pBase) / BYTES_PAGE; + break; + } + } + else if ( m_CommitMutex.TryLock() ) + { + if ( !m_pNextAlloc ) + { + PageStatus_t *pAllocatedPageStatus = (PageStatus_t *)pSharedData->m_FreePages.Pop(); + if ( pAllocatedPageStatus ) + { + iPage = pAllocatedPageStatus - &pSharedData->m_PageStatus[0]; + } + else + { + while (1) + { + byte *pBlock = pSharedData->m_pNextBlock; + if ( pBlock >= pSharedData->m_pLimit ) + { + break; + } + if ( ThreadInterlockedAssignPointerIf( (void **)&pSharedData->m_pNextBlock, (void *)( pBlock + BYTES_PAGE ), (void *)pBlock ) ) + { + iPage = (size_t)((byte *)pBlock - pSharedData->m_pBase) / BYTES_PAGE; + pAllocatedPageStatus = &pSharedData->m_PageStatus[iPage]; + break; + } + } + } + + if ( pAllocatedPageStatus ) + { + byte *pBlock = pSharedData->m_pBase + ( iPage * BYTES_PAGE ); + if ( pAllocatedPageStatus->m_nAllocated == NOT_COMMITTED ) + { + pSharedData->m_Allocator.Commit( pBlock ); + } + + pAllocatedPageStatus->m_pPool = this; + pAllocatedPageStatus->m_nAllocated = 0; + pAllocatedPageStatus->m_pNextPageInPool = m_pFirstPage; + m_pFirstPage = pAllocatedPageStatus; +#ifdef TRACK_SBH_COUNTS + m_nFreeBlocks += ( BYTES_PAGE / m_nBlockSize ); +#endif + m_nCommittedPages++; + m_pNextAlloc = pBlock; + } + else + { + m_pNextAlloc = NULL; + m_CommitMutex.Unlock(); + sharedLock.UnlockRead(); + return NULL; + } + } + m_CommitMutex.Unlock(); + } + else + { + if ( iThreadPriority == INT_MAX) + { + iThreadPriority = ThreadGetPriority(); + } + + if ( iThreadPriority > 0 ) + { + ThreadSleep( 0 ); + } + } + } + + if ( pResult ) + { + break; + } + } + else + { + iPage = (size_t)((byte *)pResult - pSharedData->m_pBase) / BYTES_PAGE; + break; + } + } + +#ifdef TRACK_SBH_COUNTS + --m_nFreeBlocks; +#endif + ++pSharedData->m_PageStatus[iPage].m_nAllocated; + sharedLock.UnlockRead(); + + return pResult; +} + +template <typename CAllocator> +void CSmallBlockPool<CAllocator>::Free( void *p ) +{ + SharedData_t *pSharedData = GetSharedData(); + size_t iPage = (size_t)((byte *)p - pSharedData->m_pBase) / BYTES_PAGE; + + CThreadSpinRWLock &sharedLock = pSharedData->m_Lock; + if ( !sharedLock.TryLockForRead() ) + { + sharedLock.LockForRead(); + } + --pSharedData->m_PageStatus[iPage].m_nAllocated; +#ifdef TRACK_SBH_COUNTS + ++m_nFreeBlocks; +#endif + m_FreeList.Push( p ); + pSharedData->m_Lock.UnlockRead(); + + ValidateFreelist( pSharedData ); +} + +// Count the free blocks. +template <typename CAllocator> +int CSmallBlockPool<CAllocator>::CountFreeBlocks() +{ +#ifdef TRACK_SBH_COUNTS + return m_nFreeBlocks; +#else + return 0; +#endif +} + +// Size of committed memory managed by this heap: +template <typename CAllocator> +int CSmallBlockPool<CAllocator>::GetCommittedSize() +{ + return m_nCommittedPages * BYTES_PAGE; +} + +// Return the total blocks memory is committed for in the heap +template <typename CAllocator> +int CSmallBlockPool<CAllocator>::CountCommittedBlocks() +{ + return m_nCommittedPages * ( BYTES_PAGE / m_nBlockSize ); +} + +// Count the number of allocated blocks in the heap: +template <typename CAllocator> +int CSmallBlockPool<CAllocator>::CountAllocatedBlocks() +{ +#ifdef TRACK_SBH_COUNTS + return CountCommittedBlocks() - CountFreeBlocks(); +#else + return 0; +#endif +} + +template <typename CAllocator> +int CSmallBlockPool<CAllocator>::PageSort( const void *p1, const void *p2 ) +{ + SharedData_t *pSharedData = GetSharedData(); + return pSharedData->m_PageStatus[*((int *)p1)].m_SortList.Count() - pSharedData->m_PageStatus[*((int *)p2)].m_SortList.Count(); +} + + +template <typename CAllocator> +bool CSmallBlockPool<CAllocator>::RemovePagesFromFreeList( byte **pPages, int nPages, bool bSortList ) +{ + // Since we don't use the depth of the tslist, and sequence is only used for push, we can remove in-place + int i; + byte **pLimits = (byte **)stackalloc( nPages * sizeof(byte *) ); + int nBlocksNotInFreeList = 0; + for ( i = 0; i < nPages; i++ ) + { + pLimits[i] = pPages[i] + BYTES_PAGE; + + if ( m_pNextAlloc >= pPages[i] && m_pNextAlloc < pLimits[i] ) + { + nBlocksNotInFreeList = ( pLimits[i] - m_pNextAlloc ) / m_nBlockSize; + m_pNextAlloc = NULL; + } + } + + int iTarget = ( ( BYTES_PAGE/m_nBlockSize ) * nPages ) - nBlocksNotInFreeList; + int iCount = 0; + + TSLHead_t *pRawFreeList = m_FreeList.AccessUnprotected(); + bool bRemove; + if ( !bSortList || m_nCommittedPages - nPages == 1 ) + { +#ifdef USE_NATIVE_SLIST + TSLNodeBase_t **ppPrevNext = (TSLNodeBase_t **)&(pRawFreeList->Next); +#else + TSLNodeBase_t **ppPrevNext = (TSLNodeBase_t **)&(pRawFreeList->value.Next); +#endif + TSLNodeBase_t *pNode = *ppPrevNext; + while ( pNode && iCount != iTarget ) + { + bRemove = false; + for ( i = 0; i < nPages; i++ ) + { + if ( (byte *)pNode >= pPages[i] && (byte *)pNode < pLimits[i] ) + { + bRemove = true; + break; + } + } + + if ( bRemove ) + { + iCount++; + *ppPrevNext = pNode->Next; + } + else + { + *ppPrevNext = pNode; + ppPrevNext = &pNode->Next; + } + pNode = pNode->Next; + } + } + else + { + SharedData_t *pSharedData = GetSharedData(); + byte *pSharedBase = pSharedData->m_pBase; + TSLNodeBase_t *pNode = m_FreeList.Detach(); + TSLNodeBase_t *pNext; + int iSortPage; + + int nSortPages = 0; + int *sortPages = (int *)stackalloc( m_nCommittedPages * sizeof(int) ); + while ( pNode ) + { + pNext = pNode->Next; + bRemove = false; + for ( i = 0; i < nPages; i++ ) + { + if ( (byte *)pNode >= pPages[i] && (byte *)pNode < pLimits[i] ) + { + iCount++; + bRemove = true; + break; + } + } + + if ( !bRemove ) + { + iSortPage = ( (byte *)pNode - pSharedBase ) / BYTES_PAGE; + if ( !pSharedData->m_PageStatus[iSortPage].m_SortList.Count() ) + { + sortPages[nSortPages++] = iSortPage; + } + pSharedData->m_PageStatus[iSortPage].m_SortList.Push( pNode ); + } + + pNode = pNext; + } + + if ( nSortPages > 1 ) + { + qsort( sortPages, nSortPages, sizeof(int), &PageSort ); + } + for ( i = 0; i < nSortPages; i++ ) + { + while ( ( pNode = pSharedData->m_PageStatus[sortPages[i]].m_SortList.Pop() ) != NULL ) + { + m_FreeList.Push( pNode ); + } + } + } + if ( iTarget != iCount ) + { + DebuggerBreakIfDebugging(); + } + + return ( iTarget == iCount ); +} + + +template <typename CAllocator> +size_t CSmallBlockPool<CAllocator>::Compact( bool bIncremental ) +{ + static bool bWarnedCorruption; + bool bIsCorrupt = false; + int i; + size_t nFreed = 0; + SharedData_t *pSharedData = GetSharedData(); + pSharedData->m_Lock.LockForWrite(); + + if ( m_pFirstPage ) + { + PageStatus_t **pReleasedPages = (PageStatus_t **)stackalloc( m_nCommittedPages * sizeof(PageStatus_t *) ); + PageStatus_t **pReleasedPagesPrevs = (PageStatus_t **)stackalloc( m_nCommittedPages * sizeof(PageStatus_t *) ); + byte **pPageBases = (byte **)stackalloc( m_nCommittedPages * sizeof(byte *) ); + int nPages = 0; + + // Gather the pages to return to the backing pool + PageStatus_t *pPage = m_pFirstPage; + PageStatus_t *pPagePrev = NULL; + while ( pPage ) + { + if ( pPage->m_nAllocated == 0 ) + { + pReleasedPages[nPages] = pPage; + pPageBases[nPages] = pSharedData->m_pBase + ( pPage - &pSharedData->m_PageStatus[0] ) * BYTES_PAGE; + pReleasedPagesPrevs[nPages] = pPagePrev; + nPages++; + + if ( bIncremental ) + { + break; + } + } + pPagePrev = pPage; + pPage = pPage->m_pNextPageInPool; + } + + if ( nPages ) + { + // Remove the pages from the pool's free list + if ( !RemovePagesFromFreeList( pPageBases, nPages, !bIncremental ) && !bWarnedCorruption ) + { + // We don't know which of the pages encountered an incomplete free list + // so we'll just push them all back in and hope for the best. This isn't + // ventilator control software! + bWarnedCorruption = true; + bIsCorrupt = true; + } + + nFreed = nPages * BYTES_PAGE; + m_nCommittedPages -= nPages; + +#ifdef TRACK_SBH_COUNTS + m_nFreeBlocks -= nPages * ( BYTES_PAGE / m_nBlockSize ); +#endif + + // Unlink the pages + for ( i = nPages - 1; i >= 0; --i ) + { + if ( pReleasedPagesPrevs[i] ) + { + pReleasedPagesPrevs[i]->m_pNextPageInPool = pReleasedPages[i]->m_pNextPageInPool; + } + else + { + m_pFirstPage = pReleasedPages[i]->m_pNextPageInPool; + } + pReleasedPages[i]->m_pNextPageInPool = NULL; + pReleasedPages[i]->m_pPool = NULL; + } + + // Push them onto the backing free lists + if ( !pSharedData->m_Allocator.IsVirtual() ) + { + for ( i = 0; i < nPages; i++ ) + { + pSharedData->m_FreePages.Push( pReleasedPages[i] ); + } + } + else + { + int nMinReserve = ( bIncremental ) ? CAllocator::MIN_RESERVE_PAGES * 8 : CAllocator::MIN_RESERVE_PAGES; + int nReserveNeeded = nMinReserve - pSharedData->m_FreePages.Count(); + if ( nReserveNeeded > 0 ) + { + int nToKeepCommitted = MIN( nReserveNeeded, nPages ); + while ( nToKeepCommitted-- ) + { + nPages--; + pSharedData->m_FreePages.Push( pReleasedPages[nPages] ); + } + } + + if ( nPages ) + { + // Detach the list, push the decommitted page on, iterate up to previous + // decommits, but them on, then push the committed pages on + TSLNodeBase_t *pNodes = pSharedData->m_FreePages.Detach(); + for ( i = 0; i < nPages; i++ ) + { + pReleasedPages[i]->m_nAllocated = NOT_COMMITTED; + pSharedData->m_Allocator.Decommit( pPageBases[i] ); + pSharedData->m_FreePages.Push( pReleasedPages[i] ); + } + + TSLNodeBase_t *pCur, *pTemp = NULL; + pCur = pNodes; + while ( pCur ) + { + if ( ((PageStatus_t *)pCur)->m_nAllocated == NOT_COMMITTED ) + { + if ( pTemp ) + { + pTemp->Next = NULL; + } + else + { + pNodes = NULL; // The list only has decommitted pages, don't go circular + } + + while ( pCur ) + { + pTemp = pCur->Next; + pSharedData->m_FreePages.Push( pCur ); + pCur = pTemp; + } + break; + } + pTemp = pCur; + pCur = pCur->Next; + } + + while ( pNodes ) + { + pTemp = pNodes->Next; + pSharedData->m_FreePages.Push( pNodes ); + pNodes = pTemp; + } + } + } + } + } + pSharedData->m_Lock.UnlockWrite(); + if ( bIsCorrupt ) + { + Warning( "***** HEAP IS CORRUPT (free compromised for block size %d,in %s heap, possible write after free *****)\n", m_nBlockSize, ( pSharedData->m_Allocator.IsVirtual() ) ? "virtual" : "physical" ); + } + return nFreed; +} + +template <typename CAllocator> +bool CSmallBlockPool<CAllocator>::Validate() +{ +#ifdef NO_SBH + return true; +#else + int invalid = 0; + + SharedData_t *pSharedData = GetSharedData(); + pSharedData->m_Lock.LockForWrite(); + + byte **pPageBases = (byte **)stackalloc( m_nCommittedPages * sizeof(byte *) ); + unsigned *pageCounts = (unsigned *)stackalloc( m_nCommittedPages * sizeof(unsigned) ); + memset( pageCounts, 0, m_nCommittedPages * sizeof(int) ); + unsigned nPages = 0; + unsigned sumAllocated = 0; + unsigned freeNotInFreeList = 0; + + // Validate page list is consistent + if ( !m_pFirstPage ) + { + if ( m_nCommittedPages != 0 ) + { + invalid = __LINE__; + goto notValid; + } + } + else + { + PageStatus_t *pPage = m_pFirstPage; + while ( pPage ) + { + pPageBases[nPages] = pSharedData->m_pBase + ( pPage - &pSharedData->m_PageStatus[0] ) * BYTES_PAGE; + if ( pPage->m_pPool != this ) + { + invalid = __LINE__; + goto notValid; + } + if ( nPages > m_nCommittedPages ) + { + invalid = __LINE__; + goto notValid; + } + sumAllocated += pPage->m_nAllocated; + if ( m_pNextAlloc >= pPageBases[nPages] && m_pNextAlloc < pPageBases[nPages] + BYTES_PAGE ) + { + freeNotInFreeList = pageCounts[nPages] = ( ( pPageBases[nPages] + BYTES_PAGE ) - m_pNextAlloc ) / m_nBlockSize; + } + + nPages++; + pPage = pPage->m_pNextPageInPool; + }; + + if ( nPages != m_nCommittedPages ) + { + invalid = __LINE__; + goto notValid; + } + } + + // Validate block counts + { + unsigned blocksPerPage = ( BYTES_PAGE / m_nBlockSize ); +#ifdef USE_NATIVE_SLIST + TSLNodeBase_t *pNode = (TSLNodeBase_t *)(m_FreeList.AccessUnprotected()->Next.Next); +#else + TSLNodeBase_t *pNode = (TSLNodeBase_t *)(m_FreeList.AccessUnprotected()->value.Next); +#endif + unsigned i; + while ( pNode ) + { + for ( i = 0; i < nPages; i++ ) + { + if ( (byte *)pNode >= pPageBases[i] && (byte *)pNode < pPageBases[i] + BYTES_PAGE ) + { + pageCounts[i]++; + break; + } + } + + if ( i == nPages ) + { + invalid = __LINE__; + goto notValid; + } + + pNode = pNode->Next; + } + + PageStatus_t *pPage = m_pFirstPage; + i = 0; + while ( pPage ) + { + unsigned nFreeOnPage = blocksPerPage - pPage->m_nAllocated; + if ( nFreeOnPage != pageCounts[i++] ) + { + invalid = __LINE__; + goto notValid; + } + pPage = pPage->m_pNextPageInPool; + } + } + +notValid: + pSharedData->m_Lock.UnlockWrite(); + + if ( invalid != 0 ) + { + return false; + } + + return true; +#endif +} + + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +template <typename CAllocator> +CSmallBlockHeap<CAllocator>::CSmallBlockHeap() +{ + m_pSharedData = CPool::GetSharedData(); + + // Build a lookup table used to find the correct pool based on size + const int MAX_TABLE = MAX_SBH_BLOCK >> 2; + int i = 0; + int nBytesElement = 0; + CPool *pCurPool = NULL; + int iCurPool = 0; + + // Blocks sized 0 - 128 are in pools in increments of 8 + for ( ; i < 32; i++ ) + { + if ( (i + 1) % 2 == 1) + { + nBytesElement += 8; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + // Blocks sized 129 - 256 are in pools in increments of 16 + for ( ; i < 64; i++ ) + { + if ( (i + 1) % 4 == 1) + { + nBytesElement += 16; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + + // Blocks sized 257 - 512 are in pools in increments of 32 + for ( ; i < 128; i++ ) + { + if ( (i + 1) % 8 == 1) + { + nBytesElement += 32; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + // Blocks sized 513 - 768 are in pools in increments of 64 + for ( ; i < 192; i++ ) + { + if ( (i + 1) % 16 == 1) + { + nBytesElement += 64; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + // Blocks sized 769 - 1024 are in pools in increments of 128 + for ( ; i < 256; i++ ) + { + if ( (i + 1) % 32 == 1) + { + nBytesElement += 128; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + // Blocks sized 1025 - 2048 are in pools in increments of 256 + for ( ; i < MAX_TABLE; i++ ) + { + if ( (i + 1) % 64 == 1) + { + nBytesElement += 256; + pCurPool = &m_Pools[iCurPool]; + pCurPool->Init( nBytesElement ); + iCurPool++; + m_PoolLookup[i] = pCurPool; + } + else + { + m_PoolLookup[i] = pCurPool; + } + } + + Assert( iCurPool == NUM_POOLS ); +} + +template <typename CAllocator> +bool CSmallBlockHeap<CAllocator>::ShouldUse( size_t nBytes ) +{ + return ( nBytes <= MAX_SBH_BLOCK ); +} + +template <typename CAllocator> +bool CSmallBlockHeap<CAllocator>::IsOwner( void * p ) +{ + if ( uintp(p) >= uintp(m_pSharedData->m_pBase) ) + { + intp index = (intp)((byte *)p - m_pSharedData->m_pBase) / BYTES_PAGE; + return ( index < ARRAYSIZE(m_pSharedData->m_PageStatus) ); + } + return false; +} + +template <typename CAllocator> +void *CSmallBlockHeap<CAllocator>::Alloc( size_t nBytes ) +{ + if ( nBytes == 0) + { + nBytes = 1; + } + Assert( ShouldUse( nBytes ) ); + CPool *pPool = FindPool( nBytes ); + void *p = pPool->Alloc(); + return p; +} + +template <typename CAllocator> +void *CSmallBlockHeap<CAllocator>::Realloc( void *p, size_t nBytes ) +{ + if ( nBytes == 0) + { + nBytes = 1; + } + + CPool *pOldPool = FindPool( p ); + CPool *pNewPool = ( ShouldUse( nBytes ) ) ? FindPool( nBytes ) : NULL; + + if ( pOldPool == pNewPool ) + { + return p; + } + + void *pNewBlock = NULL; + + if ( !pNewBlock ) + { + pNewBlock = MemAlloc_Alloc( nBytes ); // Call back out so blocks can move from the secondary to the primary pools + } + + if ( !pNewBlock ) + { + pNewBlock = malloc_internal( DEF_REGION, nBytes ); + } + + if ( pNewBlock ) + { + size_t nBytesCopy = MIN( nBytes, pOldPool->GetBlockSize() ); + memcpy( pNewBlock, p, nBytesCopy ); + } + else if ( nBytes < pOldPool->GetBlockSize() ) + { + return p; + } + + pOldPool->Free( p ); + + return pNewBlock; +} + +template <typename CAllocator> +void CSmallBlockHeap<CAllocator>::Free( void *p ) +{ + CPool *pPool = FindPool( p ); + if ( pPool ) + { + pPool->Free( p ); + } + else + { + // we probably didn't hook some allocation and now we're freeing it or the heap has been trashed! + DebuggerBreakIfDebugging(); + } +} + +template <typename CAllocator> +size_t CSmallBlockHeap<CAllocator>::GetSize( void *p ) +{ + CPool *pPool = FindPool( p ); + return pPool->GetBlockSize(); +} + +template <typename CAllocator> +void CSmallBlockHeap<CAllocator>::Usage( size_t &bytesCommitted, size_t &bytesAllocated ) +{ + bytesCommitted = 0; + bytesAllocated = 0; + for ( int i = 0; i < NUM_POOLS; i++ ) + { + bytesCommitted += m_Pools[i].GetCommittedSize(); + bytesAllocated += ( m_Pools[i].CountAllocatedBlocks() * m_Pools[i].GetBlockSize() ); + } +} + +template <typename CAllocator> +void CSmallBlockHeap<CAllocator>::DumpStats( const char *pszTag, FILE *pFile ) +{ + size_t bytesCommitted, bytesAllocated; + Usage( bytesCommitted, bytesAllocated ); + + if ( pFile ) + { + + for ( int i = 0; i < NUM_POOLS; i++ ) + { + // output for vxconsole parsing + fprintf( pFile, "Pool %2i: (size: %4u) blocks: allocated:%5i free:%5i committed:%5i (committed size:%4u kb)\n", + i, + m_Pools[i].GetBlockSize(), + m_Pools[i].CountAllocatedBlocks(), + m_Pools[i].CountFreeBlocks(), + m_Pools[i].CountCommittedBlocks(), + m_Pools[i].GetCommittedSize() ); + } + fprintf( pFile, "Totals (%s): Committed:%5u kb Allocated:%5u kb\n", pszTag, bytesCommitted / 1024, bytesAllocated / 1024 ); + } + else + { + for ( int i = 0; i < NUM_POOLS; i++ ) + { + Msg( "Pool %2i: (size: %4u) blocks: allocated:%5i free:%5i committed:%5i (committed size:%4u kb)\n",i, m_Pools[i].GetBlockSize(),m_Pools[i].CountAllocatedBlocks(), m_Pools[i].CountFreeBlocks(),m_Pools[i].CountCommittedBlocks(), m_Pools[i].GetCommittedSize() / 1024); + } + + Msg( "Totals (%s): Committed:%5u kb Allocated:%5u kb\n", pszTag, bytesCommitted / 1024, bytesAllocated / 1024 ); + } +} + +template <typename CAllocator> +CSmallBlockPool<CAllocator> *CSmallBlockHeap<CAllocator>::FindPool( size_t nBytes ) +{ + return m_PoolLookup[(nBytes - 1) >> 2]; +} + +template <typename CAllocator> +CSmallBlockPool<CAllocator> *CSmallBlockHeap<CAllocator>::FindPool( void *p ) +{ + // NOTE: If p < m_pBase, cast to unsigned size_t will cause it to be large + size_t index = (size_t)((byte *)p - m_pSharedData->m_pBase) / BYTES_PAGE; + if ( index < ARRAYSIZE(m_pSharedData->m_PageStatus) ) + return m_pSharedData->m_PageStatus[index].m_pPool; + return NULL; +} + +template <typename CAllocator> +size_t CSmallBlockHeap<CAllocator>::Compact( bool bIncremental ) +{ + size_t nRecovered = 0; + if ( bIncremental ) + { + static int iLastIncremental; + + iLastIncremental++; + for ( int i = 0; i < NUM_POOLS; i++ ) + { + int idx = ( i + iLastIncremental ) % NUM_POOLS; + nRecovered = m_Pools[idx].Compact( bIncremental ); + if ( nRecovered ) + { + iLastIncremental = idx; + break; + } + + } + } + else + { + for ( int i = 0; i < NUM_POOLS; i++ ) + { + nRecovered += m_Pools[i].Compact( bIncremental ); + } + } + return nRecovered; +} + +template <typename CAllocator> +bool CSmallBlockHeap<CAllocator>::Validate() +{ + bool valid = true; + for ( int i = 0; i < NUM_POOLS; i++ ) + { + valid = m_Pools[i].Validate() && valid; + } + return valid; +} + +#endif // MEM_SBH_ENABLED + + +//----------------------------------------------------------------------------- +// Lightweight memory tracking +//----------------------------------------------------------------------------- + +#ifdef USE_LIGHT_MEM_DEBUG + +#ifndef LIGHT_MEM_DEBUG_REQUIRES_CMD_LINE_SWITCH +#define UsingLMD() true +#else // LIGHT_MEM_DEBUG_REQUIRES_CMD_LINE_SWITCH +bool g_bUsingLMD = ( Plat_GetCommandLineA() ) ? ( strstr( Plat_GetCommandLineA(), "-uselmd" ) != NULL ) : false; +#define UsingLMD() g_bUsingLMD +#if defined( _PS3 ) +#error "Plat_GetCommandLineA() not implemented on PS3" +#endif +#endif // LIGHT_MEM_DEBUG_REQUIRES_CMD_LINE_SWITCH + +const char *g_pszUnknown = "unknown"; + +struct Sentinal_t +{ + DWORD value[4]; +}; + +Sentinal_t g_HeadSentinel = +{ + 0xdeadbeef, + 0xbaadf00d, + 0xbd122969, + 0xdeadbeef, +}; + +Sentinal_t g_TailSentinel = +{ + 0xbaadf00d, + 0xbd122969, + 0xdeadbeef, + 0xbaadf00d, +}; + +const byte g_FreeFill = 0xdd; + +static const uint LWD_FREE = 0; +static const uint LWD_ALLOCATED = 1; + +#define LMD_STATUS_BITS ( 1 ) +#define LMD_ALIGN_BITS ( 32 - LMD_STATUS_BITS ) +#define LMD_MAX_ALIGN ( 1 << ( LMD_ALIGN_BITS - 1) ) + +struct AllocHeader_t +{ + const char *pszModule; + int line; + size_t nBytes; + uint status : LMD_STATUS_BITS; + uint align : LMD_ALIGN_BITS; + Sentinal_t sentinal; +}; + +const int g_nRecentFrees = ( IsPC() ) ? 8192 : 512; +AllocHeader_t **g_pRecentFrees = (AllocHeader_t **)calloc( g_nRecentFrees, sizeof(AllocHeader_t *) ); +int g_iNextFreeSlot; + +#define INTERNAL_INLINE + +#define LMDToHeader( pUserPtr ) ( ((AllocHeader_t *)(pUserPtr)) - 1 ) +#define LMDFromHeader( pHeader ) ( (byte *)((pHeader) + 1) ) + +CThreadFastMutex g_LMDMutex; + +const char *g_pLMDFileName = NULL; +int g_nLMDLine; +int g_iLMDDepth; + +void LMDPushAllocDbgInfo( const char *pFileName, int nLine ) +{ + if ( ThreadInMainThread() ) + { + if ( !g_iLMDDepth ) + { + g_pLMDFileName = pFileName; + g_nLMDLine = nLine; + } + g_iLMDDepth++; + } +} + +void LMDPopAllocDbgInfo() +{ + if ( ThreadInMainThread() && g_iLMDDepth > 0 ) + { + g_iLMDDepth--; + if ( g_iLMDDepth == 0 ) + { + g_pLMDFileName = NULL; + g_nLMDLine = 0; + } + } +} + + +void LMDReportInvalidBlock( AllocHeader_t *pHeader, const char *pszMessage ) +{ + char szMsg[256]; + if ( pHeader ) + { + sprintf( szMsg, "HEAP IS CORRUPT: %s (block 0x%x, size %d, alignment %d)\n", pszMessage, (size_t)LMDFromHeader( pHeader ), pHeader->nBytes, pHeader->align ); + } + else + { + sprintf( szMsg, "HEAP IS CORRUPT: %s\n", pszMessage ); + } + if ( Plat_IsInDebugSession() ) + { + DebuggerBreak(); + } + else + { + WriteMiniDump(); + } +#ifdef IS_WINDOWS_PC + ::MessageBox( NULL, szMsg, "Error", MB_SYSTEMMODAL | MB_OK ); +#else + Warning( szMsg ); +#endif +} + +void LMDValidateBlock( AllocHeader_t *pHeader, bool bFreeList ) +{ + if ( !pHeader ) + return; + + if ( memcmp( &pHeader->sentinal, &g_HeadSentinel, sizeof(Sentinal_t) ) != 0 ) + { + LMDReportInvalidBlock( pHeader, "Head sentinel corrupt" ); + } + if ( memcmp( ((Sentinal_t *)(LMDFromHeader( pHeader ) + pHeader->nBytes)), &g_TailSentinel, sizeof(Sentinal_t) ) != 0 ) + { + LMDReportInvalidBlock( pHeader, "Tail sentinel corrupt" ); + } + if ( bFreeList ) + { + byte *pCur = (byte *)pHeader + sizeof(AllocHeader_t); + byte *pLimit = pCur + pHeader->nBytes; + while ( pCur != pLimit ) + { + if ( *pCur++ != g_FreeFill ) + { + LMDReportInvalidBlock( pHeader, "Write after free" ); + } + } + } +} + + +size_t LMDComputeHeaderSize( size_t align = 0 ) +{ + if ( !align ) + return sizeof(AllocHeader_t); + // For aligned allocs, the header is preceded by padding which maintains alignment + if ( align > LMD_MAX_ALIGN ) + s_StdMemAlloc.SetCRTAllocFailed( align ); // TODO: could convert alignment to exponent to get around this, or use a flag for alignments over 1KB or 1MB... + return ( ( sizeof( AllocHeader_t ) + (align-1) ) & ~(align-1) ); +} + +size_t LMDAdjustSize( size_t &nBytes, size_t align = 0 ) +{ + if ( !UsingLMD() ) + return nBytes; + // Add data before+after each alloc + return ( nBytes + LMDComputeHeaderSize( align ) + sizeof(Sentinal_t) ); +} + +void *LMDNoteAlloc( void *p, size_t nBytes, size_t align = 0, const char *pszModule = g_pszUnknown, int line = 0 ) +{ + if ( !UsingLMD() ) + { + return p; + } + + if ( g_pLMDFileName ) + { + pszModule = g_pLMDFileName; + line = g_nLMDLine; + } + + if ( p ) + { + byte *pUserPtr = ((byte*)p) + LMDComputeHeaderSize( align ); + AllocHeader_t *pHeader = LMDToHeader( pUserPtr ); + pHeader->pszModule = pszModule; + pHeader->line = line; + pHeader->status = LWD_ALLOCATED; + pHeader->nBytes = nBytes; + pHeader->align = (uint)align; + pHeader->sentinal = g_HeadSentinel; + *((Sentinal_t *)(pUserPtr + pHeader->nBytes)) = g_TailSentinel; + LMDValidateBlock( pHeader, false ); + return pUserPtr; + } + return NULL; + + // Some SBH clients rely on allocations > 16 bytes being 16-byte aligned, so we mustn't break that assumption: + MEMSTD_COMPILE_TIME_ASSERT( sizeof( AllocHeader_t ) % 16 == 0 ); +} + +void *LMDNoteFree( void *p ) +{ + if ( !UsingLMD() ) + { + return p; + } + + AUTO_LOCK( g_LMDMutex ); + if ( !p ) + { + return NULL; + } + + AllocHeader_t *pHeader = LMDToHeader( p ); + if ( pHeader->status == LWD_FREE ) + { + LMDReportInvalidBlock( pHeader, "Double free" ); + } + LMDValidateBlock( pHeader, false ); + + AllocHeader_t *pToReturn; + if ( pHeader->nBytes < 16*1024 ) + { + pToReturn = g_pRecentFrees[g_iNextFreeSlot]; + LMDValidateBlock( pToReturn, true ); + + g_pRecentFrees[g_iNextFreeSlot] = pHeader; + g_iNextFreeSlot = (g_iNextFreeSlot + 1 ) % g_nRecentFrees; + } + else + { + pToReturn = pHeader; + LMDValidateBlock( g_pRecentFrees[rand() % g_nRecentFrees], true ); + } + + pHeader->status = LWD_FREE; + memset( pHeader + 1, g_FreeFill, pHeader->nBytes ); + + if ( pToReturn && ( pToReturn->align ) ) + { + // For aligned allocations, the actual system allocation starts *before* the LMD header: + size_t headerPadding = LMDComputeHeaderSize( pToReturn->align ) - sizeof( AllocHeader_t ); + return ( ((byte*)pToReturn) - headerPadding ); + } + + return pToReturn; +} + +size_t LMDGetSize( void *p ) +{ + if ( !UsingLMD() ) + { + return (size_t)(-1); + } + + AllocHeader_t *pHeader = LMDToHeader( p ); + return pHeader->nBytes; +} + +bool LMDValidateHeap() +{ + if ( !UsingLMD() ) + { + return true; + } + + AUTO_LOCK( g_LMDMutex ); + for ( int i = 0; i < g_nRecentFrees && g_pRecentFrees[i]; i++ ) + { + LMDValidateBlock( g_pRecentFrees[i], true ); + } + return true; +} + +void *LMDRealloc( void *pMem, size_t nSize, size_t align = 0, const char *pszModule = g_pszUnknown, int line = 0 ) +{ + if ( nSize == 0 ) + { + s_StdMemAlloc.Free( pMem ); + return NULL; + } + void *pNew; +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + if ( align ) + pNew = s_StdMemAlloc.AllocAlign( nSize, align, pszModule, line ); + else +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + pNew = s_StdMemAlloc.Alloc( nSize, pszModule, line ); + if ( !pMem ) + { + return pNew; + } + AllocHeader_t *pHeader = LMDToHeader( pMem ); + if ( align != pHeader->align ) + { + LMDReportInvalidBlock( pHeader, "Realloc changed alignment!" ); + } + size_t nCopySize = MIN( nSize, pHeader->nBytes ); + memcpy( pNew, pMem, nCopySize ); + s_StdMemAlloc.Free( pMem, pszModule, line ); + return pNew; +} + +#else // USE_LIGHT_MEM_DEBUG + +#define INTERNAL_INLINE FORCEINLINE +#define UsingLMD() false +FORCEINLINE size_t LMDAdjustSize( size_t &nBytes, size_t align = 0 ) { return nBytes; } +#define LMDNoteAlloc( pHeader, ... ) (pHeader) +#define LMDNoteFree( pHeader, ... ) (pHeader) +#define LMDGetSize( pHeader ) (size_t)(-1) +#define LMDToHeader( pHeader ) (pHeader) +#define LMDFromHeader( pHeader ) (pHeader) +#define LMDValidateHeap() (true) +#define LMDPushAllocDbgInfo( pFileName, nLine ) ((void)0) +#define LMDPopAllocDbgInfo() ((void)0) +FORCEINLINE void *LMDRealloc( void *pMem, size_t nSize, size_t align = 0, const char *pszModule = NULL, int line = 0 ) { return NULL; } + +#endif // USE_LIGHT_MEM_DEBUG + +//----------------------------------------------------------------------------- +// Internal versions +//----------------------------------------------------------------------------- + +INTERNAL_INLINE void *CStdMemAlloc::InternalAllocFromPools( size_t nSize ) +{ +#if MEM_SBH_ENABLED + void *pMem; + + pMem = m_PrimarySBH.Alloc( nSize ); + if ( pMem ) + { + return pMem; + } + +#ifdef MEMALLOC_USE_SECONDARY_SBH + pMem = m_SecondarySBH.Alloc( nSize ); + if ( pMem ) + { + return pMem; + } +#endif // MEMALLOC_USE_SECONDARY_SBH + +#ifndef MEMALLOC_NO_FALLBACK + pMem = m_FallbackSBH.Alloc( nSize ); + if ( pMem ) + { + return pMem; + } +#endif // MEMALLOC_NO_FALLBACK + + CallAllocFailHandler( nSize ); +#endif // MEM_SBH_ENABLED + return NULL; +} + +INTERNAL_INLINE void *CStdMemAlloc::InternalAlloc( int region, size_t nSize ) +{ + PROFILE_ALLOC(Malloc); + + void *pMem; + +#if MEM_SBH_ENABLED + if ( m_PrimarySBH.ShouldUse( nSize ) ) // test valid for either pool + { + pMem = InternalAllocFromPools( nSize ); + if ( !pMem ) + { + CompactOnFail(); + pMem = InternalAllocFromPools( nSize ); + } + if ( pMem ) + { + ApplyMemoryInitializations( pMem, nSize ); + return pMem; + } + + ExecuteOnce( DevWarning( "\n\nDRASTIC MEMORY OVERFLOW: Fell out of small block heap!\n\n\n") ); + } +#endif // MEM_SBH_ENABLED + + pMem = malloc_internal( region, nSize ); + if ( !pMem ) + { + CompactOnFail(); + pMem = malloc_internal( region, nSize ); + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + return NULL; + } + } + + ApplyMemoryInitializations( pMem, nSize ); + return pMem; +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +INTERNAL_INLINE void *CStdMemAlloc::InternalAllocAligned( int region, size_t nSize, size_t align ) +{ + PROFILE_ALLOC(MallocAligned); + + void *pMem; + +#if MEM_SBH_ENABLED + size_t nSizeAligned = ( nSize + align - 1 ) & ~( align - 1 ); + if ( m_PrimarySBH.ShouldUse( nSizeAligned ) ) // test valid for either pool + { + pMem = InternalAllocFromPools( nSizeAligned ); + if ( !pMem ) + { + CompactOnFail(); + pMem = InternalAllocFromPools( nSizeAligned ); + } + if ( pMem ) + { + ApplyMemoryInitializations( pMem, nSizeAligned ); + return pMem; + } + + ExecuteOnce( DevWarning( "Warning: Fell out of small block heap!\n") ); + } +#endif // MEM_SBH_ENABLED + + pMem = malloc_aligned_internal( region, nSize, align ); + if ( !pMem ) + { + CompactOnFail(); + pMem = malloc_aligned_internal( region, nSize, align ); + if ( !pMem ) + { + SetCRTAllocFailed( nSize ); + return NULL; + } + } + + ApplyMemoryInitializations( pMem, nSize ); + return pMem; +} +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + +INTERNAL_INLINE void *CStdMemAlloc::InternalRealloc( void *pMem, size_t nSize ) +{ + if ( !pMem ) + { + return RegionAlloc( DEF_REGION, nSize ); + } + + PROFILE_ALLOC(Realloc); + +#if MEM_SBH_ENABLED + if ( m_PrimarySBH.IsOwner( pMem ) ) + { + return m_PrimarySBH.Realloc( pMem, nSize ); + } + +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( m_SecondarySBH.IsOwner( pMem ) ) + { + return m_SecondarySBH.Realloc( pMem, nSize ); + } + +#endif // MEMALLOC_USE_SECONDARY_SBH + +#ifndef MEMALLOC_NO_FALLBACK + if ( m_FallbackSBH.IsOwner( pMem ) ) + { + return m_FallbackSBH.Realloc( pMem, nSize ); + } +#endif // MEMALLOC_NO_FALLBACK + +#endif // MEM_SBH_ENABLED + + void *pRet = realloc_internal( pMem, nSize ); + if ( !pRet ) + { + CompactOnFail(); + pRet = realloc_internal( pMem, nSize ); + if ( !pRet ) + { + SetCRTAllocFailed( nSize ); + } + } + + return pRet; +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +INTERNAL_INLINE void *CStdMemAlloc::InternalReallocAligned( void *pMem, size_t nSize, size_t align ) +{ + if ( !pMem ) + { + return InternalAllocAligned( DEF_REGION, nSize, align ); + } + + PROFILE_ALLOC(ReallocAligned); + +#if MEM_SBH_ENABLED + if ( m_PrimarySBH.IsOwner( pMem ) ) + { + return m_PrimarySBH.Realloc( pMem, nSize ); + } + +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( m_SecondarySBH.IsOwner( pMem ) ) + { + return m_SecondarySBH.Realloc( pMem, nSize ); + } +#endif // MEMALLOC_USE_SECONDARY_SBH + +#ifndef MEMALLOC_NO_FALLBACK + if ( m_FallbackSBH.IsOwner( pMem ) ) + { + return m_FallbackSBH.Realloc( pMem, nSize ); + } +#endif // MEMALLOC_NO_FALLBACK + +#endif // MEM_SBH_ENABLED + + void *pRet = realloc_aligned_internal( pMem, nSize, align ); + if ( !pRet ) + { + CompactOnFail(); + pRet = realloc_aligned_internal( pMem, nSize, align ); + if ( !pRet ) + { + SetCRTAllocFailed( nSize ); + } + } + + return pRet; +} +#endif + +INTERNAL_INLINE void CStdMemAlloc::InternalFree( void *pMem ) +{ + if ( !pMem ) + { + return; + } + + PROFILE_ALLOC(Free); + +#if MEM_SBH_ENABLED + if ( m_PrimarySBH.IsOwner( pMem ) ) + { + m_PrimarySBH.Free( pMem ); + return; + } + +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( m_SecondarySBH.IsOwner( pMem ) ) + { + return m_SecondarySBH.Free( pMem ); + } +#endif // MEMALLOC_USE_SECONDARY_SBH + +#ifndef MEMALLOC_NO_FALLBACK + if ( m_FallbackSBH.IsOwner( pMem ) ) + { + m_FallbackSBH.Free( pMem ); + return; + } +#endif // MEMALLOC_NO_FALLBACK + +#endif // MEM_SBH_ENABLED + + free_internal( pMem ); +} + +void CStdMemAlloc::CompactOnFail() +{ + CompactHeap(); +} + +//----------------------------------------------------------------------------- +// Release versions +//----------------------------------------------------------------------------- + +void *CStdMemAlloc::Alloc( size_t nSize ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize ); + return LMDNoteAlloc( CStdMemAlloc::InternalAlloc( DEF_REGION, nAdjustedSize ), nSize ); +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void * CStdMemAlloc::AllocAlign( size_t nSize, size_t align ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize, align ); + return LMDNoteAlloc( CStdMemAlloc::InternalAllocAligned( DEF_REGION, nAdjustedSize, align ), nSize, align ); +} +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + +void *CStdMemAlloc::Realloc( void *pMem, size_t nSize ) +{ + if ( UsingLMD() ) + return LMDRealloc( pMem, nSize ); + return CStdMemAlloc::InternalRealloc( pMem, nSize ); +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void * CStdMemAlloc::ReallocAlign( void *pMem, size_t nSize, size_t align ) +{ + if ( UsingLMD() ) + return LMDRealloc( pMem, nSize, align ); + return CStdMemAlloc::InternalReallocAligned( pMem, nSize, align ); +} +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + +void CStdMemAlloc::Free( void *pMem ) +{ + pMem = LMDNoteFree( pMem ); + CStdMemAlloc::InternalFree( pMem ); +} + +void *CStdMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize ) +{ + return NULL; +} + +//----------------------------------------------------------------------------- +// Debug versions +//----------------------------------------------------------------------------- +void *CStdMemAlloc::Alloc( size_t nSize, const char *pFileName, int nLine ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize ); + return LMDNoteAlloc( CStdMemAlloc::InternalAlloc( DEF_REGION, nAdjustedSize ), nSize, 0, pFileName, nLine ); +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void *CStdMemAlloc::AllocAlign( size_t nSize, size_t align, const char *pFileName, int nLine ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize, align ); + return LMDNoteAlloc( CStdMemAlloc::InternalAllocAligned( DEF_REGION, nAdjustedSize, align ), nSize, align, pFileName, nLine ); +} +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + +void *CStdMemAlloc::Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + if ( UsingLMD() ) + return LMDRealloc( pMem, nSize, 0, pFileName, nLine ); + return CStdMemAlloc::InternalRealloc( pMem, nSize ); +} + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS +void * CStdMemAlloc::ReallocAlign( void *pMem, size_t nSize, size_t align, const char *pFileName, int nLine ) +{ + if ( UsingLMD() ) + return LMDRealloc( pMem, nSize, align, pFileName, nLine ); + return CStdMemAlloc::InternalReallocAligned( pMem, nSize, align ); +} +#endif // MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + +void CStdMemAlloc::Free( void *pMem, const char *pFileName, int nLine ) +{ + pMem = LMDNoteFree( pMem ); + CStdMemAlloc::InternalFree( pMem ); +} + +void *CStdMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + return NULL; +} + +//----------------------------------------------------------------------------- +// Region support +//----------------------------------------------------------------------------- +void *CStdMemAlloc::RegionAlloc( int region, size_t nSize ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize ); + return LMDNoteAlloc( CStdMemAlloc::InternalAlloc( region, nAdjustedSize ), nSize ); +} + +void *CStdMemAlloc::RegionAlloc( int region, size_t nSize, const char *pFileName, int nLine ) +{ + size_t nAdjustedSize = LMDAdjustSize( nSize ); + return LMDNoteAlloc( CStdMemAlloc::InternalAlloc( region, nAdjustedSize ), nSize, 0, pFileName, nLine ); +} + +#if defined (LINUX) +#include <malloc.h> +#elif defined (OSX) +#define malloc_usable_size( ptr ) malloc_size( ptr ) +extern "C" { + extern size_t malloc_size( const void *ptr ); +} +#endif // LINUX/OSX + +//----------------------------------------------------------------------------- +// Returns the size of a particular allocation (NOTE: may be larger than the size requested!) +//----------------------------------------------------------------------------- +size_t CStdMemAlloc::GetSize( void *pMem ) +{ + if ( !pMem ) + return CalcHeapUsed(); + + if ( UsingLMD() ) + { + return LMDGetSize( pMem ); + } + +#if MEM_SBH_ENABLED + if ( m_PrimarySBH.IsOwner( pMem ) ) + { + return m_PrimarySBH.GetSize( pMem ); + } + +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( m_SecondarySBH.IsOwner( pMem ) ) + { + return m_SecondarySBH.GetSize( pMem ); + } +#endif // MEMALLOC_USE_SECONDARY_SBH + +#ifndef MEMALLOC_NO_FALLBACK + if ( m_FallbackSBH.IsOwner( pMem ) ) + { + return m_FallbackSBH.GetSize( pMem ); + } +#endif // MEMALLOC_NO_FALLBACK + +#endif // MEM_SBH_ENABLED + + return msize_internal( pMem ); +} + + +//----------------------------------------------------------------------------- +// Force file + line information for an allocation +//----------------------------------------------------------------------------- +void CStdMemAlloc::PushAllocDbgInfo( const char *pFileName, int nLine ) +{ + LMDPushAllocDbgInfo( pFileName, nLine ); +} + +void CStdMemAlloc::PopAllocDbgInfo() +{ + LMDPopAllocDbgInfo(); +} + +//----------------------------------------------------------------------------- +// FIXME: Remove when we make our own heap! Crt stuff we're currently using +//----------------------------------------------------------------------------- +int32 CStdMemAlloc::CrtSetBreakAlloc( int32 lNewBreakAlloc ) +{ + return 0; +} + +int CStdMemAlloc::CrtSetReportMode( int nReportType, int nReportMode ) +{ + return 0; +} + +int CStdMemAlloc::CrtIsValidHeapPointer( const void *pMem ) +{ + return 1; +} + +int CStdMemAlloc::CrtIsValidPointer( const void *pMem, unsigned int size, int access ) +{ + return 1; +} + +int CStdMemAlloc::CrtCheckMemory( void ) +{ +#ifndef _CERT + LMDValidateHeap(); +#if MEM_SBH_ENABLED + if ( !m_PrimarySBH.Validate() ) + { + ExecuteOnce( Msg( "Small block heap is corrupt (primary)\n " ) ); + } +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( !m_SecondarySBH.Validate() ) + { + ExecuteOnce( Msg( "Small block heap is corrupt (secondary)\n " ) ); + } +#endif // MEMALLOC_USE_SECONDARY_SBH +#ifndef MEMALLOC_NO_FALLBACK + if ( !m_FallbackSBH.Validate() ) + { + ExecuteOnce( Msg( "Small block heap is corrupt (fallback)\n " ) ); + } +#endif // MEMALLOC_NO_FALLBACK +#endif // MEM_SBH_ENABLED +#endif // _CERT + return 1; +} + +int CStdMemAlloc::CrtSetDbgFlag( int nNewFlag ) +{ + return 0; +} + +void CStdMemAlloc::CrtMemCheckpoint( _CrtMemState *pState ) +{ +} + +// FIXME: Remove when we have our own allocator +void* CStdMemAlloc::CrtSetReportFile( int nRptType, void* hFile ) +{ + return 0; +} + +void* CStdMemAlloc::CrtSetReportHook( void* pfnNewHook ) +{ + return 0; +} + +int CStdMemAlloc::CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ) +{ + return 0; +} + +int CStdMemAlloc::heapchk() +{ +#ifdef _WIN32 + CrtCheckMemory(); + return _HEAPOK; +#else + return 1; +#endif +} + +void CStdMemAlloc::DumpStats() +{ + DumpStatsFileBase( "memstats" ); +} + +void CStdMemAlloc::DumpStatsFileBase( char const *pchFileBase ) +{ +#if defined( _WIN32 ) || defined( _GAMECONSOLE ) + char filename[ 512 ]; + _snprintf( filename, sizeof( filename ) - 1, +#ifdef _X360 + "D:\\%s.txt", +#elif defined( _PS3 ) + "/app_home/%s.txt", +#else + "%s.txt", +#endif + pchFileBase ); + filename[ sizeof( filename ) - 1 ] = 0; + FILE *pFile = ( IsGameConsole() ) ? NULL : fopen( filename, "wt" ); + +#if MEM_SBH_ENABLED + if ( pFile ) + fprintf( pFile, "Fixed Page SBH:\n" ); + else + Msg( "Fixed Page SBH:\n" ); + m_PrimarySBH.DumpStats("Fixed Page SBH", pFile); +#ifdef MEMALLOC_USE_SECONDARY_SBH + if ( pFile ) + fprintf( pFile, "Secondary Fixed Page SBH:\n" ); + else + Msg( "Secondary Page SBH:\n" ); + m_SecondarySBH.DumpStats("Secondary Page SBH", pFile); +#endif // MEMALLOC_USE_SECONDARY_SBH +#ifndef MEMALLOC_NO_FALLBACK + if ( pFile ) + fprintf( pFile, "\nFallback SBH:\n" ); + else + Msg( "\nFallback SBH:\n" ); + m_FallbackSBH.DumpStats("Fallback SBH", pFile); // Dump statistics to small block heap +#endif // MEMALLOC_NO_FALLBACK +#endif // MEM_SBH_ENABLED + +#ifdef _PS3 + malloc_managed_size mms; + (g_pMemOverrideRawCrtFns->pfn_malloc_stats)( &mms ); + Msg( "PS3 malloc_stats: %u / %u / %u \n", mms.current_inuse_size, mms.current_system_size, mms.max_system_size ); +#endif // _PS3 + + heapstats_internal( pFile ); +#if defined( _X360 ) + XBX_rMemDump( filename ); +#endif + + if ( pFile ) + fclose( pFile ); +#endif // _WIN32 || _GAMECONSOLE +} + +IVirtualMemorySection * CStdMemAlloc::AllocateVirtualMemorySection( size_t numMaxBytes ) +{ +#if defined( _GAMECONSOLE ) || defined( _WIN32 ) + extern IVirtualMemorySection * VirtualMemoryManager_AllocateVirtualMemorySection( size_t numMaxBytes ); + return VirtualMemoryManager_AllocateVirtualMemorySection( numMaxBytes ); +#else + return NULL; +#endif +} + +size_t CStdMemAlloc::ComputeMemoryUsedBy( char const *pchSubStr ) +{ + return 0;//dbg heap only. +} + +static inline size_t ExtraDevkitMemory( void ) +{ +#if defined( _PS3 ) + // 213MB are available in retail mode, so adjust free mem to reflect that even if we're in devkit mode + const size_t RETAIL_SIZE = 213*1024*1024; + static sys_memory_info stat; + sys_memory_get_user_memory_size( &stat ); + if ( stat.total_user_memory > RETAIL_SIZE ) + return ( stat.total_user_memory - RETAIL_SIZE ); +#elif defined( _X360 ) + // TODO: detect the new 1GB devkit... +#endif // _PS3/_X360 + return 0; +} + +void CStdMemAlloc::GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory ) +{ + if ( !pUsedMemory || !pFreeMemory ) + return; + + size_t dlMallocFree = 0; +#if defined( USE_DLMALLOC ) + // Account for free memory contained within DLMalloc's FIRST region. The rationale is as follows: + // - the first region is supposed to service large allocations via virtual allocation, and to grow as + // needed (until all physical pages are used), so true 'out of memory' failures should occur there. + // - other regions (the 2-256kb 'medium block heap', or per-DLL heaps, and the Small Block Heap) + // are sized to a pre-determined high watermark, and not intended to grow. Free memory within + // those regions is not available for large allocations, so adding that to the 'free memory' + // yields confusing data which does not correspond well with out-of-memory failures. + mallinfo info = mspace_mallinfo( g_AllocRegions[ 0 ] ); + dlMallocFree += info.fordblks; +#endif // USE_DLMALLOC + +#if defined ( _X360 ) + + // GlobalMemoryStatus tells us how much physical memory is free + MEMORYSTATUS stat; + ::GlobalMemoryStatus( &stat ); + *pFreeMemory = stat.dwAvailPhys; + *pFreeMemory += dlMallocFree; + // Adjust free mem to reflect a retail box, even if we're using a devkit with extra memory + *pFreeMemory -= ExtraDevkitMemory(); + + // Used is total minus free (discount the 32MB system reservation) + *pUsedMemory = ( stat.dwTotalPhys - 32*1024*1024 ) - *pFreeMemory; + +#elif defined( _PS3 ) + + // NOTE: we use dlmalloc instead of the system heap, so we do NOT count the system heap's free space! + //static malloc_managed_size mms; + //(g_pMemOverrideRawCrtFns->pfn_malloc_stats)( &mms ); + //int heapFree = mms.current_system_size - mms.current_inuse_size; + + // sys_memory_get_user_memory_size tells us how much PPU memory is used/free + static sys_memory_info stat; + sys_memory_get_user_memory_size( &stat ); + *pFreeMemory = stat.available_user_memory; + *pFreeMemory += dlMallocFree; + *pUsedMemory = stat.total_user_memory - *pFreeMemory; + // Adjust free mem to reflect a retail box, even if we're using a devkit with extra memory + *pFreeMemory -= ExtraDevkitMemory(); + +#else // _X360/_PS3/other + + // no data + *pFreeMemory = 0; + *pUsedMemory = 0; + +#endif // _X360/_PS3//other +} + +#define MAX_GENERIC_MEMORY_STATS 64 +GenericMemoryStat_t g_MemStats[MAX_GENERIC_MEMORY_STATS]; +int g_nMemStats = 0; +static inline int AddGenericMemoryStat( const char *name, int value ) +{ + Assert( g_nMemStats < MAX_GENERIC_MEMORY_STATS ); + if ( g_nMemStats < MAX_GENERIC_MEMORY_STATS ) + { + g_MemStats[ g_nMemStats ].name = name; + g_MemStats[ g_nMemStats ].value = value; + g_nMemStats++; + } + return g_nMemStats; +} + +int CStdMemAlloc::GetGenericMemoryStats( GenericMemoryStat_t **ppMemoryStats ) +{ + if ( !ppMemoryStats ) + return 0; + g_nMemStats = 0; + +#if MEM_SBH_ENABLED + { + // Small block heap + size_t SBHCommitted = 0, SBHAllocated = 0; + size_t commitTmp, allocTmp; +#if MEM_SBH_ENABLED + m_PrimarySBH.Usage( commitTmp, allocTmp ); + SBHCommitted += commitTmp; SBHAllocated += allocTmp; +#ifdef MEMALLOC_USE_SECONDARY_SBH + m_SecondarySBH.Usage( commitTmp, allocTmp ); + SBHCommitted += commitTmp; SBHAllocated += allocTmp; +#endif // MEMALLOC_USE_SECONDARY_SBH +#ifndef MEMALLOC_NO_FALLBACK + m_FallbackSBH.Usage( commitTmp, allocTmp ); + SBHCommitted += commitTmp; SBHAllocated += allocTmp; +#endif // MEMALLOC_NO_FALLBACK +#endif // MEM_SBH_ENABLED + + static size_t SBHMaxCommitted = 0; SBHMaxCommitted = MAX( SBHMaxCommitted, SBHCommitted ); + AddGenericMemoryStat( "SBH_cur", (int)SBHCommitted ); + AddGenericMemoryStat( "SBH_max", (int)SBHMaxCommitted ); + } +#endif // MEM_SBH_ENABLED + +#if defined( USE_DLMALLOC ) +#if !defined( MEMALLOC_REGIONS ) && defined( MEMALLOC_SEGMENT_MIXED ) + { + // Medium block heap + mallinfo infoMBH = mspace_mallinfo( g_AllocRegions[ 1 ] ); + size_t nMBHCurUsed = infoMBH.uordblks;// nMBH_WRONG_MaxUsed = infoMBH.usmblks; // TODO: figure out why dlmalloc mis-reports MBH max usage (it just returns the footprint) + static size_t nMBHMaxUsed = 0; nMBHMaxUsed = MAX( nMBHMaxUsed, nMBHCurUsed ); + AddGenericMemoryStat( "MBH_cur", (int)nMBHCurUsed ); + AddGenericMemoryStat( "MBH_max", (int)nMBHMaxUsed ); + + // Large block heap + mallinfo infoLBH = mspace_mallinfo( g_AllocRegions[ 0 ] ); + size_t nLBHCurUsed = mspace_footprint( g_AllocRegions[ 0 ] ), nLBHMaxUsed = mspace_max_footprint( g_AllocRegions[ 0 ] ), nLBHArenaSize = infoLBH.arena, nLBHFree = infoLBH.fordblks; + AddGenericMemoryStat( "LBH_cur", (int)nLBHCurUsed ); + AddGenericMemoryStat( "LBH_max", (int)nLBHMaxUsed ); + // LBH arena used+free (these are non-virtual allocations - there should be none, since we only allocate 256KB+ items in the LBH) + // TODO: I currently see the arena grow to 320KB due to a larger allocation being realloced down... if this gets worse, add an 'ALWAYS use VMM' flag to the mspace. + AddGenericMemoryStat( "LBH_arena", (int)nLBHArenaSize ); + AddGenericMemoryStat( "LBH_free", (int)nLBHFree ); + } +#else // (!MEMALLOC_REGIONS && MEMALLOC_SEGMENT_MIXED) + { + // Single dlmalloc heap (TODO: per-DLL heap stats, if we resurrect that) + mallinfo info = mspace_mallinfo( g_AllocRegions[ 0 ] ); + AddGenericMemoryStat( "mspace_cur", (int)info.uordblks ); + AddGenericMemoryStat( "mspace_max", (int)info.usmblks ); + AddGenericMemoryStat( "mspace_size", (int)mspace_footprint( g_AllocRegions[ 0 ] ) ); + } +#endif // (!MEMALLOC_REGIONS && MEMALLOC_SEGMENT_MIXED) +#endif // USE_DLMALLOC + + size_t nMaxPhysMemUsed_Delta; + nMaxPhysMemUsed_Delta = 0; +#ifdef _PS3 + { + // System heap (should not exist!) + static malloc_managed_size mms; + (g_pMemOverrideRawCrtFns->pfn_malloc_stats)( &mms ); + if ( mms.current_system_size ) + AddGenericMemoryStat( "sys_heap", (int)mms.current_system_size ); + + // Virtual Memory Manager + size_t nReserved = 0, nReservedMax = 0, nCommitted = 0, nCommittedMax = 0; + extern void VirtualMemoryManager_GetStats( size_t &nReserved, size_t &nReservedMax, size_t &nCommitted, size_t &nCommittedMax ); + VirtualMemoryManager_GetStats( nReserved, nReservedMax, nCommitted, nCommittedMax ); + AddGenericMemoryStat( "VMM_reserved", (int)nReserved ); + AddGenericMemoryStat( "VMM_reserved_max", (int)nReservedMax ); + AddGenericMemoryStat( "VMM_committed", (int)nCommitted ); + AddGenericMemoryStat( "VMM_committed_max", (int)nCommittedMax ); + + // Estimate memory committed by memory stacks (these account for all VMM allocations other than the SBH/MBH/LBH) + size_t nHeapTotal = 1024*1024*MBYTES_PRIMARY_SBH; +#if defined( USE_DLMALLOC ) + for ( int i = 0; i < ARRAYSIZE(g_AllocRegions); i++ ) + { + nHeapTotal += mspace_footprint( g_AllocRegions[i] ); + } +#endif // USE_DLMALLOC + size_t nMemStackTotal = nCommitted - nHeapTotal; + AddGenericMemoryStat( "MemStacks", (int)nMemStackTotal ); + + // On PS3, we can more accurately determine 'phys_free_min', since we know nCommittedMax + // (otherwise nPhysFreeMin is only updated intermittently; when this function is called): + nMaxPhysMemUsed_Delta = nCommittedMax - nCommitted; + } +#endif // _PS3 + +#if defined( _GAMECONSOLE ) + // Total/free/min-free physical pages + { +#if defined( _X360 ) + MEMORYSTATUS stat; + ::GlobalMemoryStatus( &stat ); + size_t nPhysTotal = stat.dwTotalPhys, nPhysFree = stat.dwAvailPhys - ExtraDevkitMemory(); +#elif defined( _PS3 ) + static sys_memory_info stat; + sys_memory_get_user_memory_size( &stat ); + size_t nPhysTotal = stat.total_user_memory, nPhysFree = stat.available_user_memory - ExtraDevkitMemory(); +#endif // _X360/_PS3 + static size_t nPhysFreeMin = nPhysTotal; + nPhysFreeMin = MIN( nPhysFreeMin, ( nPhysFree - nMaxPhysMemUsed_Delta ) ); + AddGenericMemoryStat( "phys_total", (int)nPhysTotal ); + AddGenericMemoryStat( "phys_free", (int)nPhysFree ); + AddGenericMemoryStat( "phys_free_min", (int)nPhysFreeMin ); + } +#endif // _GAMECONSOLE + + *ppMemoryStats = &g_MemStats[0]; + return g_nMemStats; +} + +void CStdMemAlloc::CompactHeap() +{ +#if MEM_SBH_ENABLED + if ( !m_CompactMutex.TryLock() ) + { + return; + } + if ( m_bInCompact ) + { + m_CompactMutex.Unlock(); + return; + } + + m_bInCompact = true; + size_t nBytesRecovered; +#ifndef MEMALLOC_NO_FALLBACK + nBytesRecovered = m_FallbackSBH.Compact( false ); + if ( nBytesRecovered && IsGameConsole() ) + { + Msg( "Compact freed %d bytes from virtual heap (up to 256k still committed)\n", nBytesRecovered ); + } +#endif // MEMALLOC_NO_FALLBACK + nBytesRecovered = m_PrimarySBH.Compact( false ); +#ifdef MEMALLOC_USE_SECONDARY_SBH + nBytesRecovered += m_SecondarySBH.Compact( false ); +#endif + if ( nBytesRecovered && IsGameConsole() ) + { + Msg( "Compact released %d bytes from the SBH\n", nBytesRecovered ); + } + + nBytesRecovered = compact_internal(); + if ( nBytesRecovered && IsGameConsole() ) + { + Msg( "Compact released %d bytes from the mixed block heap\n", nBytesRecovered ); + } + + m_bInCompact = false; + m_CompactMutex.Unlock(); +#endif // MEM_SBH_ENABLED +} + +void CStdMemAlloc::CompactIncremental() +{ +#if MEM_SBH_ENABLED + if ( !m_CompactMutex.TryLock() ) + { + return; + } + if ( m_bInCompact ) + { + m_CompactMutex.Unlock(); + return; + } + + m_bInCompact = true; +#ifndef MEMALLOC_NO_FALLBACK + m_FallbackSBH.Compact( true ); +#endif + m_PrimarySBH.Compact( true ); +#ifdef MEMALLOC_USE_SECONDARY_SBH + m_SecondarySBH.Compact( true ); +#endif + m_bInCompact = false; + m_CompactMutex.Unlock(); +#endif // MEM_SBH_ENABLED +} + +MemAllocFailHandler_t CStdMemAlloc::SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ) +{ + MemAllocFailHandler_t pfnPrevious = m_pfnFailHandler; + m_pfnFailHandler = pfnMemAllocFailHandler; + return pfnPrevious; +} + +size_t CStdMemAlloc::DefaultFailHandler( size_t nBytes ) +{ + if ( IsX360() ) + { +#ifdef _X360 + ExecuteOnce( + { + char buffer[256]; + _snprintf( buffer, sizeof( buffer ), "***** Memory pool overflow, attempted allocation size: %u (not a critical error)\n", nBytes ); + XBX_OutputDebugString( buffer ); + } + ); +#endif // _X360 + } + return 0; +} + +void CStdMemAlloc::SetStatsExtraInfo( const char *pMapName, const char *pComment ) +{ +} + +void CStdMemAlloc::SetCRTAllocFailed( size_t nSize ) +{ + m_sMemoryAllocFailed = nSize; + + DebuggerBreakIfDebugging(); +#if defined( _PS3 ) && defined( _DEBUG ) + DebuggerBreak(); +#endif // _PS3 + + char buffer[256]; +#ifdef COMPILER_GCC + _snprintf( buffer, sizeof( buffer ), "***** OUT OF MEMORY! attempted allocation size: %u ****\n", nSize ); +#else + _snprintf( buffer, sizeof( buffer ), "***** OUT OF MEMORY! attempted allocation size: %u ****\n", nSize ); +#endif // COMPILER_GCC + +#ifdef _X360 + XBX_OutputDebugString( buffer ); + if ( !Plat_IsInDebugSession() ) + { + XBX_CrashDump( true ); +#if defined( _DEMO ) + XLaunchNewImage( XLAUNCH_KEYWORD_DEFAULT_APP, 0 ); +#else + XLaunchNewImage( "default.xex", 0 ); +#endif // _DEMO + } +#elif defined(_WIN32 ) + OutputDebugString( buffer ); + if ( !Plat_IsInDebugSession() ) + { + WriteMiniDump(); + abort(); + } +#else // _X360/_WIN32/other + printf( "%s\n", buffer ); + if ( !Plat_IsInDebugSession() ) + { + WriteMiniDump(); +#if defined( _PS3 ) + DumpStats(); +#endif + Plat_ExitProcess( 0 ); + } +#endif // _X360/_WIN32/other + +} + +size_t CStdMemAlloc::MemoryAllocFailed() +{ + return m_sMemoryAllocFailed; +} + +#endif // MEM_IMPL_TYPE_STD + +#endif // STEAM diff --git a/external/vpc/tier0/memstd.h b/external/vpc/tier0/memstd.h new file mode 100644 index 0000000..ea594c4 --- /dev/null +++ b/external/vpc/tier0/memstd.h @@ -0,0 +1,452 @@ +//----------------------------------------------------------------------------- +// NOTE! This should never be called directly from leaf code +// Just use new,delete,malloc,free etc. They will call into this eventually +//----------------------------------------------------------------------------- +#include "pch_tier0.h" + +#if IS_WINDOWS_PC +#define WIN_32_LEAN_AND_MEAN +#include <windows.h> +#define VA_COMMIT_FLAGS MEM_COMMIT +#define VA_RESERVE_FLAGS MEM_RESERVE +#elif defined( _X360 ) +#undef Verify +#define _XBOX +#include <xtl.h> +#undef _XBOX +#include "xbox/xbox_win32stubs.h" +#define VA_COMMIT_FLAGS (MEM_COMMIT|MEM_NOZERO|MEM_LARGE_PAGES) +#define VA_RESERVE_FLAGS (MEM_RESERVE|MEM_LARGE_PAGES) +#elif defined( _PS3 ) +#include "sys/memory.h" +#include "sys/mempool.h" +#include "sys/process.h" +#include <sys/vm.h> + +#endif + +//#include <malloc.h> +#include <algorithm> +#include "tier0/dbg.h" +#include "tier0/memalloc.h" +#include "tier0/threadtools.h" +#include "tier0/tslist.h" +#include "mem_helpers.h" + +#ifndef _PS3 +#pragma pack(4) +#endif + +#define MIN_SBH_BLOCK 8 +#define MIN_SBH_ALIGN 8 +#define MAX_SBH_BLOCK 2048 +#define MAX_POOL_REGION (4*1024*1024) + + +#define NUM_POOLS 42 + +#if defined( _WIN32 ) || defined( _PS3 ) +// FIXME: Disable small block heap on win64 for now; it's busted because +// it's expecting SLIST_HEADER to look different than it does on win64 +#if !defined( PLATFORM_WINDOWS_PC64 ) +#define MEM_SBH_ENABLED 1 +#endif +#endif + +#if !defined(_CERT) && ( defined(_X360) || defined(_PS3) ) +#define TRACK_SBH_COUNTS +#endif + +#if defined(_X360) + +// 360 uses a 48MB primary (physical) SBH and 10MB secondary (virtual) SBH, with no fallback +#define MBYTES_PRIMARY_SBH 48 +#define MEMALLOC_USE_SECONDARY_SBH +#define MBYTES_SECONDARY_SBH 10 +#define MEMALLOC_NO_FALLBACK + +#elif defined(_PS3) + +// PS3 uses just a 32MB SBH - this was enough to avoid overflow when Portal 2 shipped. +// NOTE: when Steam uses the game's tier0 allocator (see memalloc.h), we increase the size +// of the SBH and MBH (see memstd.cpp) to accommodate those extra allocations. +#define MBYTES_PRIMARY_SBH ( 32 + MBYTES_STEAM_SBH_USAGE ) +#define MEMALLOC_NO_FALLBACK + +#else // _X360 | _PS3 + +// Other platforms use a 48MB primary SBH and a (32MB) fallback SBH +#define MBYTES_PRIMARY_SBH 48 + +#endif // _X360 | _PS3 + +#define MEMSTD_COMPILE_TIME_ASSERT( pred ) switch(0){case 0:case pred:;} + +//----------------------------------------------------------------------------- +// Small block pool +//----------------------------------------------------------------------------- + +class CFreeList : public CTSListBase +{ +public: + void Push( void *p ) { CTSListBase::Push( (TSLNodeBase_t *)p ); } + byte *Pop() { return (byte *)CTSListBase::Pop(); } +}; + +template <typename CAllocator> +class CSmallBlockHeap; + +template <typename CAllocator> +class CSmallBlockPool +{ +public: + CSmallBlockPool() + { + m_nBlockSize = 0; + m_nCommittedPages = 0; + m_pFirstPage = NULL; + } + + void Init( unsigned nBlockSize ); + size_t GetBlockSize(); + void *Alloc(); + void Free( void *p ); + int CountFreeBlocks(); + int GetCommittedSize(); + int CountCommittedBlocks(); + int CountAllocatedBlocks(); + size_t Compact( bool bIncremental ); + bool Validate(); + + enum + { + BYTES_PAGE = CAllocator::BYTES_PAGE, + NOT_COMMITTED = -1 + }; + +private: + typedef CSmallBlockHeap<CAllocator> CHeap; + friend class CSmallBlockHeap<CAllocator>; + + struct PageStatus_t : public TSLNodeBase_t + { + PageStatus_t() + { + m_pPool = NULL; + m_nAllocated = NOT_COMMITTED; + m_pNextPageInPool = NULL; + } + + CSmallBlockPool<CAllocator> * m_pPool; + PageStatus_t * m_pNextPageInPool; + CInterlockedInt m_nAllocated; + CTSListBase m_SortList; + }; + + struct SharedData_t + { + CAllocator m_Allocator; + CTSListBase m_FreePages; + CThreadSpinRWLock m_Lock; + PageStatus_t m_PageStatus[CAllocator::TOTAL_BYTES/CAllocator::BYTES_PAGE]; + byte * m_pNextBlock; + byte * m_pBase; + byte * m_pLimit; + }; + + static int PageSort( const void *p1, const void *p2 ) ; + bool RemovePagesFromFreeList( byte **pPages, int nPages, bool bSortList ); + + void ValidateFreelist( SharedData_t *pSharedData ); + + CFreeList m_FreeList; + + CInterlockedPtr<byte> m_pNextAlloc; + + PageStatus_t * m_pFirstPage; + unsigned m_nBlockSize; + unsigned m_nCommittedPages; + + CThreadFastMutex m_CommitMutex; + +#ifdef TRACK_SBH_COUNTS + CInterlockedInt m_nFreeBlocks; +#endif + + static SharedData_t *GetSharedData() + { + return &gm_SharedData; + } + + static SharedData_t gm_SharedData; +}; + +//----------------------------------------------------------------------------- +// Small block heap (multi-pool) +//----------------------------------------------------------------------------- + +template <typename CAllocator> +class CSmallBlockHeap +{ +public: + CSmallBlockHeap(); + bool ShouldUse( size_t nBytes ); + bool IsOwner( void * p ); + void *Alloc( size_t nBytes ); + void *Realloc( void *p, size_t nBytes ); + void Free( void *p ); + size_t GetSize( void *p ); + void DumpStats( const char *pszTag, FILE *pFile = NULL ); + void Usage( size_t &bytesCommitted, size_t &bytesAllocated ); + size_t Compact( bool bIncremental ); + bool Validate(); + + enum + { + BYTES_PAGE = CAllocator::BYTES_PAGE + }; + +private: + typedef CSmallBlockPool<CAllocator> CPool; + typedef struct CSmallBlockPool<CAllocator>::SharedData_t SharedData_t; + + CPool *FindPool( size_t nBytes ); + CPool *FindPool( void *p ); + + // Map size to a pool address to a pool + CPool *m_PoolLookup[MAX_SBH_BLOCK >> 2]; + CPool m_Pools[NUM_POOLS]; + + SharedData_t *m_pSharedData; +}; + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +class CStdMemAlloc : public IMemAlloc +{ +public: + CStdMemAlloc(); + + // Internal versions + void *InternalAlloc( int region, size_t nSize ); +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + void *InternalAllocAligned( int region, size_t nSize, size_t align ); +#endif + void *InternalAllocFromPools( size_t nSize ); + void *InternalRealloc( void *pMem, size_t nSize ); +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + void *InternalReallocAligned( void *pMem, size_t nSize, size_t align ); +#endif + void InternalFree( void *pMem ); + + void CompactOnFail(); + + // Release versions + virtual void *Alloc( size_t nSize ); + virtual void *Realloc( void *pMem, size_t nSize ); + virtual void Free( void *pMem ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize ); + + // Debug versions + virtual void *Alloc( size_t nSize, const char *pFileName, int nLine ); + virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ); + virtual void Free( void *pMem, const char *pFileName, int nLine ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ); + +#ifdef MEMALLOC_SUPPORTS_ALIGNED_ALLOCATIONS + virtual void *AllocAlign( size_t nSize, size_t align ); + virtual void *AllocAlign( size_t nSize, size_t align, const char *pFileName, int nLine ); + virtual void *ReallocAlign( void *pMem, size_t nSize, size_t align ); + virtual void *ReallocAlign( void *pMem, size_t nSize, size_t align, const char *pFileName, int nLine ); +#endif + + virtual void *RegionAlloc( int region, size_t nSize ); + virtual void *RegionAlloc( int region, size_t nSize, const char *pFileName, int nLine ); + + // Returns size of a particular allocation + virtual size_t GetSize( void *pMem ); + + // Force file + line information for an allocation + virtual void PushAllocDbgInfo( const char *pFileName, int nLine ); + virtual void PopAllocDbgInfo(); + + virtual int32 CrtSetBreakAlloc( int32 lNewBreakAlloc ); + virtual int CrtSetReportMode( int nReportType, int nReportMode ); + virtual int CrtIsValidHeapPointer( const void *pMem ); + virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access ); + virtual int CrtCheckMemory( void ); + virtual int CrtSetDbgFlag( int nNewFlag ); + virtual void CrtMemCheckpoint( _CrtMemState *pState ); + void* CrtSetReportFile( int nRptType, void* hFile ); + void* CrtSetReportHook( void* pfnNewHook ); + int CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ); + virtual int heapchk(); + + virtual void DumpStats(); + virtual void DumpStatsFileBase( char const *pchFileBase ); + virtual size_t ComputeMemoryUsedBy( char const *pchSubStr ); + virtual void GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory ); + + virtual bool IsDebugHeap() { return false; } + + virtual void GetActualDbgInfo( const char *&pFileName, int &nLine ) {} + virtual void RegisterAllocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) {} + virtual void RegisterDeallocation( const char *pFileName, int nLine, size_t nLogicalSize, size_t nActualSize, unsigned nTime ) {} + + virtual int GetVersion() { return MEMALLOC_VERSION; } + + virtual void OutOfMemory( size_t nBytesAttempted = 0 ) { SetCRTAllocFailed( nBytesAttempted ); } + + virtual IVirtualMemorySection * AllocateVirtualMemorySection( size_t numMaxBytes ); + + virtual int GetGenericMemoryStats( GenericMemoryStat_t **ppMemoryStats ); + + virtual void CompactHeap(); + virtual void CompactIncremental(); + + virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ); + size_t CallAllocFailHandler( size_t nBytes ) { return (*m_pfnFailHandler)( nBytes); } + + virtual uint32 GetDebugInfoSize() { return 0; } + virtual void SaveDebugInfo( void *pvDebugInfo ) { } + virtual void RestoreDebugInfo( const void *pvDebugInfo ) {} + virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ) {} + + static size_t DefaultFailHandler( size_t ); + void DumpBlockStats( void *p ) {} + +#if MEM_SBH_ENABLED + class CVirtualAllocator + { + public: + enum + { + BYTES_PAGE = (64*1024), + TOTAL_BYTES = (32*1024*1024), + MIN_RESERVE_PAGES = 4, + }; + + byte *AllocatePoolMemory() + { +#ifdef _WIN32 + return (byte *)VirtualAlloc( NULL, TOTAL_BYTES, VA_RESERVE_FLAGS, PAGE_NOACCESS ); +#elif defined( _PS3 ) + Error( "" ); + return NULL; +#else +#error +#endif + } + + bool IsVirtual() + { + return true; + } + + bool Decommit( void *pPage ) + { +#ifdef _WIN32 + return ( VirtualFree( pPage, BYTES_PAGE, MEM_DECOMMIT ) != 0 ); +#elif defined( _PS3 ) + return false; +#else +#error +#endif + } + + bool Commit( void *pPage ) + { +#ifdef _WIN32 + return ( VirtualAlloc( pPage, BYTES_PAGE, VA_COMMIT_FLAGS, PAGE_READWRITE ) != NULL ); +#elif defined( _PS3 ) + return false; +#else +#error +#endif + } + }; + + typedef CSmallBlockHeap<CVirtualAllocator> CVirtualSmallBlockHeap; + + template <size_t SIZE_MB, bool bPhysical> + class CFixedAllocator + { + public: + enum + { + BYTES_PAGE = (16*1024), + TOTAL_BYTES = (SIZE_MB*1024*1024), + MIN_RESERVE_PAGES = TOTAL_BYTES/BYTES_PAGE, + }; + + byte *AllocatePoolMemory() + { +#ifdef _WIN32 +#ifdef _X360 + if ( bPhysical ) + return (byte *)XPhysicalAlloc( TOTAL_BYTES, MAXULONG_PTR, 4096, PAGE_READWRITE | MEM_16MB_PAGES ); +#endif + return (byte *)VirtualAlloc( NULL, TOTAL_BYTES, VA_COMMIT_FLAGS, PAGE_READWRITE ); +#elif defined( _PS3 ) + // TODO: release this section on shutdown (use GetMemorySectionForAddress) + extern IVirtualMemorySection * VirtualMemoryManager_AllocateVirtualMemorySection( size_t numMaxBytes ); + IVirtualMemorySection *pSection = VirtualMemoryManager_AllocateVirtualMemorySection( TOTAL_BYTES ); + if ( !pSection ) + Error( "CFixedAllocator::AllocatePoolMemory() failed in VirtualMemoryManager_AllocateVirtualMemorySection\n" ); + if ( !pSection->CommitPages( pSection->GetBaseAddress(), TOTAL_BYTES ) ) + Error( "CFixedAllocator::AllocatePoolMemory() failed in IVirtualMemorySection::CommitPages\n" ); + return reinterpret_cast<byte *>( pSection->GetBaseAddress() ); +#else +#error +#endif + } + + bool IsVirtual() + { + return false; + } + + bool Decommit( void *pPage ) + { + return false; + } + + bool Commit( void *pPage ) + { + return false; + } + }; + + typedef CSmallBlockHeap<CFixedAllocator< MBYTES_PRIMARY_SBH, true> > CFixedSmallBlockHeap; +#ifdef MEMALLOC_USE_SECONDARY_SBH + typedef CSmallBlockHeap<CFixedAllocator< MBYTES_SECONDARY_SBH, false> > CFixedVirtualSmallBlockHeap; // @TODO: move back into above heap if number stays at 16 [7/15/2009 tom] +#endif + + CFixedSmallBlockHeap m_PrimarySBH; +#ifdef MEMALLOC_USE_SECONDARY_SBH + CFixedVirtualSmallBlockHeap m_SecondarySBH; +#endif +#ifndef MEMALLOC_NO_FALLBACK + CVirtualSmallBlockHeap m_FallbackSBH; +#endif + +#endif // MEM_SBH_ENABLED + + + virtual void SetStatsExtraInfo( const char *pMapName, const char *pComment ); + + virtual size_t MemoryAllocFailed(); + + void SetCRTAllocFailed( size_t nMemSize ); + + MemAllocFailHandler_t m_pfnFailHandler; + size_t m_sMemoryAllocFailed; + CThreadFastMutex m_CompactMutex; + bool m_bInCompact; +}; + +#ifndef _PS3 +#pragma pack() +#endif diff --git a/external/vpc/tier0/memvalidate.cpp b/external/vpc/tier0/memvalidate.cpp new file mode 100644 index 0000000..17c9514 --- /dev/null +++ b/external/vpc/tier0/memvalidate.cpp @@ -0,0 +1,498 @@ +//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: Memory allocation! +// +// $NoKeywords: $ +//=============================================================================// + +#include "pch_tier0.h" + +#ifndef STEAM + +#ifdef TIER0_VALIDATE_HEAP + +#include <malloc.h> +#include "tier0/dbg.h" +#include "tier0/memalloc.h" +#include "mem_helpers.h" + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +extern IMemAlloc *g_pActualAlloc; + +//----------------------------------------------------------------------------- +// NOTE! This should never be called directly from leaf code +// Just use new,delete,malloc,free etc. They will call into this eventually +//----------------------------------------------------------------------------- +class CValidateAlloc : public IMemAlloc +{ +public: + enum + { + HEAP_PREFIX_BUFFER_SIZE = 12, + HEAP_SUFFIX_BUFFER_SIZE = 8, + }; + + CValidateAlloc(); + + // Release versions + virtual void *Alloc( size_t nSize ); + virtual void *Realloc( void *pMem, size_t nSize ); + virtual void Free( void *pMem ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize ); + + // Debug versions + virtual void *Alloc( size_t nSize, const char *pFileName, int nLine ); + virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ); + virtual void Free( void *pMem, const char *pFileName, int nLine ); + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ); + + // Returns size of a particular allocation + virtual size_t GetSize( void *pMem ); + + // Force file + line information for an allocation + virtual void PushAllocDbgInfo( const char *pFileName, int nLine ); + virtual void PopAllocDbgInfo(); + + virtual long CrtSetBreakAlloc( long lNewBreakAlloc ); + virtual int CrtSetReportMode( int nReportType, int nReportMode ); + virtual int CrtIsValidHeapPointer( const void *pMem ); + virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access ); + virtual int CrtCheckMemory( void ); + virtual int CrtSetDbgFlag( int nNewFlag ); + virtual void CrtMemCheckpoint( _CrtMemState *pState ); + void* CrtSetReportFile( int nRptType, void* hFile ); + void* CrtSetReportHook( void* pfnNewHook ); + int CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ); + virtual int heapchk(); + + virtual void DumpStats() {} + virtual void DumpStatsFileBase( char const *pchFileBase ) {} + + virtual bool IsDebugHeap() + { + return true; + } + + virtual int GetVersion() { return MEMALLOC_VERSION; } + + virtual void CompactHeap(); + virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ); + + virtual uint32 GetDebugInfoSize() { return 0; } + virtual void SaveDebugInfo( void *pvDebugInfo ) { } + virtual void RestoreDebugInfo( const void *pvDebugInfo ) {} + virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ) {} + +private: + struct HeapPrefix_t + { + HeapPrefix_t *m_pPrev; + HeapPrefix_t *m_pNext; + int m_nSize; + unsigned char m_Prefix[HEAP_PREFIX_BUFFER_SIZE]; + }; + + struct HeapSuffix_t + { + unsigned char m_Suffix[HEAP_SUFFIX_BUFFER_SIZE]; + }; + +private: + // Returns the actual debug info + void GetActualDbgInfo( const char *&pFileName, int &nLine ); + + // Updates stats + void RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ); + void RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ); + + HeapSuffix_t *Suffix( HeapPrefix_t *pPrefix ); + void *AllocationStart( HeapPrefix_t *pBase ); + HeapPrefix_t *PrefixFromAllocation( void *pAlloc ); + const HeapPrefix_t *PrefixFromAllocation( const void *pAlloc ); + + // Add to the list! + void AddToList( HeapPrefix_t *pHeap, int nSize ); + + // Remove from the list! + void RemoveFromList( HeapPrefix_t *pHeap ); + + // Validate the allocation + bool ValidateAllocation( HeapPrefix_t *pHeap ); + +private: + HeapPrefix_t *m_pFirstAllocation; + char m_pPrefixImage[HEAP_PREFIX_BUFFER_SIZE]; + char m_pSuffixImage[HEAP_SUFFIX_BUFFER_SIZE]; +}; + + +//----------------------------------------------------------------------------- +// Singleton... +//----------------------------------------------------------------------------- +static CValidateAlloc s_ValidateAlloc; + +#ifdef _PS3 + +IMemAlloc *g_pMemAllocInternalPS3 = &s_ValidateAlloc; + +#else // !_PS3 + +IMemAlloc *g_pMemAlloc = &s_ValidateAlloc; + +#endif // _PS3 + + +//----------------------------------------------------------------------------- +// Constructor. +//----------------------------------------------------------------------------- +CValidateAlloc::CValidateAlloc() +{ + m_pFirstAllocation = 0; + memset( m_pPrefixImage, 0xBE, HEAP_PREFIX_BUFFER_SIZE ); + memset( m_pSuffixImage, 0xAF, HEAP_SUFFIX_BUFFER_SIZE ); +} + + +//----------------------------------------------------------------------------- +// Accessors... +//----------------------------------------------------------------------------- +inline CValidateAlloc::HeapSuffix_t *CValidateAlloc::Suffix( HeapPrefix_t *pPrefix ) +{ + return reinterpret_cast<HeapSuffix_t *>( (unsigned char*)( pPrefix + 1 ) + pPrefix->m_nSize ); +} + +inline void *CValidateAlloc::AllocationStart( HeapPrefix_t *pBase ) +{ + return static_cast<void *>( pBase + 1 ); +} + +inline CValidateAlloc::HeapPrefix_t *CValidateAlloc::PrefixFromAllocation( void *pAlloc ) +{ + if ( !pAlloc ) + return NULL; + + return ((HeapPrefix_t*)pAlloc) - 1; +} + +inline const CValidateAlloc::HeapPrefix_t *CValidateAlloc::PrefixFromAllocation( const void *pAlloc ) +{ + return ((const HeapPrefix_t*)pAlloc) - 1; +} + + +//----------------------------------------------------------------------------- +// Add to the list! +//----------------------------------------------------------------------------- +void CValidateAlloc::AddToList( HeapPrefix_t *pHeap, int nSize ) +{ + pHeap->m_pPrev = NULL; + pHeap->m_pNext = m_pFirstAllocation; + if ( m_pFirstAllocation ) + { + m_pFirstAllocation->m_pPrev = pHeap; + } + pHeap->m_nSize = nSize; + + m_pFirstAllocation = pHeap; + + HeapSuffix_t *pSuffix = Suffix( pHeap ); + memcpy( pHeap->m_Prefix, m_pPrefixImage, HEAP_PREFIX_BUFFER_SIZE ); + memcpy( pSuffix->m_Suffix, m_pSuffixImage, HEAP_SUFFIX_BUFFER_SIZE ); +} + + +//----------------------------------------------------------------------------- +// Remove from the list! +//----------------------------------------------------------------------------- +void CValidateAlloc::RemoveFromList( HeapPrefix_t *pHeap ) +{ + if ( !pHeap ) + return; + + ValidateAllocation( pHeap ); + if ( pHeap->m_pPrev ) + { + pHeap->m_pPrev->m_pNext = pHeap->m_pNext; + } + else + { + m_pFirstAllocation = pHeap->m_pNext; + } + + if ( pHeap->m_pNext ) + { + pHeap->m_pNext->m_pPrev = pHeap->m_pPrev; + } +} + + +//----------------------------------------------------------------------------- +// Validate the allocation +//----------------------------------------------------------------------------- +bool CValidateAlloc::ValidateAllocation( HeapPrefix_t *pHeap ) +{ + HeapSuffix_t *pSuffix = Suffix( pHeap ); + + bool bOk = true; + if ( memcmp( pHeap->m_Prefix, m_pPrefixImage, HEAP_PREFIX_BUFFER_SIZE ) ) + { + bOk = false; + } + + if ( memcmp( pSuffix->m_Suffix, m_pSuffixImage, HEAP_SUFFIX_BUFFER_SIZE ) ) + { + bOk = false; + } + + if ( !bOk ) + { + Warning("Memory trash detected in allocation %X!\n", (void*)(pHeap+1) ); + Assert( 0 ); + } + + return bOk; +} + +//----------------------------------------------------------------------------- +// Release versions +//----------------------------------------------------------------------------- +void *CValidateAlloc::Alloc( size_t nSize ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + HeapPrefix_t *pHeap = (HeapPrefix_t*)g_pActualAlloc->Alloc( nActualSize ); + AddToList( pHeap, nSize ); + return AllocationStart( pHeap ); +} + +void *CValidateAlloc::Realloc( void *pMem, size_t nSize ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + pHeap = (HeapPrefix_t*)g_pActualAlloc->Realloc( pHeap, nActualSize ); + AddToList( pHeap, nSize ); + + return AllocationStart( pHeap ); +} + +void CValidateAlloc::Free( void *pMem ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + g_pActualAlloc->Free( pHeap ); +} + +void *CValidateAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + pHeap = (HeapPrefix_t*)g_pActualAlloc->Expand_NoLongerSupported( pHeap, nActualSize ); + AddToList( pHeap, nSize ); + + return AllocationStart( pHeap ); +} + + +//----------------------------------------------------------------------------- +// Debug versions +//----------------------------------------------------------------------------- +void *CValidateAlloc::Alloc( size_t nSize, const char *pFileName, int nLine ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + HeapPrefix_t *pHeap = (HeapPrefix_t*)g_pActualAlloc->Alloc( nActualSize, pFileName, nLine ); + AddToList( pHeap, nSize ); + return AllocationStart( pHeap ); +} + +void *CValidateAlloc::Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + pHeap = (HeapPrefix_t*)g_pActualAlloc->Realloc( pHeap, nActualSize, pFileName, nLine ); + AddToList( pHeap, nSize ); + + return AllocationStart( pHeap ); +} + +void CValidateAlloc::Free( void *pMem, const char *pFileName, int nLine ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + g_pActualAlloc->Free( pHeap, pFileName, nLine ); +} + +void *CValidateAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ) +{ + Assert( heapchk() == _HEAPOK ); + Assert( CrtCheckMemory() ); + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + RemoveFromList( pHeap ); + + int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t); + pHeap = (HeapPrefix_t*)g_pActualAlloc->Expand_NoLongerSupported( pHeap, nActualSize, pFileName, nLine ); + AddToList( pHeap, nSize ); + + return AllocationStart( pHeap ); +} + + +//----------------------------------------------------------------------------- +// Returns size of a particular allocation +//----------------------------------------------------------------------------- +size_t CValidateAlloc::GetSize( void *pMem ) +{ + if ( !pMem ) + return CalcHeapUsed(); + + HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + return pHeap->m_nSize; +} + + +//----------------------------------------------------------------------------- +// Force file + line information for an allocation +//----------------------------------------------------------------------------- +void CValidateAlloc::PushAllocDbgInfo( const char *pFileName, int nLine ) +{ + g_pActualAlloc->PushAllocDbgInfo( pFileName, nLine ); +} + +void CValidateAlloc::PopAllocDbgInfo() +{ + g_pActualAlloc->PopAllocDbgInfo( ); +} + +//----------------------------------------------------------------------------- +// FIXME: Remove when we make our own heap! Crt stuff we're currently using +//----------------------------------------------------------------------------- +long CValidateAlloc::CrtSetBreakAlloc( long lNewBreakAlloc ) +{ + return g_pActualAlloc->CrtSetBreakAlloc( lNewBreakAlloc ); +} + +int CValidateAlloc::CrtSetReportMode( int nReportType, int nReportMode ) +{ + return g_pActualAlloc->CrtSetReportMode( nReportType, nReportMode ); +} + +int CValidateAlloc::CrtIsValidHeapPointer( const void *pMem ) +{ + const HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + return g_pActualAlloc->CrtIsValidHeapPointer( pHeap ); +} + +int CValidateAlloc::CrtIsValidPointer( const void *pMem, unsigned int size, int access ) +{ + const HeapPrefix_t *pHeap = PrefixFromAllocation( pMem ); + return g_pActualAlloc->CrtIsValidPointer( pHeap, size, access ); +} + +int CValidateAlloc::CrtCheckMemory( void ) +{ + return g_pActualAlloc->CrtCheckMemory( ); +} + +int CValidateAlloc::CrtSetDbgFlag( int nNewFlag ) +{ + return g_pActualAlloc->CrtSetDbgFlag( nNewFlag ); +} + +void CValidateAlloc::CrtMemCheckpoint( _CrtMemState *pState ) +{ + g_pActualAlloc->CrtMemCheckpoint( pState ); +} + +void* CValidateAlloc::CrtSetReportFile( int nRptType, void* hFile ) +{ + return g_pActualAlloc->CrtSetReportFile( nRptType, hFile ); +} + +void* CValidateAlloc::CrtSetReportHook( void* pfnNewHook ) +{ + return g_pActualAlloc->CrtSetReportHook( pfnNewHook ); +} + +int CValidateAlloc::CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ) +{ + return g_pActualAlloc->CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg ); +} + +int CValidateAlloc::heapchk() +{ + bool bOk = true; + + // Validate the heap + HeapPrefix_t *pHeap = m_pFirstAllocation; + for( pHeap = m_pFirstAllocation; pHeap; pHeap = pHeap->m_pNext ) + { + if ( !ValidateAllocation( pHeap ) ) + { + bOk = false; + } + } + +#ifdef _WIN32 + return bOk ? _HEAPOK : 0; +#elif POSIX + return bOk; +#else +#error +#endif +} + +// Returns the actual debug info +void CValidateAlloc::GetActualDbgInfo( const char *&pFileName, int &nLine ) +{ + g_pActualAlloc->GetActualDbgInfo( pFileName, nLine ); +} + +// Updates stats +void CValidateAlloc::RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ) +{ + g_pActualAlloc->RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ); +} + +void CValidateAlloc::RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ) +{ + g_pActualAlloc->RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ); +} + +void CValidateAlloc::CompactHeap() +{ + g_pActualAlloc->CompactHeap(); +} + +MemAllocFailHandler_t CValidateAlloc::SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ) +{ + return g_pActualAlloc->SetAllocFailHandler( pfnMemAllocFailHandler ); +} + +#endif // TIER0_VALIDATE_HEAP + +#endif // STEAM diff --git a/external/vpc/tier0/minidump.cpp b/external/vpc/tier0/minidump.cpp new file mode 100644 index 0000000..7d2a85b --- /dev/null +++ b/external/vpc/tier0/minidump.cpp @@ -0,0 +1,317 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include "pch_tier0.h" +#include "tier0/minidump.h" +#include "tier0/platform.h" + + +#if defined( _WIN32 ) && !defined(_X360 ) && ( _MSC_VER >= 1300 ) + +#include "tier0/valve_off.h" +#define WIN_32_LEAN_AND_MEAN +#define _WIN32_WINNT 0x0403 +#include <windows.h> +#include <time.h> +#include <dbghelp.h> + +#endif + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +#if defined( _WIN32 ) && !defined( _X360 ) + +#if _MSC_VER >= 1300 + +// MiniDumpWriteDump() function declaration (so we can just get the function directly from windows) +typedef BOOL (WINAPI *MINIDUMPWRITEDUMP) + ( + HANDLE hProcess, + DWORD dwPid, + HANDLE hFile, + MINIDUMP_TYPE DumpType, + CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, + CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, + CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam + ); + + +// true if we're currently writing a minidump caused by an assert +static bool g_bWritingNonfatalMinidump = false; +// counter used to make sure minidump names are unique +static int g_nMinidumpsWritten = 0; + +//----------------------------------------------------------------------------- +// Purpose: Creates a new file and dumps the exception info into it +// Input : uStructuredExceptionCode - windows exception code, unused. +// pExceptionInfo - call stack. +// minidumpType - type of minidump to write. +// ptchMinidumpFileNameBuffer - if not-NULL points to a writable tchar buffer +// of length at least _MAX_PATH to contain the name +// of the written minidump file on return. +//----------------------------------------------------------------------------- +bool WriteMiniDumpUsingExceptionInfo( + unsigned int uStructuredExceptionCode, + ExceptionInfo_t * pExceptionInfo, + uint32 minidumpType, + tchar *ptchMinidumpFileNameBuffer /* = NULL */ + ) +{ + if ( ptchMinidumpFileNameBuffer ) + { + *ptchMinidumpFileNameBuffer = tchar( 0 ); + } + + // get the function pointer directly so that we don't have to include the .lib, and that + // we can easily change it to using our own dll when this code is used on win98/ME/2K machines + HMODULE hDbgHelpDll = ::LoadLibrary( "DbgHelp.dll" ); + if ( !hDbgHelpDll ) + return false; + + bool bReturnValue = false; + MINIDUMPWRITEDUMP pfnMiniDumpWrite = (MINIDUMPWRITEDUMP) ::GetProcAddress( hDbgHelpDll, "MiniDumpWriteDump" ); + + if ( pfnMiniDumpWrite ) + { + // create a unique filename for the minidump based on the current time and module name + struct tm curtime; + Plat_GetLocalTime( &curtime ); + ++g_nMinidumpsWritten; + + // strip off the rest of the path from the .exe name + tchar rgchModuleName[MAX_PATH]; +#ifdef TCHAR_IS_WCHAR + ::GetModuleFileNameW( NULL, rgchModuleName, sizeof(rgchModuleName) / sizeof(tchar) ); +#else + ::GetModuleFileName( NULL, rgchModuleName, sizeof(rgchModuleName) / sizeof(tchar) ); +#endif + tchar *pch = _tcsrchr( rgchModuleName, '.' ); + if ( pch ) + { + *pch = 0; + } + pch = _tcsrchr( rgchModuleName, '\\' ); + if ( pch ) + { + // move past the last slash + pch++; + } + else + { + pch = _T("unknown"); + } + + + // can't use the normal string functions since we're in tier0 + tchar rgchFileName[MAX_PATH]; + _sntprintf( rgchFileName, sizeof(rgchFileName) / sizeof(tchar), + _T("%s_%s_%d%.2d%2d%.2d%.2d%.2d_%d.mdmp"), + pch, + g_bWritingNonfatalMinidump ? "assert" : "crash", + curtime.tm_year + 1900, /* Year less 2000 */ + curtime.tm_mon + 1, /* month (0 - 11 : 0 = January) */ + curtime.tm_mday, /* day of month (1 - 31) */ + curtime.tm_hour, /* hour (0 - 23) */ + curtime.tm_min, /* minutes (0 - 59) */ + curtime.tm_sec, /* seconds (0 - 59) */ + g_nMinidumpsWritten // ensures the filename is unique + ); + + BOOL bMinidumpResult = FALSE; +#ifdef TCHAR_IS_WCHAR + HANDLE hFile = ::CreateFileW( rgchFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); +#else + HANDLE hFile = ::CreateFile( rgchFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); +#endif + + if ( hFile ) + { + // dump the exception information into the file + _MINIDUMP_EXCEPTION_INFORMATION ExInfo; + ExInfo.ThreadId = ::GetCurrentThreadId(); + ExInfo.ExceptionPointers = (PEXCEPTION_POINTERS)pExceptionInfo; + ExInfo.ClientPointers = FALSE; + + bMinidumpResult = (*pfnMiniDumpWrite)( ::GetCurrentProcess(), ::GetCurrentProcessId(), hFile, (MINIDUMP_TYPE)minidumpType, &ExInfo, NULL, NULL ); + ::CloseHandle( hFile ); + + if ( bMinidumpResult ) + { + bReturnValue = true; + + if ( ptchMinidumpFileNameBuffer ) + { + // Copy the file name from "pSrc = rgchFileName" into "pTgt = ptchMinidumpFileNameBuffer" + tchar *pTgt = ptchMinidumpFileNameBuffer; + tchar const *pSrc = rgchFileName; + while ( ( *( pTgt ++ ) = *( pSrc ++ ) ) != tchar( 0 ) ) + continue; + } + } + + // fall through to trying again + } + + // mark any failed minidump writes by renaming them + if ( !bMinidumpResult ) + { + tchar rgchFailedFileName[MAX_PATH]; + _sntprintf( rgchFailedFileName, sizeof(rgchFailedFileName) / sizeof(tchar), "(failed)%s", rgchFileName ); + rename( rgchFileName, rgchFailedFileName ); + } + } + + ::FreeLibrary( hDbgHelpDll ); + + // call the log flush function if one is registered to try to flush any logs + //CallFlushLogFunc(); + + return bReturnValue; +} + + +void InternalWriteMiniDumpUsingExceptionInfo( unsigned int uStructuredExceptionCode, ExceptionInfo_t * pExceptionInfo ) +{ + // First try to write it with all the indirectly referenced memory (ie: a large file). + // If that doesn't work, then write a smaller one. + uint32 iType = MINIDUMP_WithDataSegs | MINIDUMP_WithIndirectlyReferencedMemory; + if ( !WriteMiniDumpUsingExceptionInfo( uStructuredExceptionCode, pExceptionInfo, iType ) ) + { + iType = MINIDUMP_WithDataSegs; + WriteMiniDumpUsingExceptionInfo( uStructuredExceptionCode, pExceptionInfo, iType ); + } +} + +// minidump function to use +static FnMiniDump g_pfnWriteMiniDump = InternalWriteMiniDumpUsingExceptionInfo; + +//----------------------------------------------------------------------------- +// Purpose: Set a function to call which will write our minidump, overriding +// the default function +// Input : pfn - Pointer to minidump function to set +// Output : Previously set function +//----------------------------------------------------------------------------- +FnMiniDump SetMiniDumpFunction( FnMiniDump pfn ) +{ + FnMiniDump pfnTemp = g_pfnWriteMiniDump; + g_pfnWriteMiniDump = pfn; + return pfnTemp; +} + + +//----------------------------------------------------------------------------- +// Unhandled exceptions +//----------------------------------------------------------------------------- +static FnMiniDump g_UnhandledExceptionFunction; +static LONG STDCALL ValveUnhandledExceptionFilter( _EXCEPTION_POINTERS* pExceptionInfo ) +{ + uint uStructuredExceptionCode = pExceptionInfo->ExceptionRecord->ExceptionCode; + g_UnhandledExceptionFunction( uStructuredExceptionCode, (ExceptionInfo_t*)pExceptionInfo ); + return EXCEPTION_CONTINUE_SEARCH; +} + +void MinidumpSetUnhandledExceptionFunction( FnMiniDump pfn ) +{ + g_UnhandledExceptionFunction = pfn; + SetUnhandledExceptionFilter( ValveUnhandledExceptionFilter ); +} + + +//----------------------------------------------------------------------------- +// Purpose: writes out a minidump from the current process +//----------------------------------------------------------------------------- +typedef void (*FnMiniDumpInternal_t)( unsigned int uStructuredExceptionCode, _EXCEPTION_POINTERS * pExceptionInfo ); + +void WriteMiniDump() +{ + // throw an exception so we can catch it and get the stack info + g_bWritingNonfatalMinidump = true; + __try + { + ::RaiseException + ( + 0, // dwExceptionCode + EXCEPTION_NONCONTINUABLE, // dwExceptionFlags + 0, // nNumberOfArguments, + NULL // const ULONG_PTR* lpArguments + ); + + // Never get here (non-continuable exception) + } + // Write the minidump from inside the filter (GetExceptionInformation() is only + // valid in the filter) + __except ( g_pfnWriteMiniDump( 0, (ExceptionInfo_t*)GetExceptionInformation() ), EXCEPTION_EXECUTE_HANDLER ) + { + } + g_bWritingNonfatalMinidump = false; +} + +PLATFORM_OVERLOAD bool g_bInException = false; +#include <eh.h> + +//----------------------------------------------------------------------------- +// Purpose: Catches and writes out any exception throw by the specified function +//----------------------------------------------------------------------------- +void CatchAndWriteMiniDump( FnWMain pfn, int argc, tchar *argv[] ) +{ + if ( Plat_IsInDebugSession() ) + { + // don't mask exceptions when running in the debugger + pfn( argc, argv ); + } + else + { + try + { +#pragma warning(push) +#pragma warning(disable : 4535) // warning C4535: calling _set_se_translator() requires /EHa + _set_se_translator( (FnMiniDumpInternal_t)g_pfnWriteMiniDump ); +#pragma warning(pop) + pfn( argc, argv ); + } + catch (...) + { + g_bInException = true; + Log_Msg( LOG_CONSOLE, _T("Fatal exception caught, minidump written\n") ); + // handle everything and just quit, we've already written out our minidump + } + } +} + +#else + +PLATFORM_INTERFACE void WriteMiniDump() +{ +} + +PLATFORM_INTERFACE void CatchAndWriteMiniDump( FnWMain pfn, int argc, tchar *argv[] ) +{ + pfn( argc, argv ); +} + +#endif +#elif defined(_X360 ) +PLATFORM_INTERFACE void WriteMiniDump() +{ +#if !defined( _CERT ) + DmCrashDump(false); +#endif +} + +#else // !_WIN32 + +PLATFORM_INTERFACE void WriteMiniDump() +{ +} + +PLATFORM_INTERFACE void CatchAndWriteMiniDump( FnWMain pfn, int argc, tchar *argv[] ) +{ + pfn( argc, argv ); +} + +#endif diff --git a/external/vpc/tier0/pch_tier0.cpp b/external/vpc/tier0/pch_tier0.cpp new file mode 100644 index 0000000..1cf6ecc --- /dev/null +++ b/external/vpc/tier0/pch_tier0.cpp @@ -0,0 +1,11 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + + +#include "pch_tier0.h" + + diff --git a/external/vpc/tier0/pch_tier0.h b/external/vpc/tier0/pch_tier0.h new file mode 100644 index 0000000..6156ad4 --- /dev/null +++ b/external/vpc/tier0/pch_tier0.h @@ -0,0 +1,49 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $Workfile: $ +// $NoKeywords: $ +//===========================================================================// + + +#if defined( PLATFORM_WINDOWS_PC ) +#define WIN32_LEAN_AND_MEAN +#define _WIN32_WINNT 0x0403 +#include <windows.h> +#elif defined( _PS3 ) +#include <cellstatus.h> +#include <sys/prx.h> +#endif + + + +#include "tier0/platform.h" + +// First include standard libraries +#include "tier0/valve_off.h" +#include <assert.h> +#include <stdio.h> +#include <ctype.h> +#include <math.h> +#include <ctype.h> +#include <limits.h> + +#include <stddef.h> +#ifdef PLATFORM_POSIX +#include <unistd.h> +#include <ctype.h> +#include <limits.h> +#define _MAX_PATH PATH_MAX +#endif + +#include "tier0/valve_on.h" + +#include "tier0/basetypes.h" +#include "tier0/dbgflag.h" +#include "tier0/dbg.h" +#ifdef STEAM +#include "tier0/memhook.h" +#endif +#include "tier0/validator.h" +#include "tier0/fasttimer.h" diff --git a/external/vpc/tier0/platform.cpp b/external/vpc/tier0/platform.cpp new file mode 100644 index 0000000..15cb1f6 --- /dev/null +++ b/external/vpc/tier0/platform.cpp @@ -0,0 +1,559 @@ +//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $NoKeywords: $ +//===========================================================================// + +#include "pch_tier0.h" +#include <time.h> + +#if defined(_WIN32) && !defined(_X360) +#define WINDOWS_LEAN_AND_MEAN +#define _WIN32_WINNT 0x0403 +#include <windows.h> +#endif +#include <errno.h> +#include <assert.h> +#include "tier0/platform.h" +#if defined( _X360 ) +#include "xbox/xbox_console.h" +#endif +#include "tier0/threadtools.h" + +#include "tier0/memalloc.h" + +#if defined( _PS3 ) +#include <cell/fios/fios_common.h> +#include <cell/fios/fios_memory.h> +#include <cell/fios/fios_configuration.h> +#include <sys/process.h> + +#if !defined(_CERT) +#include "sn/LibSN.h" +#endif + +/* +#include <sys/types.h> +#include <sys/process.h> +#include <sys/prx.h> + +#include <sysutil/sysutil_syscache.h> + +#include <cell/sysmodule.h> +*/ +#include <cell/fios/fios_time.h> +#endif // _PS3 + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#ifdef _WIN32 +static LARGE_INTEGER g_PerformanceFrequency; +static LARGE_INTEGER g_MSPerformanceFrequency; +static LARGE_INTEGER g_ClockStart; +static bool s_bTimeInitted; +#endif + +// Benchmark mode uses this heavy-handed method +static bool g_bBenchmarkMode = false; +#ifdef _WIN32 +static double g_FakeBenchmarkTime = 0; +static double g_FakeBenchmarkTimeInc = 1.0 / 66.0; +#endif + +static CThreadFastMutex g_LocalTimeMutex; + + +#ifdef _WIN32 +static void InitTime() +{ + if( !s_bTimeInitted ) + { + s_bTimeInitted = true; + QueryPerformanceFrequency(&g_PerformanceFrequency); + g_MSPerformanceFrequency.QuadPart = g_PerformanceFrequency.QuadPart / 1000; + QueryPerformanceCounter(&g_ClockStart); + } +} +#endif + +bool Plat_IsInBenchmarkMode() +{ + return g_bBenchmarkMode; +} + +void Plat_SetBenchmarkMode( bool bBenchmark ) +{ + g_bBenchmarkMode = bBenchmark; +} + +#ifdef _PS3 +cell::fios::abstime_t g_fiosLaunchTime = 0; +#endif + + +double Plat_FloatTime() +{ +#ifdef _WIN32 + if (! s_bTimeInitted ) + InitTime(); + if ( g_bBenchmarkMode ) + { + g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc; + return g_FakeBenchmarkTime; + } + + LARGE_INTEGER CurrentTime; + + QueryPerformanceCounter( &CurrentTime ); + + double fRawSeconds = (double)( CurrentTime.QuadPart - g_ClockStart.QuadPart ) / (double)(g_PerformanceFrequency.QuadPart); + + return fRawSeconds; +#else + return cell::fios::FIOSAbstimeToMicroseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime ) * 1e-6; +#endif +} + + +uint32 Plat_MSTime() +{ +#ifdef _WIN32 + if (! s_bTimeInitted ) + InitTime(); + if ( g_bBenchmarkMode ) + { + g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc; + return (uint32)(g_FakeBenchmarkTime * 1000.0); + } + + LARGE_INTEGER CurrentTime; + + QueryPerformanceCounter( &CurrentTime ); + + return (uint32) ( ( CurrentTime.QuadPart - g_ClockStart.QuadPart ) / g_MSPerformanceFrequency.QuadPart); +#elif defined(_PS3) + return (uint32) cell::fios::FIOSAbstimeToMilliseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime ); +#else + #error +#endif +} + +uint64 Timer_GetTimeUS() +{ +#ifdef _PS3 + return cell::fios::FIOSAbstimeToMicroseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime ); +#else + return uint64( Plat_FloatTime() * 1000000 ); +#endif +} + +uint64 Plat_GetClockStart() +{ +#if defined( _WIN32 ) + if ( !s_bTimeInitted ) + InitTime(); + + return g_ClockStart.QuadPart; +#elif defined( _PS3 ) + return g_fiosLaunchTime; +#else + return 0; +#endif +} + +void Plat_GetLocalTime( struct tm *pNow ) +{ + // We just provide a wrapper on this function so we can protect access to time() everywhere. + time_t ltime; + time( <ime ); + + Plat_ConvertToLocalTime( ltime, pNow ); +} + +void Plat_ConvertToLocalTime( uint64 nTime, struct tm *pNow ) +{ + // Since localtime() returns a global, we need to protect against multiple threads stomping it. + g_LocalTimeMutex.Lock(); + + time_t ltime = (time_t)nTime; + tm *pTime = localtime( <ime ); + if ( pTime ) + *pNow = *pTime; + else + memset( pNow, 0, sizeof( *pNow ) ); + + g_LocalTimeMutex.Unlock(); +} + +void Plat_GetTimeString( struct tm *pTime, char *pOut, int nMaxBytes ) +{ + g_LocalTimeMutex.Lock(); + + char *pStr = asctime( pTime ); + strncpy( pOut, pStr, nMaxBytes ); + pOut[nMaxBytes-1] = 0; + + g_LocalTimeMutex.Unlock(); +} + + +void Plat_gmtime( uint64 nTime, struct tm *pTime ) +{ + time_t tmtTime = nTime; +#ifdef _PS3 + struct tm * tmp = gmtime( &tmtTime ); + * pTime = * tmp; +#else + gmtime_s( pTime, &tmtTime ); +#endif +} + +time_t Plat_timegm( struct tm *timeptr ) +{ +#ifndef _GAMECONSOLE + return _mkgmtime( timeptr ); +#else + int *pnCrashHereBecauseConsolesDontSupportMkGmTime = 0; + *pnCrashHereBecauseConsolesDontSupportMkGmTime = 0; + return 0; +#endif +} + +void Plat_GetModuleFilename( char *pOut, int nMaxBytes ) +{ +#ifdef PLATFORM_WINDOWS_PC + GetModuleFileName( NULL, pOut, nMaxBytes ); + if ( GetLastError() != ERROR_SUCCESS ) + Error( "Plat_GetModuleFilename: The buffer given is too small (%d bytes).", nMaxBytes ); +#elif PLATFORM_X360 + pOut[0] = 0x00; // return null string on Xbox 360 +#else + // We shouldn't need this on POSIX. + Assert( false ); + pOut[0] = 0x00; // Null the returned string in release builds +#endif +} + +void Plat_ExitProcess( int nCode ) +{ +#if defined( _WIN32 ) && !defined( _X360 ) + // We don't want global destructors in our process OR in any DLL to get executed. + // _exit() avoids calling global destructors in our module, but not in other DLLs. + TerminateProcess( GetCurrentProcess(), nCode ); +#elif defined(_PS3) + // We do not use this path to exit on PS3 (naturally), rather we want a clear crash: + int *x = NULL; *x = 1; +#else + _exit( nCode ); +#endif +} + +void GetCurrentDate( int *pDay, int *pMonth, int *pYear ) +{ + struct tm long_time; + Plat_GetLocalTime( &long_time ); + + *pDay = long_time.tm_mday; + *pMonth = long_time.tm_mon + 1; + *pYear = long_time.tm_year + 1900; +} + +// Wraps the thread-safe versions of asctime. buf must be at least 26 bytes +char *Plat_asctime( const struct tm *tm, char *buf, size_t bufsize ) +{ +#ifdef _PS3 + snprintf( buf, bufsize, "%s", asctime(tm) ); + return buf; +#else + if ( EINVAL == asctime_s( buf, bufsize, tm ) ) + return NULL; + else + return buf; +#endif +} + + +// Wraps the thread-safe versions of ctime. buf must be at least 26 bytes +char *Plat_ctime( const time_t *timep, char *buf, size_t bufsize ) +{ +#ifdef _PS3 + snprintf( buf, bufsize, "%s", ctime( timep ) ); + return buf; +#else + if ( EINVAL == ctime_s( buf, bufsize, timep ) ) + return NULL; + else + return buf; +#endif +} + + +// Wraps the thread-safe versions of gmtime +struct tm *Plat_gmtime( const time_t *timep, struct tm *result ) +{ +#ifdef _PS3 + *result = *gmtime( timep ); + return result; +#else + if ( EINVAL == gmtime_s( result, timep ) ) + return NULL; + else + return result; +#endif +} + + +// Wraps the thread-safe versions of localtime +struct tm *Plat_localtime( const time_t *timep, struct tm *result ) +{ +#ifdef _PS3 + *result = *localtime( timep ); + return result; +#else + if ( EINVAL == localtime_s( result, timep ) ) + return NULL; + else + return result; +#endif +} + +bool vtune( bool resume ) +{ +#if IS_WINDOWS_PC + static bool bInitialized = false; + static void (__cdecl *VTResume)(void) = NULL; + static void (__cdecl *VTPause) (void) = NULL; + + // Grab the Pause and Resume function pointers from the VTune DLL the first time through: + if( !bInitialized ) + { + bInitialized = true; + + HINSTANCE pVTuneDLL = LoadLibrary( "vtuneapi.dll" ); + + if( pVTuneDLL ) + { + VTResume = (void(__cdecl *)())GetProcAddress( pVTuneDLL, "VTResume" ); + VTPause = (void(__cdecl *)())GetProcAddress( pVTuneDLL, "VTPause" ); + } + } + + // Call the appropriate function, as indicated by the argument: + if( resume && VTResume ) + { + VTResume(); + return true; + + } + else if( !resume && VTPause ) + { + VTPause(); + return true; + } +#endif + return false; +} + +bool Plat_IsInDebugSession() +{ +#if defined( _X360 ) + return (XBX_IsDebuggerPresent() != 0); +#elif defined( _WIN32 ) + return (IsDebuggerPresent() != 0); +#elif defined( _PS3 ) && !defined(_CERT) + return snIsDebuggerPresent(); +#else + return false; +#endif +} + +void Plat_DebugString( const char * psz ) +{ +#ifdef _CERT + return; // do nothing! +#endif + +#if defined( _X360 ) + XBX_OutputDebugString( psz ); +#elif defined( _WIN32 ) + ::OutputDebugStringA( psz ); +#elif defined(_PS3) + printf("%s",psz); +#else + // do nothing? +#endif +} + + +#if defined( PLATFORM_WINDOWS_PC ) +void Plat_MessageBox( const char *pTitle, const char *pMessage ) +{ + MessageBox( NULL, pMessage, pTitle, MB_OK ); +} +#endif + +PlatOSVersion_t Plat_GetOSVersion() +{ +#ifdef PLATFORM_WINDOWS_PC + OSVERSIONINFO info; + info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + if ( GetVersionEx( &info ) ) + return (PlatOSVersion_t)info.dwMajorVersion; + return PLAT_OS_VERSION_UNKNOWN; +#elif defined( PLATFORM_X360 ) + return PLAT_OS_VERSION_XBOX360; +#else + return PLAT_OS_VERSION_UNKNOWN; +#endif +} + +#if defined( PLATFORM_PS3 ) +//copied from platform_posix.cpp +static char g_CmdLine[ 2048 ] = ""; +PLATFORM_INTERFACE void Plat_SetCommandLine( const char *cmdLine ) +{ + strncpy( g_CmdLine, cmdLine, sizeof(g_CmdLine) ); + g_CmdLine[ sizeof(g_CmdLine) -1 ] = 0; +} +#endif + +PLATFORM_INTERFACE const tchar *Plat_GetCommandLine() +{ +#if defined( _PS3 ) +#pragma message("Plat_GetCommandLine() not implemented on PS3") // **** + return g_CmdLine; +#elif defined( TCHAR_IS_WCHAR ) + return GetCommandLineW(); +#else + return GetCommandLine(); +#endif +} + +PLATFORM_INTERFACE const char *Plat_GetCommandLineA() +{ +#if defined( _PS3 ) +#pragma message("Plat_GetCommandLineA() not implemented on PS3") // **** + return g_CmdLine; +#else + return GetCommandLineA(); +#endif +} + + +//----------------------------------------------------------------------------- +// Dynamically load a function +//----------------------------------------------------------------------------- +#ifdef PLATFORM_WINDOWS + +void *Plat_GetProcAddress( const char *pszModule, const char *pszName ) +{ + HMODULE hModule = ::LoadLibrary( pszModule ); + return ( hModule ) ? ::GetProcAddress( hModule, pszName ) : NULL; +} + +#endif + + + +// -------------------------------------------------------------------------------------------------- // +// Memory stuff. +// +// DEPRECATED. Still here to support binary back compatability of tier0.dll +// +// -------------------------------------------------------------------------------------------------- // +#ifndef _X360 +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + +typedef void (*Plat_AllocErrorFn)( unsigned long size ); + +void Plat_DefaultAllocErrorFn( unsigned long size ) +{ +} + +Plat_AllocErrorFn g_AllocError = Plat_DefaultAllocErrorFn; +#endif + +#if !defined( _X360 ) && !defined( _PS3 ) + + +CRITICAL_SECTION g_AllocCS; +class CAllocCSInit +{ +public: + CAllocCSInit() + { + InitializeCriticalSection( &g_AllocCS ); + } +} g_AllocCSInit; + + +PLATFORM_INTERFACE void* Plat_Alloc( unsigned long size ) +{ + EnterCriticalSection( &g_AllocCS ); +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + void *pRet = MemAlloc_Alloc( size ); +#else + void *pRet = malloc( size ); +#endif + LeaveCriticalSection( &g_AllocCS ); + if ( pRet ) + { + return pRet; + } + else + { +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + g_AllocError( size ); +#endif + return 0; + } +} + + +PLATFORM_INTERFACE void* Plat_Realloc( void *ptr, unsigned long size ) +{ + EnterCriticalSection( &g_AllocCS ); +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + void *pRet = g_pMemAlloc->Realloc( ptr, size ); +#else + void *pRet = realloc( ptr, size ); +#endif + LeaveCriticalSection( &g_AllocCS ); + if ( pRet ) + { + return pRet; + } + else + { +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + g_AllocError( size ); +#endif + return 0; + } +} + + +PLATFORM_INTERFACE void Plat_Free( void *ptr ) +{ + EnterCriticalSection( &g_AllocCS ); +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + g_pMemAlloc->Free( ptr ); +#else + free( ptr ); +#endif + LeaveCriticalSection( &g_AllocCS ); +} + +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) +PLATFORM_INTERFACE void Plat_SetAllocErrorFn( Plat_AllocErrorFn fn ) +{ + g_AllocError = fn; +} +#endif + +#endif + + +#endif
\ No newline at end of file diff --git a/external/vpc/tier0/platform_posix.cpp b/external/vpc/tier0/platform_posix.cpp new file mode 100644 index 0000000..90a8c76 --- /dev/null +++ b/external/vpc/tier0/platform_posix.cpp @@ -0,0 +1,426 @@ +//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "pch_tier0.h" +#include "tier0/platform.h" +#include "tier0/memalloc.h" +#include "tier0/dbg.h" +#include "tier0/threadtools.h" + +#include <sys/time.h> +#include <unistd.h> + +#ifdef OSX +#include <sys/sysctl.h> +#include <mach/mach.h> +#include <mach/mach_time.h> +#endif + + +static bool g_bBenchmarkMode = false; +static double g_FakeBenchmarkTime = 0; +static double g_FakeBenchmarkTimeInc = 1.0 / 66.0; + + +bool Plat_IsInBenchmarkMode() +{ + return g_bBenchmarkMode; +} + +void Plat_SetBenchmarkMode( bool bBenchmark ) +{ + g_bBenchmarkMode = bBenchmark; +} + + + +#ifdef OSX + +static uint64 start_time = 0; +static mach_timebase_info_data_t sTimebaseInfo; +static double conversion = 0.0; + +void InitTime() +{ + start_time = mach_absolute_time(); + mach_timebase_info(&sTimebaseInfo); + conversion = 1e-9 * (double) sTimebaseInfo.numer / (double) sTimebaseInfo.denom; +} + +uint64 Plat_GetClockStart() +{ + if ( !start_time ) + { + InitTime(); + } + + return start_time * conversion; +} + +double Plat_FloatTime() +{ + if ( g_bBenchmarkMode ) + { + g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc; + return g_FakeBenchmarkTime; + } + + if ( !start_time ) + { + InitTime(); + } + + uint64 now = mach_absolute_time(); + + return ( now - start_time ) * conversion; +} +#else + +static int secbase = 0; + +void InitTime( struct timeval &tp ) +{ + secbase = tp.tv_sec; +} + +uint64 Plat_GetClockStart() +{ + if ( !secbase ) + { + struct timeval tp; + gettimeofday( &tp, NULL ); + InitTime( tp ); + } + + return secbase; +} + + +double Plat_FloatTime() +{ + if ( g_bBenchmarkMode ) + { + g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc; + return g_FakeBenchmarkTime; + } + + struct timeval tp; + + gettimeofday( &tp, NULL ); + + if ( !secbase ) + { + InitTime( tp ); + return ( tp.tv_usec / 1000000.0 ); + } + + return (( tp.tv_sec - secbase ) + tp.tv_usec / 1000000.0 ); +} +#endif + + +uint32 Plat_MSTime() +{ + if ( g_bBenchmarkMode ) + { + g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc; + return (unsigned long)(g_FakeBenchmarkTime * 1000.0); + } + + struct timeval tp; + static int secbase = 0; + + gettimeofday( &tp, NULL ); + + if ( !secbase ) + { + secbase = tp.tv_sec; + return ( tp.tv_usec / 1000.0 ); + } + + return (unsigned long)(( tp.tv_sec - secbase )*1000.0 + tp.tv_usec / 1000.0 ); + +} + +// Wraps the thread-safe versions of asctime. buf must be at least 26 bytes +char *Plat_asctime( const struct tm *tm, char *buf, size_t bufsize ) +{ + return asctime_r( tm, buf ); +} + +// Wraps the thread-safe versions of ctime. buf must be at least 26 bytes +char *Plat_ctime( const time_t *timep, char *buf, size_t bufsize ) +{ + return ctime_r( timep, buf ); +} + +// Wraps the thread-safe versions of gmtime +struct tm *Plat_gmtime( const time_t *timep, struct tm *result ) +{ + return gmtime_r( timep, result ); +} + +time_t Plat_timegm( struct tm *timeptr ) +{ + return timegm( timeptr ); +} + +// Wraps the thread-safe versions of localtime +struct tm *Plat_localtime( const time_t *timep, struct tm *result ) +{ + return localtime_r( timep, result ); +} + +bool vtune( bool resume ) +{ +} + + +// -------------------------------------------------------------------------------------------------- // +// Memory stuff. +// -------------------------------------------------------------------------------------------------- // + +PLATFORM_INTERFACE void Plat_DefaultAllocErrorFn( unsigned long size ) +{ +} + +typedef void (*Plat_AllocErrorFn)( unsigned long size ); +Plat_AllocErrorFn g_AllocError = Plat_DefaultAllocErrorFn; + +PLATFORM_INTERFACE void* Plat_Alloc( unsigned long size ) +{ + void *pRet = g_pMemAlloc->Alloc( size ); + if ( pRet ) + { + return pRet; + } + else + { + g_AllocError( size ); + return 0; + } +} + + +PLATFORM_INTERFACE void* Plat_Realloc( void *ptr, unsigned long size ) +{ + void *pRet = g_pMemAlloc->Realloc( ptr, size ); + if ( pRet ) + { + return pRet; + } + else + { + g_AllocError( size ); + return 0; + } +} + + +PLATFORM_INTERFACE void Plat_Free( void *ptr ) +{ +#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE) + g_pMemAlloc->Free( ptr ); +#else + free( ptr ); +#endif +} + + +PLATFORM_INTERFACE void Plat_SetAllocErrorFn( Plat_AllocErrorFn fn ) +{ + g_AllocError = fn; +} + +static char g_CmdLine[ 2048 ]; +PLATFORM_INTERFACE void Plat_SetCommandLine( const char *cmdLine ) +{ + strncpy( g_CmdLine, cmdLine, sizeof(g_CmdLine) ); + g_CmdLine[ sizeof(g_CmdLine) -1 ] = 0; +} + +PLATFORM_INTERFACE void Plat_SetCommandLineArgs( char **argv, int argc ) +{ + g_CmdLine[0] = 0; + for ( int i = 0; i < argc; i++ ) + { + strncat( g_CmdLine, argv[i], sizeof(g_CmdLine) - strlen(g_CmdLine) ); + } + + g_CmdLine[ sizeof(g_CmdLine) -1 ] = 0; +} + + +PLATFORM_INTERFACE const tchar *Plat_GetCommandLine() +{ + return g_CmdLine; +} + +PLATFORM_INTERFACE bool Is64BitOS() +{ +#if defined OSX + return true; +#elif defined LINUX + FILE *pp = popen( "uname -m", "r" ); + if ( pp != NULL ) + { + char rgchArchString[256]; + fgets( rgchArchString, sizeof( rgchArchString ), pp ); + pclose( pp ); + if ( !strncasecmp( rgchArchString, "x86_64", strlen( "x86_64" ) ) ) + return true; + } +#else + Assert( !"implement Is64BitOS" ); +#endif + return false; +} + + +bool Plat_IsInDebugSession() +{ +#if defined(OSX) + int mib[4]; + struct kinfo_proc info; + size_t size; + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PID; + mib[3] = getpid(); + size = sizeof(info); + info.kp_proc.p_flag = 0; + sysctl(mib,4,&info,&size,NULL,0); + bool result = ((info.kp_proc.p_flag & P_TRACED) == P_TRACED); + return result; +#elif defined(LINUX) + char s[256]; + snprintf(s, 256, "/proc/%d/cmdline", getppid()); + FILE * fp = fopen(s, "r"); + if (fp != NULL) + { + fread(s, 256, 1, fp); + fclose(fp); + return (0 == strncmp(s, "gdb", 3)); + } + return false; +#endif +} + + + +void Plat_ExitProcess( int nCode ) +{ + _exit( nCode ); +} + +static int s_nWatchDogTimerTimeScale = 0; +static bool s_bInittedWD = false; + + +static void InitWatchDogTimer( void ) +{ + if( !strstr( g_CmdLine, "-nowatchdog" ) ) + { +#ifdef _DEBUG + s_nWatchDogTimerTimeScale = 10; // debug is slow +#else + s_nWatchDogTimerTimeScale = 1; +#endif + + } + +} + +// watchdog timer support +void BeginWatchdogTimer( int nSecs ) +{ + if (! s_bInittedWD ) + { + s_bInittedWD = true; + InitWatchDogTimer(); + } + nSecs *= s_nWatchDogTimerTimeScale; + nSecs = MIN( nSecs, 5 * 60 ); // no more than 5 minutes no matter what + if ( nSecs ) + alarm( nSecs ); +} + +void EndWatchdogTimer( void ) +{ + alarm( 0 ); +} + +static CThreadMutex g_LocalTimeMutex; + + +void Plat_GetLocalTime( struct tm *pNow ) +{ + // We just provide a wrapper on this function so we can protect access to time() everywhere. + time_t ltime; + time( <ime ); + + Plat_ConvertToLocalTime( ltime, pNow ); +} + +void Plat_ConvertToLocalTime( uint64 nTime, struct tm *pNow ) +{ + // Since localtime() returns a global, we need to protect against multiple threads stomping it. + g_LocalTimeMutex.Lock(); + + time_t ltime = (time_t)nTime; + tm *pTime = localtime( <ime ); + if ( pTime ) + *pNow = *pTime; + else + memset( pNow, 0, sizeof( *pNow ) ); + + g_LocalTimeMutex.Unlock(); +} + +void Plat_GetTimeString( struct tm *pTime, char *pOut, int nMaxBytes ) +{ + g_LocalTimeMutex.Lock(); + + char *pStr = asctime( pTime ); + strncpy( pOut, pStr, nMaxBytes ); + pOut[nMaxBytes-1] = 0; + + g_LocalTimeMutex.Unlock(); +} + + +void Plat_gmtime( uint64 nTime, struct tm *pTime ) +{ + time_t tmtTime = nTime; + struct tm * tmp = gmtime( &tmtTime ); + * pTime = * tmp; +} + +#ifdef LINUX +size_t ApproximateProcessMemoryUsage( void ) +{ + int nRet = 0; + FILE *pFile = fopen( "/proc/self/statm", "r" ); + if ( pFile ) + { + int nSize, nTotalProgramSize, nResident, nResidentSetSize, nShare, nSharedPagesTotal, nDummy0; + if ( fscanf( pFile, "%d %d %d %d %d %d %d", &nSize, &nTotalProgramSize, &nResident, &nResidentSetSize, &nShare, &nSharedPagesTotal, &nDummy0 ) ) + { + nRet = 4096 * nSize; + } + fclose( pFile ); + } + return nRet; +} +#else + +size_t ApproximateProcessMemoryUsage( void ) +{ + return 0; +} + +#endif diff --git a/external/vpc/tier0/pme.cpp b/external/vpc/tier0/pme.cpp new file mode 100644 index 0000000..23a5442 --- /dev/null +++ b/external/vpc/tier0/pme.cpp @@ -0,0 +1,162 @@ +//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +//===========================================================================// + +#include "tier0/platform.h" + +#include "pch_tier0.h" +#define WINDOWS_LEAN_AND_MEAN +#include <windows.h> + +#pragma warning( disable : 4530 ) // warning: exception handler -GX option + +#include "tier0/platform.h" +#include "tier0/vprof.h" +#include "tier0/pmelib.h" +#include "tier0/l2cache.h" +#include "tier0/dbg.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + + +//----------------------------------------------------------------------------- +// Purpose: Initialization +//----------------------------------------------------------------------------- +void InitPME( void ) +{ + bool bInit = false; + + PME *pPME = PME::Instance(); + if ( pPME ) + { + if ( pPME->GetVendor() != INTEL ) + return; + + if ( pPME->GetProcessorFamily() != PENTIUM4_FAMILY ) + return; + + pPME->SetProcessPriority( ProcessPriorityHigh ); + + bInit = true; + + DevMsg( 1, _T("PME Initialized.\n") ); + } + else + { + DevMsg( 1, _T("PME Uninitialized.\n") ); + } + +#ifdef VPROF_ENABLED + g_VProfCurrentProfile.PMEInitialized( bInit ); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: Shutdown +//----------------------------------------------------------------------------- +void ShutdownPME( void ) +{ + PME *pPME = PME::Instance(); + if ( pPME ) + { + pPME->SetProcessPriority( ProcessPriorityNormal ); + } + +#ifdef VPROF_ENABLED + g_VProfCurrentProfile.PMEInitialized( false ); +#endif +} + +//============================================================================= +// +// CL2Cache Code. +// + +static int s_nCreateCount = 0; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CL2Cache::CL2Cache() +{ + m_nID = s_nCreateCount++; + m_pL2CacheEvent = new P4Event_BSQ_cache_reference; + m_iL2CacheMissCount = 0; + m_i64Start = 0; + m_i64End = 0; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CL2Cache::~CL2Cache() +{ + if ( m_pL2CacheEvent ) + { + delete m_pL2CacheEvent; + m_pL2CacheEvent = NULL; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CL2Cache::Start( void ) +{ + if ( m_pL2CacheEvent ) + { + // Set this up to check for L2 cache misses. + m_pL2CacheEvent->eventMask->RD_2ndL_MISS = 1; + + // Set the event mask and set the capture mode. +// m_pL2CacheEvent->SetCaptureMode( USR_Only ); + m_pL2CacheEvent->SetCaptureMode( OS_and_USR ); + + // That's it, now sw capture events + m_pL2CacheEvent->StopCounter(); + m_pL2CacheEvent->ClearCounter(); + + m_pL2CacheEvent->StartCounter(); + m_i64Start = m_pL2CacheEvent->ReadCounter(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CL2Cache::End( void ) +{ + if ( m_pL2CacheEvent ) + { + // Stop the counter and find the delta. + m_i64End = m_pL2CacheEvent->ReadCounter(); + int64 i64Delta = m_i64End - m_i64Start; + m_pL2CacheEvent->StopCounter(); + + // Save the delta for later query. + m_iL2CacheMissCount = ( int )i64Delta; + } +} + +#pragma warning( default : 4530 ) + +#ifdef DBGFLAG_VALIDATE +//----------------------------------------------------------------------------- +// Purpose: Ensure that all of our internal structures are consistent, and +// account for all memory that we've allocated. +// Input: validator - Our global validator object +// pchName - Our name (typically a member var in our container) +//----------------------------------------------------------------------------- +void CL2Cache::Validate( CValidator &validator, tchar *pchName ) +{ + validator.Push( _T("CL2Cache"), this, pchName ); + + validator.ClaimMemory( m_pL2CacheEvent ); + + validator.Pop( ); +} +#endif // DBGFLAG_VALIDATE + diff --git a/external/vpc/tier0/pme_posix.cpp b/external/vpc/tier0/pme_posix.cpp new file mode 100644 index 0000000..ff782ce --- /dev/null +++ b/external/vpc/tier0/pme_posix.cpp @@ -0,0 +1,51 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include "tier0/platform.h" +#include "tier0/vprof.h" +#include "tier0/dbg.h" + +//----------------------------------------------------------------------------- +// Purpose: Initialization +//----------------------------------------------------------------------------- +void InitPME( void ) +{ +} + +//----------------------------------------------------------------------------- +// Purpose: Shutdown +//----------------------------------------------------------------------------- +void ShutdownPME( void ) +{ +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CL2Cache::CL2Cache() +{ +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CL2Cache::~CL2Cache() +{ +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CL2Cache::Start( void ) +{ +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CL2Cache::End( void ) +{ +} diff --git a/external/vpc/tier0/pmelib.cpp b/external/vpc/tier0/pmelib.cpp new file mode 100644 index 0000000..c4f1aad --- /dev/null +++ b/external/vpc/tier0/pmelib.cpp @@ -0,0 +1,665 @@ +//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $NoKeywords: $ +// +//===========================================================================// + +#ifdef _WIN32 +#include <windows.h> + +#pragma warning( disable : 4530 ) // warning: exception handler -GX option + +#include "tier0/valve_off.h" +#include "tier0/pmelib.h" +#if _MSC_VER >=1300 +#else +#include "winioctl.h" +#endif +#include "tier0/valve_on.h" + +#include "tier0/ioctlcodes.h" + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +PME* PME::_singleton = 0; + +// Single interface. +PME* PME::Instance() +{ + if (_singleton == 0) + { + _singleton = new PME; + } + return _singleton; +} + +//--------------------------------------------------------------------------- +// Open the device driver and detect the processor +//--------------------------------------------------------------------------- +HRESULT PME::Init( void ) +{ + OSVERSIONINFO OS; + + if ( bDriverOpen ) + return E_DRIVER_ALREADY_OPEN; + + switch( vendor ) + { + case INTEL: + case AMD: + break; + default: + bDriverOpen = FALSE; // not an Intel or Athlon processor so return false + return E_UNKNOWN_CPU_VENDOR; + } + + //----------------------------------------------------------------------- + // Get the operating system version + //----------------------------------------------------------------------- + OS.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); + GetVersionEx( &OS ); + + if ( OS.dwPlatformId == VER_PLATFORM_WIN32_NT ) + { + hFile = CreateFile( // WINDOWS NT + "\\\\.\\GDPERF", + GENERIC_READ, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + } + else + { + hFile = CreateFile( // WINDOWS 95 + "\\\\.\\GDPERF.VXD", + GENERIC_READ, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + } + + if (hFile == INVALID_HANDLE_VALUE ) + return E_CANT_OPEN_DRIVER; + + + bDriverOpen = TRUE; + + + //------------------------------------------------------------------- + // We have successfully opened the device driver, get the family + // of the processor. + //------------------------------------------------------------------- + + + + //------------------------------------------------------------------- + // We need to write to counter 0 on the pro family to enable both + // of the performance counters. We write to both so they start in a + // known state. For the pentium this is not necessary. + //------------------------------------------------------------------- + if (vendor == INTEL && version.Family == PENTIUMPRO_FAMILY) + { + SelectP5P6PerformanceEvent(P6_CLOCK, 0, TRUE, TRUE); + SelectP5P6PerformanceEvent(P6_CLOCK, 1, TRUE, TRUE); + } + + return S_OK; + + +} + + + +//--------------------------------------------------------------------------- +// Close the device driver +//--------------------------------------------------------------------------- +HRESULT PME::Close(void) +{ + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + bDriverOpen = false; + + if (hFile) // if we have no driver handle, return FALSE + { + HRESULT hr = CloseHandle(hFile); + + hFile = NULL; + return hr; + } + else + return E_DRIVER_NOT_OPEN; + + +} + +//--------------------------------------------------------------------------- +// Select the event to monitor with counter 0 +// +HRESULT PME::SelectP5P6PerformanceEvent(uint32 dw_event, uint32 dw_counter, + bool b_user, bool b_kernel) +{ + HRESULT hr = S_OK; + + if (dw_counter>1) // is the counter valid + return E_BAD_COUNTER; + + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + if ( ((dw_event>>28)&0xF) != (uint32)version.Family) + { + return E_ILLEGAL_OPERATION; // this operation is not for this processor + } + + if ( (((dw_event & 0x300)>>8) & (dw_counter+1)) == 0 ) + { + return E_ILLEGAL_OPERATION; // this operation is not for this counter + } + + switch(version.Family) + { + case PENTIUM_FAMILY: + { + uint64 i64_cesr; + int i_kernel_bit,i_user_bit; + BYTE u1_event = (BYTE)((dw_event & (0x3F0000))>>16); + + if (dw_counter==0) // the kernel and user mode bits depend on + { // counter being used. + i_kernel_bit = 6; + i_user_bit = 7; + } + else + { + i_kernel_bit = 22; + i_user_bit = 23; + } + + ReadMSR(0x11, &i64_cesr); // get current P5 event select (cesr) + + // top 32bits of cesr are not valid so ignore them + i64_cesr &= ((dw_counter == 0)?0xffff0000:0x0000ffff); + WriteMSR(0x11,i64_cesr); // stop the counter + WriteMSR((dw_counter==0)?0x12:0x13,0ui64); // clear the p.counter + + // set the user and kernel mode bits + i64_cesr |= ( b_user?(1<<7):0 ) | ( b_kernel?(1<<6):0 ); + + // is this the special P5 value that signals count clocks?? + if (u1_event == 0x3f) + { + WriteMSR(0x11, i64_cesr|0x100); // Count clocks + } + else + { + WriteMSR(0x11, i64_cesr|u1_event); // Count events + } + + } + break; + + case PENTIUMPRO_FAMILY: + + { + BYTE u1_event = (BYTE)((dw_event & (0xFF0000))>>16); + BYTE u1_mask = (BYTE)((dw_event & 0xFF)); + + // Event select 0 and 1 are identical. + hr = WriteMSR((dw_counter==0)?0x186:0x187, + + + uint64((u1_event | (b_user?(1<<16):0) | (b_kernel?(1<<17):0) | (1<<22) | (1<<18) | (u1_mask<<8)) ) + ); + } + break; + + case PENTIUM4_FAMILY: + // use the p4 path + break; + + default: + return E_UNKNOWN_CPU; + } + + return hr; +} + +//--------------------------------------------------------------------------- +// Read model specific register +//--------------------------------------------------------------------------- +HRESULT PME::ReadMSR(uint32 dw_reg, int64 * pi64_value) +{ + HRESULT hr; + DWORD dw_ret_len; + + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + hr = DeviceIoControl + ( + hFile, // Handle to device + (DWORD) IOCTL_READ_MSR, // IO Control code for Read + &dw_reg, // Input Buffer to driver. + sizeof(uint32), // Length of input buffer. + pi64_value, // Output Buffer from driver. + sizeof(int64), // Length of output buffer in bytes. + &dw_ret_len, // Bytes placed in output buffer. + NULL // NULL means wait till op. completes + ); + + if (hr == S_OK && dw_ret_len != sizeof(int64)) + hr = E_BAD_DATA; + + return hr; +} + +HRESULT PME::ReadMSR(uint32 dw_reg, uint64 * pi64_value) +{ + HRESULT hr; + DWORD dw_ret_len; + + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + hr = DeviceIoControl + ( + hFile, // Handle to device + (DWORD) IOCTL_READ_MSR, // IO Control code for Read + &dw_reg, // Input Buffer to driver. + sizeof(uint32), // Length of input buffer. + pi64_value, // Output Buffer from driver. + sizeof(uint64), // Length of output buffer in bytes. + &dw_ret_len, // Bytes placed in output buffer. + NULL // NULL means wait till op. completes + ); + + if (hr == S_OK && dw_ret_len != sizeof(uint64)) + hr = E_BAD_DATA; + + return hr; +} + +//--------------------------------------------------------------------------- +// Write model specific register +//--------------------------------------------------------------------------- +HRESULT PME::WriteMSR(uint32 dw_reg, const int64 & i64_value) +{ + HRESULT hr; + DWORD dw_buffer[3]; + DWORD dw_ret_len; + + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + dw_buffer[0] = dw_reg; // setup the 12 byte input + *((int64*)(&dw_buffer[1]))= i64_value; + + hr = DeviceIoControl + ( + hFile, // Handle to device + (DWORD) IOCTL_WRITE_MSR, // IO Control code for Read + dw_buffer, // Input Buffer to driver. + 12, // Length of Input buffer + NULL, // Buffer from driver, None for WRMSR + 0, // Length of output buffer in bytes. + &dw_ret_len, // Bytes placed in DataBuffer. + NULL // NULL means wait till op. completes. + ); + + if (hr == S_OK && dw_ret_len != 0) + hr = E_BAD_DATA; + + return hr; +} + + + +HRESULT PME::WriteMSR(uint32 dw_reg, const uint64 & i64_value) +{ + HRESULT hr; + DWORD dw_buffer[3]; + DWORD dw_ret_len; + + if (bDriverOpen == false) // driver is not going + return E_DRIVER_NOT_OPEN; + + dw_buffer[0] = dw_reg; // setup the 12 byte input + *((uint64*)(&dw_buffer[1]))= i64_value; + + hr = DeviceIoControl + ( + hFile, // Handle to device + (DWORD) IOCTL_WRITE_MSR, // IO Control code for Read + dw_buffer, // Input Buffer to driver. + 12, // Length of Input buffer + NULL, // Buffer from driver, None for WRMSR + 0, // Length of output buffer in bytes. + &dw_ret_len, // Bytes placed in DataBuffer. + NULL // NULL means wait till op. completes. + ); + + //E_POINTER + if (hr == S_OK && dw_ret_len != 0) + hr = E_BAD_DATA; + + return hr; +} + + + + + + + + + + + + + +#pragma hdrstop + + + + +//--------------------------------------------------------------------------- +// Return the frequency of the processor in Hz. +// + +double PME::GetCPUClockSpeedFast(void) +{ + int64 i64_perf_start, i64_perf_freq, i64_perf_end; + int64 i64_clock_start,i64_clock_end; + double d_loop_period, d_clock_freq; + + //----------------------------------------------------------------------- + // Query the performance of the Windows high resolution timer. + //----------------------------------------------------------------------- + QueryPerformanceFrequency((LARGE_INTEGER*)&i64_perf_freq); + + //----------------------------------------------------------------------- + // Query the current value of the Windows high resolution timer. + //----------------------------------------------------------------------- + QueryPerformanceCounter((LARGE_INTEGER*)&i64_perf_start); + i64_perf_end = 0; + + //----------------------------------------------------------------------- + // Time of loop of 250000 windows cycles with RDTSC + //----------------------------------------------------------------------- + RDTSC(i64_clock_start); + while(i64_perf_end<i64_perf_start+250000) + { + QueryPerformanceCounter((LARGE_INTEGER*)&i64_perf_end); + } + RDTSC(i64_clock_end); + + //----------------------------------------------------------------------- + // Caclulate the frequency of the RDTSC timer and therefore calculate + // the frequency of the processor. + //----------------------------------------------------------------------- + i64_clock_end -= i64_clock_start; + + d_loop_period = ((double)(i64_perf_freq)) / 250000.0; + d_clock_freq = ((double)(i64_clock_end & 0xffffffff))*d_loop_period; + + return (float)d_clock_freq; +} + + + +// takes 1 second +double PME::GetCPUClockSpeedSlow(void) +{ + + if (m_CPUClockSpeed != 0) + return m_CPUClockSpeed; + + unsigned long start_ms, stop_ms; + unsigned long start_tsc,stop_tsc; + + // boosting priority helps with noise. its optional and i dont think + // it helps all that much + + PME * pme = PME::Instance(); + + pme->SetProcessPriority(ProcessPriorityHigh); + + // wait for millisecond boundary + start_ms = GetTickCount() + 5; + while (start_ms <= GetTickCount()); + + // read timestamp (you could use QueryPerformanceCounter in hires mode if you want) +#ifdef COMPILER_MSVC64 + RDTSC(start_tsc); +#else + __asm + { + rdtsc + mov dword ptr [start_tsc+0],eax + mov dword ptr [start_tsc+4],edx + } +#endif + + // wait for end + stop_ms = start_ms + 1000; // longer wait gives better resolution + while (stop_ms > GetTickCount()); + + // read timestamp (you could use QueryPerformanceCounter in hires mode if you want) +#ifdef COMPILER_MSVC64 + RDTSC(stop_tsc); +#else + __asm + { + rdtsc + mov dword ptr [stop_tsc+0],eax + mov dword ptr [stop_tsc+4],edx + } +#endif + + + // normalize priority + pme->SetProcessPriority(ProcessPriorityNormal); + + // return clock speed + // optionally here you could round to known clocks, like speeds that are multimples + // of 100, 133, 166, etc. + m_CPUClockSpeed = ((stop_tsc - start_tsc) * 1000.0) / (double)(stop_ms - start_ms); + return m_CPUClockSpeed; + +} + + + +const unsigned short cccr_escr_map[NCOUNTERS][8] = +{ + { + 0x3B2, + 0x3B4, + 0x3AA, + 0x3B6, + 0x3AC, + 0x3C8, + 0x3A2, + 0x3A0, + }, + { + 0x3B2, + 0x3B4, + 0x3AA, + 0x3B6, + 0x3AC, + 0x3C8, + 0x3A2, + 0x3A0, + }, + { + 0x3B3, + 0x3B5, + 0x3AB, + 0x3B7, + 0x3AD, + 0x3C9, + 0x3A3, + 0x3A1, + }, + { + 0x3B3, + 0x3B5, + 0x3AB, + 0x3B7, + 0x3AD, + 0x3C9, + 0x3A3, + 0x3A1, + }, + { + + 0x3C0, + 0x3C4, + 0x3C2, + }, + { + 0x3C0, + 0x3C4, + 0x3C2, + }, + { + 0x3C1, + 0x3C5, + 0x3C3, + }, + { + 0x3C1, + 0x3C5, + 0x3C3, + }, + { + 0x3A6, + 0x3A4, + 0x3AE, + 0x3B0, + 0, + 0x3A8, + }, + { + 0x3A6, + 0x3A4, + 0x3AE, + 0x3B0, + 0, + 0x3A8, + }, + { + + 0x3A7, + 0x3A5, + 0x3AF, + 0x3B1, + 0, + 0x3A9, + }, + { + + 0x3A7, + 0x3A5, + 0x3AF, + 0x3B1, + 0, + 0x3A9, + }, + { + + 0x3BA, + 0x3CA, + 0x3BC, + 0x3BE, + 0x3B8, + 0x3CC, + 0x3E0, + }, + { + + 0x3BA, + 0x3CA, + 0x3BC, + 0x3BE, + 0x3B8, + 0x3CC, + 0x3E0, + }, + { + + 0x3BB, + 0x3CB, + 0x3BD, + 0, + 0x3B9, + 0x3CD, + 0x3E1, + }, + { + + + 0x3BB, + 0x3CB, + 0x3BD, + 0, + 0x3B9, + 0x3CD, + 0x3E1, + }, + { + 0x3BA, + 0x3CA, + 0x3BC, + 0x3BE, + 0x3B8, + 0x3CC, + 0x3E0, + }, + { + + 0x3BB, + 0x3CB, + 0x3BD, + 0, + 0x3B9, + 0x3CD, + 0x3E1, + }, +}; + +#ifdef DBGFLAG_VALIDATE +//----------------------------------------------------------------------------- +// Purpose: Ensure that all of our internal structures are consistent, and +// account for all memory that we've allocated. +// Input: validator - Our global validator object +// pchName - Our name (typically a member var in our container) +//----------------------------------------------------------------------------- +void PME::Validate( CValidator &validator, tchar *pchName ) +{ + validator.Push( _T("PME"), this, pchName ); + + validator.ClaimMemory( this ); + + validator.ClaimMemory( cache ); + + validator.ClaimMemory( ( void * ) vendor_name.c_str( ) ); + validator.ClaimMemory( ( void * ) brand.c_str( ) ); + + validator.Pop( ); +} +#endif // DBGFLAG_VALIDATE + +#pragma warning( default : 4530 ) // warning: exception handler -GX option +#endif + diff --git a/external/vpc/tier0/resource.h b/external/vpc/tier0/resource.h new file mode 100644 index 0000000..6a4ef65 --- /dev/null +++ b/external/vpc/tier0/resource.h @@ -0,0 +1,35 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by assert_dialog.rc +// +#define IDD_ASSERT_DIALOG 101 +#define IDC_FILENAME_CONTROL 1000 +#define IDC_LINE_CONTROL 1001 +#define IDC_IGNORE_FILE 1002 +#define IDC_IGNORE_NEARBY 1003 +#define IDC_IGNORE_NUMLINES 1004 +#define IDC_IGNORE_THIS 1005 +#define IDC_BREAK 1006 +#define IDC_IGNORE_ALL 1008 +#define IDC_IGNORE_ALWAYS 1009 +#define IDC_IGNORE_NUMTIMES 1010 +#define IDC_ASSERT_MSG_CTRL 1011 +#define IDC_NOID -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 103 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1005 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/external/vpc/tier0/stacktools.cpp b/external/vpc/tier0/stacktools.cpp new file mode 100644 index 0000000..7a93d61 --- /dev/null +++ b/external/vpc/tier0/stacktools.cpp @@ -0,0 +1,1682 @@ +//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $Workfile: $ +// $NoKeywords: $ +//===========================================================================// + +#include "pch_tier0.h" +#include "tier0/stacktools.h" +#include "tier0/threadtools.h" +#include "tier0/icommandline.h" + +#include "tier0/valve_off.h" + +#if defined( PLATFORM_WINDOWS_PC ) +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <dbghelp.h> +#endif + +#if defined( PLATFORM_X360 ) +#include <xbdm.h> +#include "xbox/xbox_console.h" +#include "xbox/xbox_vxconsole.h" +#include <map> +#include <set> +#endif + +#include "tier0/valve_on.h" + +#include "tier0/memdbgon.h" + + +#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION ) //disable the whole toolset + +int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + return 0; +} + +int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + return 0; +} + +//where we'll find our PDB's for win32. Translation will not work until this has been called once (even if with NULL) +void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList ) +{ +} + +void StackToolsNotify_LoadedLibrary( const char *szLibName ) +{ +} + +int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style ) +{ + if( iOutBufferSize > 0 ) + *szOutput = '\0'; + + return 0; +} + +void PreloadStackInformation( const void **pAddresses, int iAddressCount ) +{ +} + +bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut ) +{ + if( iMaxFileNameLength > 0 ) + *pFileNameOut = '\0'; + + return false; +} + +bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut ) +{ + if( iMaxSymbolNameLength > 0 ) + *pSymbolNameOut = '\0'; + + return false; +} + +bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength ) +{ + if( iMaxModuleNameLength > 0 ) + *pModuleNameOut = '\0'; + + return false; +} + +#else //#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + +//=============================================================================================================== +// Shared Windows/X360 code +//=============================================================================================================== + +CTHREADLOCALPTR( CStackTop_Base ) g_StackTop; + +class CStackTop_FriendFuncs : public CStackTop_Base +{ +public: + friend int AppendParentStackTrace( void **pReturnAddressesOut, int iArrayCount, int iAlreadyFilled ); + friend int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ); +}; + + +inline int AppendParentStackTrace( void **pReturnAddressesOut, int iArrayCount, int iAlreadyFilled ) +{ + CStackTop_FriendFuncs *pTop = (CStackTop_FriendFuncs *)(CStackTop_Base *)g_StackTop; + if( pTop != NULL ) + { + if( pTop->m_pReplaceAddress != NULL ) + { + for( int i = iAlreadyFilled; --i >= 0; ) + { + if( pReturnAddressesOut[i] == pTop->m_pReplaceAddress ) + { + iAlreadyFilled = i; + break; + } + } + } + + if( pTop->m_iParentStackTraceLength != 0 ) + { + int iCopy = MIN( iArrayCount - iAlreadyFilled, pTop->m_iParentStackTraceLength ); + memcpy( pReturnAddressesOut + iAlreadyFilled, pTop->m_pParentStackTrace, iCopy * sizeof( void * ) ); + iAlreadyFilled += iCopy; + } + } + + return iAlreadyFilled; +} + +inline bool ValidStackAddress( void *pAddress, const void *pNoLessThan, const void *pNoGreaterThan ) +{ + if( (uint64)pAddress & 3 ) + return false; + if( pAddress < pNoLessThan ) //frame pointer traversal should always increase the pointer + return false; + if( pAddress > pNoGreaterThan ) //never traverse outside the stack (Oh 0xCCCCCCCC, how I hate you) + return false; + +#if defined( WIN32 ) && !defined( _X360 ) && 1 + if( IsBadReadPtr( pAddress, (sizeof( void * ) * 2) ) ) //safety net, but also throws an exception (handled internally) to stop bad access + return false; +#endif + + return true; +} + +#pragma auto_inline( off ) +int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + //Only tested in windows. This function won't work with frame pointer omission enabled. "vpc /nofpo" all projects +#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\ + (defined( WIN32 ) && !defined( _X360 )) + void *pStackCrawlEBP; + __asm + { + mov [pStackCrawlEBP], ebp; + } + + /* + With frame pointer omission disabled, this should be the pattern all the way up the stack + [ebp+00] Old ebp value + [ebp+04] Return address + */ + + void *pNoLessThan = pStackCrawlEBP; //impossible for a valid stack to traverse before this address + int i; + + CStackTop_FriendFuncs *pTop = (CStackTop_FriendFuncs *)(CStackTop_Base *)g_StackTop; + if( pTop != NULL ) //we can do fewer error checks if we have a valid reference point for the top of the stack + { + void *pNoGreaterThan = pTop->m_pStackBase; + + //skips + for( i = 0; i != iSkipCount; ++i ) + { + if( (pStackCrawlEBP < pNoLessThan) || (pStackCrawlEBP > pNoGreaterThan) ) + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 ); + + pNoLessThan = pStackCrawlEBP; + pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value + } + + //store + for( i = 0; i != iArrayCount; ++i ) + { + if( (pStackCrawlEBP < pNoLessThan) || (pStackCrawlEBP > pNoGreaterThan) ) + break; + + pReturnAddressesOut[i] = *((void **)pStackCrawlEBP + 1); + + pNoLessThan = pStackCrawlEBP; + pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value + } + + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i ); + } + else + { + void *pNoGreaterThan = ((unsigned char *)pNoLessThan) + (1024 * 1024); //standard stack is 1MB. TODO: Get actual stack end address if available since this check isn't foolproof + + //skips + for( i = 0; i != iSkipCount; ++i ) + { + if( !ValidStackAddress( pStackCrawlEBP, pNoLessThan, pNoGreaterThan ) ) + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 ); + + pNoLessThan = pStackCrawlEBP; + pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value + } + + //store + for( i = 0; i != iArrayCount; ++i ) + { + if( !ValidStackAddress( pStackCrawlEBP, pNoLessThan, pNoGreaterThan ) ) + break; + + pReturnAddressesOut[i] = *((void **)pStackCrawlEBP + 1); + + pNoLessThan = pStackCrawlEBP; + pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value + } + + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i ); + } +#endif + + return 0; +} +#pragma auto_inline( on ) + + + + + + +#if defined( WIN32 ) && !defined( _X360 ) +//=============================================================================================================== +// Windows version of the toolset +//=============================================================================================================== + + +#if defined( TIER0_FPO_DISABLED ) +//# define USE_CAPTURESTACKBACKTRACE //faster than StackWalk64, but only works on XP or newer and only with Frame Pointer Omission optimization disabled(/Oy-) for every function it traces through +#endif + + +#if defined(_M_IX86) || defined(_M_X64) +# define USE_STACKWALK64 +# if defined(_M_IX86) +# define STACKWALK64_MACHINETYPE IMAGE_FILE_MACHINE_I386 +# else +# define STACKWALK64_MACHINETYPE IMAGE_FILE_MACHINE_AMD64 +# endif +#endif + +typedef DWORD (WINAPI *PFN_SymGetOptions)( VOID ); +typedef DWORD (WINAPI *PFN_SymSetOptions)( IN DWORD SymOptions ); +typedef BOOL (WINAPI *PFN_SymSetSearchPath)( IN HANDLE hProcess, IN PSTR SearchPath ); +typedef BOOL (WINAPI *PFN_SymInitialize)( IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess ); +typedef BOOL (WINAPI *PFN_SymCleanup)( IN HANDLE hProcess ); +typedef BOOL (WINAPI *PFN_SymEnumerateModules64)( IN HANDLE hProcess, IN PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, IN PVOID UserContext ); +typedef BOOL (WINAPI *PFN_EnumerateLoadedModules64)( IN HANDLE hProcess, IN PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, IN PVOID UserContext ); +typedef DWORD64 (WINAPI *PFN_SymLoadModule64)( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll ); +typedef BOOL (WINAPI *PFN_SymUnloadModule64)( IN HANDLE hProcess, IN DWORD64 BaseOfDll ); +typedef BOOL (WINAPI *PFN_SymFromAddr)( IN HANDLE hProcess, IN DWORD64 Address, OUT PDWORD64 Displacement, IN OUT PSYMBOL_INFO Symbol ); +typedef BOOL (WINAPI *PFN_SymGetLineFromAddr64)( IN HANDLE hProcess, IN DWORD64 qwAddr, OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE64 Line64 ); +typedef BOOL (WINAPI *PFN_SymGetModuleInfo64)( IN HANDLE hProcess, IN DWORD64 dwAddr, OUT PIMAGEHLP_MODULE64 ModuleInfo ); +typedef BOOL (WINAPI *PFN_StackWalk64)( DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress ); +typedef USHORT (WINAPI *PFN_CaptureStackBackTrace)( IN ULONG FramesToSkip, IN ULONG FramesToCapture, OUT PVOID *BackTrace, OUT OPTIONAL PULONG BackTraceHash ); + + +DWORD WINAPI SymGetOptions_DummyFn( VOID ) +{ + return 0; +} + +DWORD WINAPI SymSetOptions_DummyFn( IN DWORD SymOptions ) +{ + return 0; +} + +BOOL WINAPI SymSetSearchPath_DummyFn( IN HANDLE hProcess, IN PSTR SearchPath ) +{ + return FALSE; +} + +BOOL WINAPI SymInitialize_DummyFn( IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess ) +{ + return FALSE; +} + +BOOL WINAPI SymCleanup_DummyFn( IN HANDLE hProcess ) +{ + return TRUE; +} + +BOOL WINAPI SymEnumerateModules64_DummyFn( IN HANDLE hProcess, IN PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, IN PVOID UserContext ) +{ + return FALSE; +} + +BOOL WINAPI EnumerateLoadedModules64_DummyFn( IN HANDLE hProcess, IN PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, IN PVOID UserContext ) +{ + return FALSE; +} + +DWORD64 WINAPI SymLoadModule64_DummyFn( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll ) +{ + return 0; +} + +BOOL WINAPI SymUnloadModule64_DummyFn( IN HANDLE hProcess, IN DWORD64 BaseOfDll ) +{ + return FALSE; +} + +BOOL WINAPI SymFromAddr_DummyFn( IN HANDLE hProcess, IN DWORD64 Address, OUT PDWORD64 Displacement, IN OUT PSYMBOL_INFO Symbol ) +{ + return FALSE; +} + +BOOL WINAPI SymGetLineFromAddr64_DummyFn( IN HANDLE hProcess, IN DWORD64 qwAddr, OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE64 Line64 ) +{ + return FALSE; +} + +BOOL WINAPI SymGetModuleInfo64_DummyFn( IN HANDLE hProcess, IN DWORD64 dwAddr, OUT PIMAGEHLP_MODULE64 ModuleInfo ) +{ + return FALSE; +} + + + +BOOL WINAPI StackWalk64_DummyFn( DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress ) +{ + return FALSE; +} + +USHORT WINAPI CaptureStackBackTrace_DummyFn( IN ULONG FramesToSkip, IN ULONG FramesToCapture, OUT PVOID *BackTrace, OUT OPTIONAL PULONG BackTraceHash ) +{ + return 0; +} + +class CHelperFunctionsLoader +{ +public: + CHelperFunctionsLoader( void ) + { + m_bIsInitialized = false; + m_bShouldReloadSymbols = false; + m_hDbgHelpDll = NULL; + m_szPDBSearchPath = NULL; + m_pSymInitialize = SymInitialize_DummyFn; + m_pSymCleanup = SymCleanup_DummyFn; + m_pSymSetOptions = SymSetOptions_DummyFn; + m_pSymGetOptions = SymGetOptions_DummyFn; + m_pSymSetSearchPath = SymSetSearchPath_DummyFn; + m_pSymEnumerateModules64 = SymEnumerateModules64_DummyFn; + m_pEnumerateLoadedModules64 = EnumerateLoadedModules64_DummyFn; + m_pSymLoadModule64 = SymLoadModule64_DummyFn; + m_pSymUnloadModule64 = SymUnloadModule64_DummyFn; + m_pSymFromAddr = SymFromAddr_DummyFn; + m_pSymGetLineFromAddr64 = SymGetLineFromAddr64_DummyFn; + m_pSymGetModuleInfo64 = SymGetModuleInfo64_DummyFn; + +#if defined( USE_STACKWALK64 ) + m_pStackWalk64 = StackWalk64_DummyFn; +#endif + +#if defined( USE_CAPTURESTACKBACKTRACE ) + m_pCaptureStackBackTrace = CaptureStackBackTrace_DummyFn; + m_hNTDllDll = NULL; +#endif + } + + ~CHelperFunctionsLoader( void ) + { + m_pSymCleanup( m_hProcess ); + + if( m_hDbgHelpDll != NULL ) + ::FreeLibrary( m_hDbgHelpDll ); + +#if defined( USE_CAPTURESTACKBACKTRACE ) + if( m_hNTDllDll != NULL ) + ::FreeLibrary( m_hNTDllDll ); +#endif + + if( m_szPDBSearchPath != NULL ) + delete []m_szPDBSearchPath; + } + + static BOOL CALLBACK UnloadSymbolsCallback( PSTR ModuleName, DWORD64 BaseOfDll, PVOID UserContext ) + { + const CHelperFunctionsLoader *pThis = ((CHelperFunctionsLoader *)UserContext); + pThis->m_pSymUnloadModule64( pThis->m_hProcess, BaseOfDll ); + return TRUE; + } + +#if _MSC_VER >= 1600 + static BOOL CALLBACK LoadSymbolsCallback( PCSTR ModuleName, DWORD64 ModuleBase, ULONG ModuleSize, PVOID UserContext ) +#else + static BOOL CALLBACK LoadSymbolsCallback( PSTR ModuleName, DWORD64 ModuleBase, ULONG ModuleSize, PVOID UserContext ) +#endif + { + const CHelperFunctionsLoader *pThis = ((CHelperFunctionsLoader *)UserContext); + //SymLoadModule64( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll ); + pThis->m_pSymLoadModule64( pThis->m_hProcess, NULL, (PSTR)ModuleName, (PSTR)ModuleName, ModuleBase, ModuleSize ); + return TRUE; + } + + void TryLoadingNewSymbols( void ) + { + AUTO_LOCK_FM( m_Mutex ); + + if( m_bIsInitialized ) + { + //m_pSymEnumerateModules64( m_hProcess, UnloadSymbolsCallback, this ); //unloaded modules we've already loaded + m_pEnumerateLoadedModules64( m_hProcess, LoadSymbolsCallback, this ); //load everything + m_bShouldReloadSymbols = false; + } + } + + void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList ) + { + AUTO_LOCK_FM( m_Mutex ); + + if( m_szPDBSearchPath != NULL ) + delete []m_szPDBSearchPath; + + if( szSemicolonSeparatedList == NULL ) + { + m_szPDBSearchPath = NULL; + return; + } + + int iLength = (int)strlen( szSemicolonSeparatedList ) + 1; + char *pNewPath = new char [iLength]; + memcpy( pNewPath, szSemicolonSeparatedList, iLength ); + m_szPDBSearchPath = pNewPath; + + //re-init search paths. Or if we haven't yet loaded dbghelp.dll, this will go to the dummy function and do nothing + m_pSymSetSearchPath( m_hProcess, m_szPDBSearchPath ); + //TryLoadingNewSymbols(); + m_bShouldReloadSymbols = true; + } + + bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut ) + { + if( pAddress == NULL ) + return false; + + AUTO_LOCK_FM( m_Mutex ); + + unsigned char genericbuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME*sizeof(TCHAR)]; + + ((PSYMBOL_INFO)genericbuffer)->SizeOfStruct = sizeof(SYMBOL_INFO); + ((PSYMBOL_INFO)genericbuffer)->MaxNameLen = MAX_SYM_NAME; + + DWORD64 dwDisplacement; + if( m_pSymFromAddr( m_hProcess, (DWORD64)pAddress, &dwDisplacement, (PSYMBOL_INFO)genericbuffer) ) + { + strncpy( pSymbolNameOut, ((PSYMBOL_INFO)genericbuffer)->Name, iMaxSymbolNameLength ); + if( pDisplacementOut != NULL ) + *pDisplacementOut = dwDisplacement; + return true; + } + + return false; + } + + bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut ) + { + if( pAddress == NULL ) + return false; + + AUTO_LOCK_FM( m_Mutex ); + + tchar szBuffer[1024]; + szBuffer[0] = _T('\0'); + + IMAGEHLP_LINE64 imageHelpLine64; + imageHelpLine64.SizeOfStruct = sizeof(IMAGEHLP_LINE64); + imageHelpLine64.FileName = szBuffer; + + DWORD dwDisplacement; + if( m_pSymGetLineFromAddr64( m_hProcess, (DWORD64)pAddress, &dwDisplacement, &imageHelpLine64 ) ) + { + strncpy( pFileNameOut, imageHelpLine64.FileName, iMaxFileNameLength ); + iLineNumberOut = imageHelpLine64.LineNumber; + + if( pDisplacementOut != NULL ) + *pDisplacementOut = dwDisplacement; + + return true; + } + + return false; + } + + bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength ) + { + AUTO_LOCK_FM( m_Mutex ); + IMAGEHLP_MODULE64 moduleInfo; + + moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64); + + if ( m_pSymGetModuleInfo64( m_hProcess, (DWORD64)pAddress, &moduleInfo ) ) + { + strncpy( pModuleNameOut, moduleInfo.ModuleName, iMaxModuleNameLength ); + return true; + } + + return false; + } + + //only returns false if we ran out of buffer space. + bool TranslatePointer( const void * const pAddress, tchar *pTranslationOut, int iTranslationBufferLength, TranslateStackInfo_StyleFlags_t style ) + { + //AUTO_LOCK( m_Mutex ); + + if( pTranslationOut == NULL ) + return false; + + if( iTranslationBufferLength <= 0 ) + return false; + + //sample desired output + // valid translation - "tier0.dll!CHelperFunctionsLoader::TranslatePointer - u:\Dev\L4D\src\tier0\stacktools.cpp(162) + 4 bytes" + // fallback translation - "tier0.dll!0x01234567" + + tchar *pWrite = pTranslationOut; + *pWrite = '\0'; + int iLength; + + if( style & TSISTYLEFLAG_MODULENAME ) + { + if( !this->GetModuleNameFromAddress( pAddress, pWrite, iTranslationBufferLength ) ) + strncpy( pWrite, "unknown_module", iTranslationBufferLength ); + + iLength = (int)strlen( pWrite ); + pWrite += iLength; + iTranslationBufferLength -= iLength; + + if( iTranslationBufferLength < 2 ) + return false; //need more buffer + + if( style & TSISTYLEFLAG_SYMBOLNAME ) + { + *pWrite = '!'; + ++pWrite; + --iTranslationBufferLength; + *pWrite = '\0'; + } + } + + //use symbol name to test if the rest is going to work. So grab it whether they want it or not + if( !this->GetSymbolNameFromAddress( pAddress, pWrite, iTranslationBufferLength, NULL ) ) + { + int nBytesWritten = _snprintf( pWrite, iTranslationBufferLength, "0x%p", pAddress ); + if ( nBytesWritten < 0 ) + { + *pWrite = '\0'; // if we can't write all of the line/lineandoffset, don't write any at all + return false; + } + return true; + } + else if( style & TSISTYLEFLAG_SYMBOLNAME ) + { + iLength = (int)strlen( pWrite ); + pWrite += iLength; + iTranslationBufferLength -= iLength; + } + else + { + *pWrite = '\0'; //symbol name lookup worked, but unwanted, discard + } + + if( style & (TSISTYLEFLAG_FULLPATH | TSISTYLEFLAG_SHORTPATH | TSISTYLEFLAG_LINE | TSISTYLEFLAG_LINEANDOFFSET) ) + { + if( pWrite != pTranslationOut ) //if we've written anything yet, separate the printed data from the file name and line + { + if( iTranslationBufferLength < 6 ) + return false; //need more buffer + + pWrite[0] = ' '; //append " - " + pWrite[1] = '-'; + pWrite[2] = ' '; + pWrite[3] = '\0'; + pWrite += 3; + iTranslationBufferLength -= 3; + } + + uint32 iLine; + uint32 iDisplacement; + char szFileName[MAX_PATH]; + if( this->GetFileAndLineFromAddress( pAddress, szFileName, MAX_PATH, iLine, &iDisplacement ) ) + { + if( style & TSISTYLEFLAG_FULLPATH ) + { + iLength = (int)strlen( szFileName ); + if ( iTranslationBufferLength < iLength + 1 ) + return false; + + memcpy( pWrite, szFileName, iLength + 1 ); + pWrite += iLength; + iTranslationBufferLength -= iLength; + } + else if( style & TSISTYLEFLAG_SHORTPATH ) + { + //shorten the path and copy + iLength = (int)strlen( szFileName ); + char *pShortened = szFileName + iLength; + int iSlashesAllowed = 3; + while( pShortened > szFileName ) + { + if( (*pShortened == '\\') || (*pShortened == '/') ) + { + --iSlashesAllowed; + if( iSlashesAllowed == 0 ) + break; + } + + --pShortened; + } + + iLength = (int)strlen( pShortened ); + if( iTranslationBufferLength < iLength + 1 ) + { + //Remove the " - " that we can't append to + pWrite -= 3; + iTranslationBufferLength += 3; + *pWrite = '\0'; + return false; + } + + memcpy( pWrite, szFileName, iLength + 1 ); + pWrite += iLength; + iTranslationBufferLength -= iLength; + } + + if( style & (TSISTYLEFLAG_LINE | TSISTYLEFLAG_LINEANDOFFSET) ) + { + int nBytesWritten = _snprintf( pWrite, iTranslationBufferLength, ((style & TSISTYLEFLAG_LINEANDOFFSET) && (iDisplacement != 0)) ? "(%d) + %d bytes" : "(%d)", iLine, iDisplacement ); + if ( nBytesWritten < 0 ) + { + *pWrite = '\0'; // if we can't write all of the line/lineandoffset, don't write any at all + return false; + } + + pWrite += nBytesWritten; + iTranslationBufferLength -= nBytesWritten; + } + } + else + { + //Remove the " - " that we didn't append to + pWrite -= 3; + iTranslationBufferLength += 3; + *pWrite = '\0'; + } + } + + return true; + } + + + //about to actually use the functions, load if necessary + void EnsureReady( void ) + { + if( m_bIsInitialized ) + { + if( m_bShouldReloadSymbols ) + TryLoadingNewSymbols(); + + return; + } + + AUTO_LOCK_FM( m_Mutex ); + + //Only enabled for P4 and Steam Beta builds + if( (CommandLine()->FindParm( "-steam" ) != 0) && //is steam + (CommandLine()->FindParm( "-internalbuild" ) == 0) ) //is not steam beta + { + //disable the toolset by falsifying initialized state + m_bIsInitialized = true; + return; + } + + m_hProcess = GetCurrentProcess(); + if( m_hProcess == NULL ) + return; + + m_bIsInitialized = true; + + // get the function pointer directly so that we don't have to include the .lib, and that + // we can easily change it to using our own dll when this code is used on win98/ME/2K machines + m_hDbgHelpDll = ::LoadLibrary( "DbgHelp.dll" ); + if ( !m_hDbgHelpDll ) + { + //it's possible it's just way too early to initialize (as shown with attempts at using these tools in the memory allocator) + if( m_szPDBSearchPath == NULL ) //not a rock solid check, but pretty good compromise between endless failing initialization and general failure due to trying too early + m_bIsInitialized = false; + + return; + } + + m_pSymInitialize = (PFN_SymInitialize) ::GetProcAddress( m_hDbgHelpDll, "SymInitialize" ); + if( m_pSymInitialize == NULL ) + { + //very bad + ::FreeLibrary( m_hDbgHelpDll ); + m_hDbgHelpDll = NULL; + m_pSymInitialize = SymInitialize_DummyFn; + return; + } + + m_pSymCleanup = (PFN_SymCleanup) ::GetProcAddress( m_hDbgHelpDll, "SymCleanup" ); + if( m_pSymCleanup == NULL ) + m_pSymCleanup = SymCleanup_DummyFn; + + m_pSymGetOptions = (PFN_SymGetOptions) ::GetProcAddress( m_hDbgHelpDll, "SymGetOptions" ); + if( m_pSymGetOptions == NULL ) + m_pSymGetOptions = SymGetOptions_DummyFn; + + m_pSymSetOptions = (PFN_SymSetOptions) ::GetProcAddress( m_hDbgHelpDll, "SymSetOptions" ); + if( m_pSymSetOptions == NULL ) + m_pSymSetOptions = SymSetOptions_DummyFn; + + m_pSymSetSearchPath = (PFN_SymSetSearchPath) ::GetProcAddress( m_hDbgHelpDll, "SymSetSearchPath" ); + if( m_pSymSetSearchPath == NULL ) + m_pSymSetSearchPath = SymSetSearchPath_DummyFn; + + m_pSymEnumerateModules64 = (PFN_SymEnumerateModules64) ::GetProcAddress( m_hDbgHelpDll, "SymEnumerateModules64" ); + if( m_pSymEnumerateModules64 == NULL ) + m_pSymEnumerateModules64 = SymEnumerateModules64_DummyFn; + + m_pEnumerateLoadedModules64 = (PFN_EnumerateLoadedModules64) ::GetProcAddress( m_hDbgHelpDll, "EnumerateLoadedModules64" ); + if( m_pEnumerateLoadedModules64 == NULL ) + m_pEnumerateLoadedModules64 = EnumerateLoadedModules64_DummyFn; + + m_pSymLoadModule64 = (PFN_SymLoadModule64) ::GetProcAddress( m_hDbgHelpDll, "SymLoadModule64" ); + if( m_pSymLoadModule64 == NULL ) + m_pSymLoadModule64 = SymLoadModule64_DummyFn; + + m_pSymUnloadModule64 = (PFN_SymUnloadModule64) ::GetProcAddress( m_hDbgHelpDll, "SymUnloadModule64" ); + if( m_pSymUnloadModule64 == NULL ) + m_pSymUnloadModule64 = SymUnloadModule64_DummyFn; + + m_pSymFromAddr = (PFN_SymFromAddr) ::GetProcAddress( m_hDbgHelpDll, "SymFromAddr" ); + if( m_pSymFromAddr == NULL ) + m_pSymFromAddr = SymFromAddr_DummyFn; + + m_pSymGetLineFromAddr64 = (PFN_SymGetLineFromAddr64) ::GetProcAddress( m_hDbgHelpDll, "SymGetLineFromAddr64" ); + if( m_pSymGetLineFromAddr64 == NULL ) + m_pSymGetLineFromAddr64 = SymGetLineFromAddr64_DummyFn; + + m_pSymGetModuleInfo64 = (PFN_SymGetModuleInfo64) ::GetProcAddress( m_hDbgHelpDll, "SymGetModuleInfo64" ); + if( m_pSymGetModuleInfo64 == NULL ) + m_pSymGetModuleInfo64 = SymGetModuleInfo64_DummyFn; + +#if defined( USE_STACKWALK64 ) + m_pStackWalk64 = (PFN_StackWalk64) ::GetProcAddress( m_hDbgHelpDll, "StackWalk64" ); + if( m_pStackWalk64 == NULL ) + m_pStackWalk64 = StackWalk64_DummyFn; +#endif + + +#if defined( USE_CAPTURESTACKBACKTRACE ) + m_hNTDllDll = ::LoadLibrary( "ntdll.dll" ); + + m_pCaptureStackBackTrace = (PFN_CaptureStackBackTrace) ::GetProcAddress( m_hNTDllDll, "RtlCaptureStackBackTrace" ); + if( m_pCaptureStackBackTrace == NULL ) + m_pCaptureStackBackTrace = CaptureStackBackTrace_DummyFn; +#endif + + + m_pSymSetOptions( m_pSymGetOptions() | + SYMOPT_DEFERRED_LOADS | //load on demand + SYMOPT_EXACT_SYMBOLS | //don't load the wrong file + SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS | //don't prompt ever + SYMOPT_LOAD_LINES ); //load line info + + m_pSymInitialize( m_hProcess, m_szPDBSearchPath, FALSE ); + TryLoadingNewSymbols(); + } + + bool m_bIsInitialized; + bool m_bShouldReloadSymbols; + HANDLE m_hProcess; + HMODULE m_hDbgHelpDll; + char *m_szPDBSearchPath; + CThreadFastMutex m_Mutex; //DbgHelp functions are all single threaded. + + PFN_SymInitialize m_pSymInitialize; + PFN_SymCleanup m_pSymCleanup; + PFN_SymGetOptions m_pSymGetOptions; + PFN_SymSetOptions m_pSymSetOptions; + PFN_SymSetSearchPath m_pSymSetSearchPath; + PFN_SymEnumerateModules64 m_pSymEnumerateModules64; + PFN_EnumerateLoadedModules64 m_pEnumerateLoadedModules64; + PFN_SymLoadModule64 m_pSymLoadModule64; + PFN_SymUnloadModule64 m_pSymUnloadModule64; + + PFN_SymFromAddr m_pSymFromAddr; + PFN_SymGetLineFromAddr64 m_pSymGetLineFromAddr64; + PFN_SymGetModuleInfo64 m_pSymGetModuleInfo64; + +#if defined( USE_STACKWALK64 ) + PFN_StackWalk64 m_pStackWalk64; +#endif + +#if defined( USE_CAPTURESTACKBACKTRACE ) + HMODULE m_hNTDllDll; + PFN_CaptureStackBackTrace m_pCaptureStackBackTrace; +#endif +}; +static CHelperFunctionsLoader s_HelperFunctions; + + + +#if defined( USE_STACKWALK64 ) //most reliable method thanks to boatloads of windows helper functions. Also the slowest. +int CrawlStack_StackWalk64( CONTEXT *pExceptionContext, void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + s_HelperFunctions.EnsureReady(); + + AUTO_LOCK_FM( s_HelperFunctions.m_Mutex ); + + CONTEXT currentContext; + memcpy( ¤tContext, pExceptionContext, sizeof( CONTEXT ) ); + + STACKFRAME64 sfFrame = { 0 }; //memset(&sfFrame, 0x0, sizeof(sfFrame)); + sfFrame.AddrPC.Mode = sfFrame.AddrFrame.Mode = AddrModeFlat; + sfFrame.AddrPC.Offset = currentContext.Eip; + sfFrame.AddrFrame.Offset = currentContext.Ebp; + + HANDLE hThread = GetCurrentThread(); + + int i; + for( i = 0; i != iSkipCount; ++i ) //skip entries that the requesting function thinks are uninformative + { + if(!s_HelperFunctions.m_pStackWalk64( STACKWALK64_MACHINETYPE, s_HelperFunctions.m_hProcess, hThread, &sfFrame, ¤tContext, NULL, NULL, NULL, NULL ) || + (sfFrame.AddrFrame.Offset == 0) ) + { + return 0; + } + } + + for( i = 0; i != iArrayCount; ++i ) + { + if(!s_HelperFunctions.m_pStackWalk64( STACKWALK64_MACHINETYPE, s_HelperFunctions.m_hProcess, hThread, &sfFrame, ¤tContext, NULL, NULL, NULL, NULL ) || + (sfFrame.AddrFrame.Offset == 0) ) + { + break; + } + pReturnAddressesOut[i] = (void *)sfFrame.AddrPC.Offset; + } + + return i; +} + +void GetCallStackReturnAddresses_Exception( void **CallStackReturnAddresses, int *pRetCount, int iSkipCount, _EXCEPTION_POINTERS * pExceptionInfo ) +{ + int iCount = CrawlStack_StackWalk64( pExceptionInfo->ContextRecord, CallStackReturnAddresses, *pRetCount, iSkipCount + 1 ); //skipping RaiseException() + *pRetCount = iCount; +} +#endif //#if defined( USE_STACKWALK64 ) + + + +int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + s_HelperFunctions.EnsureReady(); + + ++iSkipCount; //skip this function + +#if defined( USE_CAPTURESTACKBACKTRACE ) + if( s_HelperFunctions.m_pCaptureStackBackTrace != CaptureStackBackTrace_DummyFn ) + { + //docs state a total limit of 63 back traces between skipped and stored + int iRetVal = s_HelperFunctions.m_pCaptureStackBackTrace( iSkipCount, MIN( iArrayCount, 63 - iSkipCount ), pReturnAddressesOut, NULL ); + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, iRetVal ); + } +#endif +#if defined( USE_STACKWALK64 ) + if( s_HelperFunctions.m_pStackWalk64 != StackWalk64_DummyFn ) + { + int iInOutArrayCount = iArrayCount; //array count becomes both input and output with exception handler version + __try + { + ::RaiseException( 0, EXCEPTION_NONCONTINUABLE, 0, NULL ); + } + __except ( GetCallStackReturnAddresses_Exception( pReturnAddressesOut, &iInOutArrayCount, iSkipCount, GetExceptionInformation() ), EXCEPTION_EXECUTE_HANDLER ) + { + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, iInOutArrayCount ); + } + } +#endif + + return GetCallStack_Fast( pReturnAddressesOut, iArrayCount, iSkipCount ); +} + +void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList ) +{ + s_HelperFunctions.SetStackTranslationSymbolSearchPath( szSemicolonSeparatedList ); +} + +void StackToolsNotify_LoadedLibrary( const char *szLibName ) +{ + s_HelperFunctions.m_bShouldReloadSymbols = true; +} + +int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style ) +{ + s_HelperFunctions.EnsureReady(); + tchar *szStartOutput = szOutput; + + if( szEntrySeparator == NULL ) + szEntrySeparator = _T(""); + + int iSeparatorSize = (int)strlen( szEntrySeparator ); + + for( int i = 0; i < iCallStackCount; ++i ) + { + if( !s_HelperFunctions.TranslatePointer( pCallStack[i], szOutput, iOutBufferSize, style ) ) + { + return i; + } + + int iLength = (int)strlen( szOutput ); + szOutput += iLength; + iOutBufferSize -= iLength; + + if( iOutBufferSize > iSeparatorSize ) + { + memcpy( szOutput, szEntrySeparator, iSeparatorSize * sizeof( tchar ) ); + szOutput += iSeparatorSize; + iOutBufferSize -= iSeparatorSize; + } + *szOutput = '\0'; + } + + szOutput -= iSeparatorSize; + if( szOutput >= szStartOutput ) + *szOutput = '\0'; + + return iCallStackCount; +} + +void PreloadStackInformation( void * const *pAddresses, int iAddressCount ) +{ + //nop on anything but 360 +} + +bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut ) +{ + s_HelperFunctions.EnsureReady(); + return s_HelperFunctions.GetFileAndLineFromAddress( pAddress, pFileNameOut, iMaxFileNameLength, iLineNumberOut, pDisplacementOut ); +} + +bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut ) +{ + s_HelperFunctions.EnsureReady(); + return s_HelperFunctions.GetSymbolNameFromAddress( pAddress, pSymbolNameOut, iMaxSymbolNameLength, pDisplacementOut ); +} + +bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength ) +{ + s_HelperFunctions.EnsureReady(); + return s_HelperFunctions.GetModuleNameFromAddress( pAddress, pModuleNameOut, iMaxModuleNameLength ); +} + +#else //#if defined( WIN32 ) && !defined( _X360 ) + +//=============================================================================================================== +// X360 version of the toolset +//=============================================================================================================== + +class C360StackTranslationHelper +{ +public: + C360StackTranslationHelper( void ) + { + m_bInitialized = true; + } + + ~C360StackTranslationHelper( void ) + { + StringSet_t::const_iterator iter; + + //module names + { + iter = m_ModuleNameSet.begin(); + while(iter != m_ModuleNameSet.end()) + { + char *pModuleName = (char*)(*iter); + delete []pModuleName; + iter++; + } + m_ModuleNameSet.clear(); + } + + //file names + { + iter = m_FileNameSet.begin(); + while(iter != m_FileNameSet.end()) + { + char *pFileName = (char*)(*iter); + delete []pFileName; + iter++; + } + m_FileNameSet.clear(); + } + + //symbol names + { + iter = m_SymbolNameSet.begin(); + while(iter != m_SymbolNameSet.end()) + { + char *pSymbolName = (char*)(*iter); + delete []pSymbolName; + iter++; + } + m_SymbolNameSet.clear(); + } + + m_bInitialized = false; + } + +private: + struct StackAddressInfo_t; +public: + + inline StackAddressInfo_t *CreateEntry( const FullStackInfo_t &info ) + { + std::pair<AddressInfoMapIter_t, bool> retval = m_AddressInfoMap.insert( AddressInfoMapEntry_t( info.pAddress, StackAddressInfo_t() ) ); + if( retval.first->second.szModule != NULL ) + return &retval.first->second; //already initialized + + retval.first->second.iLine = info.iLine; + + + //share strings + + //module + { + const char *pModuleName; + StringSet_t::const_iterator iter = m_ModuleNameSet.find( info.szModuleName ); + if ( iter == m_ModuleNameSet.end() ) + { + int nLen = strlen(info.szModuleName) + 1; + pModuleName = new char [nLen]; + memcpy( (char *)pModuleName, info.szModuleName, nLen ); + m_ModuleNameSet.insert( pModuleName ); + } + else + { + pModuleName = (char *)(*iter); + } + + retval.first->second.szModule = pModuleName; + } + + //file + { + const char *pFileName; + StringSet_t::const_iterator iter = m_FileNameSet.find( info.szFileName ); + if ( iter == m_FileNameSet.end() ) + { + int nLen = strlen(info.szFileName) + 1; + pFileName = new char [nLen]; + memcpy( (char *)pFileName, info.szFileName, nLen ); + m_FileNameSet.insert( pFileName ); + } + else + { + pFileName = (char *)(*iter); + } + + retval.first->second.szFileName = pFileName; + } + + //symbol + { + const char *pSymbolName; + StringSet_t::const_iterator iter = m_SymbolNameSet.find( info.szSymbol ); + if ( iter == m_SymbolNameSet.end() ) + { + int nLen = strlen(info.szSymbol) + 1; + pSymbolName = new char [nLen]; + memcpy( (char *)pSymbolName, info.szSymbol, nLen ); + m_SymbolNameSet.insert( pSymbolName ); + } + else + { + pSymbolName = (char *)(*iter); + } + + retval.first->second.szSymbol = pSymbolName; + } + + return &retval.first->second; + } + + inline StackAddressInfo_t *FindInfoEntry( const void *pAddress ) + { + AddressInfoMapIter_t Iter = m_AddressInfoMap.find( pAddress ); + if( Iter != m_AddressInfoMap.end() ) + return &Iter->second; + + return NULL; + } + + inline int RetrieveStackInfo( const void * const *pAddresses, FullStackInfo_t *pReturnedStructs, int iAddressCount ) + { + int ReturnedTranslatedCount = -1; + //construct the message + // Header Finished Count(out) Input Count Input Array Returned data write address + int iMessageSize = 2 + sizeof( int * ) + sizeof( uint32 ) + (sizeof( void * ) * iAddressCount) + sizeof( FullStackInfo_t * ); + uint8 *pMessage = (uint8 *)stackalloc( iMessageSize ); + uint8 *pMessageWrite = pMessage; + pMessageWrite[0] = XBX_DBG_BNH_STACKTRANSLATOR; //have this message handled by stack translator handler + pMessageWrite[1] = ST_BHC_GETTRANSLATIONINFO; + pMessageWrite += 2; + *(int **)pMessageWrite = (int *)BigDWord( (DWORD)&ReturnedTranslatedCount ); + pMessageWrite += sizeof( int * ); + *(uint32 *)pMessageWrite = (uint32)BigDWord( (DWORD)iAddressCount ); + pMessageWrite += sizeof( uint32 ); + memcpy( pMessageWrite, pAddresses, iAddressCount * sizeof( void * ) ); + pMessageWrite += iAddressCount * sizeof( void * ); + *(FullStackInfo_t **)pMessageWrite = (FullStackInfo_t *)BigDWord( (DWORD)pReturnedStructs ); + bool bSuccess = XBX_SendBinaryData( pMessage, iMessageSize, false, 30000 ); + ReturnedTranslatedCount = BigDWord( ReturnedTranslatedCount ); + + if( bSuccess && (ReturnedTranslatedCount > 0) ) + { + return ReturnedTranslatedCount; + } + return 0; + } + + inline StackAddressInfo_t *CreateEntry( const void *pAddress ) + { + //ask VXConsole for information about the addresses we're clueless about + + FullStackInfo_t ReturnedData; + ReturnedData.pAddress = pAddress; + ReturnedData.szFileName[0] = '\0'; //strncpy( ReturnedData.szFileName, "FileUninitialized", sizeof( ReturnedData.szFileName ) ); + ReturnedData.szModuleName[0] = '\0'; //strncpy( ReturnedData.szModuleName, "ModuleUninitialized", sizeof( ReturnedData.szModuleName ) ); + ReturnedData.szSymbol[0] = '\0'; //strncpy( ReturnedData.szSymbol, "SymbolUninitialized", sizeof( ReturnedData.szSymbol ) ); + ReturnedData.iLine = 0; + ReturnedData.iSymbolOffset = 0; + + int iTranslated = RetrieveStackInfo( &pAddress, &ReturnedData, 1 ); + + if( iTranslated == 1 ) + { + //store + return CreateEntry( ReturnedData ); + } + + return FindInfoEntry( pAddress ); //probably won't work, but last ditch. + } + + inline StackAddressInfo_t *FindOrCreateEntry( const void *pAddress ) + { + StackAddressInfo_t *pReturn = FindInfoEntry( pAddress ); + if( pReturn == NULL ) + { + pReturn = CreateEntry( pAddress ); + } + + return pReturn; + } + + inline void LoadStackInformation( void * const *pAddresses, int iAddressCount ) + { + Assert( (iAddressCount > 0) && (pAddresses != NULL) ); + + int iNeedLoading = 0; + void **pNeedLoading = (void **)stackalloc( sizeof( const void * ) * iAddressCount ); //addresses we need to ask VXConsole about + + for( int i = 0; i != iAddressCount; ++i ) + { + if( FindInfoEntry( pAddresses[i] ) == NULL ) + { + //need to load this address + pNeedLoading[iNeedLoading] = pAddresses[i]; + ++iNeedLoading; + } + } + + if( iNeedLoading != 0 ) + { + //ask VXConsole for information about the addresses we're clueless about + FullStackInfo_t *pReturnedStructs = (FullStackInfo_t *)stackalloc( sizeof( FullStackInfo_t ) * iNeedLoading ); + + for( int i = 0; i < iNeedLoading; ++i ) + { + pReturnedStructs[i].pAddress = 0; + pReturnedStructs[i].szFileName[0] = '\0'; //strncpy( pReturnedStructs[i].szFileName, "FileUninitialized", sizeof( pReturnedStructs[i].szFileName ) ); + pReturnedStructs[i].szModuleName[0] = '\0'; //strncpy( pReturnedStructs[i].szModuleName, "ModuleUninitialized", sizeof( pReturnedStructs[i].szModuleName ) ); + pReturnedStructs[i].szSymbol[0] = '\0'; //strncpy( pReturnedStructs[i].szSymbol, "SymbolUninitialized", sizeof( pReturnedStructs[i].szSymbol ) ); + pReturnedStructs[i].iLine = 0; + pReturnedStructs[i].iSymbolOffset = 0; + } + + int iTranslated = RetrieveStackInfo( pNeedLoading, pReturnedStructs, iNeedLoading ); + + if( iTranslated == iNeedLoading ) + { + //store + for( int i = 0; i < iTranslated; ++i ) + { + CreateEntry( pReturnedStructs[i] ); + } + } + } + } + + inline bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut ) + { + StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress ); + if( pInfo && (pInfo->szFileName[0] != '\0') ) + { + strncpy( pFileNameOut, pInfo->szFileName, iMaxFileNameLength ); + iLineNumberOut = pInfo->iLine; + + if( pDisplacementOut ) + *pDisplacementOut = 0; //can't get line displacement on 360 + + return true; + } + + return false; + } + + inline bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut ) + { + StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress ); + if( pInfo && (pInfo->szSymbol[0] != '\0') ) + { + strncpy( pSymbolNameOut, pInfo->szSymbol, iMaxSymbolNameLength ); + + if( pDisplacementOut ) + *pDisplacementOut = pInfo->iSymbolOffset; + + return true; + } + + return false; + } + + inline bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength ) + { + StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress ); + if( pInfo && (pInfo->szModule[0] != '\0') ) + { + strncpy( pModuleNameOut, pInfo->szModule, iMaxModuleNameLength ); + return true; + } + + return false; + } + + + CThreadFastMutex m_hMutex; + +private: + +#pragma pack(push) +#pragma pack(1) + struct StackAddressInfo_t + { + StackAddressInfo_t( void ) : szModule(NULL), szFileName(NULL), szSymbol(NULL), iLine(0), iSymbolOffset(0) {} + const char *szModule; + const char *szFileName; + const char *szSymbol; + uint32 iLine; + uint32 iSymbolOffset; + }; +#pragma pack(pop) + + typedef std::map< const void *, StackAddressInfo_t, std::less<const void *>> AddressInfoMap_t; + typedef AddressInfoMap_t::iterator AddressInfoMapIter_t; + typedef AddressInfoMap_t::value_type AddressInfoMapEntry_t; + + class CStringLess + { + public: + bool operator()(const char *pszLeft, const char *pszRight ) const + { + return ( V_tier0_stricmp( pszLeft, pszRight ) < 0 ); + } + }; + + typedef std::set<const char *, CStringLess> StringSet_t; + + AddressInfoMap_t m_AddressInfoMap; //TODO: retire old entries? + StringSet_t m_ModuleNameSet; + StringSet_t m_FileNameSet; + StringSet_t m_SymbolNameSet; + bool m_bInitialized; + +}; +static C360StackTranslationHelper s_360StackTranslator; + + +int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount ) +{ + ++iSkipCount; //skip this function + + //DmCaptureStackBackTrace() has no skip functionality, so we need to grab everything and skip within that list + void **pAllResults = (void **)stackalloc( sizeof( void * ) * (iArrayCount + iSkipCount) ); + if( DmCaptureStackBackTrace( iArrayCount + iSkipCount, pAllResults ) == XBDM_NOERR ) + { + for( int i = 0; i != iSkipCount; ++i ) + { + if( *pAllResults == NULL ) //DmCaptureStackBackTrace() NULL terminates the list instead of telling us how many were returned + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 ); + + ++pAllResults; //move the pointer forward so the second loop indices match up + } + + for( int i = 0; i != iArrayCount; ++i ) + { + if( pAllResults[i] == NULL ) //DmCaptureStackBackTrace() NULL terminates the list instead of telling us how many were returned + return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i ); + + pReturnAddressesOut[i] = pAllResults[i]; + } + + return iArrayCount; //no room to append parent + } + + return GetCallStack_Fast( pReturnAddressesOut, iArrayCount, iSkipCount ); +} + + +void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList ) +{ + //nop on 360 +} + + +void StackToolsNotify_LoadedLibrary( const char *szLibName ) +{ + //send off the notice to VXConsole + uint8 message[2]; + message[0] = XBX_DBG_BNH_STACKTRANSLATOR; //have this message handled by stack translator handler + message[1] = ST_BHC_LOADEDLIBARY; //loaded a library notification + XBX_SendBinaryData( message, 2 ); +} + + +int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style ) +{ + if( iCallStackCount == 0 ) + { + if( iOutBufferSize > 1 ) + *szOutput = '\0'; + + return 0; + } + + if( szEntrySeparator == NULL ) + szEntrySeparator = ""; + + int iSeparatorLength = strlen( szEntrySeparator ) + 1; + int iDataSize = (sizeof( void * ) * iCallStackCount) + (iSeparatorLength * sizeof( tchar )) + 1; //1 for style flags + + //360 is incapable of translation on it's own. Encode the stack for translation in VXConsole + //Encoded section is as such ":CSDECODE[encoded binary]" + int iEncodedSize = -EncodeBinaryToString( NULL, iDataSize, NULL, 0 ); //get needed buffer size + const tchar cControlPrefix[] = XBX_CALLSTACKDECODEPREFIX; + const size_t cControlLength = (sizeof( cControlPrefix )/sizeof(tchar)) - 1; //-1 to remove null terminator + + if( iOutBufferSize > (iEncodedSize + (int)cControlLength + 2) ) //+2 for ']' and null term + { + COMPILE_TIME_ASSERT( TSISTYLEFLAG_LAST < (1<<8) ); //need to update the encoder/decoder to use more than a byte for style flags + + uint8 *pData = (uint8 *)stackalloc( iDataSize ); + pData[0] = (uint8)style; + memcpy( pData + 1, szEntrySeparator, iSeparatorLength * sizeof( tchar ) ); + memcpy( pData + 1 + (iSeparatorLength * sizeof( tchar )), pCallStack, iCallStackCount * sizeof( void * ) ); + + memcpy( szOutput, XBX_CALLSTACKDECODEPREFIX, cControlLength * sizeof( tchar ) ); + int iLength = cControlLength + EncodeBinaryToString( pData, iDataSize, &szOutput[cControlLength], (iOutBufferSize - cControlLength) ); + + szOutput[iLength] = ']'; + szOutput[iLength + 1] = '\0'; + } + + return iCallStackCount; +} + +void PreloadStackInformation( void * const *pAddresses, int iAddressCount ) +{ + AUTO_LOCK_FM( s_360StackTranslator.m_hMutex ); + s_360StackTranslator.LoadStackInformation( pAddresses, iAddressCount ); +} + +bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut ) +{ + AUTO_LOCK_FM( s_360StackTranslator.m_hMutex ); + return s_360StackTranslator.GetFileAndLineFromAddress( pAddress, pFileNameOut, iMaxFileNameLength, iLineNumberOut, pDisplacementOut ); +} + +bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut ) +{ + AUTO_LOCK_FM( s_360StackTranslator.m_hMutex ); + return s_360StackTranslator.GetSymbolNameFromAddress( pAddress, pSymbolNameOut, iMaxSymbolNameLength, pDisplacementOut ); +} + +bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength ) +{ + AUTO_LOCK_FM( s_360StackTranslator.m_hMutex ); + return s_360StackTranslator.GetModuleNameFromAddress( pAddress, pModuleNameOut, iMaxModuleNameLength ); +} + +#endif //#else //#if defined( WIN32 ) && !defined( _X360 ) + +#endif //#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + + + + +CCallStackStorage::CCallStackStorage( FN_GetCallStack GetStackFunction, uint32 iSkipCalls ) +{ + iValidEntries = GetStackFunction( pStack, ARRAYSIZE( pStack ), iSkipCalls + 1 ); +} + + + +CStackTop_CopyParentStack::CStackTop_CopyParentStack( void * const *pParentStackTrace, int iParentStackTraceLength ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + //miniature version of GetCallStack_Fast() +#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\ + (defined( WIN32 ) && !defined( _X360 )) + void *pStackCrawlEBP; + __asm + { + mov [pStackCrawlEBP], ebp; + } + pStackCrawlEBP = *(void **)pStackCrawlEBP; + m_pReplaceAddress = *((void **)pStackCrawlEBP + 1); + m_pStackBase = (void *)((void **)pStackCrawlEBP + 1); +#else + m_pReplaceAddress = NULL; + m_pStackBase = this; +#endif + + m_pParentStackTrace = NULL; + + if( (pParentStackTrace != NULL) && (iParentStackTraceLength > 0) ) + { + while( (iParentStackTraceLength > 0) && (pParentStackTrace[iParentStackTraceLength - 1] == NULL) ) + { + --iParentStackTraceLength; + } + + if( iParentStackTraceLength > 0 ) + { + m_pParentStackTrace = new void * [iParentStackTraceLength]; + memcpy( (void **)m_pParentStackTrace, pParentStackTrace, sizeof( void * ) * iParentStackTraceLength ); + } + } + + m_iParentStackTraceLength = iParentStackTraceLength; + + m_pPrevTop = g_StackTop; + g_StackTop = this; + Assert( (CStackTop_Base *)g_StackTop == this ); +#endif //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) +} + +CStackTop_CopyParentStack::~CStackTop_CopyParentStack( void ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + Assert( (CStackTop_Base *)g_StackTop == this ); + g_StackTop = m_pPrevTop; + + if( m_pParentStackTrace != NULL ) + { + delete []m_pParentStackTrace; + } +#endif +} + + + +CStackTop_ReferenceParentStack::CStackTop_ReferenceParentStack( void * const *pParentStackTrace, int iParentStackTraceLength ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + //miniature version of GetCallStack_Fast() +#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\ + (defined( WIN32 ) && !defined( _X360 )) + void *pStackCrawlEBP; + __asm + { + mov [pStackCrawlEBP], ebp; + } + pStackCrawlEBP = *(void **)pStackCrawlEBP; + m_pReplaceAddress = *((void **)pStackCrawlEBP + 1); + m_pStackBase = (void *)((void **)pStackCrawlEBP + 1); +#else + m_pReplaceAddress = NULL; + m_pStackBase = this; +#endif + + m_pParentStackTrace = pParentStackTrace; + + if( (pParentStackTrace != NULL) && (iParentStackTraceLength > 0) ) + { + while( (iParentStackTraceLength > 0) && (pParentStackTrace[iParentStackTraceLength - 1] == NULL) ) + { + --iParentStackTraceLength; + } + } + + m_iParentStackTraceLength = iParentStackTraceLength; + + m_pPrevTop = g_StackTop; + g_StackTop = this; + Assert( (CStackTop_Base *)g_StackTop == this ); +#endif //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) +} + +CStackTop_ReferenceParentStack::~CStackTop_ReferenceParentStack( void ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + Assert( (CStackTop_Base *)g_StackTop == this ); + g_StackTop = m_pPrevTop; + + ReleaseParentStackReferences(); +#endif +} + +void CStackTop_ReferenceParentStack::ReleaseParentStackReferences( void ) +{ +#if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) + m_pParentStackTrace = NULL; + m_iParentStackTraceLength = 0; +#endif +} + + + + +//Encodes data so that every byte's most significant bit is a 1. Ensuring no null terminators. +//This puts the encoded data in the 128-255 value range. Leaving all standard ascii characters for control. +//Returns string length (not including the written null terminator as is standard). +//Or if the buffer is too small. Returns negative of necessary buffer size (including room needed for null terminator) +int EncodeBinaryToString( const void *pToEncode, int iDataLength, char *pEncodeOut, int iEncodeBufferSize ) +{ + int iEncodedSize = iDataLength; + iEncodedSize += (iEncodedSize + 6) / 7; //Have 1 control byte for every 7 actual bytes + iEncodedSize += sizeof( uint32 ) + 1; //data size at the beginning of the blob and null terminator at the end + + if( (iEncodedSize > iEncodeBufferSize) || (pEncodeOut == NULL) || (pToEncode == NULL) ) + return -iEncodedSize; //not enough room + + uint8 *pEncodeWrite = (uint8 *)pEncodeOut; + + //first encode the data size. Encodes lowest 28 bits and discards the high 4 + pEncodeWrite[0] = ((iDataLength >> 21) & 0xFF) | 0x80; + pEncodeWrite[1] = ((iDataLength >> 14) & 0xFF) | 0x80; + pEncodeWrite[2] = ((iDataLength >> 7) & 0xFF) | 0x80; + pEncodeWrite[3] = ((iDataLength >> 0) & 0xFF) | 0x80; + pEncodeWrite += 4; + + const uint8 *pEncodeRead = (const uint8 *)pToEncode; + const uint8 *pEncodeStop = pEncodeRead + iDataLength; + uint8 *pEncodeWriteLastControlByte = pEncodeWrite; + int iControl = 0; + + //Encode the data + while( pEncodeRead < pEncodeStop ) + { + if( iControl == 0 ) + { + pEncodeWriteLastControlByte = pEncodeWrite; + *pEncodeWriteLastControlByte = 0x80; + } + else + { + *pEncodeWrite = *pEncodeRead | 0x80; //encoded data always has the MSB bit set (cheap avoidance of null terminators) + *pEncodeWriteLastControlByte |= (((*pEncodeRead) & 0x80) ^ 0x80) >> iControl; //We use the control byte to XOR the MSB back to original values on decode + ++pEncodeRead; + } + + ++pEncodeWrite; + ++iControl; + iControl &= 7; //8->0 + } + *pEncodeWrite = '\0'; + + return iEncodedSize - 1; +} + +//Decodes a string produced by EncodeBinaryToString(). Safe to decode in place if you don't mind trashing your string, binary byte count always less than string byte count. +//Returns: +// >= 0 is the decoded data size +// INT_MIN (most negative value possible) indicates an improperly formatted string (not our data) +// all other negative values are the negative of how much dest buffer size is necessary. +int DecodeBinaryFromString( const char *pString, void *pDestBuffer, int iDestBufferSize, char **ppParseFinishOut ) +{ + const uint8 *pDecodeRead = (const uint8 *)pString; + + if( (pDecodeRead[0] < 0x80) || (pDecodeRead[1] < 0x80) || (pDecodeRead[2] < 0x80) || (pDecodeRead[3] < 0x80) ) + { + if( ppParseFinishOut != NULL ) + *ppParseFinishOut = (char *)pString; + + return INT_MIN; //Don't know what the string is, but it's not our format + } + + int iDecodedSize = 0; + iDecodedSize |= (pDecodeRead[0] & 0x7F) << 21; + iDecodedSize |= (pDecodeRead[1] & 0x7F) << 14; + iDecodedSize |= (pDecodeRead[2] & 0x7F) << 7; + iDecodedSize |= (pDecodeRead[3] & 0x7F) << 0; + pDecodeRead += 4; + + int iTextLength = iDecodedSize; + iTextLength += (iTextLength + 6) / 7; //Have 1 control byte for every 7 actual bytes + + //make sure it's formatted properly + for( int i = 0; i != iTextLength; ++i ) + { + if( pDecodeRead[i] < 0x80 ) //encoded data always has MSB set + { + if( ppParseFinishOut != NULL ) + *ppParseFinishOut = (char *)pString; + + return INT_MIN; //either not our data, or part of the string is missing + } + } + + if( iDestBufferSize < iDecodedSize ) + { + if( ppParseFinishOut != NULL ) + *ppParseFinishOut = (char *)pDecodeRead; + + return -iDecodedSize; //dest buffer not big enough to hold the data + } + + const uint8 *pStopDecoding = pDecodeRead + iTextLength; + uint8 *pDecodeWrite = (uint8 *)pDestBuffer; + int iControl = 0; + int iLSBXOR = 0; + + while( pDecodeRead < pStopDecoding ) + { + if( iControl == 0 ) + { + iLSBXOR = *pDecodeRead; + } + else + { + *pDecodeWrite = *pDecodeRead ^ ((iLSBXOR << iControl) & 0x80); + ++pDecodeWrite; + } + + ++pDecodeRead; + ++iControl; + iControl &= 7; //8->0 + } + + if( ppParseFinishOut != NULL ) + *ppParseFinishOut = (char *)pDecodeRead; + + return iDecodedSize; +} + + diff --git a/external/vpc/tier0/threadtools.cpp b/external/vpc/tier0/threadtools.cpp new file mode 100644 index 0000000..735f233 --- /dev/null +++ b/external/vpc/tier0/threadtools.cpp @@ -0,0 +1,3096 @@ +//========== Copyright 2005, Valve Corporation, All rights reserved. ======== +// +// Purpose: +// +//============================================================================= + +#include "tier0/platform.h" + +#if defined( PLATFORM_WINDOWS_PC ) +#define WIN32_LEAN_AND_MEAN +#define _WIN32_WINNT 0x0403 +#include <windows.h> +#endif + +#ifdef PLATFORM_WINDOWS + #include <process.h> + #ifdef PLATFORM_WINDOWS_PC + #include <Mmsystem.h> + #pragma comment(lib, "winmm.lib") + #endif +#elif PLATFORM_PS3 + #include <sched.h> + #include <unistd.h> + #include <exception> + #include <errno.h> + #include <pthread.h> + #include <sys/time.h> + #include <sys/timer.h> + #define GetLastError() errno + typedef void *LPVOID; +#elif PLATFORM_POSIX + #include <sched.h> + #include <exception> + #include <errno.h> + #include <signal.h> + #include <pthread.h> + #include <sys/time.h> + #define GetLastError() errno + typedef void *LPVOID; +#if !defined(OSX) + #include <sys/fcntl.h> + #include <sys/unistd.h> + #define sem_unlink( arg ) +#else + #define pthread_yield pthread_yield_np + #include <mach/thread_act.h> +#endif // !OSX + +#endif + +#ifndef _PS3 +#include <memory.h> +#endif +#include "tier0/threadtools.h" + +#ifdef _X360 +#include "xbox/xbox_win32stubs.h" +#endif + +#include <map> + +// Must be last header... +#include "tier0/memdbgon.h" + +#ifdef _PS3 +#include "ps3/ps3_win32stubs.h" +#define NEW_WAIT_FOR_MULTIPLE_OBJECTS +bool gbCheckNotMultithreaded = true; +#endif + +#define THREADS_DEBUG 1 + +#define DEBUG_ERROR(XX) Assert(0) + +// Need to ensure initialized before other clients call in for main thread ID +#ifdef _WIN32 +#pragma warning(disable:4073) +#pragma init_seg(lib) +#endif + +#ifdef _WIN32 +ASSERT_INVARIANT(TT_SIZEOF_CRITICALSECTION == sizeof(CRITICAL_SECTION)); +ASSERT_INVARIANT(TT_INFINITE == INFINITE); +#endif + +// thread creation counter. +// this is used to provide a unique threadid for each running thread in g_nThreadID ( a thread local variable ). + +const int MAX_THREAD_IDS = 128; + +static volatile bool s_bThreadIDAllocated[MAX_THREAD_IDS]; + +#ifdef LINUX + +DLL_CLASS_EXPORT __thread int g_nThreadID; + +#elif defined(_PS3) + #include "tls_ps3.h" +#else + CTHREADLOCALINT g_nThreadID; +#endif + + +static CThreadFastMutex s_ThreadIDMutex; + +PLATFORM_INTERFACE void AllocateThreadID( void ) +{ + AUTO_LOCK( s_ThreadIDMutex ); + for( int i = 1; i < MAX_THREAD_IDS; i++ ) + { + if ( ! s_bThreadIDAllocated[i] ) + { + g_nThreadID = i; + s_bThreadIDAllocated[i] = true; + return; + } + } + Error( "Out of thread ids. Decrease the number of threads or increase MAX_THREAD_IDS\n" ); +} + +PLATFORM_INTERFACE void FreeThreadID( void ) +{ + AUTO_LOCK( s_ThreadIDMutex ); + int nThread = g_nThreadID; + if ( nThread ) + s_bThreadIDAllocated[nThread] = false; +} + + +//----------------------------------------------------------------------------- +// Simple thread functions. +// Because _beginthreadex uses stdcall, we need to convert to cdecl +//----------------------------------------------------------------------------- +struct ThreadProcInfo_t +{ + ThreadProcInfo_t( ThreadFunc_t pfnThread, void *pParam ) + : pfnThread( pfnThread), + pParam( pParam ) + { + } + + ThreadFunc_t pfnThread; + void * pParam; +}; + +//--------------------------------------------------------- + +#ifdef PLATFORM_WINDOWS +static DWORD WINAPI ThreadProcConvert( void *pParam ) +{ + ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam); + AllocateThreadID(); + delete ((ThreadProcInfo_t *)pParam); + unsigned nRet = (*info.pfnThread)(info.pParam); + FreeThreadID(); + return nRet; +} +#elif defined( PLATFORM_PS3 ) +union ThreadProcInfoUnion_t +{ + struct Val_t + { + ThreadFunc_t pfnThread; + void * pParam; + } + val; + uint64_t val64; +}; +static void ThreadProcConvertUnion( uint64_t param ) +{ + COMPILE_TIME_ASSERT( sizeof( ThreadProcInfoUnion_t ) == 8 ); + ThreadProcInfoUnion_t info; + info.val64 = param; + AllocateThreadID(); + unsigned nRet = (*info.val.pfnThread)(info.val.pParam); + FreeThreadID(); + sys_ppu_thread_exit( nRet ); +} +static void* ThreadProcConvert( void *pParam ) +{ + ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam); + AllocateThreadID(); + delete ((ThreadProcInfo_t *)pParam); + unsigned nRet = (*info.pfnThread)(info.pParam); + FreeThreadID(); + return ( void * ) nRet; +} + +#else +static void* ThreadProcConvert( void *pParam ) +{ + ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam); + AllocateThreadID(); + delete ((ThreadProcInfo_t *)pParam); + unsigned nRet = (*info.pfnThread)(info.pParam); + FreeThreadID(); + return ( void * ) nRet; +} +#endif + + + +#if defined( _PS3 ) + +/******************************************************************************* +* Thread Local Storage globals and functions +*******************************************************************************/ +#ifndef _PS3 +__thread void *gTLSValues[ MAX_TLS_VALUES ] = { NULL }; +__thread bool gTLSFlags[ MAX_TLS_VALUES ] = { false }; +__thread bool gbWaitObjectsCreated = false; +__thread sys_semaphore_t gWaitObjectsSemaphore; +#endif // !_PS3 + +static char gThreadName[28] = ""; + +// Simple TLS allocator. Linearly searches for a free slot. +uint32 TlsAlloc() +{ + for ( int i = 0; i < MAX_TLS_VALUES; ++i ) + { + if ( !gTLSFlags[i] ) + { + gTLSFlags[i] = true; + return i; + } + } + +#ifdef _PS3 + DEBUG_ERROR("TlsAlloc(): Out of TLS\n"); +#endif + + return 0xFFFFFFFF; +} + +void TlsFree( uint32 index ) +{ + gTLSValues[ index ] = NULL; + gTLSFlags[ index ] = false; +} + +void *TlsGetValue( uint32 index ) +{ + return gTLSValues[ index ]; +} + +void TlsSetValue( uint32 index, void *pValue ) +{ + gTLSValues[ index ] = pValue; +} +#endif //_PS3 + + + +#ifdef PLATFORM_WINDOWS +class CThreadHandleToIDMap +{ +public: + HANDLE m_hThread; + uint m_ThreadID; + CThreadHandleToIDMap *m_pNext; +}; +static CThreadHandleToIDMap *g_pThreadHandleToIDMaps = NULL; +static CThreadMutex g_ThreadHandleToIDMapMutex; +static volatile int g_nThreadHandleToIDMaps = 0; + +static void AddThreadHandleToIDMap( HANDLE hThread, uint threadID ) +{ + if ( !hThread ) + return; + + // Remember this handle/id combo. + CThreadHandleToIDMap *pMap = new CThreadHandleToIDMap; + pMap->m_hThread = hThread; + pMap->m_ThreadID = threadID; + + // Add it to the global list. + g_ThreadHandleToIDMapMutex.Lock(); + pMap->m_pNext = g_pThreadHandleToIDMaps; + g_pThreadHandleToIDMaps = pMap; + ++g_nThreadHandleToIDMaps; + + g_ThreadHandleToIDMapMutex.Unlock(); + + if ( g_nThreadHandleToIDMaps > 500 ) + Error( "ThreadHandleToIDMap overflow." ); +} + +// This assumes you've got g_ThreadHandleToIDMapMutex locked!! +static bool InternalLookupHandleToThreadIDMap( HANDLE hThread, CThreadHandleToIDMap* &pMap, CThreadHandleToIDMap** &ppPrev ) +{ + ppPrev = &g_pThreadHandleToIDMaps; + for ( pMap=g_pThreadHandleToIDMaps; pMap; pMap=pMap->m_pNext ) + { + if ( pMap->m_hThread == hThread ) + return true; + + ppPrev = &pMap->m_pNext; + } + + return false; +} + +static void RemoveThreadHandleToIDMap( HANDLE hThread ) +{ + if ( !hThread ) + return; + + CThreadHandleToIDMap *pMap, **ppPrev; + + g_ThreadHandleToIDMapMutex.Lock(); + + if ( g_nThreadHandleToIDMaps <= 0 ) + Error( "ThreadHandleToIDMap underflow." ); + + if ( InternalLookupHandleToThreadIDMap( hThread, pMap, ppPrev ) ) + { + *ppPrev = pMap->m_pNext; + delete pMap; + --g_nThreadHandleToIDMaps; + } + + g_ThreadHandleToIDMapMutex.Unlock(); +} + +static uint LookupThreadIDFromHandle( HANDLE hThread ) +{ + if ( hThread == NULL || hThread == GetCurrentThread() ) + return GetCurrentThreadId(); + + float flStartTime = Plat_FloatTime(); + while ( Plat_FloatTime() - flStartTime < 2 ) + { + CThreadHandleToIDMap *pMap, **ppPrev; + + g_ThreadHandleToIDMapMutex.Lock(); + bool bRet = InternalLookupHandleToThreadIDMap( hThread, pMap, ppPrev ); + g_ThreadHandleToIDMapMutex.Unlock(); + + if ( bRet ) + return pMap->m_ThreadID; + + // We should only get here if a thread that is just starting up is currently in AddThreadHandleToIDMap. + // Give up the timeslice and try again. + ThreadSleep( 1 ); + } + + Assert( !"LookupThreadIDFromHandle failed!" ); + Warning( "LookupThreadIDFromHandle couldn't find thread ID for handle." ); + return 0; +} +#endif + + +//--------------------------------------------------------- + +ThreadHandle_t * CreateTestThreads( ThreadFunc_t fnThread, int numThreads, int nProcessorsToDistribute ) +{ + ThreadHandle_t *pHandles = (new ThreadHandle_t[numThreads+1]) + 1; + pHandles[-1] = (ThreadHandle_t)INT_TO_POINTER( numThreads ); + for( int i = 0; i < numThreads; ++i ) + { + //TestThreads(); + ThreadHandle_t hThread; + const unsigned int nDefaultStackSize = 64 * 1024; // this stack size is used in case stackSize == 0 + hThread = CreateSimpleThread( fnThread, INT_TO_POINTER( i ), nDefaultStackSize ); + + if ( nProcessorsToDistribute ) + { + int32 mask = 1 << (i % nProcessorsToDistribute); + ThreadSetAffinity( hThread, mask ); + } + +/* + ThreadProcInfoUnion_t info; + info.val.pfnThread = fnThread; + info.val.pParam = (void*)(i); + if ( int nError = sys_ppu_thread_create( &hThread, ThreadProcConvertUnion, info.val64, 1001, nDefaultStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, "SimpleThread" ) != CELL_OK ) + { + printf( "PROBLEM!\n" ); + Error( "Cannot create thread, error %d\n", nError ); + return 0; + } +*/ + //ThreadHandle_t hThread = CreateSimpleThread( fnThread, (void*)i ); + pHandles[i] = hThread; + } +// printf("Finishinged CreateTestThreads(%p,%d)\n", (void*)fnThread, numThreads ); + return pHandles; +} + +void JoinTestThreads( ThreadHandle_t *pHandles ) +{ + int nCount = POINTER_TO_INT( pHandles[-1] ); +// printf("Joining test threads @%p[%d]:\n", pHandles, nCount ); +// for( int i = 0; i < nCount; ++i ) +// { +// printf(" %p,\n", (void*)pHandles[i] ); +// } + for( int i = 0; i < nCount; ++i ) + { +// printf( "Joining %p", (void*) pHandles[i] ); +// if( !i ) sys_timer_usleep(100000); + ThreadJoin( pHandles[i] ); + ReleaseThreadHandle( pHandles[i] ); + } + delete[]( pHandles - 1 ); +} + + + +ThreadHandle_t CreateSimpleThread( ThreadFunc_t pfnThread, void *pParam, unsigned stackSize ) +{ +#ifdef PLATFORM_WINDOWS + DWORD threadID; + HANDLE hThread = (HANDLE)CreateThread( NULL, stackSize, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ), 0, &threadID ); + AddThreadHandleToIDMap( hThread, threadID ); + return (ThreadHandle_t)hThread; +#elif PLATFORM_PS3 + //TestThreads(); + ThreadHandle_t th; + ThreadProcInfoUnion_t info; + info.val.pfnThread = pfnThread; + info.val.pParam = pParam; + const unsigned int nDefaultStackSize = 64 * 1024; // this stack size is used in case stackSize == 0 + if ( sys_ppu_thread_create( &th, ThreadProcConvertUnion, info.val64, 1001, stackSize ? stackSize : nDefaultStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, "SimpleThread" ) != CELL_OK ) + { + AssertMsg1( 0, "Failed to create thread (error 0x%x)", errno ); + return 0; + } + return th; +#elif PLATFORM_POSIX + pthread_t tid; + pthread_create( &tid, NULL, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ) ); + return ( ThreadHandle_t ) tid; +#else + Assert( 0 ); + DebuggerBreak(); + return 0; +#endif +} + + +bool ReleaseThreadHandle( ThreadHandle_t hThread ) +{ +#ifdef _WIN32 + bool bRetVal = ( CloseHandle( hThread ) != 0 ); + RemoveThreadHandleToIDMap( (HANDLE)hThread ); + return bRetVal; +#else + return true; +#endif +} + +//----------------------------------------------------------------------------- +// +// Wrappers for other simple threading operations +// +//----------------------------------------------------------------------------- + +void ThreadSleep(unsigned nMilliseconds) +{ +#ifdef _WIN32 + +#ifdef PLATFORM_WINDOWS_PC + static bool bInitialized = false; + if ( !bInitialized ) + { + bInitialized = true; + // Set the timer resolution to 1 ms (default is 10.0, 15.6, 2.5, 1.0 or + // some other value depending on hardware and software) so that we can + // use Sleep( 1 ) to avoid wasting CPU time without missing our frame + // rate. + timeBeginPeriod( 1 ); + } +#endif + + Sleep( nMilliseconds ); +#elif PLATFORM_PS3 + if( nMilliseconds == 0 ) + { + // sys_ppu_thread_yield doesn't seem to function properly, so sleep instead. + sys_timer_usleep( 60 ); + } + else + { + sys_timer_usleep( nMilliseconds * 1000 ); + } +#elif defined(POSIX) + usleep( nMilliseconds * 1000 ); +#endif +} + +//----------------------------------------------------------------------------- + +#ifndef ThreadGetCurrentId +ThreadId_t ThreadGetCurrentId() +{ +#ifdef _WIN32 + return GetCurrentThreadId(); +#elif defined( _PS3 ) + sys_ppu_thread_t th = 0; + sys_ppu_thread_get_id( &th ); + return th; +#elif defined(POSIX) + return (ThreadId_t)pthread_self(); +#else + Assert(0); + DebuggerBreak(); + return 0; +#endif +} +#endif + +//----------------------------------------------------------------------------- +ThreadHandle_t ThreadGetCurrentHandle() +{ +#ifdef _WIN32 + return (ThreadHandle_t)GetCurrentThread(); +#elif defined( _PS3 ) + sys_ppu_thread_t th = 0; + sys_ppu_thread_get_id( &th ); + return th; +#elif defined(POSIX) + return (ThreadHandle_t)pthread_self(); +#else + Assert(0); + DebuggerBreak(); + return 0; +#endif +} + +//----------------------------------------------------------------------------- + +int ThreadGetPriority( ThreadHandle_t hThread ) +{ + if ( !hThread ) + { + hThread = ThreadGetCurrentHandle(); + } + +#ifdef _WIN32 + return ::GetThreadPriority( (HANDLE)hThread ); +#elif defined( _PS3 ) + int iPri = 0; + sys_ppu_thread_get_priority( hThread, &iPri ); + return iPri; +#else + return 0; +#endif +} + +//----------------------------------------------------------------------------- + +bool ThreadSetPriority( ThreadHandle_t hThread, int priority ) +{ + if ( !hThread ) + { + hThread = ThreadGetCurrentHandle(); + } + +#ifdef _WIN32 + return ( SetThreadPriority(hThread, priority) != 0 ); +#elif defined( _PS3 ) + int retval = sys_ppu_thread_set_priority( hThread, priority ); + return retval >= CELL_OK; +#elif defined(POSIX) + struct sched_param thread_param; + thread_param.sched_priority = priority; + //pthread_setschedparam( (pthread_t ) hThread, SCHED_RR, &thread_param ); + return true; +#endif +} + +//----------------------------------------------------------------------------- + +void ThreadSetAffinity( ThreadHandle_t hThread, int nAffinityMask ) +{ + if ( !hThread ) + { + hThread = ThreadGetCurrentHandle(); + } + +#ifdef _WIN32 + SetThreadAffinityMask( hThread, nAffinityMask ); +#elif defined(POSIX) +// cpu_set_t cpuSet; +// CPU_ZERO( cpuSet ); +// for( int i = 0 ; i < 32; i++ ) +// if ( nAffinityMask & ( 1 << i ) ) +// CPU_SET( cpuSet, i ); +// sched_setaffinity( hThread, sizeof( cpuSet ), &cpuSet ); +#endif + +} + +//----------------------------------------------------------------------------- + +#ifndef _X360 +uint InitMainThread() +{ + ThreadSetDebugName( "MainThrd" ); + + return ThreadGetCurrentId(); +} + +unsigned long g_ThreadMainThreadID = InitMainThread(); + +bool ThreadInMainThread() +{ + return ( ThreadGetCurrentId() == g_ThreadMainThreadID ); +} + +void DeclareCurrentThreadIsMainThread() +{ + g_ThreadMainThreadID = ThreadGetCurrentId(); +} + +#else +byte *InitMainThread() +{ + byte b; + + return AlignValue( &b, 64*1024 ); +} +#define STACK_SIZE_360 327680 +byte *g_pBaseMainStack = InitMainThread(); +byte *g_pLimitMainStack = InitMainThread() - STACK_SIZE_360; +#endif + +//----------------------------------------------------------------------------- +bool ThreadJoin( ThreadHandle_t hThread, unsigned timeout ) +{ + if ( !hThread ) + { + return false; + } + +#ifdef _WIN32 + DWORD dwWait = WaitForSingleObject( (HANDLE)hThread, timeout ); + if ( dwWait == WAIT_TIMEOUT) + return false; + if ( dwWait != WAIT_OBJECT_0 && ( dwWait != WAIT_FAILED && GetLastError() != 0 ) ) + { + Assert( 0 ); + return false; + } +#elif defined( _PS3 ) + uint64 uiExitCode = 0; + int retval = sys_ppu_thread_join( hThread, &uiExitCode ); + return ( retval >= CELL_OK ); +#elif defined(POSIX) + if ( pthread_join( (pthread_t)hThread, NULL ) != 0 ) + return false; +#else + Assert(0); + DebuggerBreak(); +#endif + return true; +} + +//----------------------------------------------------------------------------- +void ThreadSetDebugName( ThreadHandle_t hThread, const char *pszName ) +{ +#ifdef WIN32 + if ( Plat_IsInDebugSession() ) + { +#define MS_VC_EXCEPTION 0x406d1388 + + typedef struct tagTHREADNAME_INFO + { + DWORD dwType; // must be 0x1000 + LPCSTR szName; // pointer to name (in same addr space) + DWORD dwThreadID; // thread ID (-1 caller thread) + DWORD dwFlags; // reserved for future use, most be zero + } THREADNAME_INFO; + + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = pszName; + info.dwThreadID = LookupThreadIDFromHandle( hThread ); + + if ( info.dwThreadID != 0 ) + { + info.dwFlags = 0; + + __try + { + RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(DWORD), (ULONG_PTR *)&info); + } + __except (EXCEPTION_CONTINUE_EXECUTION) + { + } + } + } +#endif +} + + + +//----------------------------------------------------------------------------- +// Used to thread LoadLibrary on the 360 +//----------------------------------------------------------------------------- +static ThreadedLoadLibraryFunc_t s_ThreadedLoadLibraryFunc = 0; +PLATFORM_INTERFACE void SetThreadedLoadLibraryFunc( ThreadedLoadLibraryFunc_t func ) +{ + s_ThreadedLoadLibraryFunc = func; +} + +PLATFORM_INTERFACE ThreadedLoadLibraryFunc_t GetThreadedLoadLibraryFunc() +{ + return s_ThreadedLoadLibraryFunc; +} + + +//----------------------------------------------------------------------------- +// +// CThreadSyncObject (note nothing uses this directly (I think) ) +// +//----------------------------------------------------------------------------- + + +#ifdef _PS3 +uint32_t CThreadSyncObject::m_bstaticMutexInitialized = false; +uint32_t CThreadSyncObject::m_bstaticMutexInitializing = false; +sys_lwmutex_t CThreadSyncObject::m_staticMutex; +#endif + + +CThreadSyncObject::CThreadSyncObject() +#ifdef _WIN32 + : m_hSyncObject( NULL ), m_bCreatedHandle(false) +#elif defined(POSIX) && !defined(PLATFORM_PS3) + : m_bInitalized( false ) +#endif +{ +#ifdef _PS3 + //Do we nee to initialise the staticMutex? + if (m_bstaticMutexInitialized) return; + + //If we are the first thread then create the mutex + if ( cellAtomicCompareAndSwap32(&m_bstaticMutexInitializing, false, true) == false ) + { + sys_lwmutex_attribute_t mutexAttr; + sys_lwmutex_attribute_initialize( mutexAttr ); + mutexAttr.attr_recursive = SYS_SYNC_RECURSIVE; + int err = sys_lwmutex_create( &m_staticMutex, &mutexAttr ); + Assert(err == CELL_OK); + m_bstaticMutexInitialized = true; + } + else + { + //Another thread is already in the process of initialising the mutex, wait for it + while ( !m_bstaticMutexInitialized ) + { + // sys_ppu_thread_yield doesn't seem to function properly, so sleep instead. + sys_timer_usleep( 60 ); + } + } +#endif +} + +//--------------------------------------------------------- + +CThreadSyncObject::~CThreadSyncObject() +{ +#ifdef _WIN32 + if ( m_hSyncObject && m_bCreatedHandle ) + { + if ( !CloseHandle(m_hSyncObject) ) + { + Assert( 0 ); + } + } +#elif defined(POSIX) && !defined( PLATFORM_PS3 ) + if ( m_bInitalized ) + { + pthread_cond_destroy( &m_Condition ); + pthread_mutex_destroy( &m_Mutex ); + m_bInitalized = false; + } +#endif +} + +//--------------------------------------------------------- + +bool CThreadSyncObject::operator!() const +{ +#if PLATFORM_PS3 + return m_bstaticMutexInitialized; +#elif defined( _WIN32 ) + return !m_hSyncObject; +#elif defined(POSIX) + return !m_bInitalized; +#endif +} + +//--------------------------------------------------------- + +void CThreadSyncObject::AssertUseable() +{ +#ifdef THREADS_DEBUG +#if PLATFORM_PS3 + AssertMsg( m_bstaticMutexInitialized, "Thread synchronization object is unuseable" ); +#elif defined( _WIN32 ) + AssertMsg( m_hSyncObject, "Thread synchronization object is unuseable" ); +#elif defined(POSIX) + AssertMsg( m_bInitalized, "Thread synchronization object is unuseable" ); +#endif +#endif +} + +//--------------------------------------------------------- + +#if defined(_WIN32) || ( defined(POSIX) && !defined( _PS3 ) ) +bool CThreadSyncObject::Wait( uint32 dwTimeout ) +{ +#ifdef THREADS_DEBUG + AssertUseable(); +#endif +#ifdef _WIN32 + return ( WaitForSingleObject( m_hSyncObject, dwTimeout ) == WAIT_OBJECT_0 ); +#elif defined( POSIX ) && !defined( PLATFORM_PS3 ) + pthread_mutex_lock( &m_Mutex ); + bool bRet = false; + if ( m_cSet > 0 ) + { + bRet = true; + m_bWakeForEvent = false; + } + else + { + volatile int ret = 0; + + while ( !m_bWakeForEvent && ret != ETIMEDOUT ) + { + struct timeval tv; + gettimeofday( &tv, NULL ); + volatile struct timespec tm; + + uint64 actualTimeout = dwTimeout; + + if ( dwTimeout == TT_INFINITE && m_bManualReset ) + actualTimeout = 10; // just wait 10 msec at most for manual reset events and loop instead + + volatile uint64 nNanoSec = (uint64)tv.tv_usec*1000 + (uint64)actualTimeout*1000000; + tm.tv_sec = tv.tv_sec + nNanoSec /1000000000; + tm.tv_nsec = nNanoSec % 1000000000; + + do + { + ret = pthread_cond_timedwait( &m_Condition, &m_Mutex, (const timespec *)&tm ); + } + while( ret == EINTR ); + + bRet = ( ret == 0 ); + + if ( m_bManualReset ) + { + if ( m_cSet ) + break; + if ( dwTimeout == TT_INFINITE && ret == ETIMEDOUT ) + ret = 0; // force the loop to spin back around + } + } + + if ( bRet ) + m_bWakeForEvent = false; + } + if ( !m_bManualReset && bRet ) + m_cSet = 0; + pthread_mutex_unlock( &m_Mutex ); + return bRet; +#endif +} +#endif + +#ifdef _WIN32 +#pragma optimize( "", off ) // The compiler optimizer screws up the function below. +#endif + +uint32 CThreadSyncObject::WaitForMultiple( int nObjects, CThreadSyncObject **ppObjects, bool bWaitAll, uint32 dwTimeout ) +{ +#if defined( _WIN32 ) + + CThreadSyncObject *pHandles = (CThreadSyncObject*)stackalloc( sizeof(CThreadSyncObject) * nObjects ); + for ( int i=0; i < nObjects; i++ ) + { + pHandles[i].m_hSyncObject = ppObjects[i]->m_hSyncObject; + } + + return WaitForMultiple( nObjects, pHandles, bWaitAll, dwTimeout ); + +#else + + // TODO: Need a more efficient implementation of this. + uint32 dwStartTime = 0; + + if ( dwTimeout != TT_INFINITE ) + dwStartTime = Plat_MSTime(); + + // If bWaitAll = true, then we need to track which ones were triggered. + char *pWasTriggered = NULL; + int nTriggered = 0; + if ( bWaitAll ) + { + pWasTriggered = (char*)stackalloc( nObjects ); + memset( pWasTriggered, 0, nObjects ); + } + + while ( 1 ) + { + for ( int i=0; i < nObjects; i++ ) + { + if ( bWaitAll && pWasTriggered[i] ) + continue; + +#ifdef _PS3 + Assert( !"Not implemented!" ); + if ( false ) +#else + if ( ppObjects[i]->Wait( 0 ) ) +#endif + { + ++nTriggered; + if ( bWaitAll ) + { + if ( nTriggered == nObjects ) + return 0; + else + pWasTriggered[i] = 1; + } + else + { + return i; + } + } + } + + // Timeout? + if ( dwTimeout != TT_INFINITE ) + { + if ( Plat_MSTime() - dwStartTime >= dwTimeout ) + return TW_TIMEOUT; + } + + ThreadSleep( 0 ); + } + +#endif +} + +#ifdef _WIN32 +#pragma optimize( "", on ) +#endif + +uint32 CThreadSyncObject::WaitForMultiple( int nObjects, CThreadSyncObject *pObjects, bool bWaitAll, uint32 dwTimeout ) +{ +#if defined(_WIN32 ) + + HANDLE *pHandles = (HANDLE*)stackalloc( sizeof(HANDLE) * nObjects ); + for ( int i=0; i < nObjects; i++ ) + { + pHandles[i] = pObjects[i].m_hSyncObject; + } + + DWORD ret = WaitForMultipleObjects( nObjects, pHandles, bWaitAll, dwTimeout ); + if ( ret == WAIT_TIMEOUT ) + return TW_TIMEOUT; + else if ( ret >= WAIT_OBJECT_0 && (ret-WAIT_OBJECT_0) < (uint32)nObjects ) + return (int)(ret - WAIT_OBJECT_0); + else if ( ret >= WAIT_ABANDONED_0 && (ret - WAIT_ABANDONED_0) < (uint32)nObjects ) + Error( "Unhandled WAIT_ABANDONED in WaitForMultipleObjects" ); + else if ( ret == WAIT_FAILED ) + return TW_FAILED; + else + Error( "Unknown return value (%lu) from WaitForMultipleObjects", ret ); + + // We'll never get here.. + return 0; + +#else + + CThreadSyncObject **ppObjects = (CThreadSyncObject**)stackalloc( sizeof( CThreadSyncObject* ) * nObjects ); + for ( int i=0; i < nObjects; i++ ) + { + ppObjects[i] = &pObjects[i]; + } + + return WaitForMultiple( nObjects, ppObjects, bWaitAll, dwTimeout ); + +#endif +} + +// To implement these, I need to check that casts are safe +uint32 CThreadEvent::WaitForMultiple( int nObjects, CThreadEvent *pObjects, bool bWaitAll, uint32 dwTimeout ) +{ + // If data ever gets added to CThreadEvent, then we need a different implementation. +#ifdef _PS3 + CThreadEvent **ppObjects = (CThreadEvent**)stackalloc( sizeof( CThreadEvent* ) * nObjects ); + for ( int i=0; i < nObjects; i++ ) + { + ppObjects[i] = &pObjects[i]; + } + return WaitForMultipleObjects( nObjects, ppObjects, bWaitAll, dwTimeout ); +#else + COMPILE_TIME_ASSERT( sizeof( CThreadSyncObject ) == 0 || sizeof( CThreadEvent ) == sizeof( CThreadSyncObject ) ); + return CThreadSyncObject::WaitForMultiple( nObjects, (CThreadSyncObject*)pObjects, bWaitAll, dwTimeout ); +#endif +} + + +uint32 CThreadEvent::WaitForMultiple( int nObjects, CThreadEvent **ppObjects, bool bWaitAll, uint32 dwTimeout ) +{ +#ifdef _PS3 + return WaitForMultipleObjects( nObjects, ppObjects, bWaitAll, dwTimeout ); +#else + // If data ever gets added to CThreadEvent, then we need a different implementation. + COMPILE_TIME_ASSERT( sizeof( CThreadSyncObject )== 0 || sizeof( CThreadEvent ) == sizeof( CThreadSyncObject ) ); + return CThreadSyncObject::WaitForMultiple( nObjects, (CThreadSyncObject**)ppObjects, bWaitAll, dwTimeout ); +#endif +} + + + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +CThreadEvent::CThreadEvent( bool bManualReset ) +{ +#ifdef _WIN32 + m_hSyncObject = CreateEvent( NULL, bManualReset, FALSE, NULL ); + m_bCreatedHandle = true; + AssertMsg1(m_hSyncObject, "Failed to create event (error 0x%x)", GetLastError() ); +#elif defined( _PS3 ) + + m_bManualReset = bManualReset; + m_bSet = 0; + m_bInitalized = false; + m_numWaitingThread = 0; + + // set up linked list of wait objects + + memset(&m_waitObjects[0], 0, sizeof(m_waitObjects)); + m_pWaitObjectsList = &m_waitObjects[0]; + m_pWaitObjectsPool = &m_waitObjects[1]; + + for (int i = 2; i < CTHREADEVENT_MAX_WAITING_THREADS + 2; i++) + { + LLLinkNode(m_pWaitObjectsPool, &m_waitObjects[i]); + } +#elif defined( POSIX ) + pthread_mutexattr_t Attr; + pthread_mutexattr_init( &Attr ); + pthread_mutex_init( &m_Mutex, &Attr ); + pthread_mutexattr_destroy( &Attr ); + pthread_cond_init( &m_Condition, NULL ); + m_bInitalized = true; + m_cSet = 0; + m_bWakeForEvent = false; + m_bManualReset = bManualReset; +#else +#error "Implement me" +#endif +} + + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +#ifdef _PS3 + +// +// linked list functionality +// + +//----------------------------------------------------------------------------- +// Purpose: Linked list implementation +//----------------------------------------------------------------------------- + +CThreadEventWaitObject* CThreadEvent::LLUnlinkNode(CThreadEventWaitObject *node) +{ + // <sergiy> Note: if you have a null-access crash here, it may mean that CTHREADEVENT_MAX_WAITING_THREADS is not high enough + // and the linked list pool is simply exhausted + node->m_pPrev->m_pNext = node->m_pNext; + if (node->m_pNext) node->m_pNext->m_pPrev = node->m_pPrev; + node->m_pNext = node->m_pPrev = NULL; + + return node; +} + +CThreadEventWaitObject* CThreadEvent::LLLinkNode(CThreadEventWaitObject* list, CThreadEventWaitObject *node) +{ + node->m_pNext = list->m_pNext; + if (node->m_pNext) + { + node->m_pNext->m_pPrev = node; + } + + list->m_pNext = node; + node->m_pPrev = list; + + return node; +} + +//----------------------------------------------------------------------------- +// Helper function to atomically write index into destination and set semaphore +// This is used by WaitForMultipleObjects(WAIT_ANY) because once the semaphore +// is set, the waiting thread also needs to know which event triggered it +// We do NOT need this to be atomic because if a number of events fire it doesn't +// matter which one of these we pick +//----------------------------------------------------------------------------- +void CThreadEventWaitObject::Set() +{ + *m_pFlag = m_index; + sys_semaphore_post(*m_pSemaphore, 1); +} + +// +// CThreadEvent::RegisterWaitingThread +// +void CThreadEvent::RegisterWaitingThread(sys_semaphore_t *pSemaphore, int index, int *flag) +{ + sys_lwmutex_lock(&m_staticMutex, 0); + + // if we are already set, then signal this semaphore + if (m_bSet) + { + CThreadEventWaitObject waitObject; + waitObject.Init(pSemaphore, index, flag); + waitObject.Set(); + + if (!m_bManualReset) + { + m_bSet = false; + } + } + else + { + if (!m_pWaitObjectsPool->m_pNext) + { + DEBUG_ERROR("CThreadEvent: Ran out of events; cannot register waiting thread\n"); + } + + // add this semaphore to linked list - can be added more than once it doesn't matter + + CThreadEventWaitObject *pWaitObject = LLUnlinkNode(m_pWaitObjectsPool->m_pNext); + + pWaitObject->Init(pSemaphore, index, flag); + + LLLinkNode(m_pWaitObjectsList, pWaitObject); + } + + sys_lwmutex_unlock(&m_staticMutex); +} + +// +// CThreadEvent::UnregisterWaitingThread +// +void CThreadEvent::UnregisterWaitingThread(sys_semaphore_t *pSemaphore) +{ + // remove all instances of this semaphore from linked list + + sys_lwmutex_lock(&m_staticMutex, 0); + + CThreadEventWaitObject *pWaitObject = m_pWaitObjectsList->m_pNext; + + while (pWaitObject) + { + CThreadEventWaitObject *pNext = pWaitObject->m_pNext; + + if (pWaitObject->m_pSemaphore == pSemaphore) + { + LLUnlinkNode(pWaitObject); + LLLinkNode(m_pWaitObjectsPool, pWaitObject); + } + + pWaitObject = pNext; + } + + sys_lwmutex_unlock(&m_staticMutex); +} + +#endif // _PS3 + + +#ifdef PLATFORM_WINDOWS + CThreadEvent::CThreadEvent( const char *name, bool initialState, bool bManualReset ) + { + m_hSyncObject = CreateEvent( NULL, bManualReset, (BOOL) initialState, name ); + AssertMsg1( m_hSyncObject, "Failed to create event (error 0x%x)", GetLastError() ); + } + + + NamedEventResult_t CThreadEvent::CheckNamedEvent( const char *name, uint32 dwTimeout ) + { + HANDLE eHandle = OpenEvent( SYNCHRONIZE, FALSE, name ); + + if ( eHandle == NULL ) return TT_EventDoesntExist; + + DWORD result = WaitForSingleObject( eHandle, dwTimeout ); + + return ( result == WAIT_OBJECT_0 ) ? TT_EventSignaled : TT_EventNotSignaled; + } +#endif + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + + +//--------------------------------------------------------- + +bool CThreadEvent::Set() +{ +////////////////////////////////////////////////////////////// +#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// + AssertUseable(); +#ifdef _WIN32 + return ( SetEvent( m_hSyncObject ) != 0 ); +#elif defined( _PS3 ) + + sys_lwmutex_lock(&m_staticMutex, 0); + + if (m_bManualReset) + { + //Mark event as set + m_bSet = true; + + //If any threads are already waiting then signal them to run + if (m_bInitalized) + { + int err = sys_semaphore_post( m_Semaphore, m_numWaitingThread); + Assert(err == CELL_OK); + } + } + else + { + //If any threads are already waiting then signal ONE to run, else signal next to run + + if (m_numWaitingThread>0) + { + int err = sys_semaphore_post( m_Semaphore, 1); + Assert(err == CELL_OK); + } + else + { + m_bSet=true; + } + } + + sys_lwmutex_unlock(&m_staticMutex); + + return true; + + +#elif defined(POSIX) + pthread_mutex_lock( &m_Mutex ); + m_cSet = 1; + m_bWakeForEvent = true; + int ret = pthread_cond_signal( &m_Condition ); + pthread_mutex_unlock( &m_Mutex ); + return ret == 0; +#endif + + +////////////////////////////////////////////////////////////// +#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// + + sys_lwmutex_lock(&m_staticMutex, 0); + + //Mark event as set + m_bSet = true; + + // signal registered semaphores + while (m_pWaitObjectsList->m_pNext) + { + CThreadEventWaitObject *pWaitObject = LLUnlinkNode(m_pWaitObjectsList->m_pNext); + + pWaitObject->Set(); + + LLLinkNode(m_pWaitObjectsPool, pWaitObject); + + if (!m_bManualReset) + { + m_bSet = false; + break; + } + } + + sys_lwmutex_unlock(&m_staticMutex); + + return true; + +////////////////////////////////////////////////////////////// +#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// +} + +//--------------------------------------------------------- + +bool CThreadEvent::Reset() +{ +#ifdef THREADS_DEBUG + AssertUseable(); +#endif +#ifdef _WIN32 + return ( ResetEvent( m_hSyncObject ) != 0 ); +#elif defined( _PS3 ) + + //Just mark us as no longer signaled + m_bSet = 0; + + return true; +#elif defined(POSIX) + pthread_mutex_lock( &m_Mutex ); + m_cSet = 0; + m_bWakeForEvent = false; + pthread_mutex_unlock( &m_Mutex ); + return true; +#endif +} + +//--------------------------------------------------------- + +bool CThreadEvent::Check() +{ + #ifdef _PS3 + return m_bSet; // Please, use for debugging only! + #endif +#ifdef THREADS_DEBUG + AssertUseable(); +#endif + return Wait( 0 ); +} + + + +bool CThreadEvent::Wait( uint32 dwTimeout ) +{ +////////////////////////////////////////////////////////////// +#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// + + +#if defined( _WIN32 ) || ( defined( POSIX ) && !defined( _PS3 ) ) + return CThreadSyncObject::Wait( dwTimeout ); +#elif defined( _PS3 ) + + { + + if (dwTimeout == 0) + { + //If timeout is 0 then just test it now (and reset it if manual ) + if (m_bSet) + { + if ( !m_bManualReset ) m_bSet=false; + return true; + } + return false; + } + + if (!AddWaitingThread()) + { + //Waiting thread NOT added because m_bSet was already set + if ( !m_bManualReset ) m_bSet=false; + return true; + } + + uint32 timeout; + int countTimeout = 0; + int ret = ETIMEDOUT; + while ( timeout=MIN(1, dwTimeout) ) + { + // on the PS3, "infinite timeout" is specified by zero, not + // 0xFFFFFFFF, so we need to perform that ternary here. +#error Untested code: + ret = sys_semaphore_wait( m_Semaphore, timeout == TT_INFINITE ? 0 : timeout * 1000 ); + Assert( (ret == CELL_OK) || (ret == ETIMEDOUT) ); + + if ( ret == CELL_OK ) + break; + + dwTimeout -= timeout; + countTimeout++; + if (countTimeout > 30) + { + printf("WARNING: possible deadlock in CThreadEvent::Wait() !!!\n"); + } + } + + RemoveWaitingThread(); + + if ( !m_bManualReset ) m_bSet=false; + + return ret == CELL_OK; + } + +#endif + +////////////////////////////////////////////////////////////// +#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// + + + CThreadEvent *pThis = this; + DWORD res = WaitForMultipleObjects(1, &pThis, true, dwTimeout); + return res == WAIT_OBJECT_0; + + +////////////////////////////////////////////////////////////// +#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS +////////////////////////////////////////////////////////////// +} + +#ifdef _WIN32 +//----------------------------------------------------------------------------- +// +// CThreadSemaphore +// +// To get Posix implementation, try http://www-128.ibm.com/developerworks/eserver/library/es-win32linux-sem.html +// +//----------------------------------------------------------------------------- + +CThreadSemaphore::CThreadSemaphore( int32 initialValue, int32 maxValue ) +{ +#ifdef _WIN32 + if ( maxValue ) + { + AssertMsg( maxValue > 0, "Invalid max value for semaphore" ); + AssertMsg( initialValue >= 0 && initialValue <= maxValue, "Invalid initial value for semaphore" ); + + m_hSyncObject = CreateSemaphore( NULL, initialValue, maxValue, NULL ); + + AssertMsg1(m_hSyncObject, "Failed to create semaphore (error 0x%x)", GetLastError()); + } + else + { + m_hSyncObject = NULL; + } +#elif defined( _PS3 ) + if ( maxValue ) + { + m_sema_max_val = maxValue; + m_semaCount = initialValue; + } +#endif +} + + +#ifdef _PS3 +//--------------------------------------------------------- + +bool CThreadSemaphore::AddWaitingThread() +{ + bool result; + + sys_lwmutex_lock(&m_staticMutex, 0); + + if (cellAtomicTestAndDecr32(&m_semaCount) > 0) + { + result=false; + } + else + { + result=true; + m_numWaitingThread++; + + if ( m_numWaitingThread == 1 ) + { + sys_semaphore_attribute_t semAttr; + sys_semaphore_attribute_initialize( semAttr ); + Assert(m_semaCount == 0); + int err = sys_semaphore_create( &m_Semaphore, &semAttr, 0, m_sema_max_val ); + Assert( err == CELL_OK ); + m_bInitalized = true; + } + } + + sys_lwmutex_unlock(&m_staticMutex); + return result; +} + +void CThreadSemaphore::RemoveWaitingThread() +{ + sys_lwmutex_lock(&m_staticMutex, 0); + + m_numWaitingThread--; + + if ( m_numWaitingThread == 0) + { + int err = sys_semaphore_destroy( m_Semaphore ); + Assert( err == CELL_OK ); + m_bInitalized = false; + } + + sys_lwmutex_unlock(&m_staticMutex); +} + +#endif + +#ifdef _PS3 + +bool CThreadSemaphore::Wait( uint32 dwTimeout ) +{ +#ifdef THREADS_DEBUG + AssertUseable(); +#endif + + +#ifndef NO_THREAD_SYNC + if (!AddWaitingThread()) + { + //Waiting thread NOT added because semaphore was already in a signaled state + return true; + } + + int ret = sys_semaphore_wait( m_Semaphore, dwTimeout == TT_INFINITE ? 0 : dwTimeout * 1000 ); + Assert( (ret == CELL_OK) || (ret == ETIMEDOUT) ); + + RemoveWaitingThread(); + + int old = cellAtomicDecr32(&m_semaCount); + Assert(old>0); +#else + int ret = CELL_OK; +#endif + + // sys_ppu_thread_yield doesn't seem to function properly, so sleep instead. + sys_timer_usleep( 60 ); + + + + return ret == CELL_OK; +} + +#endif + +//--------------------------------------------------------- + +bool CThreadSemaphore::Release( int32 releaseCount, int32 *pPreviousCount ) +{ +#ifdef THRDTOOL_DEBUG + AssertUseable(); +#endif +#ifdef _WIN32 + return ( ReleaseSemaphore( m_hSyncObject, releaseCount, (LPLONG)pPreviousCount ) != 0 ); +#elif defined( _PS3 ) + +#ifndef NO_THREAD_SYNC + + if (m_bInitalized) + { + sys_semaphore_value_t previousVal; + sys_semaphore_get_value( m_Semaphore, &previousVal ); + + cellAtomicAdd32(&m_semaCount, releaseCount); + + *pPreviousCount = previousVal; + + int err = sys_semaphore_post( m_Semaphore, releaseCount ); + Assert(err == CELL_OK); + } + +#endif + + return true; +#endif +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +CThreadFullMutex::CThreadFullMutex( bool bEstablishInitialOwnership, const char *pszName ) +{ + m_hSyncObject = CreateMutex( NULL, bEstablishInitialOwnership, pszName ); + + AssertMsg1( m_hSyncObject, "Failed to create mutex (error 0x%x)", GetLastError() ); +} + +//--------------------------------------------------------- + +bool CThreadFullMutex::Release() +{ +#ifdef THRDTOOL_DEBUG + AssertUseable(); +#endif + return ( ReleaseMutex( m_hSyncObject ) != 0 ); +} + +#endif + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +#if ( defined(WIN32) || defined(OSX) ) && !defined(PLATFORM_PS3) +namespace GenericThreadLocals +{ +CThreadLocalBase::CThreadLocalBase() +{ +#ifdef _WIN32 + m_index = TlsAlloc(); + AssertMsg( m_index != 0xFFFFFFFF, "Bad thread local" ); + if ( m_index == 0xFFFFFFFF ) + Error( "Out of thread local storage!\n" ); +#elif defined(POSIX) + if ( pthread_key_create( (pthread_key_t *)&m_index, NULL ) != 0 ) + Error( "Out of thread local storage!\n" ); +#endif +} + +//--------------------------------------------------------- + +CThreadLocalBase::~CThreadLocalBase() +{ +#ifdef _WIN32 + if ( m_index != 0xFFFFFFFF ) + TlsFree( m_index ); + m_index = 0xFFFFFFFF; +#elif defined(POSIX) + pthread_key_delete( m_index ); +#endif +} + +//--------------------------------------------------------- + +void * CThreadLocalBase::Get() const +{ +#ifdef _WIN32 + if ( m_index != 0xFFFFFFFF ) + return TlsGetValue( m_index ); + AssertMsg( 0, "Bad thread local" ); + return NULL; +#elif defined(POSIX) + void *value = pthread_getspecific( m_index ); + return value; +#endif +} + +//--------------------------------------------------------- + +void CThreadLocalBase::Set( void *value ) +{ +#ifdef _WIN32 + if (m_index != 0xFFFFFFFF) + TlsSetValue(m_index, value); + else + AssertMsg( 0, "Bad thread local" ); +#elif defined(POSIX) + if ( pthread_setspecific( m_index, value ) != 0 ) + AssertMsg( 0, "Bad thread local" ); +#endif +} +} // namespace GenericThreadLocals +#endif // ( defined(WIN32) || defined(POSIX) ) && !defined(PLATFORM_PS3) +//----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- + +#ifdef MSVC +//#ifdef _X360 +#define TO_INTERLOCK_PARAM(p) ((volatile long *)p) +#define TO_INTERLOCK_PTR_PARAM(p) ((void **)p) +//#else +//#define TO_INTERLOCK_PARAM(p) (p) +//#define TO_INTERLOCK_PTR_PARAM(p) (p) +//#endif + +#if !defined(USE_INTRINSIC_INTERLOCKED) && !defined(_X360) +int32 ThreadInterlockedIncrement( int32 volatile *pDest ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedIncrement( TO_INTERLOCK_PARAM(pDest) ); +} + +int32 ThreadInterlockedDecrement( int32 volatile *pDest ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedDecrement( TO_INTERLOCK_PARAM(pDest) ); +} + +int32 ThreadInterlockedExchange( int32 volatile *pDest, int32 value ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedExchange( TO_INTERLOCK_PARAM(pDest), value ); +} + +int32 ThreadInterlockedExchangeAdd( int32 volatile *pDest, int32 value ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedExchangeAdd( TO_INTERLOCK_PARAM(pDest), value ); +} + +int32 ThreadInterlockedCompareExchange( int32 volatile *pDest, int32 value, int32 comperand ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedCompareExchange( TO_INTERLOCK_PARAM(pDest), value, comperand ); +} + +bool ThreadInterlockedAssignIf( int32 volatile *pDest, int32 value, int32 comperand ) +{ + Assert( (size_t)pDest % 4 == 0 ); + +#if !(defined(_WIN64) || defined (_X360)) + __asm + { + mov eax,comperand + mov ecx,pDest + mov edx,value + lock cmpxchg [ecx],edx + mov eax,0 + setz al + } +#else + return ( InterlockedCompareExchange( TO_INTERLOCK_PARAM(pDest), value, comperand ) == comperand ); +#endif +} + +#endif + +#if !defined( USE_INTRINSIC_INTERLOCKED ) || defined( _WIN64 ) +void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value ); +} + +void *ThreadInterlockedCompareExchangePointer( void * volatile *pDest, void *value, void *comperand ) +{ + Assert( (size_t)pDest % 4 == 0 ); + return InterlockedCompareExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value, comperand ); +} + +bool ThreadInterlockedAssignPointerIf( void * volatile *pDest, void *value, void *comperand ) +{ + Assert( (size_t)pDest % 4 == 0 ); +#if !(defined(_WIN64) || defined (_X360)) + __asm + { + mov eax,comperand + mov ecx,pDest + mov edx,value + lock cmpxchg [ecx],edx + mov eax,0 + setz al + } +#else + return ( InterlockedCompareExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value, comperand ) == comperand ); +#endif +} +#endif + +int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand ) +{ + Assert( (size_t)pDest % 8 == 0 ); + +#if defined(_WIN64) || defined (_X360) + return InterlockedCompareExchange64( pDest, value, comperand ); +#else + __asm + { + lea esi,comperand; + lea edi,value; + + mov eax,[esi]; + mov edx,4[esi]; + mov ebx,[edi]; + mov ecx,4[edi]; + mov esi,pDest; + lock CMPXCHG8B [esi]; + } +#endif +} + +bool ThreadInterlockedAssignIf64(volatile int64 *pDest, int64 value, int64 comperand ) +{ + Assert( (size_t)pDest % 8 == 0 ); + +#if defined(_X360) || defined(_WIN64) + return ( ThreadInterlockedCompareExchange64( pDest, value, comperand ) == comperand ); +#else + __asm + { + lea esi,comperand; + lea edi,value; + + mov eax,[esi]; + mov edx,4[esi]; + mov ebx,[edi]; + mov ecx,4[edi]; + mov esi,pDest; + lock CMPXCHG8B [esi]; + mov eax,0; + setz al; + } +#endif +} + +#elif defined(GNUC) + +#ifdef OSX +#include <libkern/OSAtomic.h> +#endif + + +long ThreadInterlockedIncrement( long volatile *pDest ) +{ + return __sync_fetch_and_add( pDest, 1 ) + 1; +} + +long ThreadInterlockedDecrement( long volatile *pDest ) +{ + return __sync_fetch_and_sub( pDest, 1 ) - 1; +} + +long ThreadInterlockedExchange( long volatile *pDest, long value ) +{ + return __sync_lock_test_and_set( pDest, value ); +} + +long ThreadInterlockedExchangeAdd( long volatile *pDest, long value ) +{ + return __sync_fetch_and_add( pDest, value ); +} + +long ThreadInterlockedCompareExchange( long volatile *pDest, long value, long comperand ) +{ + return __sync_val_compare_and_swap( pDest, comperand, value ); +} + +bool ThreadInterlockedAssignIf( long volatile *pDest, long value, long comperand ) +{ + return __sync_bool_compare_and_swap( pDest, comperand, value ); +} + +#if !defined( USE_INTRINSIC_INTERLOCKED ) +void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value ) +{ + return __sync_lock_test_and_set( pDest, value ); +} + +void *ThreadInterlockedCompareExchangePointer( void *volatile *pDest, void *value, void *comperand ) +{ + return __sync_val_compare_and_swap( pDest, comperand, value ); +} + +bool ThreadInterlockedAssignPointerIf( void * volatile *pDest, void *value, void *comperand ) +{ + return __sync_bool_compare_and_swap( pDest, comperand, value ); +} +#endif + +int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand ) +{ +#if defined(OSX) + int64 retVal = *pDest; + if ( OSAtomicCompareAndSwap64( comperand, value, pDest ) ) + retVal = *pDest; + + return retVal; +#else + return __sync_val_compare_and_swap( pDest, comperand, value ); +#endif +} + +bool ThreadInterlockedAssignIf64( int64 volatile * pDest, int64 value, int64 comperand ) +{ + return __sync_bool_compare_and_swap( pDest, comperand, value ); +} + + +#elif defined( _PS3 ) + +// This is defined in the header! + +#else +// This will perform horribly, +#error "Falling back to mutexed interlocked operations, you really don't have intrinsics you can use?"ß +CThreadMutex g_InterlockedMutex; + +long ThreadInterlockedIncrement( long volatile *pDest ) +{ + AUTO_LOCK( g_InterlockedMutex ); + return ++(*pDest); +} + +long ThreadInterlockedDecrement( long volatile *pDest ) +{ + AUTO_LOCK( g_InterlockedMutex ); + return --(*pDest); +} + +long ThreadInterlockedExchange( long volatile *pDest, long value ) +{ + AUTO_LOCK( g_InterlockedMutex ); + long retVal = *pDest; + *pDest = value; + return retVal; +} + +void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value ) +{ + AUTO_LOCK( g_InterlockedMutex ); + void *retVal = *pDest; + *pDest = value; + return retVal; +} + +long ThreadInterlockedExchangeAdd( long volatile *pDest, long value ) +{ + AUTO_LOCK( g_InterlockedMutex ); + long retVal = *pDest; + *pDest += value; + return retVal; +} + +long ThreadInterlockedCompareExchange( long volatile *pDest, long value, long comperand ) +{ + AUTO_LOCK( g_InterlockedMutex ); + long retVal = *pDest; + if ( *pDest == comperand ) + *pDest = value; + return retVal; +} + +void *ThreadInterlockedCompareExchangePointer( void * volatile *pDest, void *value, void *comperand ) +{ + AUTO_LOCK( g_InterlockedMutex ); + void *retVal = *pDest; + if ( *pDest == comperand ) + *pDest = value; + return retVal; +} + + +int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand ) +{ + Assert( (size_t)pDest % 8 == 0 ); + AUTO_LOCK( g_InterlockedMutex ); + int64 retVal = *pDest; + if ( *pDest == comperand ) + *pDest = value; + return retVal; +} + +#endif + +int64 ThreadInterlockedExchange64( int64 volatile *pDest, int64 value ) +{ + Assert( (size_t)pDest % 8 == 0 ); + int64 Old; + + do + { + Old = *pDest; + } while (ThreadInterlockedCompareExchange64(pDest, value, Old) != Old); + + return Old; +} + + +//----------------------------------------------------------------------------- + +#if defined(_WIN32) && defined(THREAD_PROFILER) +void ThreadNotifySyncNoop(void *p) {} + +#define MAP_THREAD_PROFILER_CALL( from, to ) \ + void from(void *p) \ + { \ + static CDynamicFunction<void (*)(void *)> dynFunc( "libittnotify.dll", #to, ThreadNotifySyncNoop ); \ + (*dynFunc)(p); \ + } + +MAP_THREAD_PROFILER_CALL( ThreadNotifySyncPrepare, __itt_notify_sync_prepare ); +MAP_THREAD_PROFILER_CALL( ThreadNotifySyncCancel, __itt_notify_sync_cancel ); +MAP_THREAD_PROFILER_CALL( ThreadNotifySyncAcquired, __itt_notify_sync_acquired ); +MAP_THREAD_PROFILER_CALL( ThreadNotifySyncReleasing, __itt_notify_sync_releasing ); + +#endif + +//----------------------------------------------------------------------------- +// +// CThreadMutex +// +//----------------------------------------------------------------------------- + +#ifdef _PS3 +CThreadMutex::CThreadMutex() +{ + // sys_mutex with recursion enabled is like a win32 critical section + sys_mutex_attribute_t mutexAttr; + sys_mutex_attribute_initialize( mutexAttr ); + mutexAttr.attr_recursive = SYS_SYNC_RECURSIVE; + sys_mutex_create( &m_Mutex, &mutexAttr ); +} +CThreadMutex::~CThreadMutex() +{ + sys_mutex_destroy( m_Mutex ); +} +#elif !defined( POSIX ) +CThreadMutex::CThreadMutex() +{ +#ifdef THREAD_MUTEX_TRACING_ENABLED + memset( &m_CriticalSection, 0, sizeof(m_CriticalSection) ); +#endif + InitializeCriticalSectionAndSpinCount((CRITICAL_SECTION *)&m_CriticalSection, 4000); +#ifdef THREAD_MUTEX_TRACING_SUPPORTED + // These need to be initialized unconditionally in case mixing release & debug object modules + // Lock and unlock may be emitted as COMDATs, in which case may get spurious output + m_currentOwnerID = m_lockCount = 0; + m_bTrace = false; +#endif +} + +CThreadMutex::~CThreadMutex() +{ + DeleteCriticalSection((CRITICAL_SECTION *)&m_CriticalSection); +} +#endif // !POSIX + +#ifdef IS_WINDOWS_PC +typedef BOOL (WINAPI*TryEnterCriticalSectionFunc_t)(LPCRITICAL_SECTION); +static CDynamicFunction<TryEnterCriticalSectionFunc_t> DynTryEnterCriticalSection( "Kernel32.dll", "TryEnterCriticalSection" ); +#elif defined( _X360 ) +#define DynTryEnterCriticalSection TryEnterCriticalSection +#endif + +bool CThreadMutex::TryLock() +{ +#if defined( MSVC ) +#ifdef THREAD_MUTEX_TRACING_ENABLED + uint thisThreadID = ThreadGetCurrentId(); + if ( m_bTrace && m_currentOwnerID && ( m_currentOwnerID != thisThreadID ) ) + Msg( "Thread %u about to try-wait for lock %x owned by %u\n", ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID ); +#endif + if ( DynTryEnterCriticalSection != NULL ) + { + if ( (*DynTryEnterCriticalSection )( (CRITICAL_SECTION *)&m_CriticalSection ) != FALSE ) + { +#ifdef THREAD_MUTEX_TRACING_ENABLED + if (m_lockCount == 0) + { + // we now own it for the first time. Set owner information + m_currentOwnerID = thisThreadID; + if ( m_bTrace ) + Msg( "Thread %u now owns lock 0x%x\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection ); + } + m_lockCount++; +#endif + return true; + } + return false; + } + Lock(); + return true; +#elif defined( _PS3 ) + +#ifndef NO_THREAD_SYNC + if ( sys_mutex_trylock( m_Mutex ) == CELL_OK ) +#endif + + return true; + + return false; // ?? moved from EA code + +#elif defined( POSIX ) + return pthread_mutex_trylock( &m_Mutex ) == 0; +#else +#error "Implement me!" + return true; +#endif +} + +//----------------------------------------------------------------------------- +// +// CThreadFastMutex +// +//----------------------------------------------------------------------------- + +#ifdef THREAD_FAST_MUTEX_TIMINGS +// This is meant to be used in combination with breakpoints and in-debugee, so we turn the optimizer off +#pragma optimize( "", off ) +CThreadFastMutex *g_pIgnoredMutexes[256]; // Ignore noisy non-problem mutex. Probably could be an array. Right now needed only for sound thread +float g_MutexTimingTolerance = 5; +bool g_bMutexTimingOutput; + +void TrapMutexTimings( uint32 probableBlocker, uint32 thisThread, volatile CThreadFastMutex *pMutex, CFastTimer &spikeTimer, CAverageCycleCounter &sleepTimer ) +{ + spikeTimer.End(); + if ( spikeTimer.GetDuration().GetMillisecondsF() > g_MutexTimingTolerance ) + { + bool bIgnore = false; + for ( int j = 0; j < ARRAYSIZE( g_pIgnoredMutexes ) && g_pIgnoredMutexes[j]; j++ ) + { + if ( g_pIgnoredMutexes[j] == pMutex ) + { + bIgnore = true; + break; + } + } + + if ( !bIgnore && spikeTimer.GetDuration().GetMillisecondsF() < 100 ) + { + volatile float FastMutexDuration = spikeTimer.GetDuration().GetMillisecondsF(); + volatile float average = sleepTimer.GetAverageMilliseconds(); + volatile float peak = sleepTimer.GetPeakMilliseconds(); volatile int xx = 6; + if ( g_bMutexTimingOutput ) + { + char szBuf[256]; + Msg( "M (%.8x): [%.8x <-- %.8x] (%f,%f,%f)\n", pMutex, probableBlocker, thisThread, FastMutexDuration, average, peak ); + } + } + } +} + +#else +#define TrapMutexTimings( a, b, c, d, e ) ((void)0) +#endif + +//------------------------------------- + +#define THREAD_SPIN (8*1024) + +void CThreadFastMutex::Lock( const uint32 threadId, unsigned nSpinSleepTime ) volatile +{ +#ifdef THREAD_FAST_MUTEX_TIMINGS + CAverageCycleCounter sleepTimer; + CFastTimer spikeTimer; + uint32 currentOwner = m_ownerID; + spikeTimer.Start(); + sleepTimer.Init(); +#endif + int i; + if ( nSpinSleepTime != TT_INFINITE ) + { + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLock( threadId ) ) + { + TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer ); + return; + } + ThreadPause(); + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLock( threadId ) ) + { + TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer ); + return; + } + ThreadPause(); + if ( i % 1024 == 0 ) + { +#ifdef THREAD_FAST_MUTEX_TIMINGS + CAverageTimeMarker marker( &sleepTimer ); +#endif + ThreadSleep( 0 ); + } + } + +#ifdef _WIN32 + if ( !nSpinSleepTime && GetThreadPriority( GetCurrentThread() ) > THREAD_PRIORITY_NORMAL ) + { + nSpinSleepTime = 1; + } +#endif + + if ( nSpinSleepTime ) + { + for ( i = THREAD_SPIN; i != 0; --i ) + { +#ifdef THREAD_FAST_MUTEX_TIMINGS + CAverageTimeMarker marker( &sleepTimer ); +#endif + if ( TryLock( threadId ) ) + { + TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer ); + return; + } + + ThreadPause(); + ThreadSleep( 0 ); + } + + } + + for ( ;; ) + { +#ifdef THREAD_FAST_MUTEX_TIMINGS + CAverageTimeMarker marker( &sleepTimer ); +#endif + if ( TryLock( threadId ) ) + { + TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer ); + return; + } + + ThreadPause(); + ThreadSleep( nSpinSleepTime ); + } + } + else + { + for ( ;; ) + { + if ( TryLock( threadId ) ) + { + TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer ); + return; + } + + ThreadPause(); + } + } +} + +#ifdef THREAD_FAST_MUTEX_TIMINGS +#pragma optimize( "", on ) +#endif + +//----------------------------------------------------------------------------- +// +// CThreadRWLock +// +//----------------------------------------------------------------------------- + +void CThreadRWLock::WaitForRead() +{ + m_nPendingReaders++; + + do + { + m_mutex.Unlock(); + m_CanRead.Wait(); + m_mutex.Lock(); + } + while (m_nWriters); + + m_nPendingReaders--; +} + + +void CThreadRWLock::LockForWrite() +{ + m_mutex.Lock(); + bool bWait = ( m_nWriters != 0 || m_nActiveReaders != 0 ); + m_nWriters++; + m_CanRead.Reset(); + m_mutex.Unlock(); + + if ( bWait ) + { + m_CanWrite.Wait(); + } +} + +void CThreadRWLock::UnlockWrite() +{ + m_mutex.Lock(); + m_nWriters--; + if ( m_nWriters == 0) + { + if ( m_nPendingReaders ) + { + m_CanRead.Set(); + } + } + else + { + m_CanWrite.Set(); + } + m_mutex.Unlock(); +} + +//----------------------------------------------------------------------------- +// +// CThreadSpinRWLock +// +//----------------------------------------------------------------------------- +#ifndef OLD_SPINRWLOCK + +void CThreadSpinRWLock::SpinLockForWrite() +{ + int i; + + if ( TryLockForWrite_UnforcedInline() ) + { + return; + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForWrite_UnforcedInline() ) + { + return; + } + ThreadPause(); + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForWrite_UnforcedInline() ) + { + return; + } + ThreadPause(); + if ( i % 1024 == 0 ) + { + ThreadSleep( 0 ); + } + } + + for ( i = THREAD_SPIN * 4; i != 0; --i ) + { + if ( TryLockForWrite_UnforcedInline() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 0 ); + } + + for ( ;; ) // coded as for instead of while to make easy to breakpoint success + { + if ( TryLockForWrite_UnforcedInline() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 1 ); + } +} + +void CThreadSpinRWLock::SpinLockForRead() +{ + int i; + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForRead_UnforcedInline() ) + { + return; + } + ThreadPause(); + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForRead_UnforcedInline() ) + { + return; + } + ThreadPause(); + if ( i % 1024 == 0 ) + { + ThreadSleep( 0 ); + } + } + + for ( i = THREAD_SPIN * 4; i != 0; --i ) + { + if ( TryLockForRead_UnforcedInline() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 0 ); + } + + for ( ;; ) // coded as for instead of while to make easy to breakpoint success + { + if ( TryLockForRead_UnforcedInline() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 1 ); + } +} + +#else +/* (commented out to reduce distraction in colorized editor, remove entirely when new implementation settles) +void CThreadSpinRWLock::SpinLockForWrite( const uint32 threadId ) +{ + int i; + + if ( TryLockForWrite( threadId ) ) + { + return; + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForWrite( threadId ) ) + { + return; + } + ThreadPause(); + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForWrite( threadId ) ) + { + return; + } + ThreadPause(); + if ( i % 1024 == 0 ) + { + ThreadSleep( 0 ); + } + } + + for ( i = THREAD_SPIN * 4; i != 0; --i ) + { + if ( TryLockForWrite( threadId ) ) + { + return; + } + + ThreadPause(); + ThreadSleep( 0 ); + } + + for ( ;; ) // coded as for instead of while to make easy to breakpoint success + { + if ( TryLockForWrite( threadId ) ) + { + return; + } + + ThreadPause(); + ThreadSleep( 1 ); + } +} + +void CThreadSpinRWLock::LockForRead() +{ + int i; + if ( TryLockForRead() ) + { + return; + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForRead() ) + { + return; + } + ThreadPause(); + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if ( TryLockForRead() ) + { + return; + } + ThreadPause(); + if ( i % 1024 == 0 ) + { + ThreadSleep( 0 ); + } + } + + for ( i = THREAD_SPIN * 4; i != 0; --i ) + { + if ( TryLockForRead() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 0 ); + } + + for ( ;; ) // coded as for instead of while to make easy to breakpoint success + { + if ( TryLockForRead() ) + { + return; + } + + ThreadPause(); + ThreadSleep( 1 ); + } +} + +void CThreadSpinRWLock::UnlockRead() +{ + int i; + + Assert( m_lockInfo.m_nReaders > 0 && m_lockInfo.m_writerId == 0 ); + + //uint32 nLockInfoReaders = m_lockInfo.m_nReaders; + LockInfo_t oldValue; + LockInfo_t newValue; + + if( IsX360() ) + { + // this is the code equivalent to original code (see below) that doesn't cause LHS on Xbox360 + // WARNING: This code assumes BIG Endian CPU + oldValue.m_i64 = uint32( m_lockInfo.m_nReaders ); + newValue.m_i64 = oldValue.m_i64 - 1; // NOTE: when we have -1 (or 0xFFFFFFFF) readers, this will result in non-equivalent code + } + else + { + // this is the original code that worked here for a while + oldValue.m_nReaders = m_lockInfo.m_nReaders; + oldValue.m_writerId = 0; + newValue.m_nReaders = oldValue.m_nReaders - 1; + newValue.m_writerId = 0; + } + ThreadMemoryBarrier(); + if( AssignIf( newValue, oldValue ) ) + return; + + ThreadPause(); + oldValue.m_nReaders = m_lockInfo.m_nReaders; + newValue.m_nReaders = oldValue.m_nReaders - 1; + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if( AssignIf( newValue, oldValue ) ) + return; + ThreadPause(); + oldValue.m_nReaders = m_lockInfo.m_nReaders; + newValue.m_nReaders = oldValue.m_nReaders - 1; + } + + for ( i = THREAD_SPIN; i != 0; --i ) + { + if( AssignIf( newValue, oldValue ) ) + return; + ThreadPause(); + if ( i % 512 == 0 ) + { + ThreadSleep( 0 ); + } + oldValue.m_nReaders = m_lockInfo.m_nReaders; + newValue.m_nReaders = oldValue.m_nReaders - 1; + } + + for ( i = THREAD_SPIN * 4; i != 0; --i ) + { + if( AssignIf( newValue, oldValue ) ) + return; + ThreadPause(); + ThreadSleep( 0 ); + oldValue.m_nReaders = m_lockInfo.m_nReaders; + newValue.m_nReaders = oldValue.m_nReaders - 1; + } + + for ( ;; ) // coded as for instead of while to make easy to breakpoint success + { + if( AssignIf( newValue, oldValue ) ) + return; + ThreadPause(); + ThreadSleep( 1 ); + oldValue.m_nReaders = m_lockInfo.m_nReaders; + newValue.m_nReaders = oldValue.m_nReaders - 1; + } +} + +void CThreadSpinRWLock::UnlockWrite() +{ + Assert( m_lockInfo.m_writerId == ThreadGetCurrentId() && m_lockInfo.m_nReaders == 0 ); + static const LockInfo_t newValue = { { 0, 0 } }; + ThreadMemoryBarrier(); + ThreadInterlockedExchange64( (int64 *)&m_lockInfo, *((int64 *)&newValue) ); + m_nWriters--; +} +*/ +#endif + +#if defined( _PS3 ) +// All CThread code is inline in the header for PS3 + +// This function is implemented here rather than the header because g_pCurThread resolves to GetCurThread() on PS3 +// and we don't want to create a dependency on the ELF stub for everyone who includes the header. +PLATFORM_INTERFACE CThread *GetCurThreadPS3() +{ + return (CThread*)g_pCurThread; +} + +PLATFORM_INTERFACE void SetCurThreadPS3( CThread *pThread ) +{ + g_pCurThread = pThread; +} +#else +// The CThread implementation needs to be inlined for performance on the PS3 - It makes a difference of more than 1ms/frame +// for other platforms, we include the .inl in the .cpp file where it existed before +#include "../public/tier0/threadtools.inl" +#endif + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +CWorkerThread::CWorkerThread() +: m_EventSend(true), // must be manual-reset for PeekCall() + m_EventComplete(true), // must be manual-reset to handle multiple wait with thread properly + m_Param(0), + m_ReturnVal(0) +{ +} + +//--------------------------------------------------------- + +int CWorkerThread::CallWorker(unsigned dw, unsigned timeout, bool fBoostWorkerPriorityToMaster) +{ + return Call(dw, timeout, fBoostWorkerPriorityToMaster); +} + +//--------------------------------------------------------- + +int CWorkerThread::CallMaster(unsigned dw, unsigned timeout) +{ + return Call(dw, timeout, false); +} + +//--------------------------------------------------------- + +CThreadEvent &CWorkerThread::GetCallHandle() +{ + return m_EventSend; +} + +//--------------------------------------------------------- + +unsigned CWorkerThread::GetCallParam() const +{ + return m_Param; +} + +//--------------------------------------------------------- + +int CWorkerThread::BoostPriority() +{ + int iInitialPriority = GetPriority(); + +#ifdef WIN32 + const int iNewPriority = ThreadGetPriority( GetThreadHandle() ); + if (iNewPriority > iInitialPriority) + ThreadSetPriority( GetThreadHandle(), iNewPriority); +#elif !defined( _PS3 ) + const int iNewPriority = ThreadGetPriority( (ThreadHandle_t)GetThreadID() ); + if (iNewPriority > iInitialPriority) + ThreadSetPriority( (ThreadHandle_t)GetThreadID(), iNewPriority); +#endif + + return iInitialPriority; +} + +//--------------------------------------------------------- +static uint32 DefaultWaitFunc( uint32 nHandles, CThreadEvent** ppHandles, int bWaitAll, uint32 timeout ) +{ + return CThreadEvent::WaitForMultiple( nHandles, ppHandles, bWaitAll!=0, timeout ) ; +} + + +int CWorkerThread::Call(unsigned dwParam, unsigned timeout, bool fBoostPriority, WaitFunc_t waitFunc) +{ + AssertMsg(!m_EventSend.Check(), "Cannot perform call if there's an existing call pending" ); + + AUTO_LOCK( m_Lock ); + + if (!IsAlive()) + return WTCR_FAIL; + + int iInitialPriority = 0; + if (fBoostPriority) + { + iInitialPriority = BoostPriority(); + } + + // set the parameter, signal the worker thread, wait for the completion to be signaled + m_Param = dwParam; + + m_EventComplete.Reset(); + m_EventSend.Set(); + + WaitForReply( timeout, waitFunc ); + + if (fBoostPriority) + SetPriority(iInitialPriority); + + return m_ReturnVal; +} + +//--------------------------------------------------------- +// +// Wait for a request from the client +// +//--------------------------------------------------------- +int CWorkerThread::WaitForReply( unsigned timeout ) +{ + return WaitForReply( timeout, NULL ); +} + +int CWorkerThread::WaitForReply( unsigned timeout, WaitFunc_t pfnWait ) +{ + if (!pfnWait) + { + pfnWait = &DefaultWaitFunc; + } + + CThreadEvent *waits[] = + { + &m_EventComplete, + &m_ExitEvent + }; + + unsigned result; + bool bInDebugger = Plat_IsInDebugSession(); + + uint32 dwActualTimeout = ( (timeout==TT_INFINITE) ? 30000 : timeout ); + + do + { +#ifdef WIN32 + // Make sure the thread handle hasn't been closed + if ( !GetThreadHandle() ) + { + result = 1; + break; + } +#endif + + result = (*pfnWait)( ARRAYSIZE( waits ), waits, false, dwActualTimeout ); + + AssertMsg(timeout != TT_INFINITE || result != TW_TIMEOUT, "Possible hung thread, call to thread timed out"); + + } while ( bInDebugger && ( timeout == TT_INFINITE && result == TW_TIMEOUT ) ); + + if ( result != 0 ) + { + if (result == TW_TIMEOUT) + { + m_ReturnVal = WTCR_TIMEOUT; + } + else if (result == 1) + { + DevMsg( 2, "Thread failed to respond, probably exited\n"); + m_EventSend.Reset(); + m_ReturnVal = WTCR_TIMEOUT; + } + else + { + m_EventSend.Reset(); + m_ReturnVal = WTCR_THREAD_GONE; + } + } + + return m_ReturnVal; +} + + +//--------------------------------------------------------- +// +// Wait for a request from the client +// +//--------------------------------------------------------- + +bool CWorkerThread::WaitForCall(unsigned * pResult) +{ + return WaitForCall(TT_INFINITE, pResult); +} + +//--------------------------------------------------------- + +bool CWorkerThread::WaitForCall(unsigned dwTimeout, unsigned * pResult) +{ + bool returnVal = m_EventSend.Wait(dwTimeout); + if (pResult) + *pResult = m_Param; + return returnVal; +} + +//--------------------------------------------------------- +// +// is there a request? +// + +bool CWorkerThread::PeekCall(unsigned * pParam) +{ + if (!m_EventSend.Check()) + { + return false; + } + else + { + if (pParam) + { + *pParam = m_Param; + } + return true; + } +} + +//--------------------------------------------------------- +// +// Reply to the request +// + +void CWorkerThread::Reply(unsigned dw) +{ + m_Param = 0; + m_ReturnVal = dw; + + // The request is now complete so PeekCall() should fail from + // now on + // + // This event should be reset BEFORE we signal the client + m_EventSend.Reset(); + + // Tell the client we're finished + m_EventComplete.Set(); +} + + +//----------------------------------------------------------------------------- + + +#if defined( _PS3 ) + +/******************************************************************************* +* PS3 equivalent to Win32 function for setting events +*******************************************************************************/ +BOOL SetEvent( CThreadEvent *pEvent ) +{ + bool bRetVal = pEvent->Set(); + if ( !bRetVal ) + Assert(0); + + return bRetVal; +} + +/******************************************************************************* +* PS3 equivalent to Win32 function for resetting events +*******************************************************************************/ +BOOL ResetEvent( CThreadEvent *pEvent ) +{ + return pEvent->Reset(); +} + +#define MAXIMUM_WAIT_OBJECTS 64 + +/******************************************************************************* +* Wait for a selection of events to terminate +*******************************************************************************/ +DWORD WaitForMultipleObjects( DWORD nCount, CThreadEvent **lppHandles, BOOL bWaitAll, DWORD dwMilliseconds ) +{ + ////////////////////////////////////////////////////////////// +#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS + ////////////////////////////////////////////////////////////// + + + // Support for a limited amount of events + if ( nCount >= MAXIMUM_WAIT_OBJECTS ) + { + Assert(0); + return false; + } + + bool bRunning = true; + unsigned int result = TW_FAILED; + + // For bWaitAll + int numEvent = 0; + int eventComplete[ MAXIMUM_WAIT_OBJECTS ] = {0}; + + uint64_t timeDiffMS = 0; + uint64_t startTimeMS = Plat_MSTime(); + uint64_t endTimeMS = 0; + + while ( bRunning ) + { + // Check for a timeout + if ( bRunning && ( dwMilliseconds != INFINITE ) && ( timeDiffMS > dwMilliseconds ) ) + { + result = TW_TIMEOUT; + bRunning = false; + } + + // Wait for all the events to be set + if ( bWaitAll ) + { + for ( int event = 0; event < nCount; ++event ) + { + if ( lppHandles[event]->Wait(1) ) + { + // If an event is complete, mark it as complete in our list + if ( eventComplete[ event ] == 0 ) + { + numEvent++; + eventComplete[ event ] = 1; + } + } + } + + // If all the events have been set, terminate the function + if ( numEvent >= nCount ) + { + result = WAIT_OBJECT_0; + bRunning = false; + } + } + + // Wait for one event to be set + else + { + for ( int event = 0; event < nCount; ++event ) + { + if ( lppHandles[event]->Wait(1) ) + { + result = WAIT_OBJECT_0 + event; + bRunning = false; + break; + } + } + } + + endTimeMS = Plat_MSTime(); + timeDiffMS = endTimeMS - startTimeMS; + } + + return result; + + + + ////////////////////////////////////////////////////////////// +#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS // (expected PS3 only) + ////////////////////////////////////////////////////////////// +#ifndef _PS3 +#error This code was written expecting to be run on PS3. +#endif + + // check if we have a wait objects semaphore + if (!gbWaitObjectsCreated) + { + sys_semaphore_attribute_t semAttr; + sys_semaphore_attribute_initialize(semAttr); + sys_semaphore_create(&gWaitObjectsSemaphore, &semAttr, 0, 0xFFFF); + + gbWaitObjectsCreated = true; + } + + // Support for a limited amount of events + if ( nCount >= MAXIMUM_WAIT_OBJECTS ) + { + Assert(0); + return false; + } + + unsigned int result = WAIT_FAILED; + int res = CELL_OK; + int event = -1; + int numEvent = 0; + + // run through events registering this thread with each one + for (int i = 0; i < nCount; i++) + { + lppHandles[i]->RegisterWaitingThread(&gWaitObjectsSemaphore, i, &event); + } + + + // in the Source API, a timeOut of 0 means very short timeOut, not (as in the PS3 spec) an infinite timeout. + // TT_INFINITE is #defined to 2^31-1, which means "infinite timeout" on PC and "72 minutes, 35 seconds" on PS3. + // conversely, the code below (around deltaTime) expects to be able to compare against the timeout + // value given here, so we cannot just replace 0 with 1 and TT_INFINITE with 0. + // So, we replace 0 with 1, meaning "a very short time", and test for the special value TT_INFINITE + // at the moment of calling sys_semaphore_wait, where we replace it with the real "infinite timeout" + // value. It isn't safe to simply increase the declaration size of TT_INFINITE, because as you can + // see it is often assigned to uint32s. + // Also, Source timeouts are specified in milliseconds, and PS3 timeouts are in microseconds, + // so we need to multiply by one thousand. + uint32 timeOut = dwMilliseconds; + if ( timeOut == 0 ) + { + timeOut = 1; + } + else if ( timeOut != TT_INFINITE ) + { + timeOut *= 1000; + // note that it's impossible for dwMilliseconds * 1000 + // to coincidentally equal TT_INFINITE since TT_INFINITE + // is not divisible by 1000. + COMPILE_TIME_ASSERT( TT_INFINITE % 1000 != 0 ); + } + + COMPILE_TIME_ASSERT( TT_INFINITE != 0 ); // The code here was written expecting (working around) that TT_INFINITE is + // MAXINT, so if you changed this number, please read the comment above and + // carefully examine the code here to make sure that timeouts still work + // correctly on PS3. Be aware that in many places in Source, a timeout of + // 0 has some special meaning other than "infinite timeout", so track those + // down too. + + + // Wait for all the events to be set + if ( bWaitAll ) + { + while (numEvent < nCount) + { + uint64_t deltaTime = Timer_GetTimeUS(); + + res = sys_semaphore_wait(gWaitObjectsSemaphore, timeOut == TT_INFINITE ? 0 : timeOut ); + + deltaTime = Timer_GetTimeUS() - deltaTime; + + if (res == ETIMEDOUT) + { + result = TW_TIMEOUT; + break; + } + else if (res == CELL_OK) + { + numEvent++; + + if (deltaTime >= timeOut) + { + // note - if this is not truly a time out + // then it will be set to WAIT_OBJECT_0 + // after this loop + result = TW_TIMEOUT; + break; + } + else + { + timeOut -= deltaTime; + } + } + else + { + result = TW_FAILED; + break; + } + } + + if (numEvent >= nCount) + { + result = WAIT_OBJECT_0; + } + } + else // Wait for one event to be set + { + // no event fired yet, wait on semaphore + res = sys_semaphore_wait( gWaitObjectsSemaphore, timeOut == TT_INFINITE ? 0 : timeOut ); + + if (res == ETIMEDOUT) + { + result = TW_TIMEOUT; + } + else if (res == CELL_OK) + { + if ((event < 0) || (event >= nCount)) + { + DEBUG_ERROR("Bad event\n"); + } + + result = WAIT_OBJECT_0 + event; + } + } + + // run through events unregistering this thread, for benefit + // of those events that did not fire, or fired before semaphore + // was registered + for (int i = 0; i < nCount; i++) + { + lppHandles[i]->UnregisterWaitingThread(&gWaitObjectsSemaphore); + } + + // reset semaphore + while (sys_semaphore_trywait(gWaitObjectsSemaphore) != EBUSY); + + return result; + + + ////////////////////////////////////////////////////////////// +#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS + ////////////////////////////////////////////////////////////// +} + +#endif diff --git a/external/vpc/tier0/tier0_strtools.cpp b/external/vpc/tier0/tier0_strtools.cpp new file mode 100644 index 0000000..a651f26 --- /dev/null +++ b/external/vpc/tier0/tier0_strtools.cpp @@ -0,0 +1,53 @@ +//========= Copyright � Valve Corporation, All rights reserved. ============// +#include "pch_tier0.h" +#include "tier0_strtools.h" + + +#define TOLOWERC( x ) (( ( x >= 'A' ) && ( x <= 'Z' ) )?( x + 32 ) : x ) +extern "C" +int V_tier0_stricmp(const char *s1, const char *s2 ) +{ + uint8 const *pS1 = ( uint8 const * ) s1; + uint8 const *pS2 = ( uint8 const * ) s2; + for(;;) + { + int c1 = *( pS1++ ); + int c2 = *( pS2++ ); + if ( c1 == c2 ) + { + if ( !c1 ) return 0; + } + else + { + if ( ! c2 ) + { + return c1 - c2; + } + c1 = TOLOWERC( c1 ); + c2 = TOLOWERC( c2 ); + if ( c1 != c2 ) + { + return c1 - c2; + } + } + c1 = *( pS1++ ); + c2 = *( pS2++ ); + if ( c1 == c2 ) + { + if ( !c1 ) return 0; + } + else + { + if ( ! c2 ) + { + return c1 - c2; + } + c1 = TOLOWERC( c1 ); + c2 = TOLOWERC( c2 ); + if ( c1 != c2 ) + { + return c1 - c2; + } + } + } +} diff --git a/external/vpc/tier0/tier0_strtools.h b/external/vpc/tier0/tier0_strtools.h new file mode 100644 index 0000000..d65e789 --- /dev/null +++ b/external/vpc/tier0/tier0_strtools.h @@ -0,0 +1,3 @@ +//========= Copyright � Valve Corporation, All rights reserved. ============// + +extern "C" int V_tier0_stricmp(const char *s1, const char *s2 );
\ No newline at end of file diff --git a/external/vpc/tier0/valobject.cpp b/external/vpc/tier0/valobject.cpp new file mode 100644 index 0000000..caf4283 --- /dev/null +++ b/external/vpc/tier0/valobject.cpp @@ -0,0 +1,124 @@ +//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "pch_tier0.h" +#include "vstdlib/pch_vstdlib.h" + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +#ifdef DBGFLAG_VALIDATE + +//----------------------------------------------------------------------------- +// Purpose: Initializer +// Input: pchType - Type of the object we represent. +// WARNING: pchType must be a static (since we keep a copy of it around for a while) +// pvObj - Pointer to the object we represent +// pchName - Name of the individual object we represent +// WARNING: pchName must be a static (since we keep a copy of it around for a while) +// pValObjectparent- Our parent object (ie, the object that our object is a member of) +// pValObjectPrev - Object that precedes us in the linked list (we're +// always added to the end) +//----------------------------------------------------------------------------- +void CValObject::Init( tchar *pchType, void *pvObj, tchar *pchName, + CValObject *pValObjectParent, CValObject *pValObjectPrev ) +{ + m_nUser = 0; + + // Initialize pchType: + if ( NULL != pchType ) + { + V_strncpy( m_rgchType, pchType, (int) ( sizeof(m_rgchType) / sizeof(*m_rgchType) ) ); + } + else + { + m_rgchType[0] = '\0'; + } + + m_pvObj = pvObj; + + // Initialize pchName: + if ( NULL != pchName ) + { + V_strncpy( m_rgchName, pchName, sizeof(m_rgchName) / sizeof(*m_rgchName) ); + } + else + { + m_rgchName[0] = NULL; + } + + m_pValObjectParent = pValObjectParent; + + if ( NULL == pValObjectParent ) + m_nLevel = 0; + else + m_nLevel = pValObjectParent->NLevel( ) + 1; + + m_cpubMemSelf = 0; + m_cubMemSelf = 0; + m_cpubMemTree = 0; + m_cubMemTree = 0; + + // Insert us at the back of the linked list + if ( NULL != pValObjectPrev ) + { + Assert( NULL == pValObjectPrev->m_pValObjectNext ); + pValObjectPrev->m_pValObjectNext = this; + } + m_pValObjectNext = NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: Destructor +//----------------------------------------------------------------------------- +CValObject::~CValObject( ) +{ +} + + +//----------------------------------------------------------------------------- +// Purpose: The object we represent has claimed direct ownership of a block of +// memory. Record that we own it. +// Input: pvMem - Address of the memory block +//----------------------------------------------------------------------------- +void CValObject::ClaimMemoryBlock( void *pvMem ) +{ + // Get the memory block header + CMemBlockHdr *pMemBlockHdr = CMemBlockHdr::PMemBlockHdrFromPvUser( pvMem ); + pMemBlockHdr->CheckValid( ); + + // Update our counters + m_cpubMemSelf++; + m_cubMemSelf+= pMemBlockHdr->CubUser( ); + m_cpubMemTree++; + m_cubMemTree+= pMemBlockHdr->CubUser( ); + + // If we have a parent object, let it know about the memory (it'll recursively call up the tree) + if ( NULL != m_pValObjectParent ) + m_pValObjectParent->ClaimChildMemoryBlock( pMemBlockHdr->CubUser( ) ); +} + + +//----------------------------------------------------------------------------- +// Purpose: A child of ours has claimed ownership of a memory block. Make +// a note of it, and pass the message back up the tree. +// Input: cubUser - Size of the memory block +//----------------------------------------------------------------------------- +void CValObject::ClaimChildMemoryBlock( int cubUser ) +{ + m_cpubMemTree++; + m_cubMemTree += cubUser; + + if ( NULL != m_pValObjectParent ) + m_pValObjectParent->ClaimChildMemoryBlock( cubUser ); +} + + + +#endif // DBGFLAG_VALIDATE
\ No newline at end of file diff --git a/external/vpc/tier0/vprof.cpp b/external/vpc/tier0/vprof.cpp new file mode 100644 index 0000000..cf6d7ba --- /dev/null +++ b/external/vpc/tier0/vprof.cpp @@ -0,0 +1,1752 @@ +//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: Real-Time Hierarchical Profiling +// +// $NoKeywords: $ +//===========================================================================// + +#include "pch_tier0.h" + +#include "tier0/memalloc.h" +#include "tier0/valve_off.h" + +#if defined(_WIN32) && !defined(_X360) +#define WIN_32_LEAN_AND_MEAN +#include <windows.h> +#endif + +#include <assert.h> + +#ifdef _WIN32 +#pragma warning(disable:4073) +#pragma init_seg( lib ) +#endif + +#pragma warning(push, 1) +#pragma warning(disable:4786) +#pragma warning(disable:4530) +#include <map> +#include <vector> +#include <algorithm> +#pragma warning(pop) + +#include "tier0/valve_on.h" +#include "tier0/vprof.h" +#include "tier0/l2cache.h" +#include "strtools.h" + + +#ifdef _X360 + +#include "xbox/xbox_console.h" + +#elif defined(_PS3) +#include "ps3/ps3_console.h" + +#else // NOT _X360: + +#include "tier0/memdbgon.h" + +#endif + +// NOTE: Explicitly and intentionally using STL in here to not generate any +// cyclical dependencies between the low-level debug library and the higher +// level data structures (toml 01-27-03) +using namespace std; + +#ifdef VPROF_ENABLED + + +#if defined(_X360) && !defined(_CERT) // enable PIX CPU trace: +#include "tracerecording.h" +#pragma comment( lib, "tracerecording.lib" ) +#pragma comment( lib, "xbdm.lib" ) +#endif + +//----------------------------------------------------------------------------- +bool g_VProfSignalSpike; + +//----------------------------------------------------------------------------- + +CVProfile g_VProfCurrentProfile; + +int CVProfNode::s_iCurrentUniqueNodeID = 0; + + + +CVProfNode::~CVProfNode() +{ +#if !defined( _WIN32 ) && !defined( POSIX ) + delete m_pChild; + delete m_pSibling; +#endif +} + +CVProfNode *CVProfNode::GetSubNode( const tchar *pszName, int detailLevel, const tchar *pBudgetGroupName, int budgetFlags ) +{ + // Try to find this sub node + CVProfNode * child = m_pChild; + while ( child ) + { + if ( child->m_pszName == pszName ) + { + return child; + } + child = child->m_pSibling; + } + + // We didn't find it, so add it + CVProfNode * node = new CVProfNode( pszName, detailLevel, this, pBudgetGroupName, budgetFlags ); + node->m_pSibling = m_pChild; + m_pChild = node; + return node; +} + +CVProfNode *CVProfNode::GetSubNode( const tchar *pszName, int detailLevel, const tchar *pBudgetGroupName ) +{ + return GetSubNode( pszName, detailLevel, pBudgetGroupName, BUDGETFLAG_OTHER ); +} + + +//------------------------------------- + +void CVProfNode::EnterScope() +{ + m_nCurFrameCalls++; + if ( m_nRecursions++ == 0 ) + { + m_Timer.Start(); +#ifndef _X360 + if ( g_VProfCurrentProfile.UsePME() ) + { + m_L2Cache.Start(); + } +#else // 360 code: + if ( g_VProfCurrentProfile.UsePME() || ((m_iBitFlags & kRecordL2) != 0) ) + { + m_PMCData.Start(); + } + + if ( (m_iBitFlags & kCPUTrace) != 0) + { + // this node is to be recorded. Which recording mode are we in? + switch ( g_VProfCurrentProfile.GetCPUTraceMode() ) + { + case CVProfile::kFirstHitNode: + case CVProfile::kAllNodesInFrame_Recording: + case CVProfile::kAllNodesInFrame_RecordingMultiFrame: + // we are presently recording. + if ( !XTraceStartRecording( g_VProfCurrentProfile.GetCPUTraceFilename() ) ) + { + Msg( "XTraceStartRecording failed, error code %d\n", GetLastError() ); + } + + default: + // no default. + break; + } + + } + +#endif + +#ifdef VPROF_VTUNE_GROUP + g_VProfCurrentProfile.PushGroup( m_BudgetGroupID ); +#endif + } +} + +//------------------------------------- + +bool CVProfNode::ExitScope() +{ + if ( --m_nRecursions == 0 && m_nCurFrameCalls != 0 ) + { + m_Timer.End(); + m_CurFrameTime += m_Timer.GetDuration(); +#ifndef _X360 + if ( g_VProfCurrentProfile.UsePME() ) + { + m_L2Cache.End(); + m_iCurL2CacheMiss += m_L2Cache.GetL2CacheMisses(); + } +#else // 360 code: + if ( g_VProfCurrentProfile.UsePME() || ((m_iBitFlags & kRecordL2) != 0) ) + { + m_PMCData.End(); + m_iCurL2CacheMiss += m_PMCData.GetL2CacheMisses(); + m_iCurLoadHitStores += m_PMCData.GetLHS(); + } + + if ( (m_iBitFlags & kCPUTrace) != 0 ) + { + // this node is enabled to be recorded. What mode are we in? + switch ( g_VProfCurrentProfile.GetCPUTraceMode() ) + { + case CVProfile::kFirstHitNode: + { + // one-off recording. stop now. + if ( XTraceStopRecording() ) + { + Msg( "CPU trace finished.\n" ); + if ( g_VProfCurrentProfile.TraceCompleteEvent() ) + { + // signal VXConsole that trace is completed + XBX_rTraceComplete(); + } + } + // don't trace again next frame, overwriting the file. + g_VProfCurrentProfile.SetCPUTraceEnabled( CVProfile::kDisabled ); + break; + } + + case CVProfile::kAllNodesInFrame_Recording: + case CVProfile::kAllNodesInFrame_RecordingMultiFrame: + { + // one-off recording. stop now. + if ( XTraceStopRecording() ) + { + if ( g_VProfCurrentProfile.GetCPUTraceMode() == CVProfile::kAllNodesInFrame_RecordingMultiFrame ) + { + Msg( "%.3f msec in %s\n", m_CurFrameTime.GetMillisecondsF(), g_VProfCurrentProfile.GetCPUTraceFilename() ); + } + else + { + Msg( "CPU trace finished.\n" ); + } + } + + // Spew time info for file to allow figuring it out later + g_VProfCurrentProfile.LatchMultiFrame( m_CurFrameTime.GetLongCycles() ); + +#if 0 // This doesn't want to work on the xbox360-- MoveFile not available or file still being put down to disk? + char suffix[ 32 ]; + _snprintf( suffix, sizeof( suffix ), "_%.3f_msecs", flMsecs ); + + char fn[ 512 ]; + + strncpy( fn, g_VProfCurrentProfile.GetCPUTraceFilename(), sizeof( fn ) ); + + char *p = strrchr( fn, '.' ); + if ( *p ) + { + *p = 0; + } + strncat( fn, suffix, sizeof( fn ) ); + strncat( fn, ".pix2", sizeof( fn ) ); + + BOOL bSuccess = MoveFile( g_VProfCurrentProfile.GetCPUTraceFilename(), fn ); + if ( !bSuccess ) + { + DWORD eCode = GetLastError(); + Msg( "Error %d\n", eCode ); + } +#endif + + // we're still recording until the frame is done. + // but, increment the index. + g_VProfCurrentProfile.IncrementMultiTraceIndex(); + break; + } + + } + + // g_VProfCurrentProfile.IsCPUTraceEnabled() && + + + } + +#endif + +#ifdef VPROF_VTUNE_GROUP + g_VProfCurrentProfile.PopGroup(); +#endif + } + return ( m_nRecursions == 0 ); +} + +//------------------------------------- + +void CVProfNode::Pause() +{ + if ( m_nRecursions > 0 ) + { + m_Timer.End(); + m_CurFrameTime += m_Timer.GetDuration(); + +#ifndef _X360 + if ( g_VProfCurrentProfile.UsePME() ) + { + m_L2Cache.End(); + m_iCurL2CacheMiss += m_L2Cache.GetL2CacheMisses(); + } +#else // 360 code: + if ( g_VProfCurrentProfile.UsePME() || ((m_iBitFlags & kRecordL2) != 0) ) + { + m_PMCData.End(); + m_iCurL2CacheMiss += m_PMCData.GetL2CacheMisses(); + m_iCurLoadHitStores += m_PMCData.GetLHS(); + } +#endif + } + if ( m_pChild ) + { + m_pChild->Pause(); + } + if ( m_pSibling ) + { + m_pSibling->Pause(); + } +} + +//------------------------------------- + +void CVProfNode::Resume() +{ + if ( m_nRecursions > 0 ) + { + m_Timer.Start(); + +#ifndef _X360 + if ( g_VProfCurrentProfile.UsePME() ) + { + m_L2Cache.Start(); + } +#else + if ( g_VProfCurrentProfile.UsePME() || ((m_iBitFlags & kRecordL2) != 0) ) + { + m_PMCData.Start(); + } +#endif + } + if ( m_pChild ) + { + m_pChild->Resume(); + } + if ( m_pSibling ) + { + m_pSibling->Resume(); + } +} + +//------------------------------------- + +void CVProfNode::Reset() +{ + m_nPrevFrameCalls = 0; + m_PrevFrameTime.Init(); + + m_nCurFrameCalls = 0; + m_CurFrameTime.Init(); + + m_nTotalCalls = 0; + m_TotalTime.Init(); + + m_PeakTime.Init(); + + m_iPrevL2CacheMiss = 0; + m_iCurL2CacheMiss = 0; + m_iTotalL2CacheMiss = 0; + +#ifdef _X360 + m_iPrevLoadHitStores = 0; + m_iCurLoadHitStores = 0; + m_iTotalLoadHitStores = 0; +#endif + + if ( m_pChild ) + { + m_pChild->Reset(); + } + if ( m_pSibling ) + { + m_pSibling->Reset(); + } +} + + +//------------------------------------- + +void CVProfNode::MarkFrame() +{ + m_nPrevFrameCalls = m_nCurFrameCalls; + m_PrevFrameTime = m_CurFrameTime; + m_iPrevL2CacheMiss = m_iCurL2CacheMiss; +#ifdef _X360 + m_iPrevLoadHitStores = m_iCurLoadHitStores; +#endif + m_nTotalCalls += m_nCurFrameCalls; + m_TotalTime += m_CurFrameTime; + + if ( m_PeakTime.IsLessThan( m_CurFrameTime ) ) + { + m_PeakTime = m_CurFrameTime; + } + + m_CurFrameTime.Init(); + m_nCurFrameCalls = 0; + m_iTotalL2CacheMiss += m_iCurL2CacheMiss; + m_iCurL2CacheMiss = 0; +#ifdef _X360 + m_iTotalLoadHitStores += m_iCurLoadHitStores; + m_iCurLoadHitStores = 0; +#endif + if ( m_pChild ) + { + m_pChild->MarkFrame(); + } + if ( m_pSibling ) + { + m_pSibling->MarkFrame(); + } +} + +//------------------------------------- + +void CVProfNode::ResetPeak() +{ + m_PeakTime.Init(); + + if ( m_pChild ) + { + m_pChild->ResetPeak(); + } + if ( m_pSibling ) + { + m_pSibling->ResetPeak(); + } +} + + +void CVProfNode::SetCurFrameTime( unsigned long milliseconds ) +{ + m_CurFrameTime.Init( (float)milliseconds ); +} +#ifdef DBGFLAG_VALIDATE +//----------------------------------------------------------------------------- +// Purpose: Ensure that all of our internal structures are consistent, and +// account for all memory that we've allocated. +// Input: validator - Our global validator object +// pchName - Our name (typically a member var in our container) +//----------------------------------------------------------------------------- +void CVProfNode::Validate( CValidator &validator, tchar *pchName ) +{ + validator.Push( _T("CVProfNode"), this, pchName ); + + m_L2Cache.Validate( validator, _T("m_L2Cache") ); + + if ( m_pSibling ) + m_pSibling->Validate( validator, _T("m_pSibling") ); + if ( m_pChild ) + m_pChild->Validate( validator, _T("m_pChild") ); + + validator.Pop( ); +} +#endif // DBGFLAG_VALIDATE + + + +//----------------------------------------------------------------------------- + +struct TimeSums_t +{ + const tchar *pszProfileScope; + unsigned calls; + double time; + double timeLessChildren; + double peak; +}; + +static bool TimeCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + return ( lhs.time > rhs.time ); +} + +static bool TimeLessChildrenCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + return ( lhs.timeLessChildren > rhs.timeLessChildren ); +} + +static bool PeakCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + return ( lhs.peak > rhs.peak ); +} + +static bool AverageTimeCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + double avgLhs = ( lhs.calls ) ? lhs.time / (double)lhs.calls : 0.0; + double avgRhs = ( rhs.calls ) ? rhs.time / (double)rhs.calls : 0.0; + return ( avgLhs > avgRhs ); +} + +static bool AverageTimeLessChildrenCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + double avgLhs = ( lhs.calls ) ? lhs.timeLessChildren / (double)lhs.calls : 0.0; + double avgRhs = ( rhs.calls ) ? rhs.timeLessChildren / (double)rhs.calls : 0.0; + return ( avgLhs > avgRhs ); + +} +static bool PeakOverAverageCompare( const TimeSums_t &lhs, const TimeSums_t &rhs ) +{ + double avgLhs = ( lhs.calls ) ? lhs.time / (double)lhs.calls : 0.0; + double avgRhs = ( rhs.calls ) ? rhs.time / (double)rhs.calls : 0.0; + + double lhsPoA = ( avgLhs != 0 ) ? lhs.peak / avgLhs : 0.0; + double rhsPoA = ( avgRhs != 0 ) ? rhs.peak / avgRhs : 0.0; + + return ( lhsPoA > rhsPoA ); +} + +map<CVProfNode *, double> g_TimesLessChildren; +int g_TotalFrames; +map<const tchar *, uintp> g_TimeSumsMap; +vector<TimeSums_t> g_TimeSums; +CVProfNode * g_pStartNode; +const tchar * g_pszSumNode; + +//------------------------------------- + +void CVProfile::SumTimes( CVProfNode *pNode, int budgetGroupID ) +{ + if ( !pNode ) + return; // this generally only happens on a failed FindNode() + + bool bSetStartNode; + if ( !g_pStartNode && _tcscmp( pNode->GetName(), g_pszSumNode ) == 0 ) + { + g_pStartNode = pNode; + bSetStartNode = true; + } + else + bSetStartNode = false; + + if ( GetRoot() != pNode ) + { + if ( g_pStartNode && pNode->GetTotalCalls() > 0 && ( budgetGroupID == -1 || pNode->GetBudgetGroupID() == budgetGroupID ) ) + { + double timeLessChildren = pNode->GetTotalTimeLessChildren(); + + g_TimesLessChildren.insert( make_pair( pNode, timeLessChildren ) ); + + map<const tchar *, uintp>::iterator iter; + iter = g_TimeSumsMap.find( pNode->GetName() ); // intenionally using address of string rather than string compare (toml 01-27-03) + if ( iter == g_TimeSumsMap.end() ) + { + TimeSums_t timeSums = { pNode->GetName(), pNode->GetTotalCalls(), pNode->GetTotalTime(), timeLessChildren, pNode->GetPeakTime() }; + g_TimeSumsMap.insert( make_pair( pNode->GetName(), g_TimeSums.size() ) ); + g_TimeSums.push_back( timeSums ); + } + else + { + TimeSums_t &timeSums = g_TimeSums[iter->second]; + timeSums.calls += pNode->GetTotalCalls(); + timeSums.time += pNode->GetTotalTime(); + timeSums.timeLessChildren += timeLessChildren; + if ( pNode->GetPeakTime() > timeSums.peak ) + timeSums.peak = pNode->GetPeakTime(); + } + } + + if( ( !g_pStartNode || pNode != g_pStartNode ) && pNode->GetSibling() ) + { + SumTimes( pNode->GetSibling(), budgetGroupID ); + } + } + + if( pNode->GetChild() ) + { + SumTimes( pNode->GetChild(), budgetGroupID ); + } + + if ( bSetStartNode ) + g_pStartNode = NULL; +} + +//------------------------------------- + +CVProfNode *CVProfile::FindNode( CVProfNode *pStartNode, const tchar *pszNode ) +{ + if ( _tcscmp( pStartNode->GetName(), pszNode ) != 0 ) + { + CVProfNode *pFoundNode = NULL; + if ( pStartNode->GetSibling() ) + { + pFoundNode = FindNode( pStartNode->GetSibling(), pszNode ); + } + + if ( !pFoundNode && pStartNode->GetChild() ) + { + pFoundNode = FindNode( pStartNode->GetChild(), pszNode ); + } + + return pFoundNode; + } + return pStartNode; +} + +//------------------------------------- +#ifdef _X360 + +void CVProfile::PMCDisableAllNodes(CVProfNode *pStartNode) +{ + if (pStartNode == NULL) + { + pStartNode = GetRoot(); + } + + pStartNode->EnableL2andLHS(false); + + if ( pStartNode->GetSibling() ) + { + PMCDisableAllNodes(pStartNode->GetSibling()); + } + + if ( pStartNode->GetChild() ) + { + PMCDisableAllNodes(pStartNode->GetChild()); + } +} + +// recursively set l2/lhs recording state for a node and all children AND SIBLINGS +static void PMCRecursiveL2Set(CVProfNode *pNode, bool enableState) +{ + if ( pNode ) + { + pNode->EnableL2andLHS(enableState); + if ( pNode->GetSibling() ) + { + PMCRecursiveL2Set( pNode->GetSibling(), enableState ); + } + if ( pNode->GetChild() ) + { + PMCRecursiveL2Set( pNode->GetChild(), enableState ); + } + } +} + +bool CVProfile::PMCEnableL2Upon(const tchar *pszNodeName, bool bRecursive) +{ + // PMCDisableAllNodes(); + CVProfNode *pNode = FindNode( GetRoot(), pszNodeName ); + if (pNode) + { + pNode->EnableL2andLHS(true); + if (bRecursive) + { + PMCRecursiveL2Set(pNode->GetChild(), true); + } + return true; + } + else + { + return false; + } +} + +bool CVProfile::PMCDisableL2Upon(const tchar *pszNodeName, bool bRecursive) +{ + // PMCDisableAllNodes(); + CVProfNode *pNode = FindNode( GetRoot(), pszNodeName ); + if ( pNode ) + { + pNode->EnableL2andLHS( false ); + if ( bRecursive ) + { + PMCRecursiveL2Set( pNode->GetChild(), false ); + } + return true; + } + else + { + return false; + } +} + +static void DumpEnabledPMCNodesInner(CVProfNode* pNode) +{ + if (!pNode) + return; + + if (pNode->IsL2andLHSEnabled()) + { + Msg( _T("\t%s\n"), pNode->GetName() ); + } + + // depth first printing clearer + if ( pNode->GetChild() ) + { + DumpEnabledPMCNodesInner(pNode->GetChild()); + } + + if ( pNode->GetSibling() ) + { + DumpEnabledPMCNodesInner(pNode->GetChild()); + } +} + +void CVProfile::DumpEnabledPMCNodes( void ) +{ + Msg( _T("Nodes enabled for PMC counters:\n") ); + CVProfNode *pNode = GetRoot(); + DumpEnabledPMCNodesInner( pNode ); + + Msg( _T("(end)\n") ); +} + +CVProfNode *CVProfile::CPUTraceGetEnabledNode(CVProfNode *pStartNode) +{ + if (!pStartNode) + { + pStartNode = GetRoot(); + } + + if ( (pStartNode->m_iBitFlags & CVProfNode::kCPUTrace) != 0 ) + { + return pStartNode; + } + + if (pStartNode->GetSibling()) + { + CVProfNode *retval = CPUTraceGetEnabledNode(pStartNode->GetSibling()); + if (retval) + return retval; + } + + if (pStartNode->GetChild()) + { + CVProfNode *retval = CPUTraceGetEnabledNode(pStartNode->GetChild()); + if (retval) + return retval; + } + + return NULL; +} + +const char *CVProfile::SetCPUTraceFilename( const char *filename ) +{ + strncpy( m_CPUTraceFilename, filename, sizeof( m_CPUTraceFilename ) ); + return GetCPUTraceFilename(); +} + +/// Returns a pointer to an internal static, so you don't need to +/// make temporary char buffers for this to write into. What of it? +/// You're not hanging on to that pointer. That would be foolish. +const char *CVProfile::GetCPUTraceFilename() +{ + static char retBuf[256]; + + switch ( m_iCPUTraceEnabled ) + { + case kAllNodesInFrame_WaitingForMark: + case kAllNodesInFrame_Recording: + _snprintf( retBuf, sizeof( retBuf ), "e:\\%.128s%.4d.pix2", m_CPUTraceFilename, m_iSuccessiveTraceIndex ); + break; + + case kAllNodesInFrame_WaitingForMarkMultiFrame: + case kAllNodesInFrame_RecordingMultiFrame: + _snprintf( retBuf, sizeof( retBuf ), "e:\\%.128s_%.4d_%.4d.pix2", m_CPUTraceFilename, m_nFrameCount, m_iSuccessiveTraceIndex ); + break; + + default: + _snprintf( retBuf, sizeof( retBuf ), "e:\\%.128s.pix2", m_CPUTraceFilename ); + } + + return retBuf; +} + +bool CVProfile::TraceCompleteEvent( void ) +{ + return m_bTraceCompleteEvent; +} + +CVProfNode *CVProfile::CPUTraceEnableForNode(const tchar *pszNodeName) +{ + // disable whatever may be enabled already (we can only trace one node at a time) + CPUTraceDisableAllNodes(); + + CVProfNode *which = FindNode(GetRoot(), pszNodeName); + if (which) + { + which->m_iBitFlags |= CVProfNode::kCPUTrace; + return which; + } + else + return NULL; +} + +void CVProfile::CPUTraceDisableAllNodes(CVProfNode *pStartNode) +{ + if (!pStartNode) + { + pStartNode = GetRoot(); + } + + pStartNode->m_iBitFlags &= ~CVProfNode::kCPUTrace; + + if (pStartNode->GetSibling()) + { + CPUTraceDisableAllNodes(pStartNode->GetSibling()); + } + + if (pStartNode->GetChild()) + { + CPUTraceDisableAllNodes(pStartNode->GetChild()); + } + +} + +#endif + +//------------------------------------- + +void CVProfile::SumTimes( const tchar *pszStartNode, int budgetGroupID ) +{ + if ( GetRoot()->GetChild() ) + { + if ( pszStartNode == NULL ) + g_pStartNode = GetRoot(); + else + g_pStartNode = NULL; + + g_pszSumNode = pszStartNode; + SumTimes( GetRoot(), budgetGroupID ); + g_pStartNode = NULL; + } + +} + +//------------------------------------- + +void CVProfile::DumpNodes( CVProfNode *pNode, int indent, bool bAverageAndCountOnly ) +{ + if ( !pNode ) + return; // this generally only happens on a failed FindNode() + + bool fIsRoot = ( pNode == GetRoot() ); + + if ( fIsRoot || pNode == g_pStartNode ) + { + if( bAverageAndCountOnly ) + { + Msg( _T(" Avg Time/Frame (ms)\n") ); + Msg( _T("[ func+child func ] Count\n") ); + Msg( _T(" ---------- --------- --------\n") ); + } + else + { + Msg( _T(" Sum (ms) Avg Time/Frame (ms) Avg Time/Call (ms)\n") ); + Msg( _T("[ func+child func ] [ func+child func ] [ func+child func ] Count Peak\n") ); + Msg( _T(" ---------- --------- ---------- ------ ---------- ------ -------- ------\n") ); + } + } + + if ( !fIsRoot ) + { + map<CVProfNode *, double>::iterator iterTimeLessChildren = g_TimesLessChildren.find( pNode ); + + double dNodeTime = 0; + if(iterTimeLessChildren != g_TimesLessChildren.end()) + dNodeTime = iterTimeLessChildren->second; + + if( bAverageAndCountOnly ) + { + Msg( _T(" %10.3f %9.2f %8d"), + ( pNode->GetTotalCalls() > 0 ) ? pNode->GetTotalTime() / (double)NumFramesSampled() : 0, + ( pNode->GetTotalCalls() > 0 ) ? dNodeTime / (double)NumFramesSampled() : 0, + pNode->GetTotalCalls() ); + } + else + { + Msg( _T(" %10.3f %9.2f %10.3f %6.2f %10.3f %6.2f %8d %6.2f"), + pNode->GetTotalTime(), dNodeTime, + ( pNode->GetTotalCalls() > 0 ) ? pNode->GetTotalTime() / (double)NumFramesSampled() : 0, + ( pNode->GetTotalCalls() > 0 ) ? dNodeTime / (double)NumFramesSampled() : 0, + ( pNode->GetTotalCalls() > 0 ) ? pNode->GetTotalTime() / (double)pNode->GetTotalCalls() : 0, + ( pNode->GetTotalCalls() > 0 ) ? dNodeTime / (double)pNode->GetTotalCalls() : 0, + pNode->GetTotalCalls(), pNode->GetPeakTime() ); + } + + Msg( _T(" ") ); + for ( int i = 1; i < indent; i++ ) + { + Msg( _T("| ") ); + } + + Msg( _T("%s\n"), pNode->GetName() ); + } + + if( pNode->GetChild() ) + { + DumpNodes( pNode->GetChild(), indent + 1, bAverageAndCountOnly ); + } + + if( !( fIsRoot || pNode == g_pStartNode ) && pNode->GetSibling() ) + { + DumpNodes( pNode->GetSibling(), indent, bAverageAndCountOnly ); + } +} + +//------------------------------------- + +#if defined( VPROF_VXCONSOLE_EXISTS ) +static void CalcBudgetGroupTimes_Recursive( CVProfNode *pNode, unsigned int *groupTimes, int numGroups, float flScale ) +{ + int groupID; + CVProfNode *nodePtr; + + groupID = pNode->GetBudgetGroupID(); + if ( groupID >= numGroups ) + { + return; + } + + groupTimes[groupID] += flScale*pNode->GetPrevTimeLessChildren(); + + nodePtr = pNode->GetSibling(); + if ( nodePtr ) + { + CalcBudgetGroupTimes_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } + + nodePtr = pNode->GetChild(); + if ( nodePtr ) + { + CalcBudgetGroupTimes_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } +} + +static void CalcBudgetGroupL2CacheMisses_Recursive( CVProfNode *pNode, unsigned int *groupTimes, int numGroups, float flScale ) +{ + int groupID; + CVProfNode *nodePtr; + + groupID = pNode->GetBudgetGroupID(); + if ( groupID >= numGroups ) + { + return; + } + + groupTimes[groupID] += flScale*pNode->GetPrevL2CacheMissLessChildren(); + + nodePtr = pNode->GetSibling(); + if ( nodePtr ) + { + CalcBudgetGroupL2CacheMisses_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } + + nodePtr = pNode->GetChild(); + if ( nodePtr ) + { + CalcBudgetGroupL2CacheMisses_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } +} + +static void CalcBudgetGroupLHS_Recursive( CVProfNode *pNode, unsigned int *groupTimes, int numGroups, float flScale ) +{ + int groupID; + CVProfNode *nodePtr; + + groupID = pNode->GetBudgetGroupID(); + if ( groupID >= numGroups ) + { + return; + } + + groupTimes[groupID] += flScale*pNode->GetPrevLoadHitStoreLessChildren(); + + nodePtr = pNode->GetSibling(); + if ( nodePtr ) + { + CalcBudgetGroupLHS_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } + + nodePtr = pNode->GetChild(); + if ( nodePtr ) + { + CalcBudgetGroupLHS_Recursive( nodePtr, groupTimes, numGroups, flScale ); + } +} + + +void CVProfile::VXConsoleReportMode( VXConsoleReportMode_t mode ) +{ + m_ReportMode = mode; +} + +void CVProfile::VXConsoleReportScale( VXConsoleReportMode_t mode, float flScale ) +{ + m_pReportScale[mode] = flScale; +} + + +//----------------------------------------------------------------------------- +// Send the all the counter attributes once to VXConsole at profiling start +//----------------------------------------------------------------------------- +void CVProfile::VXProfileStart() +{ + const char *names[XBX_MAX_PROFILE_COUNTERS]; + COLORREF colors[XBX_MAX_PROFILE_COUNTERS]; + int numGroups; + int counterGroup; + const char *pGroupName; + int i; + int r,g,b,a; + + // vprof system must be running + if ( m_enabled <= 0 || !m_UpdateMode ) + { + return; + } + + if ( m_UpdateMode & VPROF_UPDATE_BUDGET ) + { + // update budget profiling + numGroups = g_VProfCurrentProfile.GetNumBudgetGroups(); + if ( numGroups > XBX_MAX_PROFILE_COUNTERS ) + { + numGroups = XBX_MAX_PROFILE_COUNTERS; + } + for ( i=0; i<numGroups; i++ ) + { + names[i] = g_VProfCurrentProfile.GetBudgetGroupName( i ); + g_VProfCurrentProfile.GetBudgetGroupColor( i, r, g, b, a ); + colors[i] = XMAKECOLOR( r, g, b ); + } + + // send all the profile attributes + XBX_rSetProfileAttributes( "cpu", numGroups, names, colors ); + } + + if ( m_UpdateMode & (VPROF_UPDATE_TEXTURE_GLOBAL|VPROF_UPDATE_TEXTURE_PERFRAME) ) + { + // update texture profiling + numGroups = 0; + counterGroup = (m_UpdateMode & VPROF_UPDATE_TEXTURE_GLOBAL) ? COUNTER_GROUP_TEXTURE_GLOBAL : COUNTER_GROUP_TEXTURE_PER_FRAME; + for ( i=0; i<g_VProfCurrentProfile.GetNumCounters(); i++ ) + { + if ( g_VProfCurrentProfile.GetCounterGroup( i ) == counterGroup ) + { + // strip undesired prefix + pGroupName = g_VProfCurrentProfile.GetCounterName( i ); + if ( !stricmp( pGroupName, "texgroup_frame_" ) ) + { + pGroupName += 15; + } + else if ( !stricmp( pGroupName, "texgroup_global_" ) ) + { + pGroupName += 16; + } + names[numGroups] = pGroupName; + + g_VProfCurrentProfile.GetBudgetGroupColor( numGroups, r, g, b, a ); + colors[numGroups] = XMAKECOLOR( r, g, b ); + + numGroups++; + if ( numGroups == XBX_MAX_PROFILE_COUNTERS ) + { + break; + } + } + } + + // send all the profile attributes + XBX_rSetProfileAttributes( "texture", numGroups, names, colors ); + } +} + +//----------------------------------------------------------------------------- +// Send the counters to VXConsole +//----------------------------------------------------------------------------- +void CVProfile::VXProfileUpdate() +{ + int i; + int counterGroup; + int numGroups; + unsigned int groupData[XBX_MAX_PROFILE_COUNTERS]; + + // vprof system must be running + if ( m_enabled <= 0 || !m_UpdateMode ) + { + return; + } + + if ( m_UpdateMode & VPROF_UPDATE_BUDGET ) + { + // send the cpu counters + numGroups = g_VProfCurrentProfile.GetNumBudgetGroups(); + if ( numGroups > XBX_MAX_PROFILE_COUNTERS ) + { + numGroups = XBX_MAX_PROFILE_COUNTERS; + } + memset( groupData, 0, numGroups * sizeof( unsigned int ) ); + + CVProfNode *pNode = g_VProfCurrentProfile.GetRoot(); + if ( pNode && pNode->GetChild() ) + { + switch ( m_ReportMode ) + { + default: + case VXCONSOLE_REPORT_TIME: + CalcBudgetGroupTimes_Recursive( pNode->GetChild(), groupData, numGroups, m_pReportScale[VXCONSOLE_REPORT_TIME] ); + break; + + case VXCONSOLE_REPORT_L2CACHE_MISSES: + CalcBudgetGroupL2CacheMisses_Recursive( pNode->GetChild(), groupData, numGroups, m_pReportScale[VXCONSOLE_REPORT_L2CACHE_MISSES] ); + break; + + case VXCONSOLE_REPORT_LOAD_HIT_STORE: + CalcBudgetGroupLHS_Recursive( pNode->GetChild(), groupData, numGroups, m_pReportScale[VXCONSOLE_REPORT_LOAD_HIT_STORE] ); + break; + } + } + + XBX_rSetProfileData( "cpu", numGroups, groupData ); + } + + if ( m_UpdateMode & ( VPROF_UPDATE_TEXTURE_GLOBAL|VPROF_UPDATE_TEXTURE_PERFRAME ) ) + { + // send the texture counters + numGroups = 0; + counterGroup = ( m_UpdateMode & VPROF_UPDATE_TEXTURE_GLOBAL ) ? COUNTER_GROUP_TEXTURE_GLOBAL : COUNTER_GROUP_TEXTURE_PER_FRAME; + for ( i = 0; i < g_VProfCurrentProfile.GetNumCounters(); i++ ) + { + if ( g_VProfCurrentProfile.GetCounterGroup( i ) == counterGroup ) + { + // get the size in bytes + groupData[numGroups++] = g_VProfCurrentProfile.GetCounterValue( i ); + if ( numGroups == XBX_MAX_PROFILE_COUNTERS ) + { + break; + } + } + } + + XBX_rSetProfileData( "texture", numGroups, groupData ); + } +} + +void CVProfile::VXEnableUpdateMode( int event, bool bEnable ) +{ + // enable or disable the updating of specified events + if ( bEnable ) + { + m_UpdateMode |= event; + } + else + { + m_UpdateMode &= ~event; + } + + // force a resend of possibly affected attributes + VXProfileStart(); +} + +#define MAX_VPROF_NODES_IN_LIST 4096 +static void VXBuildNodeList_r( CVProfNode *pNode, xVProfNodeItem_t *pNodeList, int *pNumNodes ) +{ + if ( !pNode ) + { + return; + } + if ( *pNumNodes >= MAX_VPROF_NODES_IN_LIST ) + { + // list full + return; + } + + // add to list + pNodeList[*pNumNodes].pName = (const char *)pNode->GetName(); + + pNodeList[*pNumNodes].pBudgetGroupName = g_VProfCurrentProfile.GetBudgetGroupName( pNode->GetBudgetGroupID() ); + int r, g, b, a; + g_VProfCurrentProfile.GetBudgetGroupColor( pNode->GetBudgetGroupID(), r, g, b, a ); + pNodeList[*pNumNodes].budgetGroupColor = XMAKECOLOR( r, g, b ); + + pNodeList[*pNumNodes].totalCalls = pNode->GetTotalCalls(); + pNodeList[*pNumNodes].inclusiveTime = pNode->GetTotalTime(); + pNodeList[*pNumNodes].exclusiveTime = pNode->GetTotalTimeLessChildren(); + (*pNumNodes)++; + + CVProfNode *nodePtr = pNode->GetSibling(); + if ( nodePtr ) + { + VXBuildNodeList_r( nodePtr, pNodeList, pNumNodes ); + } + + nodePtr = pNode->GetChild(); + if ( nodePtr ) + { + VXBuildNodeList_r( nodePtr, pNodeList, pNumNodes ); + } +} +void CVProfile::VXSendNodes( void ) +{ + Pause(); + + xVProfNodeItem_t *pNodeList = (xVProfNodeItem_t *)stackalloc( MAX_VPROF_NODES_IN_LIST * sizeof(xVProfNodeItem_t) ); + int numNodes = 0; + VXBuildNodeList_r( GetRoot(), pNodeList, &numNodes ); + + // send to vxconsole + XBX_rVProfNodeList( numNodes, pNodeList ); + + Resume(); +} +#endif + +//------------------------------------- +static void DumpSorted( const tchar *pszHeading, double totalTime, bool (*pfnSort)( const TimeSums_t &, const TimeSums_t & ), int maxLen = 999999 ) +{ + unsigned i; + vector<TimeSums_t> sortedSums; + sortedSums = g_TimeSums; + sort( sortedSums.begin(), sortedSums.end(), pfnSort ); + + Msg( _T("%s\n"), pszHeading); + Msg( _T(" Scope Calls Calls/Frame Time+Child Pct Time Pct Avg/Frame Avg/Call Avg-NoChild Peak\n")); + Msg( _T(" ---------------------------------------------------- ----------- ----------- ----------- ------ ----------- ------ ----------- ----------- ----------- -----------\n")); + for ( i = 0; i < sortedSums.size() && i < (unsigned)maxLen; i++ ) + { + double avg = ( sortedSums[i].calls ) ? sortedSums[i].time / (double)sortedSums[i].calls : 0.0; + double avgLessChildren = ( sortedSums[i].calls ) ? sortedSums[i].timeLessChildren / (double)sortedSums[i].calls : 0.0; + + Msg( _T(" %52.52s%12d%12.3f%12.3f%7.2f%12.3f%7.2f%12.3f%12.3f%12.3f%12.3f\n"), + sortedSums[i].pszProfileScope, + sortedSums[i].calls, + (float)sortedSums[i].calls / (float)g_TotalFrames, + sortedSums[i].time, + min( ( sortedSums[i].time / totalTime ) * 100.0, 100.0 ), + sortedSums[i].timeLessChildren, + min( ( sortedSums[i].timeLessChildren / totalTime ) * 100.0, 100.0 ), + sortedSums[i].time / (float)g_TotalFrames, + avg, + avgLessChildren, + sortedSums[i].peak ); + } +} + +#if defined( _X360 ) +// Dump information on all nodes with PMC recording +static void DumpPMC( CVProfNode *pNode, bool &bPrintHeader, uint64 L2thresh = 1, uint64 LHSthresh = 1 ) +{ + if (!pNode) return; + + uint64 l2 = pNode->GetL2CacheMisses(); + uint64 lhs = pNode->GetLoadHitStores(); + if ( l2 > L2thresh && + lhs > LHSthresh ) + { + // met threshold. + if (bPrintHeader) + { + // print header + Msg( _T("-- 360 PMC information --\n") ); + Msg( _T("Scope L2/call L2/frame LHS/call LHS/frame\n") ); + Msg( _T("---------------------------------------------------- --------- --------- --------- ---------\n") ); + + bPrintHeader = false; + } + + // print + float calls = pNode->GetTotalCalls(); + float frames = g_TotalFrames; + Msg( _T("%52.52s %9.2f %9.2f %9.2f %9.2f\n"), pNode->GetName(), l2/calls, l2/frames, lhs/calls, lhs/frames ); + } + + if ( pNode->GetSibling() ) + { + DumpPMC( pNode->GetSibling(), bPrintHeader, L2thresh, LHSthresh ); + } + + if ( pNode->GetChild() ) + { + DumpPMC( pNode->GetChild(), bPrintHeader, L2thresh, LHSthresh ); + } +} +#endif + +//------------------------------------- + +void CVProfile::OutputReport( int type, const tchar *pszStartNode, int budgetGroupID ) +{ + Msg( _T("******** BEGIN VPROF REPORT ********\n")); +#ifdef _MSC_VER +#if (_MSC_VER < 1300) + Msg( _T(" (note: this report exceeds the output capacity of MSVC debug window. Use console window or console log.) \n")); +#endif +#endif + + g_TotalFrames = max( NumFramesSampled() - 1, 1 ); + + if ( NumFramesSampled() == 0 || GetTotalTimeSampled() == 0) + Msg( _T("No samples\n") ); + else + { + if ( type & VPRT_SUMMARY ) + { + Msg( _T("-- Summary --\n") ); + Msg( _T("%d frames sampled for %.2f seconds\n"), g_TotalFrames, GetTotalTimeSampled() / 1000.0 ); + Msg( _T("Average %.2f fps, %.2f ms per frame\n"), 1000.0 / ( GetTotalTimeSampled() / g_TotalFrames ), GetTotalTimeSampled() / g_TotalFrames ); + Msg( _T("Peak %.2f ms frame\n"), GetPeakFrameTime() ); + + double timeAccountedFor = 100.0 - ( m_Root.GetTotalTimeLessChildren() / m_Root.GetTotalTime() ); + Msg( _T("%.0f pct of time accounted for\n"), min( 100.0, timeAccountedFor ) ); + Msg( _T("\n") ); + } + + if ( pszStartNode == NULL ) + { + pszStartNode = GetRoot()->GetName(); + } + + SumTimes( pszStartNode, budgetGroupID ); + + // Dump the hierarchy + if ( type & VPRT_HIERARCHY ) + { + Msg( _T("-- Hierarchical Call Graph --\n")); + if ( pszStartNode == NULL ) + g_pStartNode = NULL; + else + g_pStartNode = FindNode( GetRoot(), pszStartNode ); + + DumpNodes( (!g_pStartNode) ? GetRoot() : g_pStartNode, 0, false ); + Msg( _T("\n") ); + } + + if ( type & VPRT_HIERARCHY_TIME_PER_FRAME_AND_COUNT_ONLY ) + { + Msg( _T("-- Hierarchical Call Graph --\n")); + if ( pszStartNode == NULL ) + g_pStartNode = NULL; + else + g_pStartNode = FindNode( GetRoot(), pszStartNode ); + + DumpNodes( (!g_pStartNode) ? GetRoot() : g_pStartNode, 0, true ); + Msg( _T("\n") ); + } + + int maxLen = ( type & VPRT_LIST_TOP_ITEMS_ONLY ) ? 25 : 999999; + + if ( type & VPRT_LIST_BY_TIME ) + { + DumpSorted( _T("-- Profile scopes sorted by time (including children) --"), GetTotalTimeSampled(), TimeCompare, maxLen ); + Msg( _T("\n") ); + } + if ( type & VPRT_LIST_BY_TIME_LESS_CHILDREN ) + { + DumpSorted( _T("-- Profile scopes sorted by time (without children) --"), GetTotalTimeSampled(), TimeLessChildrenCompare, maxLen ); + Msg( _T("\n") ); + } + if ( type & VPRT_LIST_BY_AVG_TIME ) + { + DumpSorted( _T("-- Profile scopes sorted by average time (including children) --"), GetTotalTimeSampled(), AverageTimeCompare, maxLen ); + Msg( _T("\n") ); + } + if ( type & VPRT_LIST_BY_AVG_TIME_LESS_CHILDREN ) + { + DumpSorted( _T("-- Profile scopes sorted by average time (without children) --"), GetTotalTimeSampled(), AverageTimeLessChildrenCompare, maxLen ); + Msg( _T("\n") ); + } + if ( type & VPRT_LIST_BY_PEAK_TIME ) + { + DumpSorted( _T("-- Profile scopes sorted by peak --"), GetTotalTimeSampled(), PeakCompare, maxLen); + Msg( _T("\n") ); + } + if ( type & VPRT_LIST_BY_PEAK_OVER_AVERAGE ) + { + DumpSorted( _T("-- Profile scopes sorted by peak over average (including children) --"), GetTotalTimeSampled(), PeakOverAverageCompare, maxLen ); + Msg( _T("\n") ); + } + + // TODO: Functions by time less children + // TODO: Functions by time averages + // TODO: Functions by peak + // TODO: Peak deviation from average + g_TimesLessChildren.clear(); + g_TimeSumsMap.clear(); + g_TimeSums.clear(); + +#ifdef _X360 + bool bPrintedHeader = true; + DumpPMC( FindNode( GetRoot(), pszStartNode ), bPrintedHeader ); +#endif + + } + Msg( _T("******** END VPROF REPORT ********\n")); + +} + +//============================================================================= + +CVProfile::CVProfile() + : m_Root( _T("Root"), 0, NULL, VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, 0 ), + m_pCurNode( &m_Root ), + m_nFrames( 0 ), + m_enabled( 0 ), // don't change this. if m_enabled is anything but zero coming out of this constructor, vprof will break. + m_pausedEnabledDepth( 0 ), + m_fAtRoot( true ) +{ + +#ifdef VPROF_VTUNE_GROUP + m_GroupIDStackDepth = 1; + m_GroupIDStack[0] = 0; // VPROF_BUDGETGROUP_OTHER_UNACCOUNTED +#endif + + m_TargetThreadId = ThreadGetCurrentId(); + + // Go ahead and allocate 32 slots for budget group names + MEM_ALLOC_CREDIT(); + m_pBudgetGroups = new CVProfile::CBudgetGroup[32]; + m_nBudgetGroupNames = 0; + m_nBudgetGroupNamesAllocated = 32; + + // Add these here so that they will always be in the same order. + // VPROF_BUDGETGROUP_OTHER_UNACCOUNTED has to be FIRST!!!! + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_WORLD_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_DISPLACEMENT_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_GAME, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_PLAYER, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_NPCS, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_SERVER_ANIM, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_CLIENT_ANIMATION, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_PHYSICS, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_STATICPROP_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_MODEL_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_MODEL_FAST_PATH_RENDERING,BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_LIGHTCACHE, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_BRUSHMODEL_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_SHADOW_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_DETAILPROP_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_PARTICLE_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_ROPES, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_DLIGHT_RENDERING, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OTHER_NETWORKING, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OTHER_SOUND, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OTHER_VGUI, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OTHER_FILESYSTEM, BUDGETFLAG_OTHER | BUDGETFLAG_SERVER ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_PREDICTION, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_INTERPOLATION, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_SWAP_BUFFERS, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OCCLUSION, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_OVERLAYS, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_TOOLS, BUDGETFLAG_OTHER | BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_TEXTURE_CACHE, BUDGETFLAG_CLIENT ); + BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_REPLAY, BUDGETFLAG_SERVER ); +// BudgetGroupNameToBudgetGroupID( VPROF_BUDGETGROUP_DISP_HULLTRACES ); + + m_bPMEInit = false; + m_bPMEEnabled = false; + +#ifdef VPROF_VXCONSOLE_EXISTS + m_bTraceCompleteEvent = false; + m_iSuccessiveTraceIndex = 0; + m_ReportMode = VXCONSOLE_REPORT_TIME; + m_pReportScale[VXCONSOLE_REPORT_TIME] = 1000.0f; + m_pReportScale[VXCONSOLE_REPORT_L2CACHE_MISSES] = 1.0f; + m_pReportScale[VXCONSOLE_REPORT_LOAD_HIT_STORE] = 0.1f; + m_nFrameCount = 0; + m_nFramesRemaining = 1; + m_WorstCycles = 0; + m_WorstTraceFilename[ 0 ] = 0; + m_UpdateMode = 0; +#endif +#ifdef _X360 + m_iCPUTraceEnabled = kDisabled; +#endif +} + + +CVProfile::~CVProfile() +{ + Term(); +} + + +void CVProfile::FreeNodes_R( CVProfNode *pNode ) +{ + CVProfNode *pNext; + for ( CVProfNode *pChild = pNode->GetChild(); pChild; pChild = pNext ) + { + pNext = pChild->GetSibling(); + FreeNodes_R( pChild ); + } + + if ( pNode == GetRoot() ) + { + pNode->m_pChild = NULL; + } + else + { + delete pNode; + } +} + + +void CVProfile::Term() +{ + int i; + for( i = 0; i < m_nBudgetGroupNames; i++ ) + { + delete [] m_pBudgetGroups[i].m_pName; + } + delete m_pBudgetGroups; + m_nBudgetGroupNames = m_nBudgetGroupNamesAllocated = 0; + m_pBudgetGroups = NULL; + + int n; + for( n = 0; n < m_NumCounters; n++ ) + { + delete [] m_CounterNames[n]; + m_CounterNames[n] = NULL; + } + m_NumCounters = 0; + + // Free the nodes. + if ( GetRoot() ) + { + FreeNodes_R( GetRoot() ); + } +} + + +#define COLORMIN 160 +#define COLORMAX 255 + +static int g_ColorLookup[4] = +{ + COLORMIN, + COLORMAX, + COLORMIN+(COLORMAX-COLORMIN)/3, + COLORMIN+((COLORMAX-COLORMIN)*2)/3, +}; + +#define GET_BIT( val, bitnum ) ( ( val >> bitnum ) & 0x1 ) + +void CVProfile::GetBudgetGroupColor( int budgetGroupID, int &r, int &g, int &b, int &a ) +{ + budgetGroupID = budgetGroupID % ( 1 << 6 ); + + int index; + index = GET_BIT( budgetGroupID, 0 ) | ( GET_BIT( budgetGroupID, 5 ) << 1 ); + r = g_ColorLookup[index]; + index = GET_BIT( budgetGroupID, 1 ) | ( GET_BIT( budgetGroupID, 4 ) << 1 ); + g = g_ColorLookup[index]; + index = GET_BIT( budgetGroupID, 2 ) | ( GET_BIT( budgetGroupID, 3 ) << 1 ); + b = g_ColorLookup[index]; + a = 255; +} + +// return -1 if it doesn't exist. +int CVProfile::FindBudgetGroupName( const tchar *pBudgetGroupName ) +{ + int i; + for( i = 0; i < m_nBudgetGroupNames; i++ ) + { + if( _tcsicmp( pBudgetGroupName, m_pBudgetGroups[i].m_pName ) == 0 ) + { + return i; + } + } + return -1; +} + +int CVProfile::AddBudgetGroupName( const tchar *pBudgetGroupName, int budgetFlags ) +{ + MEM_ALLOC_CREDIT(); + tchar *pNewString = new tchar[ _tcslen( pBudgetGroupName ) + 1 ]; + _tcscpy( pNewString, pBudgetGroupName ); + if( m_nBudgetGroupNames + 1 > m_nBudgetGroupNamesAllocated ) + { + m_nBudgetGroupNamesAllocated *= 2; + m_nBudgetGroupNamesAllocated = max( m_nBudgetGroupNames + 6, m_nBudgetGroupNamesAllocated ); + + CBudgetGroup *pNew = new CBudgetGroup[ m_nBudgetGroupNamesAllocated ]; + for ( int i=0; i < m_nBudgetGroupNames; i++ ) + pNew[i] = m_pBudgetGroups[i]; + + delete [] m_pBudgetGroups; + m_pBudgetGroups = pNew; + } + + m_pBudgetGroups[m_nBudgetGroupNames].m_pName = pNewString; + m_pBudgetGroups[m_nBudgetGroupNames].m_BudgetFlags = budgetFlags; + m_nBudgetGroupNames++; + if( m_pNumBudgetGroupsChangedCallBack ) + { + (*m_pNumBudgetGroupsChangedCallBack)(); + } + +#if defined( VPROF_VXCONSOLE_EXISTS ) + // re-start with all the known budgets + VXProfileStart(); +#endif + return m_nBudgetGroupNames - 1; +} + +int CVProfile::BudgetGroupNameToBudgetGroupID( const tchar *pBudgetGroupName, int budgetFlagsToORIn ) +{ + int budgetGroupID = FindBudgetGroupName( pBudgetGroupName ); + if( budgetGroupID == -1 ) + { + budgetGroupID = AddBudgetGroupName( pBudgetGroupName, budgetFlagsToORIn ); + } + else + { + m_pBudgetGroups[budgetGroupID].m_BudgetFlags |= budgetFlagsToORIn; + } + + return budgetGroupID; +} + +int CVProfile::BudgetGroupNameToBudgetGroupID( const tchar *pBudgetGroupName ) +{ + return BudgetGroupNameToBudgetGroupID( pBudgetGroupName, BUDGETFLAG_OTHER ); +} + +int CVProfile::GetNumBudgetGroups( void ) +{ + return m_nBudgetGroupNames; +} + +void CVProfile::RegisterNumBudgetGroupsChangedCallBack( void (*pCallBack)(void) ) +{ + m_pNumBudgetGroupsChangedCallBack = pCallBack; +} + +void CVProfile::HideBudgetGroup( int budgetGroupID, bool bHide ) +{ + if( budgetGroupID != -1 ) + { + if ( bHide ) + m_pBudgetGroups[budgetGroupID].m_BudgetFlags |= BUDGETFLAG_HIDDEN; + else + m_pBudgetGroups[budgetGroupID].m_BudgetFlags &= ~BUDGETFLAG_HIDDEN; + } +} + +int *CVProfile::FindOrCreateCounter( const tchar *pName, CounterGroup_t eCounterGroup ) +{ + Assert( m_NumCounters+1 < MAXCOUNTERS ); + if ( m_NumCounters + 1 >= MAXCOUNTERS || !InTargetThread() ) + { + static int dummy; + return &dummy; + } + int i; + for( i = 0; i < m_NumCounters; i++ ) + { + if( _tcsicmp( m_CounterNames[i], pName ) == 0 ) + { + // found it! + return &m_Counters[i]; + } + } + + // NOTE: These get freed in ~CVProfile. + MEM_ALLOC_CREDIT(); + tchar *pNewName = new tchar[_tcslen( pName ) + 1]; + _tcscpy( pNewName, pName ); + m_Counters[m_NumCounters] = 0; + m_CounterGroups[m_NumCounters] = (char)eCounterGroup; + m_CounterNames[m_NumCounters++] = pNewName; + return &m_Counters[m_NumCounters-1]; +} + +void CVProfile::ResetCounters( CounterGroup_t eCounterGroup ) +{ + int i; + for( i = 0; i < m_NumCounters; i++ ) + { + if ( m_CounterGroups[i] == eCounterGroup ) + m_Counters[i] = 0; + } +} + +int CVProfile::GetNumCounters() const +{ + return m_NumCounters; +} + +const tchar *CVProfile::GetCounterName( int index ) const +{ + Assert( index >= 0 && index < m_NumCounters ); + return m_CounterNames[index]; +} + +int CVProfile::GetCounterValue( int index ) const +{ + Assert( index >= 0 && index < m_NumCounters ); + return m_Counters[index]; +} + +const tchar *CVProfile::GetCounterNameAndValue( int index, int &val ) const +{ + Assert( index >= 0 && index < m_NumCounters ); + val = m_Counters[index]; + return m_CounterNames[index]; +} + +CounterGroup_t CVProfile::GetCounterGroup( int index ) const +{ + Assert( index >= 0 && index < m_NumCounters ); + return (CounterGroup_t)m_CounterGroups[index]; +} + +#ifdef _X360 +void CVProfile::LatchMultiFrame( int64 cycles ) +{ + if ( cycles > m_WorstCycles ) + { + strncpy( m_WorstTraceFilename, GetCPUTraceFilename(), sizeof( m_WorstTraceFilename ) ); + m_WorstCycles = cycles; + } +} + +void CVProfile::SpewWorstMultiFrame() +{ + CCycleCount cc( m_WorstCycles ); + Msg( "%s == %.3f msec\n", m_WorstTraceFilename, cc.GetMillisecondsF() ); +} +#endif + +#ifdef DBGFLAG_VALIDATE + +#ifdef _WIN64 +#error the below is presumably broken on 64 bit +#endif // _WIN64 + +const int k_cSTLMapAllocOffset = 4; +#define GET_INTERNAL_MAP_ALLOC_PTR( pMap ) \ + ( * ( (void **) ( ( ( byte * ) ( pMap ) ) + k_cSTLMapAllocOffset ) ) ) +//----------------------------------------------------------------------------- +// Purpose: Ensure that all of our internal structures are consistent, and +// account for all memory that we've allocated. +// Input: validator - Our global validator object +// pchName - Our name (typically a member var in our container) +//----------------------------------------------------------------------------- +void CVProfile::Validate( CValidator &validator, tchar *pchName ) +{ + validator.Push( _T("CVProfile"), this, pchName ); + + m_Root.Validate( validator, _T("m_Root") ); + + for ( int iBudgetGroup=0; iBudgetGroup < m_nBudgetGroupNames; iBudgetGroup++ ) + validator.ClaimMemory( m_pBudgetGroups[iBudgetGroup].m_pName ); + + validator.ClaimMemory( m_pBudgetGroups ); + + // The std template map class allocates memory internally, but offer no way to get + // access to their pointer. Since this is for debug purposes only and the + // std template classes don't change, just look at the well-known offset. This + // is arguably sick and wrong, kind of like marrying a squirrel. + validator.ClaimMemory( GET_INTERNAL_MAP_ALLOC_PTR( &g_TimesLessChildren ) ); + validator.ClaimMemory( GET_INTERNAL_MAP_ALLOC_PTR( &g_TimeSumsMap ) ); + + validator.Pop( ); +} +#endif // DBGFLAG_VALIDATE + +#endif + diff --git a/external/vpc/tier0/win32consoleio.cpp b/external/vpc/tier0/win32consoleio.cpp new file mode 100644 index 0000000..8ec6fa9 --- /dev/null +++ b/external/vpc/tier0/win32consoleio.cpp @@ -0,0 +1,161 @@ +//======= Copyright � 1996-2006, Valve Corporation, All rights reserved. ====== +// +// Purpose: Win32 Console API helpers +// +//============================================================================= + +#include "pch_tier0.h" +#include "win32consoleio.h" + +#if defined( _WIN32 ) + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <io.h> +#include <fcntl.h> + +#include <iostream> + +#endif // defined( _WIN32 ) + +// NOTE: This has to be the last file included! +#include "tier0/memdbgon.h" + + +//----------------------------------------------------------------------------- +// +// Attach a console to a Win32 GUI process and setup stdin, stdout & stderr +// along with the std::iostream (cout, cin, cerr) equivalents to read and +// write to and from that console +// +// 1. Ensure the handle associated with stdio is FILE_TYPE_UNKNOWN +// if it's anything else just return false. This supports cygwin +// style command shells like rxvt which setup pipes to processes +// they spawn +// +// 2. See if the Win32 function call AttachConsole exists in kernel32 +// It's a Windows 2000 and above call. If it does, call it and see +// if it succeeds in attaching to the console of the parent process. +// If that succeeds, return false (for no new console allocated). +// This supports someone typing the command from a normal windows +// command window and having the output go to the parent window. +// It's a little funny because a GUI app detaches so the command +// prompt gets intermingled with output from this process +// +// 3. If things get to here call AllocConsole which will pop open +// a new window and allow output to go to that window. The +// window will disappear when the process exists so if it's used +// for something like a help message then do something like getchar() +// from stdin to wait for a keypress. if AllocConsole is called +// true is returned. +// +// Return: true if AllocConsole() was used to pop open a new windows console +// +//----------------------------------------------------------------------------- +bool SetupWin32ConsoleIO() +{ +#if defined( _WIN32 ) + // Only useful on Windows platforms + + bool newConsole( false ); + + if ( GetFileType( GetStdHandle( STD_OUTPUT_HANDLE ) ) == FILE_TYPE_UNKNOWN ) + { + + HINSTANCE hInst = ::LoadLibrary( "kernel32.dll" ); + typedef BOOL ( WINAPI * pAttachConsole_t )( DWORD ); + pAttachConsole_t pAttachConsole( ( BOOL ( _stdcall * )( DWORD ) )GetProcAddress( hInst, "AttachConsole" ) ); + + if ( !( pAttachConsole && (*pAttachConsole)( ( DWORD ) - 1 ) ) ) + { + newConsole = true; + AllocConsole(); + } + + *stdout = *_fdopen( _open_osfhandle( reinterpret_cast< intp >( GetStdHandle( STD_OUTPUT_HANDLE ) ), _O_TEXT ), "w" ); + setvbuf( stdout, NULL, _IONBF, 0 ); + + *stdin = *_fdopen( _open_osfhandle( reinterpret_cast< intp >( GetStdHandle( STD_INPUT_HANDLE ) ), _O_TEXT ), "r" ); + setvbuf( stdin, NULL, _IONBF, 0 ); + + *stderr = *_fdopen( _open_osfhandle( reinterpret_cast< intp >( GetStdHandle( STD_ERROR_HANDLE ) ), _O_TEXT ), "w" ); + setvbuf( stdout, NULL, _IONBF, 0 ); + + std::ios_base::sync_with_stdio(); + } + + return newConsole; + +#else // defined( _WIN32 ) + + return false; + +#endif // defined( _WIN32 ) +} + +//----------------------------------------------------------------------------- +// Win32 Console Color API Helpers, originally from cmdlib. +// Retrieves the current console color attributes. +//----------------------------------------------------------------------------- +void InitWin32ConsoleColorContext( Win32ConsoleColorContext_t *pContext ) +{ +#if PLATFORM_WINDOWS_PC + // Get the old background attributes. + CONSOLE_SCREEN_BUFFER_INFO oldInfo; + GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &oldInfo ); + pContext->m_InitialColor = pContext->m_LastColor = oldInfo.wAttributes & (FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE|FOREGROUND_INTENSITY); + pContext->m_BackgroundFlags = oldInfo.wAttributes & (BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE|BACKGROUND_INTENSITY); + + pContext->m_BadColor = 0; + if (pContext->m_BackgroundFlags & BACKGROUND_RED) + pContext->m_BadColor |= FOREGROUND_RED; + if (pContext->m_BackgroundFlags & BACKGROUND_GREEN) + pContext->m_BadColor |= FOREGROUND_GREEN; + if (pContext->m_BackgroundFlags & BACKGROUND_BLUE) + pContext->m_BadColor |= FOREGROUND_BLUE; + if (pContext->m_BackgroundFlags & BACKGROUND_INTENSITY) + pContext->m_BadColor |= FOREGROUND_INTENSITY; +#else + pContext->m_InitialColor = 0; +#endif +} + +//----------------------------------------------------------------------------- +// Sets the active console foreground color. This function is smart enough to +// avoid setting the color to something that would be unreadable given +// the user's potentially customized background color. It leaves the +// background color unchanged. +// Returns: The console's previous foreground color. +//----------------------------------------------------------------------------- +uint16 SetWin32ConsoleColor( Win32ConsoleColorContext_t *pContext, int nRed, int nGreen, int nBlue, int nIntensity ) +{ +#if PLATFORM_WINDOWS_PC + uint16 ret = pContext->m_LastColor; + pContext->m_LastColor = 0; + if ( nRed ) pContext->m_LastColor |= FOREGROUND_RED; + if ( nGreen ) pContext->m_LastColor |= FOREGROUND_GREEN; + if ( nBlue ) pContext->m_LastColor |= FOREGROUND_BLUE; + if ( nIntensity ) pContext->m_LastColor |= FOREGROUND_INTENSITY; + + // Just use the initial color if there's a match... + if ( pContext->m_LastColor == pContext->m_BadColor ) + pContext->m_LastColor = pContext->m_InitialColor; + + SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), pContext->m_LastColor | pContext->m_BackgroundFlags ); + return ret; +#else + return 0; +#endif +} + +//----------------------------------------------------------------------------- +// Restore's the active foreground console color, without distributing the current +// background color. +//----------------------------------------------------------------------------- +void RestoreWin32ConsoleColor( Win32ConsoleColorContext_t *pContext, uint16 prevColor ) +{ +#if PLATFORM_WINDOWS_PC + SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), prevColor | pContext->m_BackgroundFlags ); + pContext->m_LastColor = prevColor; +#endif +} |