Files
mono/mcs/class/referencesource/System.Data.Entity/System/Data/Common/QueryCache/QueryCacheManager.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

466 lines
17 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="QueryCacheManager.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner [....]
// @backupOwner [....]
//------------------------------------------------------------------------------
namespace System.Data.Common.QueryCache
{
using System;
using System.Collections.Generic;
using System.Data.EntityClient;
using System.Data.Metadata.Edm;
using System.Data.Objects.Internal;
using System.Diagnostics;
using System.Threading;
using System.Data.Common.Internal.Materialization;
/// <summary>
/// Provides Query Execution Plan Caching Service
/// </summary>
/// <remarks>
/// Thread safe.
/// Dispose <b>must</b> be called as there is no finalizer for this class
/// </remarks>
internal class QueryCacheManager : IDisposable
{
#region Constants/Default values for configuration parameters
/// <summary>
/// Default Soft maximum number of entries in the cache
/// Default value: 1000
/// </summary>
const int DefaultMaxNumberOfEntries = 1000;
/// <summary>
/// Default high mark for starting sweeping process
/// default value: 80% of MaxNumberOfEntries
/// </summary>
const float DefaultHighMarkPercentageFactor = 0.8f; // 80% of MaxLimit
/// <summary>
/// Recycler timer period
/// </summary>
const int DefaultRecyclerPeriodInMilliseconds = 60 * 1000;
#endregion
#region Fields
/// <summary>
/// cache lock object
/// </summary>
private readonly object _cacheDataLock = new object();
/// <summary>
/// cache data
/// </summary>
private readonly Dictionary<QueryCacheKey, QueryCacheEntry> _cacheData = new Dictionary<QueryCacheKey, QueryCacheEntry>(32);
/// <summary>
/// soft maximum number of entries in the cache
/// </summary>
private readonly int _maxNumberOfEntries;
/// <summary>
/// high mark of the number of entries to trigger the sweeping process
/// </summary>
private readonly int _sweepingTriggerHighMark;
/// <summary>
/// Eviction timer
/// </summary>
private readonly EvictionTimer _evictionTimer;
#endregion
#region Construction and Initialization
/// <summary>
/// Constructs a new Query Cache Manager instance, with default values for all 'configurable' parameters.
/// </summary>
/// <returns>A new instance of <see cref="QueryCacheManager"/> configured with default entry count, load factor and recycle period</returns>
internal static QueryCacheManager Create()
{
return new QueryCacheManager(DefaultMaxNumberOfEntries, DefaultHighMarkPercentageFactor, DefaultRecyclerPeriodInMilliseconds);
}
/// <summary>
/// Cache Constructor
/// </summary>
/// <param name="maximumSize">
/// Maximum number of entries that the cache should contain.
/// </param>
/// <param name="loadFactor">
/// The number of entries that must be present, as a percentage, before entries should be removed
/// according to the eviction policy.
/// Must be greater than 0 and less than or equal to 1.0
/// </param>
/// <param name="recycleMillis">
/// The interval, in milliseconds, at which the number of entries will be compared to the load factor
/// and eviction carried out if necessary.
/// </param>
private QueryCacheManager(int maximumSize, float loadFactor, int recycleMillis)
{
Debug.Assert(maximumSize > 0, "Maximum size must be greater than zero");
Debug.Assert(loadFactor > 0 && loadFactor <= 1, "Load factor must be greater than 0.0 and less than or equal to 1.0");
Debug.Assert(recycleMillis >= 0, "Recycle period in milliseconds must not be negative");
//
// Load hardcoded defaults
//
this._maxNumberOfEntries = maximumSize;
//
// set sweeping high mark trigger value
//
this._sweepingTriggerHighMark = (int)(_maxNumberOfEntries * loadFactor);
//
// Initialize Recycler
//
this._evictionTimer = new EvictionTimer(this, recycleMillis);
}
#endregion
#region 'External' interface
/// <summary>
/// Adds new entry to the cache using "abstract" cache context and
/// value; returns an existing entry if the key is already in the
/// dictionary.
/// </summary>
/// <param name="inQueryCacheEntry"></param>
/// <param name="outQueryCacheEntry">
/// The existing entry in the dicitionary if already there;
/// inQueryCacheEntry if none was found and inQueryCacheEntry
/// was added instead.
/// </param>
/// <returns>true if the output entry was already found; false if it had to be added.</returns>
internal bool TryLookupAndAdd(QueryCacheEntry inQueryCacheEntry, out QueryCacheEntry outQueryCacheEntry)
{
Debug.Assert(null != inQueryCacheEntry, "qEntry must not be null");
outQueryCacheEntry = null;
lock (_cacheDataLock)
{
if (!_cacheData.TryGetValue(inQueryCacheEntry.QueryCacheKey, out outQueryCacheEntry))
{
//
// add entry to cache data
//
_cacheData.Add(inQueryCacheEntry.QueryCacheKey, inQueryCacheEntry);
if (_cacheData.Count > _sweepingTriggerHighMark)
{
_evictionTimer.Start();
}
return false;
}
else
{
outQueryCacheEntry.QueryCacheKey.UpdateHit();
return true;
}
}
}
/// <summary>
/// Lookup service for a cached value.
/// </summary>
internal bool TryCacheLookup<TK, TE>(TK key, out TE value)
where TK : QueryCacheKey
{
Debug.Assert(null != key, "key must not be null");
value = default(TE);
//
// invoke internal lookup
//
QueryCacheEntry qEntry = null;
bool bHit = TryInternalCacheLookup(key, out qEntry);
//
// if it is a hit, 'extract' the entry strong type cache value
//
if (bHit)
{
value = (TE)qEntry.GetTarget();
}
return bHit;
}
/// <summary>
/// Clears the Cache
/// </summary>
internal void Clear()
{
lock (_cacheDataLock)
{
_cacheData.Clear();
}
}
#endregion
#region Private Members
/// <summary>
/// lookup service
/// </summary>
/// <param name="queryCacheKey"></param>
/// <param name="queryCacheEntry"></param>
/// <returns>true if cache hit, false if cache miss</returns>
private bool TryInternalCacheLookup( QueryCacheKey queryCacheKey, out QueryCacheEntry queryCacheEntry )
{
Debug.Assert(null != queryCacheKey, "queryCacheKey must not be null");
queryCacheEntry = null;
bool bHit = false;
//
// lock the cache for the minimal possible period
//
lock (_cacheDataLock)
{
bHit = _cacheData.TryGetValue(queryCacheKey, out queryCacheEntry);
}
//
// if cache hit
//
if (bHit)
{
//
// update hit mark in cache key
//
queryCacheEntry.QueryCacheKey.UpdateHit();
}
return bHit;
}
/// <summary>
/// Recycler handler. This method is called directly by the eviction timer.
/// It should take no action beyond invoking the <see cref="SweepCache"/> method on the
/// cache manager instance passed as <paramref name="state"/>.
/// </summary>
/// <param name="state">The cache manager instance on which the 'recycle' handler should be invoked</param>
private static void CacheRecyclerHandler(object state)
{
((QueryCacheManager)state).SweepCache();
}
/// <summary>
/// Aging factor
/// </summary>
private static readonly int[] _agingFactor = {1,1,2,4,8,16};
private static readonly int AgingMaxIndex = _agingFactor.Length - 1;
/// <summary>
/// Sweeps the cache removing old unused entries.
/// This method implements the query cache eviction policy.
/// </summary>
private void SweepCache()
{
if (!this._evictionTimer.Suspend())
{
// Return of false from .Suspend means that the manager and timer have been disposed.
return;
}
bool disabledEviction = false;
lock (_cacheDataLock)
{
//
// recycle only if entries exceeds the high mark factor
//
if (_cacheData.Count > _sweepingTriggerHighMark)
{
//
// sweep the cache
//
uint evictedEntriesCount = 0;
List<QueryCacheKey> cacheKeys = new List<QueryCacheKey>(_cacheData.Count);
cacheKeys.AddRange(_cacheData.Keys);
for (int i = 0; i < cacheKeys.Count; i++)
{
//
// if entry was not used in the last time window, then evict the entry
//
if (0 == cacheKeys[i].HitCount)
{
_cacheData.Remove(cacheKeys[i]);
evictedEntriesCount++;
}
//
// otherwise, age the entry in a progressive scheme
//
else
{
int agingIndex = unchecked(cacheKeys[i].AgingIndex + 1);
if (agingIndex > AgingMaxIndex)
{
agingIndex = AgingMaxIndex;
}
cacheKeys[i].AgingIndex = agingIndex;
cacheKeys[i].HitCount = cacheKeys[i].HitCount >> _agingFactor[agingIndex];
}
}
}
else
{
_evictionTimer.Stop();
disabledEviction = true;
}
}
if (!disabledEviction)
{
this._evictionTimer.Resume();
}
}
#endregion
#region IDisposable Members
/// <summary>
/// Dispose instance
/// </summary>
/// <remarks>Dispose <b>must</b> be called as there are no finalizers for this class</remarks>
public void Dispose()
{
// Technically, calling GC.SuppressFinalize is not required because the class does not
// have a finalizer, but it does no harm, protects against the case where a finalizer is added
// in the future, and prevents an FxCop warning.
GC.SuppressFinalize(this);
if (this._evictionTimer.Stop())
{
this.Clear();
}
}
#endregion
/// <summary>
/// Periodically invokes cache cleanup logic on a specified <see cref="QueryCacheManager"/> instance,
/// and allows this periodic callback to be suspended, resumed or stopped in a thread-safe way.
/// </summary>
private sealed class EvictionTimer
{
/// <summary>Used to control multi-threaded accesses to this instance</summary>
private readonly object _sync = new object();
/// <summary>The required interval between invocations of the cache cleanup logic</summary>
private readonly int _period;
/// <summary>The underlying QueryCacheManger that the callback will act on</summary>
private readonly QueryCacheManager _cacheManager;
/// <summary>The underlying <see cref="Timer"/> that implements the periodic callback</summary>
private Timer _timer;
internal EvictionTimer(QueryCacheManager cacheManager, int recyclePeriod)
{
this._cacheManager = cacheManager;
this._period = recyclePeriod;
}
internal void Start()
{
lock (_sync)
{
if (_timer == null)
{
this._timer = new Timer(QueryCacheManager.CacheRecyclerHandler, _cacheManager, _period, _period);
}
}
}
/// <summary>
/// Permanently stops the eviction timer.
/// It will no longer generate periodic callbacks and further calls to <see cref="Suspend"/>, <see cref="Resume"/>, or <see cref="Stop"/>,
/// though thread-safe, will have no effect.
/// </summary>
/// <returns>
/// If this eviction timer has already been stopped (using the <see cref="Stop"/> method), returns <c>false</c>;
/// otherwise, returns <c>true</c> to indicate that the call successfully stopped and cleaned up the underlying timer instance.
/// </returns>
/// <remarks>
/// Thread safe. May be called regardless of the current state of the eviction timer.
/// Once stopped, an eviction timer cannot be restarted with the <see cref="Resume"/> method.
/// </remarks>
internal bool Stop()
{
lock (_sync)
{
if (this._timer != null)
{
this._timer.Dispose();
this._timer = null;
return true;
}
else
{
return false;
}
}
}
/// <summary>
/// Pauses the operation of the eviction timer.
/// </summary>
/// <returns>
/// If this eviction timer has already been stopped (using the <see cref="Stop"/> method), returns <c>false</c>;
/// otherwise, returns <c>true</c> to indicate that the call successfully suspended the inderlying <see cref="Timer"/>
/// and no further periodic callbacks will be generated until the <see cref="Resume"/> method is called.
/// </returns>
/// <remarks>
/// Thread-safe. May be called regardless of the current state of the eviction timer.
/// Once suspended, an eviction timer may be resumed or stopped.
/// </remarks>
internal bool Suspend()
{
lock (_sync)
{
if (this._timer != null)
{
this._timer.Change(Timeout.Infinite, Timeout.Infinite);
return true;
}
else
{
return false;
}
}
}
/// <summary>
/// Causes this eviction timer to generate periodic callbacks, provided it has not been permanently stopped (using the <see cref="Stop"/> method).
/// </summary>
/// <remarks>
/// Thread-safe. May be called regardless of the current state of the eviction timer.
/// </remarks>
internal void Resume()
{
lock (_sync)
{
if (this._timer != null)
{
this._timer.Change(this._period, this._period);
}
}
}
}
}
}