public MemoryCacheEntry Dequeue() { MemoryCacheEntry ret = null; MemoryCacheEntry[] heap; bool locked = false; int index; try { queueLock.EnterWriteLock(); locked = true; heap = GetHeapWithShrink(); if (heap == null || heapCount == 0) { return(null); } ret = heap [0]; index = --heapCount; heap [0] = heap [index]; heap [index] = null; if (heapCount > 0) { BubbleDown(heap); } return(ret); } finally { if (locked) { queueLock.ExitWriteLock(); } } }
bool ExpireIfNeeded(string key, MemoryCacheEntry entry, bool needsLock = true, CacheEntryRemovedReason reason = CacheEntryRemovedReason.Expired) { bool locked = false; try { if (entry.IsExpired) { if (needsLock) { cache_lock.EnterWriteLock(); locked = true; } cache.Remove(key); perfCounters.Decrement(MemoryCachePerformanceCounters.CACHE_ENTRIES); entry.Removed(owner, CacheEntryRemovedReason.Expired); return(true); } } finally { if (locked) { cache_lock.ExitWriteLock(); } } return(false); }
long DoRemoveExpiredItems(bool needLock) { long count = 0; bool locked = false; try { if (needLock) { cache_lock.EnterWriteLock(); locked = true; } if (timedItems == null) { return(0); } long now = DateTime.Now.Ticks; MemoryCacheEntry entry = timedItems.Peek(); while (entry != null) { if (entry.Disabled) { timedItems.Dequeue(); entry = timedItems.Peek(); continue; } if (entry.ExpiresAt > now) { break; } timedItems.Dequeue(); count++; DoRemoveEntry(entry, true, entry.Key, CacheEntryRemovedReason.Expired); entry = timedItems.Peek(); } if (entry == null) { timedItems = null; expirationTimer.Dispose(); expirationTimer = null; } return(count); } finally { if (locked) { cache_lock.ExitWriteLock(); } } }
internal void Remove(MemoryCacheEntry entry) { if (entry == null) { return; } string key = entry.Key; FindContainer(key).Remove(key); }
public void Remove (MemoryCacheEntry entry) { if (entry == null) return; int hash = entry.GetHashCode (); LinkedListNode <MemoryCacheEntry> node; if (index.TryGetValue (hash, out node)) { lru.Remove (node); index.Remove (hash); } }
// NOTE: this method _MUST_ be called with the write lock held void UpdateExpirable(MemoryCacheEntry entry) { if (timedItems == null) { timedItems = new MemoryCacheEntryPriorityQueue(); } timedItems.Enqueue(entry); if (expirationTimer == null) { expirationTimer = new Timer(RemoveExpiredItems, null, owner.TimerPeriod, owner.TimerPeriod); } }
public void Set(string key, object value, CacheItemPolicy policy) { bool locked = false; try { cache_lock.EnterWriteLock(); locked = true; MemoryCacheEntry mce; bool update = false; if (cache.TryGetValue(key, out mce)) { if (mce != null) { perfCounters.Increment(MemoryCachePerformanceCounters.CACHE_HITS); mce.Value = value; mce.SetPolicy(policy); if (mce.IsExpirable) { UpdateExpirable(mce); } lru.Update(mce); return; } update = true; } perfCounters.Increment(MemoryCachePerformanceCounters.CACHE_MISSES); if (policy != null) { mce = new MemoryCacheEntry(owner, key, value, policy.AbsoluteExpiration, policy.ChangeMonitors, policy.Priority, policy.RemovedCallback, policy.SlidingExpiration, policy.UpdateCallback); } else { mce = new MemoryCacheEntry(owner, key, value); } AddToCache(key, mce, update); } finally { if (locked) { cache_lock.ExitWriteLock(); } } }
// NOTE: this must be called with the write lock held void DoRemoveEntry(MemoryCacheEntry entry, bool updateLRU = true, string key = null, CacheEntryRemovedReason reason = CacheEntryRemovedReason.Removed) { if (key == null) { key = entry.Key; } cache.Remove(key); if (updateLRU) { lru.Remove(entry); } perfCounters.Decrement(MemoryCachePerformanceCounters.CACHE_ENTRIES); entry.Removed(owner, reason); }
public void Remove(MemoryCacheEntry entry) { if (entry == null) { return; } int hash = entry.GetHashCode(); LinkedListNode <MemoryCacheEntry> node; if (index.TryGetValue(hash, out node)) { lru.Remove(node); index.Remove(hash); } }
public object AddOrGetExisting(string key, object value, CacheItemPolicy policy) { bool readLocked = false, writeLocked = false; try { cache_lock.EnterUpgradeableReadLock(); readLocked = true; MemoryCacheEntry entry; if (cache.TryGetValue(key, out entry) && entry != null) { perfCounters.Increment(MemoryCachePerformanceCounters.CACHE_HITS); return(entry.Value); } perfCounters.Increment(MemoryCachePerformanceCounters.CACHE_MISSES); cache_lock.EnterWriteLock(); writeLocked = true; if (policy == null) { entry = new MemoryCacheEntry(owner, key, value); } else { entry = new MemoryCacheEntry(owner, key, value, policy.AbsoluteExpiration, policy.ChangeMonitors, policy.Priority, policy.RemovedCallback, policy.SlidingExpiration, policy.UpdateCallback); } AddToCache(key, entry); return(null); } finally { if (writeLocked) { cache_lock.ExitWriteLock(); } if (readLocked) { cache_lock.ExitUpgradeableReadLock(); } } }
public void Update (MemoryCacheEntry entry) { if (entry == null) return; int hash = entry.GetHashCode (); LinkedListNode <MemoryCacheEntry> node; if (!index.TryGetValue (hash, out node)) { node = new LinkedListNode <MemoryCacheEntry> (entry); index.Add (hash, node); } else { lru.Remove (node); node.Value = entry; } lru.AddLast (node); }
void BubbleDown(MemoryCacheEntry[] heap) { int index = 0; int left = 1; int right = 2; MemoryCacheEntry item = heap [0]; int selected = (right < heapCount && heap [right].ExpiresAt < heap [left].ExpiresAt) ? 2 : 1; while (selected < heapCount && heap [selected].ExpiresAt < item.ExpiresAt) { heap [index] = heap [selected]; index = selected; left = (index << 1) + 1; right = left + 1; selected = right < heapCount && heap [right].ExpiresAt < heap [left].ExpiresAt ? right : left; } heap [index] = item; }
// NOTE: this method _MUST_ be called with the write lock held void AddToCache(string key, MemoryCacheEntry entry, bool update = false) { if (update) { cache [key] = entry; } else { cache.Add(key, entry); } lru.Update(entry); entry.Added(); if (!update) { perfCounters.Increment(MemoryCachePerformanceCounters.CACHE_ENTRIES); } if (entry.IsExpirable) { UpdateExpirable(entry); } }
public void Update(MemoryCacheEntry entry) { if (entry == null) { return; } int hash = entry.GetHashCode(); LinkedListNode <MemoryCacheEntry> node; if (!index.TryGetValue(hash, out node)) { node = new LinkedListNode <MemoryCacheEntry> (entry); index.Add(hash, node); } else { lru.Remove(node); node.Value = entry; } lru.AddLast(node); }
bool ExpireIfNeeded (string key, MemoryCacheEntry entry, bool needsLock = true, CacheEntryRemovedReason reason = CacheEntryRemovedReason.Expired) { bool locked = false; try { if (entry.IsExpired) { if (needsLock) { cache_lock.EnterWriteLock (); locked = true; } cache.Remove (key); perfCounters.Decrement (MemoryCachePerformanceCounters.CACHE_ENTRIES); entry.Removed (owner, CacheEntryRemovedReason.Expired); return true; } } finally { if (locked) cache_lock.ExitWriteLock (); } return false; }
public void Enqueue(MemoryCacheEntry item) { if (item == null) { return; } bool locked = false; MemoryCacheEntry[] heap; try { queueLock.EnterWriteLock(); locked = true; heap = GetHeapWithGrow(); heap [heapCount++] = item; BubbleUp(heap); } finally { if (locked) { queueLock.ExitWriteLock(); } } }
public void Set (string key, object value, CacheItemPolicy policy) { bool locked = false; try { cache_lock.EnterWriteLock (); locked = true; MemoryCacheEntry mce; bool update = false; if (cache.TryGetValue (key, out mce)) { if (mce != null) { perfCounters.Increment (MemoryCachePerformanceCounters.CACHE_HITS); mce.Value = value; mce.SetPolicy (policy); if (mce.IsExpirable) UpdateExpirable (mce); lru.Update (mce); return; } update = true; } perfCounters.Increment (MemoryCachePerformanceCounters.CACHE_MISSES); if (policy != null) mce = new MemoryCacheEntry (owner, key, value, policy.AbsoluteExpiration, policy.ChangeMonitors, policy.Priority, policy.RemovedCallback, policy.SlidingExpiration, policy.UpdateCallback); else mce = new MemoryCacheEntry (owner, key, value); AddToCache (key, mce, update); } finally { if (locked) cache_lock.ExitWriteLock (); } }
// NOTE: this method _MUST_ be called with the write lock held void AddToCache (string key, MemoryCacheEntry entry, bool update = false) { if (update) cache [key] = entry; else cache.Add (key, entry); lru.Update (entry); entry.Added (); if (!update) perfCounters.Increment (MemoryCachePerformanceCounters.CACHE_ENTRIES); if (entry.IsExpirable) UpdateExpirable (entry); }
// NOTE: this method _MUST_ be called with the write lock held void UpdateExpirable (MemoryCacheEntry entry) { if (timedItems == null) timedItems = new MemoryCacheEntryPriorityQueue (); timedItems.Enqueue (entry); if (expirationTimer == null) expirationTimer = new Timer (RemoveExpiredItems, null, owner.TimerPeriod, owner.TimerPeriod); }
public object AddOrGetExisting (string key, object value, CacheItemPolicy policy) { bool readLocked = false, writeLocked = false; try { cache_lock.EnterUpgradeableReadLock (); readLocked = true; MemoryCacheEntry entry; if (cache.TryGetValue (key, out entry) && entry != null) { perfCounters.Increment (MemoryCachePerformanceCounters.CACHE_HITS); return entry.Value; } perfCounters.Increment (MemoryCachePerformanceCounters.CACHE_MISSES); cache_lock.EnterWriteLock (); writeLocked = true; if (policy == null) entry = new MemoryCacheEntry (owner, key, value); else entry = new MemoryCacheEntry (owner, key, value, policy.AbsoluteExpiration, policy.ChangeMonitors, policy.Priority, policy.RemovedCallback, policy.SlidingExpiration, policy.UpdateCallback); AddToCache (key, entry); return null; } finally { if (writeLocked) cache_lock.ExitWriteLock (); if (readLocked) cache_lock.ExitUpgradeableReadLock (); } }
// NOTE: this must be called with the write lock held void DoRemoveEntry (MemoryCacheEntry entry, bool updateLRU = true, string key = null, CacheEntryRemovedReason reason = CacheEntryRemovedReason.Removed) { if (key == null) key = entry.Key; cache.Remove (key); if (updateLRU) lru.Remove (entry); perfCounters.Decrement (MemoryCachePerformanceCounters.CACHE_ENTRIES); entry.Removed (owner, reason); }
public void Enqueue (MemoryCacheEntry item) { if (item == null) return; bool locked = false; MemoryCacheEntry[] heap; try { queueLock.EnterWriteLock (); locked = true; heap = GetHeapWithGrow (); heap [heapCount++] = item; BubbleUp (heap); } finally { if (locked) queueLock.ExitWriteLock (); } }
void BubbleUp (MemoryCacheEntry[] heap) { int index, parentIndex; MemoryCacheEntry parent, item; if (heapCount <= 1) return; index = heapCount - 1; parentIndex = (index - 1) >> 1; item = heap [index]; while (index > 0) { parent = heap [parentIndex]; if (heap [index].ExpiresAt >= parent.ExpiresAt) break; heap [index] = parent; index = parentIndex; parentIndex = (index - 1) >> 1; } heap [index] = item; }
void BubbleDown (MemoryCacheEntry[] heap) { int index = 0; int left = 1; int right = 2; MemoryCacheEntry item = heap [0]; int selected = (right < heapCount && heap [right].ExpiresAt < heap [left].ExpiresAt) ? 2 : 1; while (selected < heapCount && heap [selected].ExpiresAt < item.ExpiresAt) { heap [index] = heap [selected]; index = selected; left = (index << 1) + 1; right = left + 1; selected = right < heapCount && heap [right].ExpiresAt < heap [left].ExpiresAt ? right : left; } heap [index] = item; }