What's New in dotMemory

New Home screen

We completely reworked the dotTrace Home screen. Now, it's much easier to configure and start new profiling sessions, work with workspaces, and perform other basic operations.

Support for Linux dumps

Now, you can analyze dumps of .NET Core applications collected on the Linux systems using gcore or dotnet-dump.

Improved memory allocation analysis

Now, dotMemory lets you analyze memory allocation on an arbitrary time interval. Just select the interval on the timeline and the Memory Allocation view will show you the objects allocated on this interval as well as the stack trace that allocated them.

.NET 5 support

dotMemory now lets you profile .NET 5 applications on Windows, macOS, and Linux. Note that to profile applications on Linux and macOS, you should use dotMemory command-line profiler.

dotMemory uses the timeline data to provide automatic inspections right on the Timeline graph. Currently, there are three inspections available:

• High Garbage Collection pressure

• Pinned objects in Gen0

• Fast Large Objects Heap growth rate

.NET 5 introduced a separate heap segment for storing pinned objects - objects that cannot be moved in a heap which leads to heap fragmentation. dotMemory shows the Pinned Object Heap in the Heap Fragmentation View. Also, now dotMemory shows memory allocated to the Pinned Object Heap in real-time during profiling.

Various timeline improvements

• Garbage collections are shown on a separate graph below the main timeline.

• Now, you can select a particular time range on the timeline: The information about GC time and allocated memory will be shown for the selected time range.

• Performance improvements.

The dotMemory command-line profiler gets support for Linux and macOS.

The dotMemory command-line profiler for Linux (any distribution with GLIBC_2.23 or later) lets you profile applications on ARM64 systems.

You can open pinned objects as a separate object set.

You can open objects that are not reachable from GC roots as a separate object set.

Bug fixes and stability improvements.

Note that we also reworked internal data format. This means that dotMemory 2020.1 snapshot format is incompatible with earlier versions. At the same time, this will let us introduce some new features in the future releases.

The new self-profiling API.
The self-profiling API (the API that lets applications initialize and start a profiling session by themselves) becomes more convenient and easy-to-use. The self-profiling API is distributed as a NuGet package.

Ability to export instance details to a .json file (.bson, .hex, and .txt are also available).

You can now view a virtual memory address of an object instance.

dotMemory console profiler improvements.
dotMemory 2019.2 stops supporting remote profiling. To offer you an adequate replacement, we significantly improved the dotMemory console profiler:

1. The console profiler is almost equal to the standalone dotMemory. You can use the console tool to get snapshots of:

   • .NET Core applications,

   • IIS Express-hosted applications,

   • Windows services,

   • UWP applications,

   • WCF service libraries,

   • or any .NET application that is started after you run a profiling session.

2. Now, the console profiler can take a memory snapshot right after this becomes possible. This feature can be helpful in case you want to take a baseline snapshot and use it for comparison.

On-demand snapshot processing.
You can start working with a snapshot without waiting until the data is fully processed.

.NET Core 3.0 full support.
dotMemory is now able to attach to the .NET Core 3.0 Preview 7 processes.

Improved support for ASP.NET Core applications in Visual Studio:

• different hosting models are correctly supported,

• browser settings and Enable SSL are taken into account when starting a profiling session,

• ASP.NET Core 3.0 Preview 7 is supported,

• and other improvements...

Profiling API gets the ability to detach from the profiled process.

Silverlight and WebDev applications are no longer supported.

.NET Core 3.0 applications support.

New profiling API. We have significantly updated the profiling API:

• we have removed the state machine. Now, you can call any API method regardless of the controller state.

• we have reduced the number of available methods, thereby simplifying the use of the API.

• now, we distribute the API as a NuGet package.

Improved navigation to type declaration. Now, the 'navigate to type declaration' action is able to navigate you not only to Visual Studio but to JetBrains Rider as well.

Improved getting snapshots by condition. The profiling controller gets a new condition for taking a snapshot: Get a snapshot if total memory usage exceeds X MB.

Improved timeline graph. Click the graph to get exact memory data at a specific time point.

Reworked IIS Express profiling settings. Now, the default way to profile a web app hosted on IIS Express is to provide dotMemory a applicationhost.config file.

Profiling of run configurations. dotMemory integrated in Visual Studio gets more profiling capabilities. Now, you can profile not only your startup project, but any 'run configuration' - a startup project, an arbitrary executable, or even any static method.

Improved timeline graph:

• The timeline is now available for all types of applications including .NET Core, ASP.NET Core, IIS-hosted web apps, and others.

• The timeline contains a new Allocated in LOH since GC chart. The chart shows instant memory allocation to the Large Object Heap and can be very helpful in detecting excessive allocations of large objects.

Now, the Finalizable objects inspection works not only with snapshots captured via dotMemory but with raw memory dumps as well. In addition, now, finalizable objects are treated as objects that exist in a snapshot/dump, so you can open them and inspect more thoroughly.

Two new root types: F-Reachable Queue / Finalization Queue.

dotMemory console runner allows you to set a name for a taken snapshot.

Improved user interface. The 2018.1 release brings multiple minor user interface improvements. The most significant change is the reworked Analysis Subject panel. Now, it's much easier to navigate your analysis path.

Improved search. Now, when searching for particular objects in object set views, you can make your search more efficient by using special symbols.

Import memory dumps. Now, you can import Windows raw memory dumps (typically, you get them using the Task Manager or Process Explorer tools) and analyze them using all the power of dotMemory.

Improved 'Group by Dominators' view. The Group by Dominators view was reworked to make it easier to understand what are the key objects in your application. The tree of dominators is now combined with the dominators sunburst chart.

Improved user interface. The dotMemory user interface was slightly redesigned to make navigation through analysis subjects and views easier. The additional benefit of this work is the increased views area.

Attach the profiler to running applications using drag and drop.

Command-line profiler. dotMemory 2017.1 includes the dotMemory.exe tool that allows you to profile from the command line. The tool is extremely helpful when you need to automate the process of gathering memory snapshots.

Finalizable objects inspection. dotMemory checks your application on finalized objects and objects queued for finalization.

Profile .NET Core applications out of the box.

Compare snapshots from different sessions. dotMemory allows you to compare memory snapshots stored in different workspaces: that is, collected in different profiling sessions.

Navigate through view history.

Navigate to type declarations in Visual Studio.

dotMemory Home view.
dotMemory receives a Home view similar to that available in recent versions of dotTrace.