509 lines
16 KiB
C#
509 lines
16 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.Runtime.Collections
|
|
{
|
|
using System.Collections.Generic;
|
|
|
|
// free-threaded so that it can deal with items releasing references and timer interactions
|
|
// interaction pattern is:
|
|
// 1) item = cache.Take(key);
|
|
// 2) if (item == null) { Create and Open Item; cache.Add(key, value); }
|
|
// 2) use item, including performing any blocking operations like open/close/etc
|
|
// 3) item.ReleaseReference();
|
|
//
|
|
// for usability purposes, if a CacheItem is non-null you can always call Release on it
|
|
class ObjectCache<TKey, TValue>
|
|
where TValue : class
|
|
{
|
|
// for performance reasons we don't just blindly start a timer up to clean up
|
|
// idle cache items. However, if we're above a certain threshold of items, then we'll start the timer.
|
|
const int timerThreshold = 1;
|
|
|
|
ObjectCacheSettings settings;
|
|
Dictionary<TKey, Item> cacheItems;
|
|
bool idleTimeoutEnabled;
|
|
bool leaseTimeoutEnabled;
|
|
IOThreadTimer idleTimer;
|
|
static Action<object> onIdle;
|
|
bool disposed;
|
|
|
|
public ObjectCache(ObjectCacheSettings settings)
|
|
: this(settings, null)
|
|
{
|
|
}
|
|
|
|
public ObjectCache(ObjectCacheSettings settings, IEqualityComparer<TKey> comparer)
|
|
{
|
|
Fx.Assert(settings != null, "caller must use a valid settings object");
|
|
this.settings = settings.Clone();
|
|
this.cacheItems = new Dictionary<TKey, Item>(comparer);
|
|
|
|
// idle feature is disabled if settings.IdleTimeout == TimeSpan.MaxValue
|
|
this.idleTimeoutEnabled = (settings.IdleTimeout != TimeSpan.MaxValue);
|
|
|
|
// lease feature is disabled if settings.LeaseTimeout == TimeSpan.MaxValue
|
|
this.leaseTimeoutEnabled = (settings.LeaseTimeout != TimeSpan.MaxValue);
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// Users like ServiceModel can hook this for ICommunicationObject or to handle other non-IDisposable objects
|
|
public Action<TValue> DisposeItemCallback
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
return this.cacheItems.Count;
|
|
}
|
|
}
|
|
|
|
public ObjectCacheItem<TValue> Add(TKey key, TValue value)
|
|
{
|
|
Fx.Assert(key != null, "caller must validate parameters");
|
|
Fx.Assert(value != null, "caller must validate parameters");
|
|
lock (ThisLock)
|
|
{
|
|
if (this.Count >= this.settings.CacheLimit || this.cacheItems.ContainsKey(key))
|
|
{
|
|
// cache is full or already has an entry - return a shell CacheItem
|
|
return new Item(key, value, this.DisposeItemCallback);
|
|
}
|
|
else
|
|
{
|
|
return InternalAdd(key, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public ObjectCacheItem<TValue> Take(TKey key)
|
|
{
|
|
return Take(key, null);
|
|
}
|
|
|
|
// this overload is used for cases where a usable object can be atomically created in a non-blocking fashion
|
|
public ObjectCacheItem<TValue> Take(TKey key, Func<TValue> initializerDelegate)
|
|
{
|
|
Fx.Assert(key != null, "caller must validate parameters");
|
|
Item cacheItem = null;
|
|
|
|
lock (ThisLock)
|
|
{
|
|
if (this.cacheItems.TryGetValue(key, out cacheItem))
|
|
{
|
|
// we have an item, add a reference
|
|
cacheItem.InternalAddReference();
|
|
}
|
|
else
|
|
{
|
|
if (initializerDelegate == null)
|
|
{
|
|
// not found in cache, no way to create.
|
|
return null;
|
|
}
|
|
|
|
TValue createdObject = initializerDelegate();
|
|
Fx.Assert(createdObject != null, "initializer delegate must always give us a valid object");
|
|
|
|
if (this.Count >= this.settings.CacheLimit)
|
|
{
|
|
// cache is full - return a shell CacheItem
|
|
return new Item(key, createdObject, this.DisposeItemCallback);
|
|
}
|
|
|
|
cacheItem = InternalAdd(key, createdObject);
|
|
}
|
|
}
|
|
|
|
return cacheItem;
|
|
}
|
|
|
|
// assumes caller takes lock
|
|
Item InternalAdd(TKey key, TValue value)
|
|
{
|
|
Item cacheItem = new Item(key, value, this);
|
|
if (this.leaseTimeoutEnabled)
|
|
{
|
|
cacheItem.CreationTime = DateTime.UtcNow;
|
|
}
|
|
|
|
this.cacheItems.Add(key, cacheItem);
|
|
StartTimerIfNecessary();
|
|
return cacheItem;
|
|
}
|
|
|
|
// assumes caller takes lock
|
|
bool Return(TKey key, Item cacheItem)
|
|
{
|
|
bool disposeItem = false;
|
|
|
|
if (this.disposed)
|
|
{
|
|
// we would have already disposed this item, do not attempt to return it
|
|
disposeItem = true;
|
|
}
|
|
else
|
|
{
|
|
cacheItem.InternalReleaseReference();
|
|
DateTime now = DateTime.UtcNow;
|
|
if (this.idleTimeoutEnabled)
|
|
{
|
|
cacheItem.LastUsage = now;
|
|
}
|
|
if (ShouldPurgeItem(cacheItem, now))
|
|
{
|
|
bool removedFromItems = this.cacheItems.Remove(key);
|
|
Fx.Assert(removedFromItems, "we should always find the key");
|
|
cacheItem.LockedDispose();
|
|
disposeItem = true;
|
|
}
|
|
}
|
|
return disposeItem;
|
|
}
|
|
|
|
void StartTimerIfNecessary()
|
|
{
|
|
if (this.idleTimeoutEnabled && this.Count > timerThreshold)
|
|
{
|
|
if (this.idleTimer == null)
|
|
{
|
|
if (onIdle == null)
|
|
{
|
|
onIdle = new Action<object>(OnIdle);
|
|
}
|
|
|
|
this.idleTimer = new IOThreadTimer(onIdle, this, false);
|
|
}
|
|
|
|
this.idleTimer.Set(this.settings.IdleTimeout);
|
|
}
|
|
}
|
|
|
|
// timer callback
|
|
static void OnIdle(object state)
|
|
{
|
|
ObjectCache<TKey, TValue> cache = (ObjectCache<TKey, TValue>)state;
|
|
cache.PurgeCache(true);
|
|
}
|
|
|
|
static void Add<T>(ref List<T> list, T item)
|
|
{
|
|
Fx.Assert(!item.Equals(default(T)), "item should never be null");
|
|
if (list == null)
|
|
{
|
|
list = new List<T>();
|
|
}
|
|
|
|
list.Add(item);
|
|
}
|
|
|
|
bool ShouldPurgeItem(Item cacheItem, DateTime now)
|
|
{
|
|
// only prune items who aren't in use
|
|
if (cacheItem.ReferenceCount > 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (this.idleTimeoutEnabled &&
|
|
now >= (cacheItem.LastUsage + this.settings.IdleTimeout))
|
|
{
|
|
return true;
|
|
}
|
|
else if (this.leaseTimeoutEnabled &&
|
|
(now - cacheItem.CreationTime) >= this.settings.LeaseTimeout)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void GatherExpiredItems(ref List<KeyValuePair<TKey, Item>> expiredItems, bool calledFromTimer)
|
|
{
|
|
if (this.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!this.leaseTimeoutEnabled && !this.idleTimeoutEnabled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DateTime now = DateTime.UtcNow;
|
|
bool setTimer = false;
|
|
|
|
lock (ThisLock)
|
|
{
|
|
foreach (KeyValuePair<TKey, Item> cacheItem in this.cacheItems)
|
|
{
|
|
if (ShouldPurgeItem(cacheItem.Value, now))
|
|
{
|
|
cacheItem.Value.LockedDispose();
|
|
Add(ref expiredItems, cacheItem);
|
|
}
|
|
}
|
|
|
|
// now remove items from the cache
|
|
if (expiredItems != null)
|
|
{
|
|
for (int i = 0; i < expiredItems.Count; i++)
|
|
{
|
|
this.cacheItems.Remove(expiredItems[i].Key);
|
|
}
|
|
}
|
|
|
|
setTimer = calledFromTimer && (this.Count > 0);
|
|
}
|
|
|
|
if (setTimer)
|
|
{
|
|
idleTimer.Set(this.settings.IdleTimeout);
|
|
}
|
|
}
|
|
|
|
void PurgeCache(bool calledFromTimer)
|
|
{
|
|
List<KeyValuePair<TKey, Item>> itemsToClose = null;
|
|
lock (ThisLock)
|
|
{
|
|
this.GatherExpiredItems(ref itemsToClose, calledFromTimer);
|
|
}
|
|
|
|
if (itemsToClose != null)
|
|
{
|
|
for (int i = 0; i < itemsToClose.Count; i++)
|
|
{
|
|
itemsToClose[i].Value.LocalDispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// dispose all the Items if they are IDisposable
|
|
public void Dispose()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
foreach (Item item in this.cacheItems.Values)
|
|
{
|
|
if (item != null)
|
|
{
|
|
// We need to Dispose every item in the cache even when it's refcount is greater than Zero, hence we call Dispose instead of LocalDispose
|
|
item.Dispose();
|
|
}
|
|
}
|
|
this.cacheItems.Clear();
|
|
// we don't cache after Dispose
|
|
this.settings.CacheLimit = 0;
|
|
this.disposed = true;
|
|
if (this.idleTimer != null)
|
|
{
|
|
this.idleTimer.Cancel();
|
|
this.idleTimer = null;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// public surface area is synchronized through this.parent.ThisLock
|
|
class Item : ObjectCacheItem<TValue>
|
|
{
|
|
readonly ObjectCache<TKey, TValue> parent;
|
|
readonly TKey key;
|
|
readonly Action<TValue> disposeItemCallback;
|
|
|
|
TValue value;
|
|
int referenceCount;
|
|
|
|
public Item(TKey key, TValue value, Action<TValue> disposeItemCallback)
|
|
: this(key, value)
|
|
{
|
|
this.disposeItemCallback = disposeItemCallback;
|
|
}
|
|
|
|
public Item(TKey key, TValue value, ObjectCache<TKey, TValue> parent)
|
|
: this(key, value)
|
|
{
|
|
this.parent = parent;
|
|
}
|
|
|
|
Item(TKey key, TValue value)
|
|
{
|
|
this.key = key;
|
|
this.value = value;
|
|
this.referenceCount = 1; // start with a reference
|
|
}
|
|
|
|
public int ReferenceCount
|
|
{
|
|
get
|
|
{
|
|
return this.referenceCount;
|
|
}
|
|
}
|
|
|
|
public override TValue Value
|
|
{
|
|
get
|
|
{
|
|
return this.value;
|
|
}
|
|
}
|
|
|
|
public DateTime CreationTime
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public DateTime LastUsage
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public override bool TryAddReference()
|
|
{
|
|
bool result;
|
|
|
|
// item may not be valid or cachable, first let's sniff for disposed without taking a lock
|
|
if (this.parent == null || this.referenceCount == -1)
|
|
{
|
|
result = false;
|
|
}
|
|
else
|
|
{
|
|
bool disposeSelf = false;
|
|
lock (this.parent.ThisLock)
|
|
{
|
|
if (this.referenceCount == -1)
|
|
{
|
|
result = false;
|
|
}
|
|
else if (this.referenceCount == 0 && this.parent.ShouldPurgeItem(this, DateTime.UtcNow))
|
|
{
|
|
LockedDispose();
|
|
disposeSelf = true;
|
|
result = false;
|
|
this.parent.cacheItems.Remove(this.key);
|
|
}
|
|
else
|
|
{
|
|
// we're still in use, simply add-ref and be done
|
|
this.referenceCount++;
|
|
Fx.Assert(this.parent.cacheItems.ContainsValue(this), "should have a valid value");
|
|
Fx.Assert(this.Value != null, "should have a valid value");
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
if (disposeSelf)
|
|
{
|
|
this.LocalDispose();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public override void ReleaseReference()
|
|
{
|
|
bool disposeItem;
|
|
|
|
if (this.parent == null)
|
|
{
|
|
Fx.Assert(this.referenceCount == 1, "reference count should have never increased");
|
|
this.referenceCount = -1; // not under a lock since we're not really in the cache
|
|
disposeItem = true;
|
|
}
|
|
else
|
|
{
|
|
lock (this.parent.ThisLock)
|
|
{
|
|
// if our reference count will still be non zero, then simply decrement
|
|
if (this.referenceCount > 1)
|
|
{
|
|
InternalReleaseReference();
|
|
disposeItem = false;
|
|
}
|
|
else
|
|
{
|
|
// otherwise we need to coordinate with our parent
|
|
disposeItem = this.parent.Return(this.key, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (disposeItem)
|
|
{
|
|
this.LocalDispose();
|
|
}
|
|
}
|
|
|
|
internal void InternalAddReference()
|
|
{
|
|
Fx.Assert(this.referenceCount >= 0, "cannot take the item marked for disposal");
|
|
this.referenceCount++;
|
|
}
|
|
|
|
internal void InternalReleaseReference()
|
|
{
|
|
Fx.Assert(this.referenceCount > 0, "can only release an item that has references");
|
|
this.referenceCount--;
|
|
}
|
|
|
|
// call this part under the lock, and Dispose outside the lock
|
|
public void LockedDispose()
|
|
{
|
|
Fx.Assert(this.referenceCount == 0, "we should only dispose items without references");
|
|
this.referenceCount = -1;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (Value != null)
|
|
{
|
|
Action<TValue> localDisposeItemCallback = this.disposeItemCallback;
|
|
if (this.parent != null)
|
|
{
|
|
Fx.Assert(localDisposeItemCallback == null, "shouldn't have both this.disposeItemCallback and this.parent");
|
|
localDisposeItemCallback = this.parent.DisposeItemCallback;
|
|
}
|
|
|
|
if (localDisposeItemCallback != null)
|
|
{
|
|
localDisposeItemCallback(Value);
|
|
}
|
|
else if (Value is IDisposable)
|
|
{
|
|
((IDisposable)Value).Dispose();
|
|
}
|
|
}
|
|
this.value = null;
|
|
// this will ensure that TryAddReference returns false
|
|
this.referenceCount = -1;
|
|
}
|
|
|
|
public void LocalDispose()
|
|
{
|
|
Fx.Assert(this.referenceCount == -1, "we should only dispose items that have had LockedDispose called on them");
|
|
this.Dispose();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|