990 lines
18 KiB
C++
990 lines
18 KiB
C++
/*++
|
|
|
|
cacheimp.h -
|
|
|
|
This file contains all the template function definitions required
|
|
to make the cache manager work.
|
|
|
|
|
|
--*/
|
|
|
|
#pragma warning(1:4700)
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
void
|
|
Cache< Data, Key, KEYREF, Constructor, fAtomic >::Schedule() {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function runs through all the items in the Cache
|
|
bumping TTL's. If there are any items ready to go
|
|
then we dump them from the Cache.
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
if( !m_fValid )
|
|
return ;
|
|
|
|
m_Lock.ShareLock() ;
|
|
|
|
DWORD cExpungable = 0 ;
|
|
BOOL fExpunge = m_ExpireList.Expire( cExpungable ) ;
|
|
m_Lock.ShareUnlock() ;
|
|
|
|
if( fExpunge ) {
|
|
KEYREF key;
|
|
Expunge( key ) ; // fIgnoreKey == TRUE by default
|
|
}
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::RemoveEntry(
|
|
CacheState* pEntry
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function removes an entry from the Cache.
|
|
We call our hash table to delete the item.
|
|
the CacheState destructor automagically removes
|
|
the item from our linked lists.
|
|
|
|
CALLER MUST HOLD APPROPRIATE LOCKS!
|
|
|
|
|
|
Arguments :
|
|
|
|
pEntry - item to be removed from cache
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfully removed !
|
|
|
|
--*/
|
|
|
|
|
|
CACHEENTRY *pCacheEntry = (CACHEENTRY*)pEntry ;
|
|
|
|
CACHEENTRY *pC = m_Lookup.DeleteData( pCacheEntry->GetKey(), pCacheEntry ) ;
|
|
if (!pC)
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
delete pC;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::QueryRemoveEntry(
|
|
CacheState* pEntry ) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called from CacheList object to
|
|
determine whether we want to remove an item from the Cache.
|
|
This function is used to implement the ExpungeSpecific
|
|
function available to clients.
|
|
|
|
CALLER MUST HOLD APPROPRIATE LOCKS!
|
|
|
|
|
|
Arguments :
|
|
|
|
pEntry - item we want to determine whether it should remain !
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfully removed !
|
|
|
|
--*/
|
|
|
|
|
|
CACHEENTRY *pCacheEntry = (CACHEENTRY*) pEntry ;
|
|
|
|
if( m_pCallbackObject ) {
|
|
return m_pCallbackObject->fRemoveCacheItem( pCacheEntry->m_pData ) ;
|
|
}
|
|
return FALSE ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::ExpungeInternal(
|
|
KEYREF key,
|
|
CACHEENTRY* pData,
|
|
BOOL fIgnoreKey,
|
|
const CACHEENTRY* pProtected,
|
|
BOOL fDoCheap
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called when we want to force some thing
|
|
out of the cache. The caller can provide a key
|
|
to force a particular item out of the cache.
|
|
|
|
CALLER MUST HOLD APPROPRIATE LOCKS!
|
|
|
|
|
|
Arguments :
|
|
|
|
pProtected - an Element we want to make sure is not removed !
|
|
key - Pointer to the key identifying the item to be removed
|
|
pData - pointer to the CACHEENTRY object containing the data
|
|
and key we wish to remove.
|
|
|
|
Return Value :
|
|
|
|
TRUE something is successfully removed from the cache.
|
|
|
|
--*/
|
|
|
|
|
|
if( !fIgnoreKey ) {
|
|
CACHEENTRY* pC = m_Lookup.DeleteData( key, pData ) ;
|
|
if (pC)
|
|
{
|
|
delete pC;
|
|
}
|
|
}
|
|
return m_ExpireList.Expunge( this, fDoCheap, pProtected ) ;
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
long Cache<Data, Key, KEYREF, Constructor, fAtomic>::s_cCreated = 0 ;
|
|
|
|
#endif
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::Cache( ) : m_fValid( FALSE ) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function initializes our member variables.
|
|
|
|
Arguments :
|
|
|
|
cMax - maximum number of elements the cache should hold
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
#ifdef DEBUG
|
|
|
|
InterlockedIncrement( &s_cCreated ) ;
|
|
|
|
#endif
|
|
|
|
AddToSchedule() ;
|
|
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::~Cache( ) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function destroys a Cache object !
|
|
|
|
Arguments :
|
|
|
|
None
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
RemoveFromSchedule() ;
|
|
|
|
//
|
|
// Member and Base class destruction follows !!
|
|
//
|
|
|
|
#ifdef DEBUG
|
|
|
|
InterlockedDecrement( &s_cCreated ) ;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::Init(
|
|
DWORD (*pfnHash)( KEYREF ),
|
|
DWORD dwLifetimeSeconds,
|
|
DWORD cMaxInstances,
|
|
PSTOPHINT_FN pfnStopHint
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function initializes the cache so that it is ready
|
|
to take entries.
|
|
|
|
Arguments :
|
|
|
|
pfnHash - function to be used to compute hash values on keys
|
|
dwLifetimeSeconds - The number of seconds objects should live in the Cache
|
|
pfnStopHint - function to be used to send stop hints during
|
|
long spins so shutdown's don't time out.
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfull
|
|
|
|
--*/
|
|
|
|
m_ExpireList.m_cMax = long(cMaxInstances) ;
|
|
m_ExpireList.m_pfnStopHint = pfnStopHint;
|
|
|
|
m_TTL = 1 + (dwLifetimeSeconds / CScheduleThread::dwNotificationSeconds) ;
|
|
|
|
return m_fValid = m_Lookup.Init( &CACHEENTRY::m_pNext, 100, 100,
|
|
pfnHash, 2, CACHEENTRY::GetKey, CACHEENTRY::MatchKey ) ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::Expunge(
|
|
KEYREF key,
|
|
CACHEENTRY* pData,
|
|
BOOL fIgnoreKey
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called when we want to force some thing
|
|
out of the cache. The caller can provide a key
|
|
to force a particular item out of the cache.
|
|
|
|
WE WILL GRAB THE NECESSARY LOCKS !
|
|
|
|
Arguments :
|
|
|
|
pfnHash - function to be used to compute hash values on keys
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfull
|
|
|
|
--*/
|
|
|
|
_ASSERT( m_fValid ) ;
|
|
|
|
m_Lock.ExclusiveLock() ;
|
|
BOOL fReturn = ExpungeInternal( key, pData, fIgnoreKey, 0, FALSE ) ;
|
|
m_Lock.ExclusiveUnlock() ;
|
|
return fReturn ;
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::ExpungeSpecific(
|
|
CALLBACKOBJ* pCallbackObject,
|
|
BOOL fForced
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called when we want to force some thing
|
|
out of the cache. The caller can provide a key
|
|
to force a particular item out of the cache.
|
|
|
|
WE WILL GRAB THE NECESSARY LOCKS !
|
|
|
|
Arguments :
|
|
|
|
pfn - callback function used to determine what to remove
|
|
from the Cache.
|
|
fForced - if TRUE then we will remove from the Cache no matter
|
|
what, even if other threads are using the object !
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfull
|
|
|
|
--*/
|
|
|
|
|
|
|
|
m_Lock.ExclusiveLock() ;
|
|
|
|
m_pCallbackObject = pCallbackObject ;
|
|
|
|
BOOL fReturn = m_ExpireList.ExpungeSpecific( this, fForced ) ;
|
|
|
|
m_Lock.ExclusiveUnlock() ;
|
|
return fReturn ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::FindOrCreateInternal(
|
|
DWORD dwHash,
|
|
KEYREF key,
|
|
Constructor& constructor,
|
|
CRefPtr< Data >& pDataOut
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called when we want something out
|
|
of the Cache. We will either find the object or create it.
|
|
|
|
WE WILL GRAB THE NECESSARY LOCKS !
|
|
|
|
Arguments :
|
|
|
|
key - The unique key used to find the item in the Cache.
|
|
constructor - An object to pass to the Data's constructor and Init
|
|
functions.
|
|
pDataOut - Smart pointer which receives the result
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfull
|
|
|
|
--*/
|
|
|
|
|
|
BOOL fReturn = FALSE ;
|
|
pDataOut = 0 ;
|
|
|
|
if( !m_fValid ) {
|
|
SetLastError( 0 ) ;
|
|
return FALSE ;
|
|
} else {
|
|
m_Lock.ShareLock() ;
|
|
|
|
//
|
|
// See if we can find an Entry in the cache for the item we want.
|
|
//
|
|
CACHEENTRY *pEntry = m_Lookup.SearchKeyHash( dwHash, key ) ;
|
|
if( pEntry ) {
|
|
pDataOut = pEntry->m_pData ;
|
|
fReturn = TRUE ;
|
|
m_ExpireList.LiveLonger( pEntry, (m_TTL/2)+1 ) ;
|
|
}
|
|
|
|
m_Lock.ShareUnlock() ;
|
|
|
|
if( pDataOut == 0 ) {
|
|
|
|
m_Lock.ExclusiveLock() ;
|
|
|
|
//
|
|
// Check that the Item we want in the Cache didn't make it
|
|
// into the Cache in the brief moment we switched from a shared
|
|
// to an exclusive lock.
|
|
//
|
|
|
|
pEntry = m_Lookup.SearchKeyHash( dwHash, key ) ;
|
|
if( pEntry != 0 ) {
|
|
//
|
|
// It's in the cache - return the cached object !
|
|
//
|
|
pDataOut = pEntry->m_pData ;
|
|
fReturn = TRUE ;
|
|
m_ExpireList.LiveLonger( pEntry, (m_TTL/2)+1 ) ;
|
|
m_Lock.ExclusiveUnlock() ;
|
|
} else {
|
|
|
|
//
|
|
// We're going to have to create one of the elements that goes
|
|
// in the cache. Let's do that now !
|
|
//
|
|
|
|
const CACHEENTRY *pCacheEntry = 0 ;
|
|
BOOL fOverFlow = FALSE ;
|
|
Data *pData = 0 ;
|
|
|
|
//
|
|
// We Add another brace here because we want to explicitly manage
|
|
// the lifetime of tempCacheEntry
|
|
//
|
|
{
|
|
//
|
|
// pEntry will be copied by the FHash template into
|
|
// another CACHEENTRY object when it does its insertion.
|
|
// NOTE: do this to use the new TFHashEx code.
|
|
// pEntry is created on the stack and its refcount should remain!
|
|
//
|
|
CACHEENTRY* pEntry = new CACHEENTRY( m_TTL ) ;
|
|
_ASSERT( pEntry );
|
|
if (pEntry)
|
|
{
|
|
//
|
|
// The constructor of the Data object is expected to initialize
|
|
// only the 'key' data of the Data object so that the data can be
|
|
// found in the Cache.
|
|
//
|
|
pEntry->m_pData = pData = new Data( key, constructor ) ;
|
|
|
|
if( pEntry->m_pData ) {
|
|
|
|
pCacheEntry = m_Lookup.InsertDataHash( dwHash, pEntry ) ;
|
|
if( pCacheEntry ) {
|
|
if( m_ExpireList.Append( pCacheEntry ) ) {
|
|
if( !ExpungeInternal( key, 0, TRUE, pCacheEntry, TRUE ) ) { // ignore key by default
|
|
m_ExpireList.ForceExpunge( this, pCacheEntry ) ;
|
|
}
|
|
}
|
|
pDataOut = pCacheEntry->m_pData ;
|
|
pDataOut->ExclusiveLock() ;
|
|
} else {
|
|
|
|
//
|
|
// The Insertion failed !
|
|
// Falling through correctly handles this error case !
|
|
//
|
|
//
|
|
// No, No, No! We need to handle the failure case here!
|
|
// Delete pEntry's reference to the Data object
|
|
// if an error occurred inserting into hash tables.
|
|
// This will automatically destroy the data object.
|
|
pEntry->m_pData = 0;
|
|
|
|
}
|
|
|
|
}
|
|
//
|
|
// Delete pEntry's reference to the Data object.
|
|
// if an error occurred inserting into hash tables etc...
|
|
// this will automatically destroy the data object.
|
|
//
|
|
// We've handled in the above error case!
|
|
// pEntry->m_pData = 0 ;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Release the cache's lock. We do this now - the constructor
|
|
// for the 'Data' object should do minimal work. We will not call
|
|
// the init function for the Data object, with the 'cache' locks
|
|
// relingquished. This lets others use the cache while expensive
|
|
// construction operations continue.
|
|
//
|
|
m_Lock.ExclusiveUnlock() ;
|
|
|
|
//
|
|
// Complete the initialization of the new Data item if it exists !
|
|
//
|
|
if( pDataOut != 0 ) {
|
|
BOOL fSuccess = pDataOut->Init( constructor ) ;
|
|
pDataOut->ExclusiveUnlock() ;
|
|
|
|
if( fSuccess ) {
|
|
|
|
fReturn = TRUE ;
|
|
|
|
} else {
|
|
|
|
pDataOut = 0 ;
|
|
|
|
//
|
|
// Need to Expire the entry we just placed in the Cache !
|
|
//
|
|
// NOTE : Expunge() manages its own locks !!!
|
|
//
|
|
Expunge( key, 0, FALSE ) ; // don't ignore key!!!
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return fReturn ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
inline BOOL
|
|
Cache<Data, Key, KEYREF, Constructor, fAtomic>::FindOrCreate(
|
|
KEYREF key,
|
|
Constructor& constructor,
|
|
CRefPtr< Data >& pDataOut ) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function is called when we want something out
|
|
of the Cache. We will either find the object or create it.
|
|
|
|
WE WILL GRAB THE NECESSARY LOCKS !
|
|
|
|
Arguments :
|
|
|
|
key - The unique key used to find the item in the Cache.
|
|
constructor - An object to pass to the Data's constructor and Init
|
|
functions.
|
|
pDataOut - Smart pointer which receives the result
|
|
|
|
Return Value :
|
|
|
|
TRUE if successfull
|
|
|
|
--*/
|
|
|
|
|
|
DWORD dw = m_pfnHash( key ) ;
|
|
|
|
return FindOrCreateInternal( dw,
|
|
key,
|
|
constructor,
|
|
pDataOut
|
|
) ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::MultiCache() :
|
|
m_fValid( FALSE ),
|
|
m_pCaches( 0 ) ,
|
|
m_cSubCaches( 0 ),
|
|
m_pfnHash( 0 ) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function initializes the MultiCache's data structures
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::~MultiCache() {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function destroys all of our data structures - release
|
|
all of our subcaches !
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
|
|
if( m_pCaches ) {
|
|
|
|
delete[] m_pCaches ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::Init(
|
|
DWORD (*pfnHash)( KEYREF ),
|
|
DWORD dwLifetimeSeconds,
|
|
DWORD cSubCaches,
|
|
DWORD cMaxElements,
|
|
PSTOPHINT_FN pfnStopHint) {
|
|
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This function initializes the MultiCache - we use
|
|
multiple independent Caches to split the work
|
|
of caching all the data.
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
|
|
//
|
|
// Check that we're in the right state for this !
|
|
//
|
|
_ASSERT( !m_fValid ) ;
|
|
_ASSERT( m_pCaches == 0 ) ;
|
|
|
|
//
|
|
// Validate our arguments !!!
|
|
//
|
|
_ASSERT( pfnHash != 0 ) ;
|
|
_ASSERT( dwLifetimeSeconds != 0 ) ;
|
|
_ASSERT( cSubCaches != 0 ) ;
|
|
_ASSERT( cMaxElements != 0 ) ;
|
|
|
|
m_pfnHash = pfnHash ;
|
|
m_cSubCaches = cSubCaches ;
|
|
|
|
//
|
|
// Allocate the necessary subcaches !
|
|
//
|
|
|
|
m_pCaches = new CACHEINSTANCE[m_cSubCaches] ;
|
|
|
|
if( !m_pCaches ) {
|
|
return FALSE ;
|
|
} else {
|
|
|
|
for( DWORD i=0; i<cSubCaches; i++ ) {
|
|
|
|
if( !m_pCaches[i].Init( m_pfnHash, dwLifetimeSeconds, (cMaxElements / cSubCaches) + 1, pfnStopHint ) ) {
|
|
delete m_pCaches ;
|
|
return FALSE ;
|
|
}
|
|
}
|
|
}
|
|
m_fValid = TRUE ;
|
|
return TRUE ;
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
DWORD
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::ChooseInstance(
|
|
DWORD dwHash
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Given a Key figure out which of our subinstances we wish to use.
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
|
|
//
|
|
// Check that we're in the right state for this !
|
|
//
|
|
_ASSERT( m_fValid ) ;
|
|
_ASSERT( m_pCaches != 0 ) ;
|
|
|
|
//
|
|
// Validate our arguments !!!
|
|
//
|
|
_ASSERT( m_pfnHash != 0 ) ;
|
|
_ASSERT( m_cSubCaches != 0 ) ;
|
|
|
|
|
|
//DWORD dwHash = m_pfnHash( k ) ;
|
|
|
|
//
|
|
// Constants below stolen from C-runtime rand() function !
|
|
//
|
|
|
|
dwHash = (((dwHash * 214013) +2531011) >> 8) % m_cSubCaches ;
|
|
|
|
return dwHash ;
|
|
|
|
}
|
|
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::Expunge(
|
|
KEYREF key,
|
|
CACHEENTRY* pData,
|
|
BOOL fExpungeAll
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Either force a specified element out of the cache,
|
|
or force out all those that are ready to go !
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
BOOL fReturn = TRUE;
|
|
if( !fExpungeAll ) {
|
|
|
|
DWORD dw = m_pfnHash( key ) ;
|
|
|
|
CACHEINSTANCE* pInstance = &m_pCaches[ChooseInstance( dw )] ;
|
|
return pInstance->Expunge( key, pData ) ;
|
|
|
|
} else {
|
|
|
|
for( DWORD i=0; i<m_cSubCaches; i++ ) {
|
|
|
|
fReturn &= m_pCaches[i].Expunge( key ) ; // ignore key by default
|
|
|
|
}
|
|
}
|
|
return fReturn ;
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::ExpungeSpecific(
|
|
CALLBACKOBJ* pCallbackObject,
|
|
BOOL fForced
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Either force a specified element out of the cache,
|
|
or force out all those that are ready to go !
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
BOOL fReturn = TRUE ;
|
|
for( DWORD i=0; i<m_cSubCaches; i++ ) {
|
|
|
|
fReturn &= m_pCaches[i].ExpungeSpecific( pCallbackObject, fForced ) ;
|
|
|
|
}
|
|
return fReturn ;
|
|
}
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::FindOrCreate(
|
|
KEYREF key,
|
|
Constructor& constructor,
|
|
CRefPtr< Data >& pDataOut
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
DWORD dw = m_pfnHash( key ) ;
|
|
|
|
CACHEINSTANCE* pInstance = &m_pCaches[ChooseInstance(dw)] ;
|
|
|
|
return pInstance->FindOrCreateInternal( dw, key, constructor, pDataOut ) ;
|
|
|
|
}
|
|
|
|
|
|
template < class Data,
|
|
class Key,
|
|
class KEYREF,
|
|
class Constructor,
|
|
BOOL fAtomic
|
|
>
|
|
BOOL
|
|
MultiCache< Data, Key, KEYREF, Constructor, fAtomic >::FindOrCreate(
|
|
KEYREF key,
|
|
DWORD dw,
|
|
Constructor& constructor,
|
|
CRefPtr< Data >& pDataOut
|
|
) {
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
|
|
Arguments :
|
|
|
|
None.
|
|
|
|
Return Value :
|
|
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
_ASSERT( dw == m_pfnHash( key ) ) ;
|
|
|
|
CACHEINSTANCE* pInstance = &m_pCaches[ChooseInstance(dw)] ;
|
|
|
|
return pInstance->FindOrCreateInternal( dw, key, constructor, pDataOut ) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|