mirror of
https://github.com/celisej567/cool-source-archive.git
synced 2026-01-05 22:10:07 +03:00
384 lines
13 KiB
C++
384 lines
13 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef DATACACHE_H
|
|
#define DATACACHE_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "datamanager.h"
|
|
#include "utlhash.h"
|
|
#include "mempool.h"
|
|
#include "tier0/tslist.h"
|
|
#include "datacache_common.h"
|
|
#include "tier3/tier3.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Data Cache class declarations
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CDataCache;
|
|
class CDataCacheSection;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct DataCacheItemData_t
|
|
{
|
|
const void* pItemData;
|
|
unsigned size;
|
|
DataCacheClientID_t clientId;
|
|
CDataCacheSection* pSection;
|
|
};
|
|
|
|
//-------------------------------------
|
|
|
|
#define DC_NO_NEXT_LOCKED ((DataCacheItem_t *)0xffffffff)
|
|
#define DC_MAX_THREADS_FRAMELOCKED 4
|
|
|
|
struct DataCacheItem_t : DataCacheItemData_t
|
|
{
|
|
DataCacheItem_t(const DataCacheItemData_t& data)
|
|
: DataCacheItemData_t(data),
|
|
hLRU(INVALID_MEMHANDLE)
|
|
{
|
|
memset(pNextFrameLocked, 0xff, sizeof(pNextFrameLocked));
|
|
}
|
|
|
|
static DataCacheItem_t* CreateResource(const DataCacheItemData_t& data) { return new DataCacheItem_t(data); }
|
|
static unsigned int EstimatedSize(const DataCacheItemData_t& data) { return data.size; }
|
|
void DestroyResource();
|
|
DataCacheItem_t* GetData() { return this; }
|
|
unsigned int Size() { return size; }
|
|
|
|
memhandle_t hLRU;
|
|
DataCacheItem_t* pNextFrameLocked[DC_MAX_THREADS_FRAMELOCKED];
|
|
|
|
DECLARE_FIXEDSIZE_ALLOCATOR_MT(DataCacheItem_t);
|
|
};
|
|
|
|
//-------------------------------------
|
|
|
|
typedef CDataManager<DataCacheItem_t, DataCacheItemData_t, DataCacheItem_t*, CThreadFastMutex> CDataCacheLRU;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDataCacheSection
|
|
//
|
|
// Purpose: Implements a sub-section of the global cache. Subsections are
|
|
// areas of the cache with thier own memory constraints and common
|
|
// management.
|
|
//-----------------------------------------------------------------------------
|
|
class CDataCacheSection : public IDataCacheSection
|
|
{
|
|
public:
|
|
CDataCacheSection(CDataCache* pSharedCache, IDataCacheClient* pClient, const char* pszName);
|
|
~CDataCacheSection();
|
|
|
|
IDataCache* GetSharedCache();
|
|
IDataCacheClient* GetClient() { return m_pClient; }
|
|
const char* GetName() { return szName; }
|
|
|
|
//--------------------------------------------------------
|
|
// IDataCacheSection methods
|
|
//--------------------------------------------------------
|
|
virtual void SetLimits(const DataCacheLimits_t& limits);
|
|
const DataCacheLimits_t& GetLimits();
|
|
virtual void SetOptions(unsigned options);
|
|
virtual void GetStatus(DataCacheStatus_t* pStatus, DataCacheLimits_t* pLimits = NULL);
|
|
|
|
inline unsigned GetNumBytes() { return m_status.nBytes; }
|
|
inline unsigned GetNumItems() { return m_status.nItems; }
|
|
|
|
inline unsigned GetNumBytesLocked() { return m_status.nBytesLocked; }
|
|
inline unsigned GetNumItemsLocked() { return m_status.nItemsLocked; }
|
|
|
|
inline unsigned GetNumBytesUnlocked() { return m_status.nBytes - m_status.nBytesLocked; }
|
|
inline unsigned GetNumItemsUnlocked() { return m_status.nItems - m_status.nItemsLocked; }
|
|
|
|
virtual void EnsureCapacity(unsigned nBytes, unsigned nItems = 1);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual bool Add(DataCacheClientID_t clientId, const void* pItemData, unsigned size, DataCacheHandle_t* pHandle);
|
|
virtual bool AddEx(DataCacheClientID_t clientId, const void* pItemData, unsigned size, unsigned flags, DataCacheHandle_t* pHandle);
|
|
virtual DataCacheHandle_t Find(DataCacheClientID_t clientId);
|
|
virtual DataCacheRemoveResult_t Remove(DataCacheHandle_t handle, const void** ppItemData = NULL, unsigned* pItemSize = NULL, bool bNotify = false);
|
|
virtual bool IsPresent(DataCacheHandle_t handle);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual void* Lock(DataCacheHandle_t handle);
|
|
virtual int Unlock(DataCacheHandle_t handle);
|
|
virtual void* Get(DataCacheHandle_t handle, bool bFrameLock = false);
|
|
virtual void* GetNoTouch(DataCacheHandle_t handle, bool bFrameLock = false);
|
|
virtual void LockMutex();
|
|
virtual void UnlockMutex();
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual int BeginFrameLocking();
|
|
virtual bool IsFrameLocking();
|
|
virtual void* FrameLock(DataCacheHandle_t handle);
|
|
virtual int EndFrameLocking();
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual int GetLockCount(DataCacheHandle_t handle);
|
|
virtual int BreakLock(DataCacheHandle_t handle);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual int* GetFrameUnlockCounterPtr();
|
|
int m_nFrameUnlockCounter;
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual bool Touch(DataCacheHandle_t handle);
|
|
virtual bool Age(DataCacheHandle_t handle);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual unsigned Flush(bool bUnlockedOnly = true, bool bNotify = true);
|
|
virtual unsigned Purge(unsigned nBytes);
|
|
unsigned PurgeItems(unsigned nItems);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual void OutputReport(DataCacheReportType_t reportType = DC_SUMMARY_REPORT);
|
|
|
|
virtual void UpdateSize(DataCacheHandle_t handle, unsigned int nNewSize);
|
|
|
|
private:
|
|
friend void DataCacheItem_t::DestroyResource();
|
|
|
|
virtual void OnAdd(DataCacheClientID_t clientId, DataCacheHandle_t hCacheItem) {}
|
|
virtual DataCacheHandle_t DoFind(DataCacheClientID_t clientId);
|
|
virtual void OnRemove(DataCacheClientID_t clientId) {}
|
|
|
|
memhandle_t GetFirstUnlockedItem();
|
|
memhandle_t GetFirstLockedItem();
|
|
memhandle_t GetNextItem(memhandle_t);
|
|
DataCacheItem_t* AccessItem(memhandle_t hCurrent);
|
|
bool DiscardItem(memhandle_t hItem, DataCacheNotificationType_t type);
|
|
bool DiscardItemData(DataCacheItem_t* pItem, DataCacheNotificationType_t type);
|
|
void NoteAdd(int size);
|
|
void NoteRemove(int size);
|
|
void NoteLock(int size);
|
|
void NoteUnlock(int size);
|
|
void NoteSizeChanged(int oldSize, int newSize);
|
|
|
|
struct FrameLock_t
|
|
{
|
|
//$ WARNING: This needs a TSLNodeBase_t as the first item in here.
|
|
TSLNodeBase_t base;
|
|
int m_iLock;
|
|
DataCacheItem_t* m_pFirst;
|
|
int m_iThread;
|
|
};
|
|
typedef CThreadLocal<FrameLock_t*> CThreadFrameLock;
|
|
|
|
CDataCacheLRU& m_LRU;
|
|
CThreadFrameLock m_ThreadFrameLock;
|
|
DataCacheStatus_t m_status;
|
|
DataCacheLimits_t m_limits;
|
|
IDataCacheClient* m_pClient;
|
|
unsigned m_options;
|
|
CDataCache* m_pSharedCache;
|
|
char szName[DC_MAX_CLIENT_NAME + 1];
|
|
CTSSimpleList<FrameLock_t> m_FreeFrameLocks;
|
|
|
|
protected:
|
|
CThreadFastMutex& m_mutex;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDataCacheSectionFastFind
|
|
//
|
|
// Purpose: A section variant that allows clients to have cache support tracking
|
|
// efficiently (a true cache, not just an LRU)
|
|
//-----------------------------------------------------------------------------
|
|
class CDataCacheSectionFastFind : public CDataCacheSection
|
|
{
|
|
public:
|
|
CDataCacheSectionFastFind(CDataCache* pSharedCache, IDataCacheClient* pClient, const char* pszName)
|
|
: CDataCacheSection(pSharedCache, pClient, pszName)
|
|
{
|
|
m_Handles.Init(1024);
|
|
}
|
|
|
|
private:
|
|
virtual DataCacheHandle_t DoFind(DataCacheClientID_t clientId);
|
|
virtual void OnAdd(DataCacheClientID_t clientId, DataCacheHandle_t hCacheItem);
|
|
virtual void OnRemove(DataCacheClientID_t clientId);
|
|
|
|
CUtlHashFast<DataCacheHandle_t> m_Handles;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDataCache
|
|
//
|
|
// Purpose: The global shared cache. Manages sections and overall budgets.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CDataCache : public CTier3AppSystem< IDataCache >
|
|
{
|
|
typedef CTier3AppSystem< IDataCache > BaseClass;
|
|
|
|
public:
|
|
CDataCache();
|
|
|
|
//--------------------------------------------------------
|
|
// IAppSystem methods
|
|
//--------------------------------------------------------
|
|
virtual bool Connect(CreateInterfaceFn factory);
|
|
virtual void Disconnect();
|
|
virtual void* QueryInterface(const char* pInterfaceName);
|
|
virtual InitReturnVal_t Init();
|
|
virtual void Shutdown();
|
|
|
|
//--------------------------------------------------------
|
|
// IDataCache methods
|
|
//--------------------------------------------------------
|
|
|
|
virtual void SetSize(int nMaxBytes);
|
|
virtual void SetOptions(unsigned options);
|
|
virtual void SetSectionLimits(const char* pszSectionName, const DataCacheLimits_t& limits);
|
|
virtual void GetStatus(DataCacheStatus_t* pStatus, DataCacheLimits_t* pLimits = NULL);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual IDataCacheSection* AddSection(IDataCacheClient* pClient, const char* pszSectionName, const DataCacheLimits_t& limits = DataCacheLimits_t(), bool bSupportFastFind = false);
|
|
virtual void RemoveSection(const char* pszClientName, bool bCallFlush = true);
|
|
virtual IDataCacheSection* FindSection(const char* pszClientName);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
void EnsureCapacity(unsigned nBytes);
|
|
virtual unsigned Purge(unsigned nBytes);
|
|
virtual unsigned Flush(bool bUnlockedOnly = true, bool bNotify = true);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
virtual void OutputReport(DataCacheReportType_t reportType = DC_SUMMARY_REPORT, const char* pszSection = NULL);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
inline unsigned GetNumBytes() { return m_status.nBytes; }
|
|
inline unsigned GetNumItems() { return m_status.nItems; }
|
|
|
|
inline unsigned GetNumBytesLocked() { return m_status.nBytesLocked; }
|
|
inline unsigned GetNumItemsLocked() { return m_status.nItemsLocked; }
|
|
|
|
inline unsigned GetNumBytesUnlocked() { return m_status.nBytes - m_status.nBytesLocked; }
|
|
inline unsigned GetNumItemsUnlocked() { return m_status.nItems - m_status.nItemsLocked; }
|
|
|
|
private:
|
|
//-----------------------------------------------------
|
|
|
|
friend class CDataCacheSection;
|
|
|
|
//-----------------------------------------------------
|
|
|
|
DataCacheItem_t* AccessItem(memhandle_t hCurrent);
|
|
|
|
bool IsInFlush() { return m_bInFlush; }
|
|
int FindSectionIndex(const char* pszSection);
|
|
|
|
// Utilities used by the data cache report
|
|
void OutputItemReport(memhandle_t hItem);
|
|
static bool SortMemhandlesBySizeLessFunc(const memhandle_t& lhs, const memhandle_t& rhs);
|
|
|
|
//-----------------------------------------------------
|
|
|
|
CDataCacheLRU m_LRU;
|
|
DataCacheStatus_t m_status;
|
|
CUtlVector<CDataCacheSection*> m_Sections;
|
|
bool m_bInFlush;
|
|
CThreadFastMutex& m_mutex;
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
extern CDataCache g_DataCache;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline DataCacheItem_t* CDataCache::AccessItem(memhandle_t hCurrent)
|
|
{
|
|
return m_LRU.GetResource_NoLockNoLRUTouch(hCurrent);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline IDataCache* CDataCacheSection::GetSharedCache()
|
|
{
|
|
return m_pSharedCache;
|
|
}
|
|
|
|
inline DataCacheItem_t* CDataCacheSection::AccessItem(memhandle_t hCurrent)
|
|
{
|
|
return m_pSharedCache->AccessItem(hCurrent);
|
|
}
|
|
|
|
// Note: if status updates are moved out of a mutexed section, will need to change these to use interlocked instructions
|
|
|
|
inline void CDataCacheSection::NoteSizeChanged(int oldSize, int newSize)
|
|
{
|
|
int nBytes = (newSize - oldSize);
|
|
|
|
m_status.nBytes += nBytes;
|
|
m_status.nBytesLocked += nBytes;
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytes, nBytes);
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytesLocked, nBytes);
|
|
}
|
|
|
|
inline void CDataCacheSection::NoteAdd(int size)
|
|
{
|
|
m_status.nBytes += size;
|
|
m_status.nItems++;
|
|
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytes, size);
|
|
ThreadInterlockedIncrement(&m_pSharedCache->m_status.nItems);
|
|
}
|
|
|
|
inline void CDataCacheSection::NoteRemove(int size)
|
|
{
|
|
m_status.nBytes -= size;
|
|
m_status.nItems--;
|
|
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytes, -size);
|
|
ThreadInterlockedDecrement(&m_pSharedCache->m_status.nItems);
|
|
}
|
|
|
|
inline void CDataCacheSection::NoteLock(int size)
|
|
{
|
|
m_status.nBytesLocked += size;
|
|
m_status.nItemsLocked++;
|
|
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytesLocked, size);
|
|
ThreadInterlockedIncrement(&m_pSharedCache->m_status.nItemsLocked);
|
|
}
|
|
|
|
inline void CDataCacheSection::NoteUnlock(int size)
|
|
{
|
|
m_status.nBytesLocked -= size;
|
|
m_status.nItemsLocked--;
|
|
|
|
ThreadInterlockedExchangeAdd(&m_pSharedCache->m_status.nBytesLocked, -size);
|
|
ThreadInterlockedDecrement(&m_pSharedCache->m_status.nItemsLocked);
|
|
|
|
// something has been unlocked, assume cached pointers are now invalid
|
|
m_nFrameUnlockCounter++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#endif // DATACACHE_H
|