Red Gate's performance and memory profilers may have gone through a complex and protracted divorce, but they're still the best of friends...

Within the next few weeks the new versions of our, now separate, performance and memory profilers will be ready for launch. We've made a few tweaks to ANTS Performance Profiler, and added a new profiling mode which makes it even faster, but the real star of the show this time around is ANTS Memory Profiler. Just like the performance profiler last time around, we've completely rewritten it.

You can download the betas via:

http://www.red-gate.com/MessageBoard/viewtopic.php?t=8949

We've also updated the memory profiler tutorial video, available on YouTube at:

http://www.youtube.com/view_play_list?p=0589CFA7EB46587E

If YouTube is blocked, or you'd prefer a higher resolution version, you can download the whole video from:

ftp://ftp.red-gate.com/ANTSMemoryProfilerBeta/Tutorial_HowToFindAMemoryLeak_Full_Video.wmv

A rewrite is always a risky endeavour and, although we've done it before, it's not something we're casual about. This time, much more so than with the performance profiler, our hand was forced because the architecture of the pre-v5 memory profiler was too restrictive and insufficiently robust to handle some of the demands we were planning to place on it.

Doing this has enabled us to create a memory profiler which imposes minimal overhead on the profiled application-in fact the performance hit is barely noticeable most of the time. Not only that, but we've vastly reduced the memory overhead as well, and whilst it's not possible to impose a hard limit, ANTS Memory Profiler 5 generally won't use much more than 32MB in the target application; previously the memory usage of the application could easily double, or more. No other .NET memory profiler can make these sorts of claims.

Here's a rundown of the major features:

• Unparalleled performance,
• Ability to take and analyse an arbitrarily large number of memory snapshots,
• Support for snapshots up to 2GB (32-bit operating systems), and 4GB (64-bit operating systems),
• Arbitrary snapshot comparisons,
• Summary information for profiling session, individual snapshots, and snapshot comparisons,
• Large object heap fragmentation statistics,
• Extremely powerful filtering options to narrow down results to the objects you really need to know about,
• A unique class graph view allowing you to quickly see where instances of a given class are being referenced,
• A unique object retention graph, showing why objects are still held in memory, so you can find the reference chains you need to break in order to free your objects,
• The ability to profile .NET executables, ASP.NET applications and web services in IIS and web development server, services, COM+ applications, and XBAP applications.

The take home message from all of this is that if you need a memory profiler, you need ANTS Memory Profiler 5. Some of you may already have tried and rejected previous versions of our memory profiler, but the time has come to think again. ANTS Memory Profiler 5 is a completely different product and, frankly, it destroys the competition.

Since a picture often is worth a thousand words I'm going to largely shut up and show you some screenshots of the new memory profiler. Where it makes sense I'll also show shots of the old profiler for comparison.

Figure 1a. The one-step setup dialog from ANTS Performance Profiler has made it in to the memory profiler.

Figure 1b. The old setup wizard from the pre-v5 days. It had served us well but the time had come to put it out to pasture.

Figure 2. Profiling our application; this will look familiar to anyone who's used ANTS Performance Profiler 4.x.

Figure 3a. The new snapshot summary view; so far I've taken two snapshots.

Figure 3b. The old summary view; note the lack of comparison information.

Figure 4a. The new class list: lots of visual cues to make interpretation easier, and plenty of filtering options.

Figure 4b. The old class list: much more workman-like, and lacking a lot in terms of filtering (it's also hard to find). Realizing this was a problem we completely revamped filtering for version 5 to make it more powerful and easier to use.

Figure 5. The brand new class reference graph. It's somewhat similar to the call graph in ANTS Performance Profiler in the way it presents information, except that it shows where most of the references to a type are coming from, and going to, rather than showing which methods are responsible for most of the CPU time for a particular method. It's one of those views that can be initially daunting but, once you've wrapped your head around what it's showing you (which doesn't take long), quickly becomes indispensable.

Figure 6. Here's the really cool thing about the class reference graph: clicking on the "Show instances of this class on this path" will show all the instances of System.Data.DataTable that are on the reference path pointing to my RBNode<...etc...>s in the centre (see figure 5).

Figure 7a. The new object list. The "Size with children" column allows you to quickly see which objects are responsible for hogging the most memory.

Figure 7b. The same view from the v4 memory profiler. Again, it has a rather sparse and functional feel. I've grouped by "Comparison" to help me identify new objects. In the new version there's a filter for this, which makes things much clearer. Also note that in v4 you really are seeing all the objects. In v5 you view objects by type, which really cuts down on the clutter.

Figure 8a. The object retention graph. This is the view that shows you why an object is still in memory and is essential when tracing memory leaks, so you can fix them. The principle is simple: once you've found out what's holding your object in memory just break the chain of references after that point and the garbage collector should be able to clean up your object. In this case we can see that my DataTable is being kept in memory by a member called Foregrounded (actually an event) on ConnectForm.

Figure 8b. The hierachy view in the v4 memory profiler: you had to use this to try to find out what's holding your object in memory. For simple applications a bit of trial and error means you can sometimes find out what's going on but, for more complex applications, whilst you might get lucky, you probably have more chance of winning the National Lottery.

Figure 9. Those filtering options in more detail: sweet.

Figure 10a. The new timeline, which allows you to compare arbitrary snapshots: here I'm comparing my third and fifth.

Figure 10b. The old snapshot chooser. You can only compare a snapshot to the immediately preceding snapshot, so here I'm comparing my second and third snapshots.

Hopefully those screenshots, at least the ones of the new memory profiler, have whetted your appetite. You can get the beta right now via:

http://www.red-gate.com/MessageBoard/viewtopic.php?t=8949

As the title of this post implies, we're expecting to put the final release out in roughly four weeks. In the meantime, enjoy!