internal MemoryCacheEntry RemoveEntry(string key, MemoryCacheEntry entry, CacheEntryRemovedReason reason)
{
MemoryCacheKey cacheKey = new MemoryCacheKey(key);
MemoryCacheStore store = GetStore(cacheKey);
return(store.Remove(cacheKey, entry, reason));
}
protected int FlushItems(DateTime limit, CacheEntryRemovedReason reason, bool blockInsert, int count = int.MaxValue)
{
var flushedItems = 0;
if (blockInsert)
{
store.BlockInsert();
}
lock (entries) {
foreach (var entry in entries)
{
if (helper.GetDateTime(entry) > limit || flushedItems >= count)
{
break;
}
flushedItems++;
}
for (var f = 0; f < flushedItems; f++)
{
store.Remove(entries.Min, null, reason);
}
}
if (blockInsert)
{
store.UnblockInsert();
}
return(flushedItems);
}
internal int FlushExpiredItems(DateTime utcNow, bool useInsertBlock)
{
if (_cEntriesInUse == 0 || GetExpiresCount(utcNow) == 0)
{
return(0);
}
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
ExpiresEntryRef inFlushHead = ExpiresEntryRef.INVALID;
ExpiresEntry[] entries;
int entryIndex;
MemoryCacheEntry cacheEntry;
int flushed = 0;
try
{
if (useInsertBlock)
{
_cacheExpires.MemoryCacheStore.BlockInsert();
}
lock (this)
{
Debug.Assert(_blockReduce == false, "_blockReduce == false");
if (_cEntriesInUse == 0 || GetExpiresCount(utcNow) == 0)
{
return(0);
}
ResetCounts(utcNow);
int cPages = _cPagesInUse;
for (int i = 0; i < _pages.Length; i++)
{
entries = _pages[i]._entries;
if (entries != null)
{
int cEntries = NUM_ENTRIES - ((entries)[0]._cFree);
for (int j = 1; j < entries.Length; j++)
{
cacheEntry = entries[j]._cacheEntry;
if (cacheEntry != null)
{
if (entries[j]._utcExpires > utcNow)
{
AddCount(entries[j]._utcExpires);
}
else
{
cacheEntry.ExpiresBucket = 0xff;
cacheEntry.ExpiresEntryRef = ExpiresEntryRef.INVALID;
entries[j]._cFree = 1;
entries[j]._next = inFlushHead;
inFlushHead = new ExpiresEntryRef(i, j);
flushed++;
_cEntriesInFlush++;
}
cEntries--;
if (cEntries == 0)
{
break;
}
}
}
cPages--;
if (cPages == 0)
{
break;
}
}
}
if (flushed == 0)
{
Dbg.Trace("CacheExpiresFlushTotal", "FlushExpiredItems flushed " + flushed +
" expired items, bucket=" + _bucket + "; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
return(0);
}
_blockReduce = true;
}
}
finally
{
if (useInsertBlock)
{
_cacheExpires.MemoryCacheStore.UnblockInsert();
}
}
Debug.Assert(!inFlushHead.IsInvalid, "!inFlushHead.IsInvalid");
MemoryCacheStore cacheStore = _cacheExpires.MemoryCacheStore;
ExpiresEntryRef current = inFlushHead;
ExpiresEntryRef next;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Index;
next = entries[entryIndex]._next;
cacheEntry = entries[entryIndex]._cacheEntry;
entries[entryIndex]._cacheEntry = null;
Debug.Assert(cacheEntry.ExpiresEntryRef.IsInvalid, "cacheEntry.ExpiresEntryRef.IsInvalid");
cacheStore.Remove(cacheEntry, cacheEntry, CacheEntryRemovedReason.Expired);
current = next;
}
try
{
if (useInsertBlock)
{
_cacheExpires.MemoryCacheStore.BlockInsert();
}
lock (this)
{
current = inFlushHead;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Index;
next = entries[entryIndex]._next;
_cEntriesInFlush--;
AddExpiresEntryToFreeList(current);
current = next;
}
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
_blockReduce = false;
Reduce();
Dbg.Trace("CacheExpiresFlushTotal", "FlushExpiredItems flushed " + flushed +
" expired items, bucket=" + _bucket + "; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
}
}
finally
{
if (useInsertBlock)
{
_cacheExpires.MemoryCacheStore.UnblockInsert();
}
}
return(flushed);
}
internal int FlushUnderUsedItems(int maxFlush, bool force)
{
UsageEntry[] entryArray;
int num;
UsageEntryRef ref6;
UsageEntryRef ref7;
if (this._cEntriesInUse == 0)
{
return(0);
}
UsageEntryRef iNVALID = UsageEntryRef.INVALID;
int num2 = 0;
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
UsageEntryRef ref4;
if (this._cEntriesInUse == 0)
{
return(0);
}
DateTime utcNow = DateTime.UtcNow;
for (UsageEntryRef ref3 = this._lastRefTail; (this._cEntriesInFlush < maxFlush) && !ref3.IsInvalid; ref3 = ref4)
{
for (ref4 = this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev; ref4.IsRef1; ref4 = this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._prev)
{
}
entryArray = this._pages[ref3.PageIndex]._entries;
num = ref3.Ref2Index;
if (!force)
{
DateTime time = entryArray[num]._utcDate;
if (((utcNow - time) <= CacheUsage.NEWADD_INTERVAL) && (utcNow >= time))
{
continue;
}
}
UsageEntryRef entryRef = new UsageEntryRef(ref3.PageIndex, ref3.Ref2Index);
entryArray[num]._cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
this.RemoveEntryFromLastRefList(entryRef);
entryArray[num]._ref1._next = iNVALID;
iNVALID = entryRef;
num2++;
this._cEntriesInFlush++;
}
if (num2 == 0)
{
return(0);
}
this._blockReduce = true;
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
MemoryCacheStore memoryCacheStore = this._cacheUsage.MemoryCacheStore;
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
MemoryCacheEntry key = entryArray[num]._cacheEntry;
entryArray[num]._cacheEntry = null;
memoryCacheStore.Remove(key, key, CacheEntryRemovedReason.Evicted);
}
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
this._cEntriesInFlush--;
this.AddUsageEntryToFreeList(ref6);
}
this._blockReduce = false;
this.Reduce();
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
return(num2);
}
internal int FlushUnderUsedItems(int maxFlush, bool force)
{
if (_cEntriesInUse == 0)
{
return(0);
}
Debug.Assert(maxFlush > 0, "maxFlush is not greater than 0, instead is " + maxFlush);
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
UsageEntryRef inFlushHead = UsageEntryRef.INVALID;
UsageEntryRef prev, prevNext;
DateTime utcDate;
UsageEntry[] entries;
int entryIndex;
MemoryCacheEntry cacheEntry;
int flushed = 0;
try
{
_cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
Debug.Assert(_blockReduce == false, "_blockReduce == false");
if (_cEntriesInUse == 0)
{
return(0);
}
DateTime utcNow = DateTime.UtcNow;
for (prev = _lastRefTail; _cEntriesInFlush < maxFlush && !prev.IsInvalid; prev = prevNext)
{
Debug.Assert(_cEntriesInUse > 0, "_cEntriesInUse > 0");
prevNext = (_pages[(prev.PageIndex)]._entries)[prev.Ref2Index]._ref2._prev;
while (prevNext.IsRef1)
{
prevNext = (_pages[(prevNext.PageIndex)]._entries)[prevNext.Ref1Index]._ref1._prev;
}
entries = (_pages[(prev.PageIndex)]._entries);
entryIndex = prev.Ref2Index;
if (!force)
{
utcDate = entries[entryIndex]._utcDate;
Debug.Assert(utcDate != DateTime.MinValue, "utcDate != DateTime.MinValue");
if (utcNow - utcDate <= CacheUsage.NEWADD_INTERVAL && utcNow >= utcDate)
{
continue;
}
}
UsageEntryRef prev1 = (new UsageEntryRef((prev).PageIndex, (prev).Ref2Index));
cacheEntry = entries[entryIndex]._cacheEntry;
Debug.Assert(cacheEntry.UsageEntryRef == prev1, "cacheEntry.UsageEntryRef == prev1");
Dbg.Trace("CacheUsageFlushUnderUsedItem", "Flushing underused items, item=" + cacheEntry.Key + ", bucket=" + _bucket);
cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
RemoveEntryFromLastRefList(prev1);
entries[entryIndex]._ref1._next = inFlushHead;
inFlushHead = prev1;
flushed++;
_cEntriesInFlush++;
}
if (flushed == 0)
{
Dbg.Trace("CacheUsageFlushTotal", "Flush(" + maxFlush + "," + force + ") removed " + flushed +
" underused items; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
return(0);
}
_blockReduce = true;
}
}
finally
{
_cacheUsage.MemoryCacheStore.UnblockInsert();
}
Debug.Assert(!inFlushHead.IsInvalid, "!inFlushHead.IsInvalid");
MemoryCacheStore cacheStore = _cacheUsage.MemoryCacheStore;
UsageEntryRef current = inFlushHead;
UsageEntryRef next;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Ref1Index;
next = entries[entryIndex]._ref1._next;
cacheEntry = entries[entryIndex]._cacheEntry;
entries[entryIndex]._cacheEntry = null;
Debug.Assert(cacheEntry.UsageEntryRef.IsInvalid, "cacheEntry.UsageEntryRef.IsInvalid");
cacheStore.Remove(cacheEntry, cacheEntry, CacheEntryRemovedReason.Evicted);
current = next;
}
try
{
_cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
current = inFlushHead;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Ref1Index;
next = entries[entryIndex]._ref1._next;
_cEntriesInFlush--;
AddUsageEntryToFreeList(current);
current = next;
}
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
_blockReduce = false;
Reduce();
Dbg.Trace("CacheUsageFlushTotal", "Flush(" + maxFlush + "," + force + ") removed " + flushed +
" underused items; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
}
}
finally
{
_cacheUsage.MemoryCacheStore.UnblockInsert();
}
return(flushed);
}
internal int FlushExpiredItems(DateTime utcNow, bool useInsertBlock)
{
ExpiresEntry[] entryArray;
int index;
MemoryCacheEntry entry;
ExpiresEntryRef ref3;
ExpiresEntryRef ref4;
if ((this._cEntriesInUse == 0) || (this.GetExpiresCount(utcNow) == 0))
{
return(0);
}
ExpiresEntryRef iNVALID = ExpiresEntryRef.INVALID;
int num2 = 0;
try
{
if (useInsertBlock)
{
this._cacheExpires.MemoryCacheStore.BlockInsert();
}
lock (this)
{
if ((this._cEntriesInUse == 0) || (this.GetExpiresCount(utcNow) == 0))
{
return(0);
}
this.ResetCounts(utcNow);
int num3 = this._cPagesInUse;
for (int i = 0; i < this._pages.Length; i++)
{
entryArray = this._pages[i]._entries;
if (entryArray != null)
{
int num5 = 0x7f - entryArray[0]._cFree;
for (int j = 1; j < entryArray.Length; j++)
{
entry = entryArray[j]._cacheEntry;
if (entry != null)
{
if (entryArray[j]._utcExpires > utcNow)
{
this.AddCount(entryArray[j]._utcExpires);
}
else
{
entry.ExpiresBucket = 0xff;
entry.ExpiresEntryRef = ExpiresEntryRef.INVALID;
entryArray[j]._cFree = 1;
entryArray[j]._next = iNVALID;
iNVALID = new ExpiresEntryRef(i, j);
num2++;
this._cEntriesInFlush++;
}
num5--;
if (num5 == 0)
{
break;
}
}
}
num3--;
if (num3 == 0)
{
break;
}
}
}
if (num2 == 0)
{
return(0);
}
this._blockReduce = true;
}
}
finally
{
if (useInsertBlock)
{
this._cacheExpires.MemoryCacheStore.UnblockInsert();
}
}
MemoryCacheStore memoryCacheStore = this._cacheExpires.MemoryCacheStore;
for (ref3 = iNVALID; !ref3.IsInvalid; ref3 = ref4)
{
entryArray = this._pages[ref3.PageIndex]._entries;
index = ref3.Index;
ref4 = entryArray[index]._next;
entry = entryArray[index]._cacheEntry;
entryArray[index]._cacheEntry = null;
memoryCacheStore.Remove(entry, entry, CacheEntryRemovedReason.Expired);
}
try
{
if (useInsertBlock)
{
this._cacheExpires.MemoryCacheStore.BlockInsert();
}
lock (this)
{
for (ref3 = iNVALID; !ref3.IsInvalid; ref3 = ref4)
{
entryArray = this._pages[ref3.PageIndex]._entries;
index = ref3.Index;
ref4 = entryArray[index]._next;
this._cEntriesInFlush--;
this.AddExpiresEntryToFreeList(ref3);
}
this._blockReduce = false;
this.Reduce();
}
}
finally
{
if (useInsertBlock)
{
this._cacheExpires.MemoryCacheStore.UnblockInsert();
}
}
return(num2);
}