dotTrace is shipped as two separate products for performance and memory profiling: dotTrace 5 Performance and dotTrace 3.5 Memory.
- Performance profiling features in dotTrace 5 Performance
- Memory profiling features in dotTrace 3.5 Memory
Top-class technology support
dotTrace Performance helps you locate performance bottlenecks in a variety of .NET applications, including those based on .NET Framework 1.x to 4.5, .NET Compact Framework 3.5, and Silverlight 4.
Multiple types of applications that dotTrace Performance is able to profile include standalone desktop applications, web applications running under IIS, IIS Express, or ASP.NET development server, Windows services, WCF services, Windows Mobile applications, and unit tests.
You can take a snapshot of application performance anytime during its execution. dotTrace Performance can be attached to a running application for profiling, and detached as soon as profiling information is captured.
This minimizes overhead imposed by running an application under the profiler. More importantly, it enables investigating performance issues in production environments where you just can't afford to restart an application every time you need to profile it.
Versatile profiling modes
Depending on your needs, you can choose between several modes of performance profiling.
Sampling profiling is the fastest profiling method, but at the expense of lower accuracy. It is extremely useful for quickly getting a general idea of your application's performance, and profiling for extensive periods of time.
Tracing profiling is a very accurate way of profiling based on CLR notifications on entering and leaving functions. It helps you learn precise timing information and the number of function calls.
Line-by-line profiling collects timing information per statement, letting you collect the most detailed information about functions that perform significant algorithmic work. Use this method wisely though as it imposes the greatest overhead on the application that is being profiled.
Integration with Visual Studio
You can launch profiling of your applications right from Visual Studio 2005, 2008, 2010 and 2012.
If your solution is opened in Visual Studio during your profiling session, you can instantly navigate from dotTrace code preview area to the corresponding code file in Visual Studio.
Profiling unit tests
If you have ReSharper installed in Visual Studio, you can easily start profiling unit tests from the code editor or ReSharper's unit test runner.
Even if you don't have ReSharper installed, you can still profile a native unit test runner provided by NUnit, MSTest, or xUnit.
Local or remote profiling
Most of the time, you're profiling local applicaitons. However, what if you're faced with a lagging application on a remote web server?
No worries: dotTrace Performance Professional Edition can connect to a remote machine to profile a standalone or web application, or a Windows service. You don't even have to install dotTrace there — just copy a couple of files.
Server-scale snapshot support
dotTrace Performance is able to profile huge applications and get snapshots of up to several hundred gigabytes in size while still working at acceptable speed. That means, you can use dotTrace Performance to profile complex desktop and server applications.
Convenient data representation
A number of informative views (Call Tree, Hot Spots, Threads Tree and more) allow insightful examination of profiling results. The importance of each function call is represented with descriptive icons, along with precise execution times and other relevant information. You can open functions in individual tabs, easily navigate views with keyboard shortcuts, and focus on relevant calls.
During performance analysis, you may want to leave a comment about a function and its behavior. dotTrace Performance provides textual annotations for functions that are saved with the snapshot and can be reviewed later.
Search and navigation
You can quickly locate functions and navigate to their calls. When searching for a function, you can type in its abbreviated name using CamelHumps, just like you do in ReSharper.
You can highlight all function occurrences in the current view and then navigate between them with a simple press of a key.
Code preview options
dotTrace Performance provides a code preview area where you can see source code or decompiled code for the currently highlighted function call.
Source code can be reconstructed from local PDB files or via symbol servers: for example, by connecting the profiler to Microsoft Reference Source Server, you can preview the source code of .NET Framework when you analyze the behaviour of library code in your snapshot. You can also choose to show preview of IL code instead of source code.
If source code is not available, dotTrace Performance can still decompile function code for your quick review.
Estimation of performance gains
Sometimes, after hours of optimizing a time-consuming function, developers are forced to start profiling from scratch to see if their optimization actually worked.
This is not a problem anymore. dotTrace Performance can recalculate all function timings in a snapshot instantly, based on a time adjustment that you set — without reprofiling your application. It's like asking the profiler: "what if I optimize this function by 40%?" Just specify the new time for a function or for all functions in a particular class. Time values for the entire snapshots will be recalculated.
dotTrace Performance is able to compare any two performance snapshots of the same application. It generates a comparison snapshot which shows the difference in the number of calls and times consumed by each function. Comparison snapshots can be viewed and analyzed the same way as regular performance snapshots.
dotTrace Performance provides Profiling SDK for enabling custom profiling scenarios in your applications. SDK allows an application to profile itself and gather performance metrics for future analysis.
Quick function info
You can look up function statistics from different views that dotTrace Performance provides. The lookup window provides a summary of function information with, such as number of calls, and time taken by calls.
Filtering and formatting
dotTrace Performance lets you hide irrelevant functions from a snapshot and highlight important ones. Filter out system calls and other non-essential functions with a combination of different filters. To emphasize important functions or classes of functions, use custom formatting rules.
In addition to filtering and formatting, dotTrace Performance provides a few more options to focus on the most relevant profiling results. For example, you can:
- Hide functions that take 0% of root time
You can hide functions that only call other functions but don't do any calculation on their own.
- Fold filtered calls
Chains of filtered calls can be set to be folded by default or folded/unfolded manually.
- Fold recursive calls
Recursive call chains can be folded to display the aggregate timings and call counts of all functions called recursively.
Any .NET Framework version
With dotTrace Memory, you can quickly profile the memory usage of your applications based on .NET Framework up to version 3.5. Profiling results are presented in the form of memory snapshots, allowing thorough analysis of memory issues.
Memory profiling modes
To check what objects are currently loaded in memory (but shouldn't be), you can dump memory at any time during profiling.
To view the difference between two application memory states, you can mark the start and the end of a time interval, then capture a difference snapshot which shows how much memory was allocated and released during the marked time interval. The view can be filtered to show only live, new, or dead objects, or the difference between new and dead objects.
Convenient data representation
Each memory snapshot holds a wealth of data on all objects allocated in memory, from the roots to every single object allocated or deleted at any time during your profiling session.
Several views are available to help you examine and analyze memory snapshots, including Class list, Namespace tree, Outgoing references, Shortest root path, and Allocation tree. You can also focus on any subsystem of your application by opening it in a separate tab.
Merging connected objects
When you are navigating though the graph of objects in memory, some dependencies are difficult to see at a glance. dotTrace Memory offers an easy way to merge (group) strongly-connected objects together, so that you can see which objects and/or groups any particular node is holding.
Find objects by class
To help you locate the presence of particular class of objects in memory, dotTrace provides the rapid Find objects by class (Ctrl+N) search feature. The use of wildcards and CamelCase abbreviations is supported for faster search results.
dotTrace Memory lets you see finalized objects — that is, objects deleted by the finalizer. You can examine them to find that some were not properly disposed of in the code of your application, which is a potential memory leak.