path: root/public/panorama/uipbmsgbase.h

//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose: 
//=============================================================================//

#ifndef PROTOBUFPOOL_H
#define PROTOBUFPOOL_H

#ifdef _WIN32
#pragma once
#endif


#include "tier0/tslist.h"
#include "tier1/fmtstr.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#if !defined( SOURCE2_PANORAMA )
#include "tier1/tsmempool.h"
#include "misc.h"
#endif
#include "tier0/vprof.h"

#include "protobuf-2.3.0/src/google/protobuf/message_lite.h"

namespace panorama
{

#define PBMEM_POOL_LOW_TARGET 256
#define PBMEM_POOL_HIGH_TARGET 512

class IProtoBufMsgMemoryPool
{
public:

	virtual ~IProtoBufMsgMemoryPool() {}

	// Methods that need to be exposed out to examine memory
	virtual uint32 GetEstimatedSize() = 0;
	virtual uint32 GetCount() = 0;
	virtual CUtlString GetName() = 0;
	virtual uint32 GetAllocHitCount() = 0;
	virtual uint32 GetAllocMissCount() = 0;
	virtual void Free( void *pObjectVoid ) = 0;

#ifdef DBGFLAG_VALIDATE
	virtual void Validate( CValidator &validator, const char *pchName ) = 0;
#endif
};


#if defined( SOURCE2_PANORAMA )
#include <tier0/memdbgon.h>
#endif

//-----------------------------------------------------------------------------
// CProtoBufMsgMemoryPool - Implementation for allocation pools for protobufmsgs.
// We create one of these per protobuf msg type, created on first construction of
// an object of that type.
//-----------------------------------------------------------------------------
template< typename PB_OBJECT_TYPE > 
class CUIProtoBufMsgMemoryPool : public IProtoBufMsgMemoryPool
{
public:

	typedef typename CTSList< PB_OBJECT_TYPE * >::Node_t Node;

	CUIProtoBufMsgMemoryPool( uint32 unTargetLow, uint32 unTargetHigh )
	{
		m_unTargetCountLow = unTargetLow;
		m_unTargetCountHigh = unTargetHigh;
		m_unEstimatedSize = 0;
		m_unAllocHitCounter = 0;
		m_unAllocMissCounter = 0;
		m_pTListFreeObjects = new CTSList< PB_OBJECT_TYPE * >();
	}


	~CUIProtoBufMsgMemoryPool()
	{
		Node *pObject = m_pTListFreeObjects->Pop();
		while ( pObject )
		{
			Destruct( pObject->elem );
#if defined( SOURCE2_PANORAMA )
			free( pObject->elem );
#else
			FreePv( pObject->elem );
#endif
			delete pObject;

			pObject = m_pTListFreeObjects->Pop();
		}
		m_pTListFreeObjects->Purge();
		delete m_pTListFreeObjects;
	}

	CUtlString GetName() 
	{ 
		return PB_OBJECT_TYPE::default_instance().GetTypeName().c_str(); 
	}

	uint32 GetEstimatedSize()
	{
		return m_pTListFreeObjects->Count()*m_unEstimatedSize;
	}

	uint32 GetCount() 
	{
		return m_pTListFreeObjects->Count();
	}

	uint32 GetAllocHitCount()
	{
		return m_unAllocHitCounter;
	}

	uint32 GetAllocMissCount()
	{
		return m_unAllocMissCounter;
	}


	Node * AllocProtoBuf()
	{
		Node *pObject = m_pTListFreeObjects->Pop();
		if ( !pObject )
		{
			++m_unAllocMissCounter;
			pObject = new Node;
#if defined( SOURCE2_PANORAMA )
			pObject->elem = (PB_OBJECT_TYPE *)malloc( sizeof( PB_OBJECT_TYPE ) );
#else
			pObject->elem = (PB_OBJECT_TYPE *)PvAllocNoLeakTracking( sizeof( PB_OBJECT_TYPE ) );
#endif
			Construct( pObject->elem );
		}
		else
		{
			++m_unAllocHitCounter;
			bool bFreeAnother = false;
			uint32 unCount = m_pTListFreeObjects->Count();

			// We'll free an extra cached msg every alloc if we are over the higher limit, and every 6th if we
			// are over the lower limit.  This allows some elasticity to peaks in demand.
			if ( unCount > m_unTargetCountHigh )
				bFreeAnother = true;
			else if ( unCount > m_unTargetCountLow && m_unAllocHitCounter % 6 == 0 )
				bFreeAnother = true;

			if ( bFreeAnother )
			{
				// Pop an extra item, so we can get down to target count over time
				Node *pThrowAway = m_pTListFreeObjects->Pop();
				if ( pThrowAway )
				{
					Destruct( pThrowAway->elem );
#if defined( SOURCE2_PANORAMA )
					free( pThrowAway->elem );
#else
					FreePv( pThrowAway->elem );
#endif
					delete pThrowAway;
				}
			}
		}
		return pObject;
	}

	inline void Free( void *pObjectVoid )
	{
		Free( (Node *)pObjectVoid );
	}

	void Free( Node *pObject )
	{
		if ( m_unFreeCounter++ % 2000 == 0 || m_unEstimatedSize == 0 )
		{
			m_unEstimatedSize = pObject->elem->SpaceUsed();
		}

		if ( m_unTargetCountHigh > 0 )
		{
			// We always cache for re-use on free, though we may throw out later on alloc to shrink the pool
			pObject->elem->Clear();
			m_pTListFreeObjects->Push( pObject );
		}
		else
		{
			Destruct( pObject->elem );
#if defined( SOURCE2_PANORAMA )
			free( pObject->elem );
#else
			FreePv( pObject->elem );
#endif
			delete pObject;
		}
	}

#ifdef DBGFLAG_VALIDATE
	void Validate( CValidator &validator, const char *pchName )
	{
		m_pTListFreeObjects->Validate( validator, "m_pTListFreeObjects" );
		validator.ClaimMemory_Aligned( m_pTListFreeObjects );
	}
#endif // DBGFLAG_VALIDATE

private:
	CTSList< PB_OBJECT_TYPE * > *m_pTListFreeObjects;

	// Not critical for these to be "right" so they don't need to be thread safe
	uint32 m_unEstimatedSize;
	uint32 m_unFreeCounter;

	// These counters are important to get correct, so interlocked in case of allocating on threads
	CInterlockedInt m_unAllocHitCounter;
	CInterlockedInt m_unAllocMissCounter;

	// Only set at construction, so not needed to be thread safe
	uint32 m_unTargetCountLow;
	uint32 m_unTargetCountHigh;
};

#if defined( SOURCE2_PANORAMA )
#include <tier0/memdbgoff.h>
#endif

//-----------------------------------------------------------------------------
// Purpose: Ref count wrapper around protobuf message objects
//-----------------------------------------------------------------------------
class CMsgLiteRefCount 
{
public:
	CMsgLiteRefCount()
	{
		m_pMemoryPool = NULL;
		m_pTSListNode = NULL;
		m_cRef = 1;
	}

	// Has to be public, so we can use in memory pool, should always already be at zero ref count though
	~CMsgLiteRefCount() { DbgAssert( 0 == m_cRef ); }

	inline int AddRef() 
	{ 
		return ThreadInterlockedIncrement( &m_cRef ); 
	}

	int Release();

	inline google::protobuf::MessageLite *AccessMsg()
	{
		return (google::protobuf::MessageLite *)(((CTSList<void *>::Node_t *)m_pTSListNode)->elem);
	}

	IProtoBufMsgMemoryPool *m_pMemoryPool;
	void *m_pTSListNode;
	void *m_pSelfNode;

#ifdef DBGFLAG_VALIDATE
	virtual void Validate( CValidator &validator, const tchar *pchName )
	{
		VALIDATE_SCOPE();
		

		if ( m_cRef != 0 )
		{
			CTSList<void *>::Node_t *pNode = (CTSList<void *>::Node_t *)m_pSelfNode;

			if ( pNode )
			{

				void *pvMem =  MemAlloc_Unalign( pNode );
				if ( !validator.IsClaimed( pvMem ) )
					validator.ClaimMemory_Aligned( pNode );
			
				if ( !validator.IsClaimed( pNode->elem ) )
					validator.ClaimMemory( pNode->elem );
			}

			pNode = (CTSList<void *>::Node_t *)m_pTSListNode;
			if ( pNode )
			{
				void *pvMem =  MemAlloc_Unalign( pNode );
				if ( !validator.IsClaimed( pvMem ) )
					validator.ClaimMemory_Aligned( pNode );
			}
		}
		
	}
#endif

private:

	friend class CUIProtoBufMsgMemoryPoolMgr;

	volatile int32 m_cRef;
};


//-----------------------------------------------------------------------------
// CProtoBufMsgMemoryPoolMgr - Manages all the message pools for render messages proto buf objects.  
// Should have one global singleton instance of this which tracks all the pools
// for individual message types.
//-----------------------------------------------------------------------------
class CUIProtoBufMsgMemoryPoolMgr
{
public:

	CUIProtoBufMsgMemoryPoolMgr()
	{
		m_pTSListMsgLiteRefCount = new CTSList<CMsgLiteRefCount*>;
	}

	~CUIProtoBufMsgMemoryPoolMgr() 
	{
		CTSList<CMsgLiteRefCount*>::Node_t *pNode = m_pTSListMsgLiteRefCount->Pop();
		while ( pNode )
		{
			delete pNode->elem;
			delete pNode;
			pNode = m_pTSListMsgLiteRefCount->Pop();
		}

		FOR_EACH_VEC( m_vecMsgPools, i )
		{
			delete m_vecMsgPools[i];
		}
		m_vecMsgPools.RemoveAll();
	}

	CTSList<CMsgLiteRefCount*>::Node_t * AllocMsgLiteRef()
	{
		CTSList<CMsgLiteRefCount*>::Node_t *pNode = m_pTSListMsgLiteRefCount->Pop();
		if ( !pNode )
		{
			pNode = new CTSList<CMsgLiteRefCount*>::Node_t;
			pNode->elem = new CMsgLiteRefCount();
			return pNode;
		}
		else
		{
			DbgAssert( pNode->elem->m_cRef == 0 );
			pNode->elem->m_cRef = 1;
		}
		return pNode;
	}

	void FreeMsgLiteRef( CTSList<CMsgLiteRefCount*>::Node_t * pRef )
	{
#if defined(_DEBUG) && !defined(NO_MALLOC_OVERRIDE) && !defined( SOURCE2_PANORAMA )
		Assert( g_pMemAllocSteam->IsValid( pRef->elem ) );
#endif
		m_pTSListMsgLiteRefCount->Push( pRef );
	}

	void RegisterPool( IProtoBufMsgMemoryPool * pPool )
	{
		m_vecMsgPools.AddToTail( pPool );
	}

	void DumpPoolInfo()
	{
		uint32 unTotalSize = 0;
		Msg( "CRenderMsgMemoryPoolMgr:\n" );
		Msg( "  PoolName                                       Count   Est. Size    Hit Rate\n" );
		Msg( "  ----------------------------------------- ----------- ----------- -----------\n" );
		FOR_EACH_VEC( m_vecMsgPools, i )
		{
			uint32 unHitCount = m_vecMsgPools[i]->GetAllocHitCount();
			uint32 unMissCount = m_vecMsgPools[i]->GetAllocMissCount();
			float flHitRate = 0.0f;
			if ( unHitCount > 0 || unMissCount > 0 )
			{
				flHitRate = (float)unHitCount / (float)(unHitCount+unMissCount);
				flHitRate *= 100.0f;
			}

			uint32 unEstimate = m_vecMsgPools[i]->GetEstimatedSize();
			Msg( "%43s%12d%12s%12s\n", m_vecMsgPools[i]->GetName().String(), m_vecMsgPools[i]->GetCount(), V_pretifymem( (float)unEstimate, 2, true ), CFmtStr( "%f%%", flHitRate ).Access() );
			unTotalSize += unEstimate;
		}
		Msg( "  -----------------------------------------------------------------------------\n" );
		Msg( "  Total: %s\n", V_pretifymem( (float)unTotalSize, 2, true ) );

		Msg( "  -----------------------------------------------------------------------------\n" );
		Msg( "TSList for CMsgLiteRef size: %s\n", V_pretifymem( (float)m_pTSListMsgLiteRefCount->Count(), 2, true ) );
	}

#ifdef DBGFLAG_VALIDATE
	void Validate( CValidator &validator, const char *pchName )
	{
		ValidateObj( m_vecMsgPools );
		FOR_EACH_VEC( m_vecMsgPools, i )
		{
			ValidatePtr( m_vecMsgPools[i] );
		}
		validator.ClaimMemory_Aligned( m_pTSListMsgLiteRefCount );
		m_pTSListMsgLiteRefCount->Validate( validator, "m_pTSListMsgLiteRefCount" );

		CUtlVector< CTSList<CMsgLiteRefCount *>::Node_t * > vecTemp;

		CTSList<CMsgLiteRefCount *>::Node_t *pNode = m_pTSListMsgLiteRefCount->Pop();
		while ( pNode )
		{
			ValidatePtrIfNeeded( pNode->elem );
			vecTemp.AddToTail( pNode );
			pNode = m_pTSListMsgLiteRefCount->Pop();
		}

		FOR_EACH_VEC( vecTemp, i )
		{
			m_pTSListMsgLiteRefCount->Push( vecTemp[i] );
		}
	}
#endif // DBGFLAG_VALIDATE

private:
	CUtlVector< IProtoBufMsgMemoryPool * > m_vecMsgPools;
	CTSList<CMsgLiteRefCount *> *m_pTSListMsgLiteRefCount;
};


// Interface that rendermsgs of all types implement
class IUIProtoBufMsg
{
public:
	virtual ~IUIProtoBufMsg() {}
	virtual void SerializeInProc( CUtlBuffer *pBuffer ) const = 0;
};


//-----------------------------------------------------------------------------
// Purpose: Base class for protobuf objects
//-----------------------------------------------------------------------------
template< typename PB_OBJECT_TYPE > 
class CUIProtoBufMsg : public IUIProtoBufMsg
{
private:
	static bool s_bRegisteredWithMemoryPoolMgr;
	static CThreadMutex s_Mutex;
	static CUIProtoBufMsgMemoryPool< PB_OBJECT_TYPE > *s_pMemoryPool;

public:

	typedef typename CTSList<PB_OBJECT_TYPE *>::Node_t Node;

	// Called on construction of each object of this type, but only does work
	// once to setup memory pools for the class type.
	static void OneTimeInit()
	{
		// If we haven't done registration do so now
		if ( !s_bRegisteredWithMemoryPoolMgr )
		{
			// Get the lock and make sure we still haven't
			s_Mutex.Lock();
			if ( !s_bRegisteredWithMemoryPoolMgr )
			{
				s_pMemoryPool = new CUIProtoBufMsgMemoryPool< PB_OBJECT_TYPE >( PBMEM_POOL_LOW_TARGET, PBMEM_POOL_HIGH_TARGET );
				UIEngine()->MsgMemoryPoolMgr()->RegisterPool( s_pMemoryPool );
				s_bRegisteredWithMemoryPoolMgr = true;
			}
			s_Mutex.Unlock();
		}
	}

	CUIProtoBufMsg()
	{
		OneTimeInit();
		CTSList<CMsgLiteRefCount *>::Node_t *pRefCountNode = UIEngine()->MsgMemoryPoolMgr()->AllocMsgLiteRef();
		m_pMsgRefCount = pRefCountNode->elem;
		m_pMsgRefCount->m_pSelfNode = pRefCountNode;
		m_pMsgRefCount->m_pMemoryPool = s_pMemoryPool;
		Node *pNode = s_pMemoryPool->AllocProtoBuf();
		m_pMsgRefCount->m_pTSListNode = pNode;
		m_bIsValid = true;
	}

	// Expose memory pool for direct allocation of underlying PB msg objects
	static Node *AllocProtoBufMsgObject() 
	{
		OneTimeInit();
		return s_pMemoryPool->AllocProtoBuf();
	}

	// Expose memory pool for direct allocation of underlying PB msg objects
	static void FreeProtoBufMsgObject( Node *pMsg ) 
	{
		s_pMemoryPool->Free( pMsg );
	}

	// Construct and deserialize in one
	CUIProtoBufMsg( CUtlBuffer *pBuffer )
	{
		OneTimeInit();
		m_pMsgRefCount = NULL;
		m_bIsValid = BDeserializeInProc( pBuffer );
	}

	// Destructor
	virtual ~CUIProtoBufMsg()
	{
		CleanupAllocations();
	}

	bool BIsValid() { return m_bIsValid; }

	inline void SerializeInProc( CUtlBuffer *pBuffer ) const
	{

		// Ensure enough for type, size, and serialized data
		pBuffer->EnsureCapacity( pBuffer->TellPut() + sizeof(uint32) + sizeof( uint64 ) ); 

		m_pMsgRefCount->AddRef();
		pBuffer->PutUnsignedInt( (int)m_eCmd );
		pBuffer->PutUnsignedInt64( (uint64)m_pMsgRefCount );
	}

	inline bool BDeserializeInProc( CUtlBuffer *pBuffer )
	{
		if ( pBuffer->GetBytesRemaining() < (int)sizeof(uint64) )
			return false;

		uint64 ulPtr = pBuffer->GetUnsignedInt64();
		if ( ulPtr == 0 )
			return false;

		CleanupAllocations();
		m_pMsgRefCount = (CMsgLiteRefCount*)ulPtr;
		m_pMsgRefCount->AddRef();
		return true;
	}
	
	void SerializeCrossProc( CUtlBuffer *pBuffer ) const
	{
		VPROF_BUDGET( "CUIProtoBufMsg::SerializeCrossProc", VPROF_BUDGETGROUP_TENFOOT );
		uint32 unSize = m_pMsgRefCount->AccessMsg()->ByteSize();

		// Ensure enough for type, size, and serialized data
		pBuffer->EnsureCapacity( pBuffer->TellPut() + sizeof(uint32) * 3 + unSize ); // bugbug cboyd - drop to * 2 whenpassthrough is removed below

		pBuffer->PutUnsignedInt( (int)m_eCmd );
		pBuffer->PutUnsignedInt( unSize );
		
		if ( unSize == 0 )
			return;

		uint8 *pBody = (uint8*)pBuffer->Base()+pBuffer->TellPut();
		m_pMsgRefCount->AccessMsg()->SerializeWithCachedSizesToArray( pBody );
		pBuffer->SeekPut( CUtlBuffer::SEEK_CURRENT, unSize );
	}
	
	bool BDeserializeCrossProc( CUtlBuffer *pBuffer )
	{
		VPROF_BUDGET( "CUIProtoBufMsg::BDeserialize", VPROF_BUDGETGROUP_TENFOOT );
		if ( pBuffer->GetBytesRemaining() < (int)sizeof(uint32) )
			return false;
		uint32 unSize = pBuffer->GetUnsignedInt();

		if ( unSize == 0 )
			return true;

		if ( pBuffer->GetBytesRemaining() < (int)unSize )
			return false;

		bool bSucccess = m_pMsgRefCount->AccessMsg()->ParseFromArray( (uint8*)pBuffer->Base()+pBuffer->TellGet(), unSize );
		pBuffer->SeekGet( CUtlBuffer::SEEK_CURRENT, unSize );

		return bSucccess;
	}

	// Accessors
	PB_OBJECT_TYPE &Body() { return *((PB_OBJECT_TYPE*)(m_pMsgRefCount->AccessMsg())); }
	const PB_OBJECT_TYPE &BodyConst() const { return *((const PB_OBJECT_TYPE*)(m_pMsgRefCount->AccessMsg())); }

protected:
	CMsgLiteRefCount *m_pMsgRefCount;
	int m_eCmd;
	bool m_bIsValid;
private:

	void CleanupAllocations()
	{
		SAFE_RELEASE( m_pMsgRefCount );
	}

};


// Statics
template< typename PB_OBJECT_TYPE > bool CUIProtoBufMsg< PB_OBJECT_TYPE>::s_bRegisteredWithMemoryPoolMgr = false;
template< typename PB_OBJECT_TYPE > CThreadMutex CUIProtoBufMsg< PB_OBJECT_TYPE>::s_Mutex;
template< typename PB_OBJECT_TYPE > CUIProtoBufMsgMemoryPool< PB_OBJECT_TYPE > *CUIProtoBufMsg< PB_OBJECT_TYPE>::s_pMemoryPool = NULL;

} // namespace panorama

#endif //PROTOBUFPOOL_H