338 lines
9.6 KiB
C++
338 lines
9.6 KiB
C++
// --------------------------------------------------------------------------------
|
|
// MemCache.h
|
|
// Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
|
|
// --------------------------------------------------------------------------------
|
|
#include "pch.hxx"
|
|
#include "memcache.h"
|
|
#include <BadStrFunctions.h>
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CELLSIZE
|
|
// --------------------------------------------------------------------------------
|
|
#define CELLSIZE(_ulIndex) ((DWORD)(_ulIndex + m_cbMin))
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CELLINDEX
|
|
// --------------------------------------------------------------------------------
|
|
#define CELLINDEX(_cb) ((ULONG)(_cb - m_cbMin))
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// ISVALIDITEM
|
|
// --------------------------------------------------------------------------------
|
|
#define ISVALIDITEM(_pv, _iCell) \
|
|
(FALSE == IsBadReadPtr(_pv, CELLSIZE(_iCell)) && \
|
|
FALSE == IsBadWritePtr(_pv, CELLSIZE(_iCell)) && \
|
|
m_pMalloc->GetSize(_pv) >= CELLSIZE(_iCell))
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::CMemoryCache
|
|
// --------------------------------------------------------------------------------
|
|
CMemoryCache::CMemoryCache(IMalloc *pMalloc, ULONG cbMin /* =0 */, ULONG cbCacheMax /* =131072 */)
|
|
: m_pMalloc(pMalloc), m_cbMin(cbMin + sizeof(MEMCACHEITEM)), m_cbCacheMax(cbCacheMax)
|
|
{
|
|
m_cRef = 1;
|
|
m_cbCacheCur = 0;
|
|
ZeroMemory(m_rgCell, sizeof(m_rgCell));
|
|
#ifdef DEBUG
|
|
ZeroMemory(&m_rMetric, sizeof(MEMCACHEMETRIC));
|
|
#endif
|
|
InitializeCriticalSection(&m_cs);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::CMemoryCache
|
|
// --------------------------------------------------------------------------------
|
|
CMemoryCache::~CMemoryCache(void)
|
|
{
|
|
#ifdef DEBUG
|
|
DebugTrace("InetComm - CMemoryCache: cAlloc = %d\n", m_rMetric.cAlloc);
|
|
DebugTrace("InetComm - CMemoryCache: cAllocCache = %d\n", m_rMetric.cAllocCache);
|
|
DebugTrace("InetComm - CMemoryCache: cbAlloc = %d bytes\n", m_rMetric.cbAlloc);
|
|
DebugTrace("InetComm - CMemoryCache: cFree = %d\n", m_rMetric.cFree);
|
|
DebugTrace("InetComm - CMemoryCache: cbFree = %d bytes\n", m_rMetric.cbFree);
|
|
DebugTrace("InetComm - CMemoryCache: cbCacheMax = %d bytes\n", m_rMetric.cbCacheMax);
|
|
DebugTrace("InetComm - CMemoryCache: cFreeFull = %d\n", m_rMetric.cFreeFull);
|
|
DebugTrace("InetComm - CMemoryCache: cLookAhead = %d\n", m_rMetric.cLookAhead);
|
|
DebugTrace("InetComm - CMemoryCache: Average Look Aheads = %d\n", (m_rMetric.cLookAhead / m_rMetric.cAlloc));
|
|
DebugTrace("InetComm - CMemoryCache: cMostFree = %d\n", m_rMetric.cMostFree);
|
|
DebugTrace("InetComm - CMemoryCache: cbMostFree = %d bytes\n", m_rMetric.cbMostFree);
|
|
DebugTrace("InetComm - CMemoryCache: cMostAlloc = %d\n", m_rMetric.cMostAlloc);
|
|
DebugTrace("InetComm - CMemoryCache: cbMostAlloc = %d bytes\n", m_rMetric.cbMostAlloc);
|
|
#endif
|
|
HeapMinimize();
|
|
DeleteCriticalSection(&m_cs);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::AddRef
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CMemoryCache::AddRef(void)
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::CMemoryCache
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CMemoryCache::Release(void)
|
|
{
|
|
if (0 != --m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::Alloc
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(LPVOID) CMemoryCache::Alloc(DWORD cbAlloc)
|
|
{
|
|
// Locals
|
|
ULONG iCell;
|
|
ULONG iCellMax;
|
|
LPVOID pvAlloc;
|
|
|
|
// No Work
|
|
if (0 == cbAlloc)
|
|
return NULL;
|
|
|
|
// Count Number of allocations
|
|
INCMETRIC(cAlloc, 1);
|
|
INCMETRIC(cbAlloc, cbAlloc);
|
|
|
|
// Get Index
|
|
iCell = CELLINDEX(cbAlloc);
|
|
|
|
// Out of range
|
|
if (iCell >= CACHECELLS)
|
|
{
|
|
// Normal Alloc
|
|
return m_pMalloc->Alloc(cbAlloc);
|
|
}
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&m_cs);
|
|
|
|
// Compute iMax
|
|
iCellMax = min(iCell + 10, CACHECELLS);
|
|
|
|
// Try to allocate within 0 - 10 bytes of iCell
|
|
while(iCell < iCellMax)
|
|
{
|
|
// Set pvAlloc
|
|
pvAlloc = m_rgCell[iCell].pvItemHead;
|
|
|
|
// Done
|
|
if (pvAlloc)
|
|
break;
|
|
|
|
// Next
|
|
iCell++;
|
|
|
|
// Metric
|
|
INCMETRIC(cLookAhead, 1);
|
|
}
|
|
|
|
// Is there memory here
|
|
if (NULL == pvAlloc)
|
|
{
|
|
// Thread Safety
|
|
LeaveCriticalSection(&m_cs);
|
|
|
|
// Normal Alloc
|
|
return m_pMalloc->Alloc(cbAlloc);
|
|
}
|
|
|
|
// Count Number of allocations
|
|
INCMETRIC(cAllocCache, 1);
|
|
INCMETRIC(cbAllocCache, CELLSIZE(iCell));
|
|
|
|
// Adjust the Chain
|
|
m_rgCell[iCell].pvItemHead = ((LPMEMCACHEITEM)pvAlloc)->pvItemNext;
|
|
|
|
// Reduce the Size
|
|
m_cbCacheCur -= CELLSIZE(iCell);
|
|
|
|
#ifdef DEBUG
|
|
memset(pvAlloc, 0xFF, cbAlloc);
|
|
m_rgCell[iCell].cAlloc++;
|
|
if (m_rgCell[iCell].cAlloc > m_rMetric.cMostAlloc)
|
|
{
|
|
m_rMetric.cMostAlloc = m_rgCell[iCell].cAlloc;
|
|
m_rMetric.cbMostAlloc = CELLSIZE(iCell);
|
|
}
|
|
#endif
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&m_cs);
|
|
|
|
// Done
|
|
return pvAlloc;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::Realloc
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(LPVOID) CMemoryCache::Realloc(LPVOID pv, DWORD cbAlloc)
|
|
{
|
|
// Locals
|
|
ULONG cbCurrent;
|
|
LPVOID pvAlloc;
|
|
|
|
// Free
|
|
if (0 == cbAlloc)
|
|
{
|
|
// Free pv
|
|
Free(pv);
|
|
|
|
// Done
|
|
return NULL;
|
|
}
|
|
|
|
// No pv
|
|
if (NULL == pv)
|
|
{
|
|
// Just Alloc
|
|
return Alloc(cbAlloc);
|
|
}
|
|
|
|
// If we have Get Size of pv
|
|
cbCurrent = m_pMalloc->GetSize(pv);
|
|
|
|
// Allocate
|
|
pvAlloc = Alloc(cbAlloc);
|
|
|
|
// Failure
|
|
if (NULL == pvAlloc)
|
|
return NULL;
|
|
|
|
// Copy
|
|
CopyMemory(pvAlloc, pv, min(cbCurrent, cbAlloc));
|
|
|
|
// Done
|
|
return pvAlloc;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::Free
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(VOID) CMemoryCache::Free(LPVOID pvFree)
|
|
{
|
|
// Locals
|
|
ULONG iCell;
|
|
ULONG cbFree;
|
|
MEMCACHEITEM rItem;
|
|
|
|
// No Work
|
|
if (NULL == pvFree)
|
|
return;
|
|
|
|
// Get the size
|
|
cbFree = m_pMalloc->GetSize(pvFree);
|
|
|
|
// Metrics
|
|
INCMETRIC(cFree, 1);
|
|
INCMETRIC(cbFree, cbFree);
|
|
|
|
// Lets put it into the cell
|
|
iCell = CELLINDEX(cbFree);
|
|
|
|
// Verify the buffer
|
|
Assert(ISVALIDITEM(pvFree, iCell));
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&m_cs);
|
|
|
|
// Size of buffer is out of range or the cache has reached its max
|
|
if (cbFree < m_cbMin || cbFree - m_cbMin > CACHECELLS || m_cbCacheCur + cbFree > m_cbCacheMax)
|
|
{
|
|
// Stats
|
|
INCMETRIC(cFreeFull, 1);
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&m_cs);
|
|
|
|
// Free It
|
|
m_pMalloc->Free(pvFree);
|
|
|
|
// Done
|
|
return;
|
|
}
|
|
|
|
// Set Next
|
|
rItem.pvItemNext = m_rgCell[iCell].pvItemHead;
|
|
|
|
#ifdef DEBUG
|
|
memset(pvFree, 0xDD, cbFree);
|
|
#endif
|
|
|
|
// Write this into the buffer
|
|
CopyMemory(pvFree, &rItem, sizeof(MEMCACHEITEM));
|
|
|
|
// Reset pvItemHead
|
|
m_rgCell[iCell].pvItemHead = pvFree;
|
|
|
|
// Increment m_cbCacheCur
|
|
m_cbCacheCur += cbFree;
|
|
|
|
#ifdef DEBUG
|
|
if (m_cbCacheCur > m_rMetric.cbCacheMax)
|
|
m_rMetric.cbCacheMax = m_cbCacheCur;
|
|
m_rgCell[iCell].cFree++;
|
|
if (m_rgCell[iCell].cFree > m_rMetric.cMostFree)
|
|
{
|
|
m_rMetric.cMostFree = m_rgCell[iCell].cFree;
|
|
m_rMetric.cbMostFree = CELLSIZE(iCell);
|
|
}
|
|
#endif
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&m_cs);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CMemoryCache::HeapMinimize
|
|
// --------------------------------------------------------------------------------
|
|
STDMETHODIMP_(VOID) CMemoryCache::HeapMinimize(void)
|
|
{
|
|
// Locals
|
|
LPVOID pvCurr;
|
|
LPVOID pvNext;
|
|
ULONG i;
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&m_cs);
|
|
|
|
// Walk throught the cells
|
|
for (i=0; i<ARRAYSIZE(m_rgCell); i++)
|
|
{
|
|
// Set Current
|
|
pvCurr = m_rgCell[i].pvItemHead;
|
|
|
|
// Call the Chain of Buffers
|
|
while(pvCurr)
|
|
{
|
|
// Valid Buffer
|
|
Assert(ISVALIDITEM(pvCurr, i));
|
|
|
|
// Get Next
|
|
pvNext = ((LPMEMCACHEITEM)pvCurr)->pvItemNext;
|
|
|
|
// Free this buffer
|
|
m_pMalloc->Free(pvCurr);
|
|
|
|
// Goto Next
|
|
pvCurr = pvNext;
|
|
}
|
|
|
|
// Clear the cell
|
|
m_rgCell[i].pvItemHead = NULL;
|
|
}
|
|
|
|
// Minimize internal cache
|
|
m_pMalloc->HeapMinimize();
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&m_cs);
|
|
}
|