system.runtime.caching 的性能 [英] Performance of system.runtime.caching
问题描述
我比较了 .NET 4.0 和企业库缓存块中 system.runtime.caching 的性能，令我惊讶的是，它在从缓存项中获取大型数据集合时表现得非常糟糕.
I have compared the performance of system.runtime.caching in .NET 4.0 and the Enterprise Library Caching Block and to my surprise it performs terribly in comparison when fetching large data collections from cache items.
企业库在大约 0.15 毫秒内获取 100 个对象，在大约 0.25 毫秒内获取 10000 个对象.这对于进程内缓存来说是快速且自然的，因为实际上不需要复制数据(仅引用).
Enterprise Library fetches 100 objects in about 0,15ms, 10000 objects in about 0,25ms. This is fast, and natural for an in-process cache because no data actually needs to be copied (only references).
.NET 4.0 缓存在大约 25 毫秒内获取 100 个对象，在大约 1500 毫秒内获取 10000 个对象！相比之下，这非常慢，这让我怀疑缓存是在进程外完成的.
The .NET 4.0 caching fetches 100 objects in about 25ms, 10000 objects in about 1500ms! This is terribly slow in comparison and it makes me suspect the caching is done out-of-process.
我是否缺少某些配置选项，例如启用进程内缓存，或者企业库缓存块真的快得多吗?
Am I missing some configuration option, for example to enable in-process caching, or is the Enterprise Library Caching Block really this much faster?
更新
这是我的基准:
首先，我将数据从数据库加载到缓存中(与基准测试分开).
First, I load the data from the database to the cache (separate from the benchmark).
我在 get 方法周围使用一个计时器来测量以毫秒为单位的时间:
I use a timer around the get methods to measure the time in milliseconds:
企业库缓存
Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager _cache;
public void InitCache(){
_cache = CacheFactory.GetCacheManager("myCacheName");
}
public void Benchmark(){
HighPerformanceTimer timer = new HighPerformanceTimer();
timer.Start();
myObject o = (myObject)_cache.GetData(myCacheKey);
timer.Stop();
Response.Write(timer.GetAsStringInMilliseconds());
}
.NET 4.0 缓存
System.Runtime.Caching.MemoryCache _cache;
public void InitCache(){
_cache = new MemoryCache("myCacheName");
}
public void Benchmark(){
HighPerformanceTimer timer = new HighPerformanceTimer();
timer.Start();
myObject o = (myObject)_cache.Get(myCacheKey);
timer.Stop();
Response.Write(timer.GetAsStringInMilliseconds());
}
基准测试执行 1000 次以计算获取对象的平均时间，以确保测试的可靠性.计时器是我使用的自定义计时器，任何计算毫秒的计时器都应该这样做.
The benchmark is executed 1000 times to compute average time to fetch the object to ensure reliability of the test. The timer is a custom timer I use, any timer counting milliseconds should do.
有趣的是myObject"有很多引用.如果涉及任何序列化，我会理解为什么此对象的性能不同(例如在分布式缓存中)，但这些都是进程内缓存，理论上应该可以正常工作而没有任何重大差异.
The interesting thing is that the "myObject" has numerous references. If there was any serialization involved I'd understand why the performance differs for this object (like in distributed caching), but these are both in-process caches that theoretically should work without many major differences at all.
推荐答案
我猜你的缓存内容或策略的细节不一样.没有看到设置或插入，很难说到底是怎么做的.
My guess is that the details of your cache contents or policies are not the same. Without seeing the setup, or the inserts, it's hard to say exactly how.
不管怎样，这两个库都有不同的性能特点，哪个更好看具体情况而定.
Regardless, the two libraries have different performance characteristics, and which one is better clearly depends on the situation.
可能我的测试(下面的代码)太简单了，无法代表，但是在我的机器上运行它时，MemoryCache 大约快了 10 倍 .
Probably my test (code below) is too simple to be representative, but with it running on my machine, MemoryCache is roughly 10x faster.
class Program
{
const string myCacheKey = "foo";
static ICacheManager _elCache;
static MemoryCache _rtCache;
public static void InitCache()
{
_elCache = CacheFactory.GetCacheManager();
_elCache.Add(myCacheKey, new object());
_rtCache = new MemoryCache("cache");
_rtCache.Add(myCacheKey, new object(), new CacheItemPolicy());
}
public static string ElBenchmark(int n)
{
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < n; i++)
{
object o = _elCache.GetData(myCacheKey);
}
timer.Stop();
return timer.ElapsedTicks.ToString();
}
public static string RtBenchmark(int n)
{
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < n; i++)
{
object o = _rtCache.Get(myCacheKey);
}
timer.Stop();
return timer.ElapsedTicks.ToString();
}
static void Main(string[] args)
{
while (true)
{
InitCache();
StringBuilder sb = new StringBuilder();
System.Diagnostics.Debug.Write("EL: " + ElBenchmark(10000));
System.Diagnostics.Debug.Write(" ");
System.Diagnostics.Debug.Write("RT: " + RtBenchmark(10000));
System.Diagnostics.Debug.Write("
");
}
}
}
<?xml version="1.0"?>
<configuration>
<configSections>
<section name="cachingConfiguration"
type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
</configSections>
<cachingConfiguration defaultCacheManager="MyCacheManager">
<cacheManagers>
<add name="MyCacheManager" type="Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
expirationPollFrequencyInSeconds="60"
maximumElementsInCacheBeforeScavenging="50000"
numberToRemoveWhenScavenging="1000"
backingStoreName="NullBackingStore" />
</cacheManagers>
<backingStores>
<add type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
name="NullBackingStore" />
</backingStores>
</cachingConfiguration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>
这篇关于system.runtime.caching 的性能的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
