dotTrace™ Memory

dotTrace is shipped as two separate products for performance and memory profiling: dotTrace 4 Performance and dotTrace 3.5 Memory.

 

Performance Profiling

Top-class technology support

dotTrace Performance provides a fast way to profile the performance of .NET applications based on .NET Framework 1.x to 4.0, .NET Compact Framework 3.5, and Silverlight 4.

Types of applications that dotTrace Performance is able to profile include standalone desktop applications, web applications running under IIS or Visual Studio development server, Windows services, smart device applications, remote applications, and unit tests.

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 for profiling complex desktop and server applications.

Versatile profiling modes

dotTrace Performance enables you to choose between several performance profiling modes:

  • Tracing profiling is a very accurate way of profiling that involves getting notifications from CLR whenever a function is entered or left. The time between these two notifications is taken as the execution time of the function. Tracing profiling helps you learn precise timing information and the number of calls on the function level.
  • Sampling profiling is a profiling method which is up to 30 times faster than tracing profiling, but at the expense of lower accuracy. It is extremely useful for at least two profiling scenarios: first, quickly getting a general idea of your application's performance, and second, profiling for extensive periods of time, up to many hours long.
  • Line-by-line profiling collects timing information for every statement in functions that have source code available. This lets you collect the most detailed information about functions that perform significant algorithmic work. You can specify exactly which functions you want to be profiled line-by-line or profile all functions for which dotTrace Performance is able to locate symbol information.

In addition, dotTrace Performance provides a 'High Accuracy' flag to account for the time spent inside the profiler. When every millisecond counts, dotTrace pays attention!

Local or remote profiling

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.

Convenient data representation

A number of informative views (Call TreeHot SpotsThreads Tree and more) allow convenient inspection of profiling data stored in snapshots. 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, focus on relevant calls, and create profiling reports by saving views to an external file.

Convenient data representation 
Instant estimation of performance gains

Instant estimation (Adjust Time)

Sometimes during profiling sessions you notice that your application is running slow or hanging, only to realize that you have failed to turn off a debug switch. After that, you have to reprofile everything.

Other times, after hours of continuous profiling, you optimize a time-consuming method, and again, you have to start from scratch to see if the optimization actually works.

dotTrace Performance comes to the rescue! It is able to recalculate a snapshot instantly — without reprofiling your application. It's like asking the profiler: "what if I optimize this function by 40%?". Just call Edit | Adjust Time and specify the new time for the function or for all functions in a particular class. Time values for the entire snapshots will be recalculated.

Comparing performance snapshots

dotTrace Performance is able to compare any two performance snapshots of the same application. It generates a comparison snapshotwhich 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.

Performance snapshot comparison 
Quick function info

Quick Info

You can look up Quick Info on any function from the Call Tree view. The lookup window provides a summary of function statistics with respect to the selected call and to all calls in the current tab.

Filtering and formatting

dotTrace Performance lets you hide functions of little importance from a snapshot and highlight those that really make a difference. 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.

Formatting important functions 
Folding calls

In addition to filtering and formatting, dotTrace Performance provides a few more options to focus on the most relevant profiling results.

  • 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:

    Folding recursive calls
Annotating snapshots

Textual annotations

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 navigate to function calls

You can quickly locate functions and navigate to them. When searching for a function, you can type in the function name using CamelHumps, just like you do in ReSharper.

Find function

You can highlight all occurrences of the function in the current view and then navigate between them with a simple press of a key:

Navigate to function occurrences 
Visual Studio integration and source code preview

dotTrace Performance provides a two-way integration with Visual Studio 2005, 2008, and 2010, allowing you to profile your applications right from the IDE, or view suspicious source code right from the profiler (and open it in Visual Studio for editing.)

Run dotTrace Performance from Visual Studio: With a single button click, you can launch profiling or your startup project directly from Visual Studio. In addition, if you have ReSharper installed in your Visual Studio, you can easily start profiling unit tests from the code editor.

dotTrace menu in Visual Studio
Open a file from dotTrace Performance in Visual Studio — if your solution is opened in Visual Studio, you can click a button in thePreview Source tab to navigate to the corresponding source file in Visual Studio.

screenshot
 

Memory Profiling

With dotTrace Memory, you can quickly profile the memory usage of your applications based on .NET Framework up to version 4. The profiling process is not only simple but fast. A wealth of profiling data is accurately recorded and presented in the form of memory snapshots, allowing thorough analysis of memory issues.
Versatile memory profiling modes

Depending on your needs, you can profile memory in two different ways:

  • To check what objects are currently loaded in memory (but shouldn't be), you can dump memory at any time during profiling.
  • To also view the difference between two application memory states, during profiling you can mark the start and the end of a time interval, then capture a snapshot containing the difference data. A difference snapshot lets you see how much new memory was allocated and how much was released during the marked time interval. The view can be filtered to show only Live objects, only Newobjects, only Dead objects, only Garbage objects, or the difference between New and Dead objects.
View difference between application memory states 
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 the profiling session.

A number of views are available to you for examining and analyzing memory snapshots, including Class ListNamespace Tree, Outgoing referencesShortest root path, and Allocation Tree.You can also focus on any subsystem of your application by opening it in a separate tab.

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.

Find objects by class 
Finalized objects

dotTrace Memory lets you see finalized objects — objects which were 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.

Finalized objects 
Merging strongly-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.

Merging strongly-connected objects 
 
Our Services
'Modern Software security protection Processes for any content'
Our Protection studio is easy to use. Protect your software with.
Cloud Network Performance Management
Specializing on these core areas are the most potential and emerging technologies that can keep the industry moving.