Currently we're using the .NET Memory Cache 4.0 for the Caching requirements. (not ASP.NET Cache, not any external Cache)
Looking at the '.NET Memory Cache 4.0' performance counters, there is data around Cache Hits, Misses, Entries, Trims etc. but nothing related to Size.
Is there is a way of measuring/knowing the current size of the Cache used by the Production Application?
I want to be able to capture this data at various points in time and get the average size of the cache.
It is an ugly implementation detail that Microsoft did not want to expose at all. Measuring object sizes in .NET is not in general possible. MemoryCache uses a fairly nasty backdoor to implement its memory limit trigger, it uses the DACCESS component of the CLR, actually intended to help implement memory profilers.
You can see it with the debugger so it isn't like you can't get to it. You just have to write very ugly code to dig through the private fields:
using System;
using System.Reflection;
using System.Runtime.Caching;
public static class MemoryCacheHackExtensions {
public static long GetApproximateSize(this MemoryCache cache) {
var statsField = typeof(MemoryCache).GetField("_stats", BindingFlags.NonPublic | BindingFlags.Instance);
var statsValue = statsField.GetValue(cache);
var monitorField = statsValue.GetType().GetField("_cacheMemoryMonitor", BindingFlags.NonPublic | BindingFlags.Instance);
var monitorValue = monitorField.GetValue(statsValue);
var sizeField = monitorValue.GetType().GetField("_sizedRef", BindingFlags.NonPublic | BindingFlags.Instance);
var sizeValue = sizeField.GetValue(monitorValue);
var approxProp = sizeValue.GetType().GetProperty("ApproximateSize", BindingFlags.NonPublic | BindingFlags.Instance);
return (long)approxProp.GetValue(sizeValue, null);
}
}
Seemed to work pretty well on .NET 4.6.1, not extensively tested. This is okay to get the lay of the land, just don't depend on it since it may break with any .NET update.
I took the original code and had to make a minor adjustment, I used "_sizedRefMultiple" instead of "_sizedRef" to make it work with .NET 4.6.
public static class MemoryCacheHackExtensions
{
public static long GetApproximateSize(this MemoryCache cache)
{
var statsField = typeof(MemoryCache).GetField("_stats", BindingFlags.NonPublic | BindingFlags.Instance);
var statsValue = statsField.GetValue(cache);
var monitorField = statsValue.GetType().GetField("_cacheMemoryMonitor", BindingFlags.NonPublic | BindingFlags.Instance);
var monitorValue = monitorField.GetValue(statsValue);
var sizeField = monitorValue.GetType().GetField("_sizedRefMultiple", BindingFlags.NonPublic | BindingFlags.Instance);
var sizeValue = sizeField.GetValue(monitorValue);
var approxProp = sizeValue.GetType().GetProperty("ApproximateSize", BindingFlags.NonPublic | BindingFlags.Instance);
return (long)approxProp.GetValue(sizeValue, null);
}
}
Finally, in .NET 7 preview, you can access the measure very easily. Some new metrics were added to IMemoryCache.
- MemoryCacheStatistics which holds cache hit/miss/estimated size and count for
IMemoryCache.- GetCurrentStatistics returns an instance of
MemoryCacheStatistics, or null whenTrackStatisticsflag is not enabled. The library has a built-in implementation available forMemoryCache.
Read more here.
As an alternative, you could also implement the IMemoryCacheManager interface and assign that to the global ObjectCache.Host property.
That requires that you are allowed to do this, i.e. no other component in your application has already done so (ASP.NET comes to mind, but I'm not sure). Personally, I use that approach in a Console/Windows Service application with no issues.
Note also, that you will only get cache sizes after a full GC or so, but that shouldn't be any different with Hans' approach.
Also note, that the below code works for named MemoryCaches, i.e. not on the instance itself.
Quite a view "but"s. But then, it doesn't require reflection.
So, here is the code.
public static class MemoryCacheHelper
{
private static readonly MemoryCacheServiceProvider s_serviceProvider = new MemoryCacheServiceProvider();
static MemoryCacheHelper()
{
try
{
ObjectCache.Host = s_serviceProvider;
}
catch (InvalidOperationException ex)
{
// ObjectCache.Host can only be set once.
}
}
public static MemoryCache Create(string name, NameValueCollection config)
{
return new MemoryCache(name, config);
}
// Return approximate cache size and when that value was last determined.
public static Tuple<long, DateTime> GetApproximateSize(string name)
{
return s_serviceProvider.GetApproximateSize(cache.Name);
}
private class MemoryCacheServiceProvider : IMemoryCacheManager, IServiceProvider
{
private readonly object m_lock = new object();
private readonly IDictionary<string, Tuple<long, DateTime>> m_sizes = new Dictionary<string, Tuple<long, DateTime>>();
public Tuple<long, DateTime> GetApproximateSize(string name)
{
lock (m_lock)
{
Tuple<long, DateTime> info;
if (m_sizes.TryGetValue(name, out info))
return info;
return null;
}
}
void IMemoryCacheManager.UpdateCacheSize(long size, MemoryCache cache)
{
lock (m_lock)
{
// The UpdateCacheSize() method will be called based on the configured "pollingInterval"
// for the respective cache. That value defaults to 2 minutes. So this statement doesn't
// fire to often and as a positive side effect we get some sort of "size-heartbeat" which
// might help when troubleshooting.
m_sizes[cache.Name] = Tuple.Create(size, DateTime.UtcNow);
}
}
void IMemoryCacheManager.ReleaseCache(MemoryCache cache)
{
lock (m_lock)
{
m_sizes.Remove(cache.Name);
}
}
object IServiceProvider.GetService(Type serviceType)
{
if (serviceType == typeof(IMemoryCacheManager))
{
return this;
}
return null;
}
}
I have written an extension method which iterates through the public properties of an the object and sums up the size values. If it's a IEnumerable or an Array it will iterate through items and calculate their size as well. This is not the best way but works good enough for me since I don't have more complicated requirements than this for my cache.
Note: there seems to be around 600 bytes of overhead per cache entry you should add it to calculations.
public static class ObjectMemorySizeCalculator
{
static int OBJECT_SIZE = IntPtr.Size == 8 ? 24 : 12;
static int POINTER_SIZE = IntPtr.Size;
public static long GetMemorySize(this object obj)
{
long memorySize = 0;
Type objType = obj.GetType();
if (objType.IsValueType)
{
memorySize = Marshal.SizeOf(obj);
}
else if (objType.Equals(typeof(string)))
{
var str = (string)obj;
memorySize = str.Length * 2 + 6 + OBJECT_SIZE;
}
else if (objType.IsArray)
{
var arr = (Array)obj;
var elementType = objType.GetElementType();
if (elementType.IsValueType)
{
long elementSize = Marshal.SizeOf(elementType);
long elementCount = arr.LongLength;
memorySize += elementSize * elementCount;
}
else
{
foreach (var element in arr)
{
memorySize += element != null ? element.GetMemorySize() + POINTER_SIZE : POINTER_SIZE;
}
}
memorySize += OBJECT_SIZE + 40;
}
else if (obj is IEnumerable)
{
var enumerable = (IEnumerable)obj;
foreach(var item in enumerable)
{
var itemType = item.GetType();
memorySize += item != null ? item.GetMemorySize() : 0;
if (itemType.IsClass)
memorySize += POINTER_SIZE;
}
memorySize += OBJECT_SIZE;
}
else if (objType.IsClass)
{
var properties = objType.GetProperties();
foreach (var property in properties)
{
var valueObject = property.GetValue(obj);
memorySize += valueObject != null ? valueObject.GetMemorySize() : 0;
if (property.GetType().IsClass)
memorySize += POINTER_SIZE;
}
memorySize += OBJECT_SIZE;
}
return memorySize;
}
I was inspired by Hans Passant's answer when trying to get the size of a MemoryDistributedCache. Here's how the code looks:
public static class MemoryDistributedCacheHackExtensions
{
public static long GetCacheSize(this MemoryDistributedCache cache)
{
var memCacheField = typeof(MemoryDistributedCache).GetField("_memCache", BindingFlags.NonPublic | BindingFlags.Instance);
var memCacheValue = memCacheField.GetValue(cache);
var cacheSizeField = memCacheValue.GetType().GetField("_cacheSize", BindingFlags.NonPublic | BindingFlags.Instance);
var cacheSizeValue = cacheSizeField.GetValue(memCacheValue);
return (long)cacheSizeValue;
}
}
So, this is not an answer to the original question. I wanted to put the code here in case someone else runs into the same problem I did.
