What's New in dotMemory

Creation Stack Trace view for object instances

We've reintroduced the Creation Stack Trace view, which was previously removed during the UI redesign. This view shows the function call stack that led to an object instance's creation, helping you identify the root cause of memory issues.

Back Traces view for object sets

We've reintroduced the Back Traces view for object sets, which was previously removed during the UI redesign. This inverted call tree shows the call chain starting from the function that created a particular set of objects, moving from bottom to top.

Visualize call tree with sunburst chart (all OSs)

The call tree can now be displayed as a sunburst chart, highlighting functions that allocate the most memory. Now, this feature is available on Windows, Linux, and macOS for both the standalone version of dotMemory and dotMemory in JetBrains Rider.

Visualize dominators with icicle chart (all OSs)

The dominator tree can now be displayed as an icicle chart, showing the memory consumption of the dominator and retained objects. This feature is available on Windows, Linux, and macOS for both the standalone version of dotMemory and dotMemory in JetBrains Rider.

User interface improvements

• Now, all dotMemory versions across all operating systems have a unified look and feel.

• Minor UI/UX improvements.

Improved view navigation

If you open an object set that results in a single element (e.g., a number of String objects), dotMemory automatically switches to a more relevant view. For example, you open a set of strings:

• Before: dotMemory opens the String object set in the Types view, displaying only a single String item, which requires manual switching to a different view for further analysis.

• Now: dotMemory automatically opens the set in the Similar Retention view. The Types view is disabled.

Improved instance search

We've added new filtering options to the Instances view:

• Search by string value: Type any string value into the filter field, and dotMemory will highlight matching strings. This makes it easier to find specific string instances based on their content.

• Regex support for string values: Use regular expressions for more advanced searches. For example, ^nAsso.{5,}ID$ matches nAssociatedObjectID.nAssociatedObjectID.

• Search by object address: You can also search for object instances by their memory address. This is useful for tracking specific objects directly.

These features are available in the standalone version of dotMemory and dotMemory in JetBrains Rider.

Improvements in dotMemory for Linux and macOS

The dotMemory version for Linux and macOS gets features that were previously available only on Windows:

• Automatic memory inspections: dotMemory for Linux and macOS gets the Inspections view, which shows a number of automatically detected memory issues.

• Cross-workspace snapshot comparison: Now, you can compare snapshots from different profiling sessions.

• Call Tree: The standalone version of dotMemory (Linux and macOS) and dotMemory in JetBrains Rider (Windows, Linux, and macOS) now have the Call Tree view.

These features are available in the standalone version of dotMemory and dotMemory in JetBrains Rider.

Visualize call tree with sunburst chart

The call tree can now be displayed as a sunburst chart, highlighting functions that allocate the most memory. The feature is available in the standalone version of dotMemory (Linux and macOS) and dotMemory in JetBrains Rider (Windows, Linux, and macOS).

Support for MAUI applications

Now, you can profile applications based on the MAUI framework. Currently, dotMemory supports profiling of WinUI applications targeting .NET 7.0+ on Windows. The support is available for dotMemory standalone and dotMemory integrated into Rider and ReSharper.

Improved support for macOS

• Now, the standalone version of dotMemory lets you specify application bundles (.app) instead of executable files.

• dotMemory in Rider can profile macOS run configurations. The following target frameworks are supported: net7.0-macos, net8.0-macos.

New views in dotMemory for Linux and macOS

The standalone version of dotMemory on Linux and macOS gets closer to its Windows counterpart, offering:

• The Similar Retention view for analyzing object sets

• The Sunburst diagram for analyzing dominator objects

Support for Frozen Object Heap

The information about immutable objects in the Frozen Object Heap is shown on the timeline, the Heap Fragmentation diagram, and the Generations view.

dotMemory Standalone on Linux and macOS

Now, you can run the standalone version of dotMemory on Linux and macOS operating systems.

Analyze process dumps on Linux

dotMemory lets you import and analyze process dumps as regular snapshots. This feature is now available on Linux. Note that the Linux version of dotMemory lets you import only the dumps collected on Linux.

Snapshot analysis in JetBrains Rider

Before 2023.2, you could use dotMemory in Rider only for memory allocation analysis. In 2023.2, you can collect memory snapshots and analyze them in Rider as in the standalone version of dotMemory.

• Snapshot analysis is available on Windows, Linux, and macOS.

• On Windows, you can also import and analyze process dumps.

• Some features and views are not available, e.g., automatic snapshot inspections and creation stack trace views.

Various improvements

Performance improvements and bug fixes.

.NET 7 support

dotMemory now lets you profile .NET 7 applications on Windows, macOS, and Linux.

Note that you might face the following issues:

• If your application creates dynamic assemblies, the profiler won't show data (method names and object types) from these assemblies. They will be shown as Unresolved.

• If you profile the application by attaching the profiler to it, the application may crash during the session.

Both issues will be fixed in the upcoming .NET 7 bugfix release.

Improved ARM CPUs support

• Linux arm32  – Now, you can run the dotMemory command-line profiler on arm32 CPUs on Linux. Supported frameworks: .NET Core 3.1, .NET 5.0 - 7.0.

• Windows arm64  – Now, you can use dotMemory on arm64 CPUs on Windows. This applies to all versions: dotMemory standalone, dotMemory in Rider, dotMemory in Visual Studio, and the dotMemory command-line tool.

dotMemory in JetBrains Rider on Linux and macOS

In addition to Windows, dotMemory is now available for JetBrains Rider on Linux and macOS:

• Two new profiling modes are available in the Run widget and in the Run | Switch profiler configurations menu – Memory (sampled allocations) and Memory (full allocations).

• Attach the profiler to a running process from the Run menu.

• Watch the Timeline graph unroll in real time. Select an interval and open the Memory Allocations view. It is equal to the same view in dotMemory Standalone and lets you analyze allocated objects and the allocation call tree for a specific time frame.

• Note that collecting memory snapshots is not available in this version.

Improvements in the dotMemory command-line profiler

The command-line profiler gets the --saving-mode argument that lets you set conditions on when to save a dotMemory workspace.

--saving-mode=always|has-snapshot|postponed:

• always – (default) save the workspace after the profiling session is finished

• has-snapshot – save the workspace on session finish only if the workspace contains at least one snapshot

• postpone – save the workspace only on session finish only if the stdin message ## dotMemory["confirm-save"] was received

dotMemory in JetBrains Rider

dotMemory is now available in the JetBrains Rider IDE:

• Two new profiling modes are available in the Run widget and in Run | Switch profiler configurations in the main menu – Memory (sampled allocations) and Memory (full allocations).

• Attach the profiler to a running process from the Run menu.

• Watch the Timeline Graph unroll in real-time. Select an interval and open the Memory Allocations view. It is equal to the same view in dotMemory Standalone and lets you analyze allocated objects and the allocation call tree for a specific time frame.

• dotMemory in Rider doesn't allow collecting snapshots in the 2022.2 version.

Support for musl-based Linux distributions

The dotMemory command-line tool now supports Alpine versions 3.13–3.15. The following CPUs and frameworks are supported:

• x64: .NET Core 3.1, .NET 5.0–6.0.

• arm64: .NET 5.0–6.0.

Attaching to applications with drag and drop

You can now attach the profiler to an already running application by simply dragging the special icon onto the application window.

Improved Profiling API

When getting a snapshot with the help of the profiling API, you can now specify a snapshot name using DotMemory.GetSnapshot("snapshot name"); The name will be shown on the dotMemory Home | Snapshots page.

Improved performance of the Similar Retention view

The Similar Retention view now processes data much faster.

Command-line tool improvement

The dotMemory command-line tool now shows its progress when saving a snapshot.

Improved profiling of child processes

Suppose you profile a root process that creates a number of managed child processes you want to profile. The root process itself is excluded from profiling for some reason (for example, it may be a shell script, a native process, or you simply exclude it with process filters).

Before: The profiler starts profiling any child process that matches the filter. Once a child process is finished, the profiler waits for one second. If no new child processes are started within this time, the profiler finishes the profiling session. This could be a problem if the root process starts child processes with a longer delay.

Now: While the root process is running, the profiler doesn't stop the profiling session. Once the root process stops working, the profiler switches to the one-second-delay approach. (edited)

.NET 6 support

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

Support for Apple M1

Now, the dotMemory command-line tool can work on computers with Apple M1 processors. The tool supports profiling of .NET 6 applications (native mode) and .NET 5 applications (Rosetta 2 mode).

Sampled memory allocation data

Now, dotMemory can get sampled data about memory allocation based on ETW events. Compared to the traditional (statistical) way of collecting allocation data, sampling is less detailed but provides a number of advantages: The sampled allocation data is collected without performance penalties. You don't need to enable collecting this data explicitly, it is always turned on. Sampled allocation data can be also collected when you attach the profiler to an already running application. Note that this feature is available only on Windows.

Subsystems view

Now, you can analyze memory allocation data using the Subsystems view. A subsystem groups all methods belonging to the same type, namespace, or assembly. The resulting view shows objects created by the subsystems and a merged call tree for each subsystem.

Performance improvements

We completely reworked the algorithm behind the dominators tree (the object retention graph). Even if an object set contains hundreds of millions of objects, dotMemory will open a particular view in a couple of minutes.

Improved memory allocation analysis

In this release, we continue improving the way you analyze memory allocation. The Memory Allocation view gets two additional dimensions:

• Methods lets you analyze the plain list of methods that allocated memory.

• Call Tree lets you analyze the allocation call tree. Each node in the tree shows not only the called method but also objects allocated by the call.

Improved filters

View filters (a search bar on top of dotMemory views) become more flexible and clear:

• The filters get additional options to narrow the search scope: #struct (search only in value types), #c (only in types), #m (only in methods), #ns (only in namespaces).

• You can get built-in help for all filters possible in the current context.

Improved object export

Now, it's possible to:

• Specify traverse depth when exporting object data.

• Select one or more types and export these data to a single file.

• Export object data from the Instances, Outgoing References, and Unreachable Objects views.

Various improvements

• Console profiler: Now, it's possible to enable/disable collecting memory allocation data with service messages.

• Stack trace copied to clipboard in dotMemory is now automatically opened in Rider / Visual Studio with ReSharper.

• Various bug fixes.

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.

Timeline inspections

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

Pinned object heap support

.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 .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 command-line tool 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.