Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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

//========= 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