598 lines
15 KiB
C++
598 lines
15 KiB
C++
//=========== 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
|