You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
560 lines
19 KiB
560 lines
19 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: Base class for objects that are kept in synch between client and server |
|
// |
|
//============================================================================= |
|
#include "stdafx.h" |
|
#include "gcsdk_gcmessages.pb.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
namespace GCSDK |
|
{ |
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Map of all the factory functions for all CSharedObject classes |
|
//---------------------------------------------------------------------------- |
|
CUtlMap<int, CSharedObject::SharedObjectInfo_t> CSharedObject::sm_mapFactories(DefLessFunc(int)); |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Registers a new CSharedObject class |
|
//---------------------------------------------------------------------------- |
|
void CSharedObject::RegisterFactory( int nTypeID, SOCreationFunc_t fnFactory, uint32 unFlags, const char *pchClassName ) |
|
{ |
|
SharedObjectInfo_t info; |
|
info.m_pFactoryFunction = fnFactory; |
|
info.m_unFlags = unFlags; |
|
info.m_pchClassName = pchClassName; |
|
info.m_sBuildCacheSubNodeName.Format( "BuildCacheSubscribed(%s)", pchClassName ); |
|
info.m_sCreateNodeName.Format( "Create(%s)", pchClassName ); |
|
info.m_sUpdateNodeName.Format( "Update(%s)", pchClassName ); |
|
sm_mapFactories.InsertOrReplace( nTypeID, info ); |
|
|
|
//register this class with our SO stats as well |
|
#ifdef GC |
|
g_SharedObjectStats.RegisterSharedObjectType( nTypeID, pchClassName ); |
|
#endif //GC |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Creates a new CSharedObject instance of the specified type ID |
|
//---------------------------------------------------------------------------- |
|
CSharedObject *CSharedObject::Create( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
AssertMsg1( sm_mapFactories.IsValidIndex( nIndex ), "Probably failed to set object type (%d) on the server/client.\n", nTypeID ); |
|
if( sm_mapFactories.IsValidIndex( nIndex ) ) |
|
{ |
|
return sm_mapFactories[nIndex].m_pFactoryFunction(); |
|
} |
|
else |
|
{ |
|
return NULL; |
|
} |
|
} |
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Various accessors for static class data |
|
//---------------------------------------------------------------------------- |
|
uint32 CSharedObject::GetTypeFlags( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
if( !sm_mapFactories.IsValidIndex( nIndex ) ) |
|
return 0; |
|
else |
|
return sm_mapFactories[nIndex].m_unFlags; |
|
} |
|
|
|
const char *CSharedObject::PchClassName( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
if( !sm_mapFactories.IsValidIndex( nIndex ) ) |
|
return 0; |
|
else |
|
return sm_mapFactories[nIndex].m_pchClassName; |
|
|
|
} |
|
|
|
const char *CSharedObject::PchClassBuildCacheNodeName( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
if( !sm_mapFactories.IsValidIndex( nIndex ) ) |
|
return 0; |
|
else |
|
return sm_mapFactories[nIndex].m_sBuildCacheSubNodeName.Get(); |
|
} |
|
|
|
const char *CSharedObject::PchClassCreateNodeName( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
if( !sm_mapFactories.IsValidIndex( nIndex ) ) |
|
return 0; |
|
else |
|
return sm_mapFactories[nIndex].m_sCreateNodeName.Get(); |
|
} |
|
|
|
const char *CSharedObject::PchClassUpdateNodeName( int nTypeID ) |
|
{ |
|
int nIndex = sm_mapFactories.Find( nTypeID ); |
|
if( !sm_mapFactories.IsValidIndex( nIndex ) ) |
|
return 0; |
|
else |
|
return sm_mapFactories[nIndex].m_sUpdateNodeName.Get(); |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Figures out if the primary keys on these two objects are the same |
|
// using the subclass-defined less function |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BIsKeyEqual( const CSharedObject & soRHS ) const |
|
{ |
|
// Make sure they are the same type. |
|
if ( GetTypeID() != soRHS.GetTypeID() ) |
|
return false; |
|
|
|
return !BIsKeyLess( soRHS ) && !soRHS.BIsKeyLess( *this ); |
|
} |
|
|
|
|
|
|
|
#ifdef GC |
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Sends a create message for this shared object to the specified |
|
// steam ID. |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BSendCreateToSteamID( const CSteamID & steamID, const CSteamID & steamIDOwner, uint64 ulVersion ) const |
|
{ |
|
// Don't send these while shutting down. We'll use higher-level |
|
// connection-oriented messages instead |
|
if ( GGCBase()->GetIsShuttingDown() ) |
|
return false; |
|
|
|
CProtoBufMsg< CMsgSOSingleObject > msg( k_ESOMsg_Create ); |
|
msg.Body().set_owner( steamIDOwner.ConvertToUint64() ); |
|
msg.Body().set_type_id( GetTypeID() ); |
|
msg.Body().set_version( ulVersion ); |
|
if( !BAddToMessage( msg.Body().mutable_object_data() ) ) |
|
{ |
|
EmitWarning( SPEW_SHAREDOBJ, SPEW_ALWAYS, "Failed to add create fields to message in create" ); |
|
return false; |
|
} |
|
|
|
return GGCBase()->BSendGCMsgToClient( steamID, msg ); |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Sends a destroy message for this object to the specified steam ID |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BSendDestroyToSteamID( const CSteamID & steamID, const CSteamID & steamIDOwner, uint64 ulVersion ) const |
|
{ |
|
// Don't send these while shutting down. We'll use higher-level |
|
// connection-oriented messages instead |
|
if ( GGCBase()->GetIsShuttingDown() ) |
|
return false; |
|
|
|
CProtoBufMsg< CMsgSOSingleObject > msg( k_ESOMsg_Destroy ); |
|
msg.Body().set_owner( steamIDOwner.ConvertToUint64() ); |
|
msg.Body().set_type_id( GetTypeID() ); |
|
msg.Body().set_version( ulVersion ); |
|
if( !BAddDestroyToMessage( msg.Body().mutable_object_data() ) ) |
|
{ |
|
EmitWarning( SPEW_SHAREDOBJ, SPEW_ALWAYS, "Failed to add key to message in create" ); |
|
return false; |
|
} |
|
return GGCBase()->BSendGCMsgToClient( steamID, msg ); |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Wraps BYieldingAddInsertToTransaction with a transaction and a |
|
// commit. |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BYieldingAddToDatabase() |
|
{ |
|
CSQLAccess sqlAccess; |
|
sqlAccess.BBeginTransaction( CFmtStr( "CSharedObject::BYieldingAddToDatabase Type %d", GetTypeID() ) ); |
|
if( !BYieldingAddInsertToTransaction( sqlAccess ) ) |
|
{ |
|
sqlAccess.RollbackTransaction(); |
|
return false; |
|
} |
|
|
|
return sqlAccess.BCommitTransaction(); |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Wraps BYieldingAddWriteToTransaction with a transaction and a |
|
// commit. |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BYieldingWriteToDatabase( const CUtlVector< int > &fields ) |
|
{ |
|
CSQLAccess sqlAccess; |
|
sqlAccess.BBeginTransaction( CFmtStr( "CSharedObject::BYieldingWriteToDatabase Type %d", GetTypeID() ) ); |
|
if( !BYieldingAddWriteToTransaction( sqlAccess, fields ) ) |
|
{ |
|
sqlAccess.RollbackTransaction(); |
|
return false; |
|
} |
|
|
|
if( sqlAccess.BCommitTransaction() ) |
|
{ |
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Wraps BYieldingAddRemoveToTransaction with a transaction and a |
|
// commit. |
|
//---------------------------------------------------------------------------- |
|
bool CSharedObject::BYieldingRemoveFromDatabase() |
|
{ |
|
CSQLAccess sqlAccess; |
|
sqlAccess.BBeginTransaction( CFmtStr( "CSharedObject::BYieldingRemoveFromDatabase Type %d", GetTypeID() ) ); |
|
if( !BYieldingAddRemoveToTransaction( sqlAccess ) ) |
|
{ |
|
sqlAccess.RollbackTransaction(); |
|
return false; |
|
} |
|
|
|
return sqlAccess.BCommitTransaction(); |
|
} |
|
|
|
//-------------------------------------------------------------------------------------------------------------------------- |
|
// CSharedObjectStats |
|
//-------------------------------------------------------------------------------------------------------------------------- |
|
|
|
//our global stats for our SO objects |
|
CSharedObjectStats g_SharedObjectStats; |
|
|
|
|
|
CSharedObjectStats::CSharedObjectStats() |
|
: m_bCollectingStats( false ) |
|
, m_nMicroSElapsed( 0 ) |
|
{ |
|
} |
|
|
|
CSharedObjectStats::SOStats_t::SOStats_t() |
|
: m_nNumActive( 0 ) |
|
{ |
|
ResetStats(); |
|
} |
|
|
|
void CSharedObjectStats::SOStats_t::ResetStats() |
|
{ |
|
m_nNumCreated = 0; |
|
m_nNumDestroyed = 0; |
|
m_nNumSends = 0; |
|
m_nRawBytesSent = 0; |
|
m_nMultiplexedBytesSent = 0; |
|
m_nNumSubOwner = 0; |
|
m_nNumSubOtherUsers = 0; |
|
m_nNumSubGameServer = 0; |
|
} |
|
|
|
void CSharedObjectStats::StartCollectingStats() |
|
{ |
|
//do nothing if already collecting |
|
if( m_bCollectingStats ) |
|
return; |
|
|
|
m_bCollectingStats = true; |
|
m_CollectTime.SetToJobTime(); |
|
} |
|
|
|
void CSharedObjectStats::StopCollectingStats() |
|
{ |
|
if( !m_bCollectingStats ) |
|
return; |
|
|
|
m_bCollectingStats = false; |
|
m_nMicroSElapsed = m_CollectTime.CServerMicroSecsPassed(); |
|
} |
|
|
|
void CSharedObjectStats::RegisterSharedObjectType( int nTypeID, const char* pszTypeName ) |
|
{ |
|
if( nTypeID < 0 ) |
|
{ |
|
AssertMsg2( false, "Error registering shared object type %d (%s), negative type ID's are not supported", nTypeID, pszTypeName ); |
|
return; |
|
} |
|
|
|
//see if we need to grow our list to accommodate this type id |
|
if( nTypeID >= m_vTypeToIndex.Count() ) |
|
{ |
|
//make sure people aren't getting carried away with index ranges |
|
AssertMsg( nTypeID < 8 * 1024, "Warning: Using a very large type ID which can be inefficient for the shared object stats. Try to keep values to a smaller range" ); |
|
int nOldSize = m_vTypeToIndex.Count(); |
|
m_vTypeToIndex.AddMultipleToTail( nTypeID + 1 - nOldSize ); |
|
for( int nCurrFill = nOldSize; nCurrFill < nTypeID; nCurrFill++ ) |
|
{ |
|
m_vTypeToIndex[ nCurrFill ] = knInvalidIndex; |
|
} |
|
} |
|
else if( m_vTypeToIndex[ nTypeID ] != knInvalidIndex ) |
|
{ |
|
//we have already registered something in this slot |
|
AssertMsg2( false, "Error registering shared object type %d (%s), may have multiple registrations of this type, check for conflicts", nTypeID, pszTypeName ); |
|
return; |
|
} |
|
|
|
//we need to register this type by adding a new record, and updating our index |
|
int nNewIndex = m_Stats.AddToTail(); |
|
m_Stats[ nNewIndex ].m_sName = pszTypeName; |
|
m_Stats[ nNewIndex ].m_nTypeID = nTypeID; |
|
m_vTypeToIndex[ nTypeID ] = nNewIndex; |
|
} |
|
|
|
void CSharedObjectStats::TrackSharedObjectLifetime( int nTypeID, int32 nCount ) |
|
{ |
|
uint16 nIndex = ( m_vTypeToIndex.IsValidIndex( nTypeID ) ) ? m_vTypeToIndex[ nTypeID ] : knInvalidIndex; |
|
if( nIndex != knInvalidIndex ) |
|
{ |
|
m_Stats[ nIndex ].m_nNumActive += nCount; |
|
} |
|
} |
|
|
|
void CSharedObjectStats::TrackSharedObjectSendCreate( int nTypeID, uint32 nCount ) |
|
{ |
|
uint16 nIndex = ( m_vTypeToIndex.IsValidIndex( nTypeID ) ) ? m_vTypeToIndex[ nTypeID ] : knInvalidIndex; |
|
if( nIndex != knInvalidIndex ) |
|
{ |
|
m_Stats[ nIndex ].m_nNumCreated += nCount; |
|
} |
|
} |
|
|
|
void CSharedObjectStats::TrackSharedObjectSendDestroy( int nTypeID, uint32 nCount ) |
|
{ |
|
uint16 nIndex = (m_vTypeToIndex.IsValidIndex( nTypeID ) ) ? m_vTypeToIndex[ nTypeID ] : knInvalidIndex; |
|
if( nIndex != knInvalidIndex ) |
|
{ |
|
m_Stats[ nIndex ].m_nNumDestroyed += nCount; |
|
} |
|
} |
|
|
|
void CSharedObjectStats::TrackSubscription( int nTypeID, uint32 nFlags, uint32 nNumSubscriptions ) |
|
{ |
|
if( !m_bCollectingStats ) |
|
return; |
|
|
|
uint16 nIndex = ( m_vTypeToIndex.IsValidIndex( nTypeID ) ) ? m_vTypeToIndex[ nTypeID ] : knInvalidIndex; |
|
if( nIndex != knInvalidIndex ) |
|
{ |
|
if( nFlags & k_ESOFlag_SendToOwner ) |
|
m_Stats[ nIndex ].m_nNumSubOwner += nNumSubscriptions; |
|
if( nFlags & k_ESOFlag_SendToOtherUsers ) |
|
m_Stats[ nIndex ].m_nNumSubOtherUsers += nNumSubscriptions; |
|
if( nFlags & k_ESOFlag_SendToOtherGameservers ) |
|
m_Stats[ nIndex ].m_nNumSubGameServer += nNumSubscriptions; |
|
} |
|
|
|
} |
|
|
|
void CSharedObjectStats::TrackSharedObjectSend( int nTypeID, uint32 nNumClients, uint32 nMsgSize ) |
|
{ |
|
if( !m_bCollectingStats ) |
|
return; |
|
|
|
uint16 nIndex = ( m_vTypeToIndex.IsValidIndex( nTypeID ) ) ? m_vTypeToIndex[ nTypeID ] : knInvalidIndex; |
|
if( nIndex != knInvalidIndex ) |
|
{ |
|
m_Stats[ nIndex ].m_nNumSends++; |
|
m_Stats[ nIndex ].m_nRawBytesSent += nMsgSize; |
|
m_Stats[ nIndex ].m_nMultiplexedBytesSent += nMsgSize * nNumClients; |
|
} |
|
} |
|
|
|
void CSharedObjectStats::ResetStats() |
|
{ |
|
FOR_EACH_VEC( m_Stats, nCurrSO ) |
|
{ |
|
m_Stats[ nCurrSO ].ResetStats(); |
|
} |
|
} |
|
|
|
bool CSharedObjectStats::SortSOStatsSent( const SOStats_t* pLhs, const SOStats_t* pRhs ) |
|
{ |
|
//highest bandwidth ones go up top |
|
if( pLhs->m_nMultiplexedBytesSent != pRhs->m_nMultiplexedBytesSent ) |
|
return pLhs->m_nMultiplexedBytesSent > pRhs->m_nMultiplexedBytesSent; |
|
|
|
//otherwise sort by the name |
|
return pLhs->m_nTypeID < pRhs->m_nTypeID; |
|
} |
|
|
|
bool CSharedObjectStats::SortSOStatsSubscribe( const SOStats_t* pLhs, const SOStats_t* pRhs ) |
|
{ |
|
//sort based on total number of subscriptions |
|
uint32 nLhsSub = pLhs->m_nNumSubOwner + pLhs->m_nNumSubOtherUsers + pLhs->m_nNumSubGameServer; |
|
uint32 nRhsSub = pRhs->m_nNumSubOwner + pRhs->m_nNumSubOtherUsers + pRhs->m_nNumSubGameServer; |
|
if( nLhsSub != nRhsSub ) |
|
return nLhsSub > nRhsSub; |
|
|
|
//otherwise sort by the name |
|
return pLhs->m_nTypeID < pRhs->m_nTypeID; |
|
} |
|
|
|
void CSharedObjectStats::ReportCollectedStats() const |
|
{ |
|
//build up a list of our stats, so we can sort them appropriately (also total how many bytes we send) |
|
uint64 nTotalRawBytes = 0; |
|
uint64 nTotalMultiplexBytes = 0; |
|
uint32 nTotalActive = 0; |
|
uint32 nTotalCreates = 0; |
|
uint32 nTotalFrees = 0; |
|
uint32 nTotalSends = 0; |
|
uint32 nTotalSubOwner = 0; |
|
uint32 nTotalSubOtherUsers = 0; |
|
uint32 nTotalSubGameServer = 0; |
|
|
|
CUtlVector< const SOStats_t* > sortedStats( 0, m_Stats.Count() ); |
|
FOR_EACH_VEC( m_Stats, nCurrSO ) |
|
{ |
|
sortedStats.AddToTail( &( m_Stats[ nCurrSO ] ) ); |
|
|
|
nTotalRawBytes += m_Stats[ nCurrSO ].m_nRawBytesSent; |
|
nTotalMultiplexBytes += m_Stats[ nCurrSO ].m_nMultiplexedBytesSent; |
|
nTotalActive += m_Stats[ nCurrSO ].m_nNumActive; |
|
nTotalCreates += m_Stats[ nCurrSO ].m_nNumCreated; |
|
nTotalFrees += m_Stats[ nCurrSO ].m_nNumDestroyed; |
|
nTotalSends += m_Stats[ nCurrSO ].m_nNumSends; |
|
nTotalSubOwner += m_Stats[ nCurrSO ].m_nNumSubOwner; |
|
nTotalSubOtherUsers += m_Stats[ nCurrSO ].m_nNumSubOtherUsers; |
|
nTotalSubGameServer += m_Stats[ nCurrSO ].m_nNumSubGameServer; |
|
} |
|
|
|
//determine the time scale to normalize this into per second measurements |
|
uint64 nMicroSElapsed = ( m_bCollectingStats ) ? m_CollectTime.CServerMicroSecsPassed() : m_nMicroSElapsed; |
|
double fSeconds = nMicroSElapsed / 1000000.0; |
|
double fToS = ( nMicroSElapsed > 0 ) ? 1000000.0 / nMicroSElapsed : 1.0; |
|
|
|
//----------------------------------------- |
|
// Update stats |
|
|
|
std::sort( sortedStats.begin(), sortedStats.end(), SortSOStatsSent ); |
|
|
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "SO Cache Transmits - %.2f second capture\n", fSeconds ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n" ); |
|
|
|
//now run through and display our report |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "Type Name SendKB % SendKB/S MPlex Create C/S Destroy D/S Update U/S Active U/S (%)\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "---- ------------------------------ ------- ------ -------- ------ ------- ------- ------- ------- ------- ------- --------- -------\n" ); |
|
|
|
FOR_EACH_VEC( sortedStats, nCurrSO ) |
|
{ |
|
const SOStats_t& stats = *sortedStats[ nCurrSO ]; |
|
|
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%4d %-30s %7u %5.1f%% %8.1f %6.2f %7u %7.0f %7u %7.0f %7u %7.0f %9u %6.3f%%\n", |
|
stats.m_nTypeID, |
|
stats.m_sName.Get(), |
|
( uint32 )( stats.m_nRawBytesSent / 1024 ), |
|
100.0 * ( double )stats.m_nRawBytesSent / ( double )MAX( 1, nTotalRawBytes ), |
|
( double )( stats.m_nRawBytesSent / 1024 ) * fToS, |
|
( double )stats.m_nMultiplexedBytesSent / MAX( 1, stats.m_nRawBytesSent ), |
|
stats.m_nNumCreated, |
|
stats.m_nNumCreated * fToS, |
|
stats.m_nNumDestroyed, |
|
stats.m_nNumDestroyed * fToS, |
|
stats.m_nNumSends, |
|
stats.m_nNumSends * fToS, |
|
stats.m_nNumActive, |
|
100.0 * stats.m_nNumSends * fToS / MAX( 1, stats.m_nNumActive ) ); |
|
} |
|
|
|
//close it out with the totals |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "---- ------------------------------ ------- ------ -------- ------ ------- ------- ------- ------- ------- ------- --------- -------\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, " Totals %7u %5.1f%% %8.1f %6.2f %7u %7.0f %7u %7.0f %7u %7.0f %9u %6.3f%%\n", |
|
( uint32 )( nTotalRawBytes / 1024 ), |
|
100.0, |
|
( double )( nTotalRawBytes / 1024 ) * fToS, |
|
( double )nTotalMultiplexBytes / ( double )MAX( 1, nTotalRawBytes ), |
|
nTotalCreates, |
|
nTotalCreates * fToS, |
|
nTotalFrees, |
|
nTotalFrees * fToS, |
|
nTotalSends, |
|
nTotalSends * fToS, |
|
nTotalActive, |
|
100.0 * nTotalSends * fToS / MAX( 1, nTotalActive ) ); |
|
|
|
//----------------------------------------- |
|
// Subscription stats |
|
|
|
std::sort( sortedStats.begin(), sortedStats.end(), SortSOStatsSubscribe ); |
|
|
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "SO Cache Subscriptions Sends - %.2f second capture\n", fSeconds ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n" ); |
|
|
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "Type Name Owner Owner/S Other Other/S Server Server/S\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "---- ------------------------------ -------- -------- -------- -------- -------- --------\n" ); |
|
|
|
FOR_EACH_VEC( sortedStats, nCurrSO ) |
|
{ |
|
const SOStats_t& stats = *sortedStats[ nCurrSO ]; |
|
|
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%4d %-30s %8u %8.0f %8u %8.0f %8u %8.0f\n", |
|
stats.m_nTypeID, |
|
stats.m_sName.Get(), |
|
stats.m_nNumSubOwner, |
|
stats.m_nNumSubOwner * fToS, |
|
stats.m_nNumSubOtherUsers, |
|
stats.m_nNumSubOtherUsers * fToS, |
|
stats.m_nNumSubGameServer, |
|
stats.m_nNumSubGameServer * fToS ); |
|
} |
|
|
|
//close it out with the totals |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%s", "---- ------------------------------ -------- -------- -------- -------- -------- --------\n" ); |
|
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, " Totals %8u %8.0f %8u %8.0f %8u %8.0f\n", |
|
nTotalSubOwner, |
|
nTotalSubOwner * fToS, |
|
nTotalSubOtherUsers, |
|
nTotalSubOtherUsers * fToS, |
|
nTotalSubGameServer, |
|
nTotalSubGameServer * fToS ); |
|
|
|
} |
|
|
|
#endif // GC |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Claims all the memory for the shared object |
|
//---------------------------------------------------------------------------- |
|
#ifdef DBGFLAG_VALIDATE |
|
void CSharedObject::Validate( CValidator &validator, const char *pchName ) |
|
{ |
|
VALIDATE_SCOPE(); |
|
} |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// Purpose: Claims all the static memory for the shared object (i.e. the |
|
// factory function map. |
|
//---------------------------------------------------------------------------- |
|
void CSharedObject::ValidateStatics( CValidator & validator ) |
|
{ |
|
CValidateAutoPushPop validatorAutoPushPop( validator, NULL, "CSharedObject::ValidateStatics", "CSharedObject::ValidateStatics" ); |
|
ValidateObj( sm_mapFactories ); |
|
} |
|
|
|
#endif |
|
|
|
|
|
} // namespace GCSDK |
|
|
|
|
|
|
|
|