Monitor your ASP.NET Cache API Behaviour

Recently I was working on diagnosing a performance issue with a customer’s web site with a colleague (this is one of our favourite engagement types so if you need some help let me know J), and we found that items were being trimmed very regularly from the ASP.NET Cache, causing excessive back-end work, and in turn reduced scalability.

* a “cache trim” is when ASP.NET looks for unused (based on a LRU algorithm) cache entries and deletes them.

So if you’re using the ASP.NET Cache API (or indeed any cache provider) to store custom application data, the moral of the story is to make sure you size your cache appropriately, and monitor it during test and live to see how it behaves.

It is worth knowing that an un-configured ASP.NET Cache takes a memory limit of the minimum of either 60% of physical RAM, or a fixed size RAM. This fixed size is different depending upon your processor architecture - see Thomas Marquardt's post here for some more detail. The idea is that when the limits imposed by configuration are approached, the cache will start trimming.

I’ve attached a very simple ASP.NET application that you can play with to study the cache behaviour while you’re reading the next section. Host it in IIS for the best results.

Setting Cache Limits

It is possible to set limits on how much memory an ASP.NET Application Pool can consume in IIS (see here), and you can also configure behaviour using settings on the cache web.config element. It is important to understand exactly what these mean;

·         privateBytesLimit (in web.config, on the cache element): This is the maximum number of bytes that the host process is permitted to consume before the cache is trimmed. In other words, it is not the memory to dedicate to the cache, nor a limit to the memory that the worker process can use... but rather the total memory usage by the w3wp process (in IIS7) at which cache trimming will occur.

·         percentagePhysicalMemoryUsedLimit (in web.config, on the cache element): This is the maximum percentage of RAM that the machine can use before the cache is trimmed. So on a 4gb machine with this set to 80%, the cache would be trimmed if Task Manager reported over 3.2gb (i.e. 80% of 4gb) was in use. Note that this is not the percentage memory used by ASP.NET or caching – it is the memory used machine-wide.

·         Private Memory Limit  (in IIS7 manager, as an advanced property of the App Pool): This is the maximum number of private bytes a worker process can consume before it is recycled (which will of course also empty the cache). If you set this limit lower than privateBytesLimit in web.config, you’ll always get a recycle before a cache trim... which sounds unlikely to be what you would want.

Things to Watch

The remaining content of this post itemises things you should consider monitoring to assess your cache’s performance. Some of it is obvious – but it is surprising how easy it is to overlook the obvious when your boss is breathing down your neck about your slow application J

Overall Application Performance

The best indicator that something might be going wrong is if your application is performing badly. Or maybe it was performing fine, but you’ve changed something or gotten more users, and suddenly it’s not so fast. Make sure you collect timing data in your IIS logs, and use LogParser to parse and analyse them. Also use standard performance counters from ASP.NET, WCF, and whatever other technologies you’re using. Get a feel for where and when things are slow or failing. This isn’t specific to caching, but it is an essential first step!

Hits on the resource you’re caching data from

Do some simple maths on the number of hits your back-end resource is getting. For example, if you have a “GetCities” web service, the results of which are cached for 2 hours, and you have 4 front-end load balanced web servers each with their own cache, you should expect a maximum of 4 hits to that web service every 2 hours. If you’re seeing more than that, alarm bells should be ringing.

Cache Entries

There are some great performance counters for the ASP.NET Cache API, so use those to monitor the state of the cache. Specifically the “ASP.NET Apps\Cache API Entries” counter is the number of items that are in the ASP.NET Cache right now. It should be broadly stable over longer periods with approximately the same load. If you cache an item per user, per region, or anything similar, be aware that this can dramatically affect your cache behaviour and memory consumption... in which case Cache Entries can be quite revealing.

Cache Trims

The “ASP.NET Apps\Cache API Trims” counter is the number of cache items that have been removed due to a memory limit being hit (i.e. they were trimmed). Obviously this should ideally be very low or zero under normal operation. Too many trims could indicate you need to revisit your caching strategy, or manually configure cache memory limits.

Cache Turnover Rate

The “ASP.NET Apps\Cache API Turnover Rate” counter shows the number of newly added and removed/expired/trimmed cache items per second. A target for this number depends on the behaviour of your application, but generally it should be fairly low – ideally items should be cached for quite some time before they expire or are removed. A high turnover rate could imply frequent trims, frequent explicit removals in application code, dependencies firing frequently (e.g. a SqlCacheDependency), or a sudden increase in user load (if, for example, you’re caching something per user).

Private Bytes

Monitoring the “Process\Private Bytes” counter for the w3wp process (assuming you’re using IIS7) tells you how much memory IIS is using for your ASP.NET application. A cache trim is likely to show up as a sudden drop in consumed bytes, and equally you should be able to see how close it is to memory limits for your configuration.

Worker Process Restarts

It is initially a little easy to confuse the cause of a drop in consumed Private Bytes between heavy cache trimming and an Application Pool recycle, so you should also watch the “ASP.NET\Worker Process Restarts” performance counter to ensure you know which happened.

Cache Removed Reasons

When you add items to the ASP.NET cache you can optionally specify a CacheItemRemovedCallback. This means that when the item is removed from the cache the call-back you’ve specified is called, passing in a CacheItemRemovedReason. This is great for adding some debugging instrumentation – if your item was trimmed due to memory pressure then the reason will be “underused”. Other reasons are Expired (you specified a time limit), Removed (you called Cache.Remove) and DependencyChanged (a file, SQL table, or other dependency setup with a CacheDependency was fired).

If you decide to add some logging using this approach I’d recommend adding a switch that enables or disables setting a call-back, as there is a small overhead in dealing with it.

Cache Memory Percentages

There are two slightly mysterious sounding cache counters too. I must admit, at first it took me a few minutes to get my head around exactly what these counters meant.

The first is “ASP.NET Apps\Cache % Machine Memory Limit Used”. This is literally the current physical memory usage by the whole machine as a percentage of the configured (or default) maximum physical memory usage. What?! Well, if you have edited the “percentagePhysicalMemoryUsedLimit” setting to 60%, this means your machine can use up to 60% of its physical memory before cache trimming occurs (not a very realistic example I know!). This counter reports the current usage as a percentage of the maximum... so if your machine is using 40% of available physical RAM, and the limit is 60%, this counter would report 66% (40 divided by 60, multiplied by 100 to get a percentage). It is important to note that this is memory consumed across the whole machine – not just by ASP.NET.

The second is “ASP.NET Apps\Cache % Process Memory Limit Used”. This is the total Private Bytes in use by the current ASP.NET process as a percentage of the limit specified in “privateBytesLimit”. So if you set the limit at 400mb, and your process is currently using 350mb, that would be reported as 87.5% (350 divided by 400, multiplied by 100 to get a percentage).

If either of these counters hits 100% ASP.NET will almost immediately trim 50% of your cache by picking the least recently used items... so obviously you don’t want to be hitting these limits often.


Phew. Well I hope that’s useful stuff. The best advice I can give is to do some real sums. Many customers cache data items per user, plus huge lists of reference data that can grow over time. The end result can be caches that are crippled over a fixed concurrent user level, or take a long time to reload large reference data sets when they have been trimmed. It is more than possible to do some rough maths to work out how much memory your application is using for the cache, and how this changes according to user numbers, regions, languages, locations, roles, user types, base offices, or other parameters – and the results can be very illuminating.

Finally, remember that you should always test using hardware, configuration, and simulated user loads that are as close to live as you can possibly afford, as this gives you the best possible chance of catching problems early.

Comments (9)
  1. Jab says:

    Nice one…!!!

    But can i ask, what is the specific tool use to monitor cache performance? or a process or code in C# or any .NET languages..

  2. Simon J Ince says:

    @ Jab;

    I’ve mentioned a few tools above, but if you mean the performance counters try searching for "perfmon"; it is just the performance console built into Windows.

    For other application-specific monitoring, other than the standard .NET counters (again monitored using perfmon) you should publish your own instrumentation; of which performance counters should be one part.

    Hope that helps!


  3. Jab says:


    Thanks for the info..but all i want to measure is the size of the items in the cache using data caching technique.. so can u give the code or link me to the site where i can find this.. i need this very much for instrumentation on data caching..

    hope u can help me..


  4. Simon J Ince says:

    @ Jab,

    I don’t think there is a way to monitor the precise size of the cache – it isn’t exposed by ASP.NET as there are intricacies to do with the implementation. For example, have a look at Tess’ post here;

    This implies that the cache is also used if you’re using inproc session state (I didn’t realise this until I saw her post!).

    I guess your best bet is to add your own instrumentation by wrapping calls to the cache in a facade that publishes size information for you.

    Hope that helps. If anyone has a better idea, shout up now!


  5. Shane says:

    Is it possible that the cached object is only partially cleared out? In our case, we have a complex object stored as a cached object, but it almost appears as though the object is partially cleared of some of its collections, which is causing errors.

    It may not be the case, but we’re currently trying to chase down some ghosts in the system, and this may be a clue.

  6. Simon J Ince says:

    @ Shane,

    "it depends" 🙂

    To be honest if I were you I’d do some isolated proof of concept tests with some detailed instrumentation to see what’s going on, but basically remember that .NET only garbage collects objects when there are no references to them left… so your cache might have one reference, but you shouldn’t hold any other references in code in static variables or similar else they could cause the GC to leave your objects in memory. I believe a Cache Trim will only clear the cache’s *references* to the objects; the garbage collector would normally do the deleting.

    Hope that makes sense.


  7. Watson says:


    We are using NCache in our organization which is a clustered in-memory distributed .NET Cache for objects and sessions in mission critical applications. It has a built in tool which helps you to monitor the performance of the cache.

    I guess it is the tool you are looking for. Below is the link to read more about. FYI there is also a free version of NCache called NCache Express.

  8. Simon J Ince says:

    @ Watson,

    I suspect that’s cheeky advertising so normally I’d delete your comment… but as I’m a big believer in distributed caches I’ll let you get away with it just this once 🙂

    Be aware that there’s also memcached, Velocity, ScaleOut, and many other options.


  9. John Clamon says:

    For IIS 7, Help for Recycling Conditions for Application Pool says that Private Memory Usage is …privately allocated system physical memory … (The property is named Maximum Used Memory in IIS 6.)

    And, Event Log entry when application pool recycles; "A worker process with process id of '4824' serving application pool '(thepool)' has requested a recycle because it reached its private bytes memory limit."

    Thus, if its private bytes then it must be the committed memory which physical memory + page file. But, help says its physical memory(in that case property must be named private working set.)

    ASP.NET Performance Monitoring, and When to Alert Administrators

    Private Bytes. The current size, in bytes, of the committed memory owned by this process.…/ms972959.aspx

    i don't find any correction to this documentation, or am i missing something?

Comments are closed.

Skip to main content