Features
 
 
 
.NET Profiler Features
General
Thread issues
Memory profiling
CPU profiling
Exception profiling
Garbage collection profiling
Integration with Visual Studio

On demand profiling

Many existing profilers are very heavyweight and cannot be run in production, but only doing testing. And there is a cumbersome process of running the application within the profiler.

Effectively running a profiling tool that has high overhead causes a large amount of problems, as it can often take hours to properly get the tool to a point in a project where the failure presents itself.

YourKit Profiler optimizes the process by profiling where, when and what is needed.

YourKit Profiler streamlines the memory profiling process is so lightweight that it can be considered "zero overhead".


Easiest installation and configuration

In our view, profiling should be non-intrusive and very easy to use. During today's fast track development, this is an invaluable to allow developers to seamlessly integrate profiling into development process.

The profiling can be done at the will of the developer, at any point during an applications run time. This allows for a much lower impact on system resources, lower time consumption, and a more precise profiling of the application.

No need for cumbersome installations and separate run processes like traditional profilers.


Unlimited profiling for one fee

License allows running of an unlimited number of .NET applications with the profiler agent in development, testing or production stages.


ASP.NET support

Profile web applications running on IIS with the help of "File | Profile ASP.NET Application".


Ability to profile in production environment

Extremely low overhead allows production code profiling.

If profiled code is obfuscated, profiler can automatically restore the original names of classes and fields. Currently, we support Dotfuscator.


Easy launching of profiled applications

Start the profiler and choose corresponding item on the Welcome screen.

The profiler will show all detected locally running profiled applications on the Welcome screen. Start obtaining profiling results with a single click!

Read more about profiling local applications

Read about profiling remote applications


32-bit and 64-bit Framework support

Both 32-bit and 64-bit .NET Frameworks are supported


Telemetry

This feature allows viewing key information about an application in runtime within live graphs, providing details about memory, garbage collection activity, loaded classes, threads, as well as CLR and OS information.

Very useful and unique feature is that the telemetry information is remembered inside the profiler agent. This allows to connect to profiled application on demand, being able to discover how the application has behaved in the past.

When you are connected to profiled application, find telemetry tabs on the session panel.

CPU telemetry

Memory telemetry

GC telemetry

Exception telemetry

Summary tab


Automated profiling: profiler API, triggers, command line tool

The profiler offers several options to profile automatically, without human interaction and/or without using the profiler UI:

  • Profiler API allows to programmatically switch profiling modes and to store profiling results
  • Triggers allow you to configure actions to be automatically performed on following events:

    • high CPU usage
    • high memory usage
    • timer

    The possible actions include:

    • log events to console, file, agent log
    • control profiling
    • capture snapshots
  • Command line tool can be used to control profiling without using the profiler UI, e.g. in case of profiling a remote server

Filters in CPU and memory views

Filters can be used in YourKit Profiler to reduce the depth of call trees. By skipping successive calls of e.g. standard library methods, you can give more focus to problematic methods of profiled application.

Filters are applied to views where method call stacks are shown, as well as to hot spot and method list views. With same snapshot you can use different filters or use no filters at all - you do not need to start a new profiling session for such a change. Views are automatically updated when filter settings are changed.

Use "Settings | Filters..." to configure filters.

Filters are used in runtime as well to reduce CPU tracing overhead.

See corresponding help topic for more details.


Improved learnability

It's easier for newbies to discover the power of the profiler thanks to the following features.

Hint panel provides direct links to context-related Help topics.

Innovative master-slave view concept allows to see key information on a single screen.

This feature greatly improves usability.

For example, when a method is selected in upper table, you can immediately see back traces or merged callees in the slave view below.

Another example: in memory views immediately see paths from GC roots:


Remote profiling

YourKit Profiler provides an ability to profile applications remotely, i.e. in case the profiled application and the profiler UI run on different machines. For example, this is much useful when profiling a remote IIS server from your workstation.

Snapshot captured on remote host can be automatically transferred via network to the local machine.

Read more about profiling remote applications


Ability to export profiling results

You can export profiling results to external formats such as HTML, CSV, XML, plain text, either from within the profiler UI or automatically by using a command line tool.

Also, "File | Copy To Clipboard..." (Ctrl+C or another platform specific shortcut) action copies text of selected row in all trees and lists.


Summary, snapshot annotation and automatic deobfuscation

The "Summary" tab provides an overview of runtime properties and parameters of profiled application, as well as a summary of application telemetry information.

Automatic deobfuscation

If the profiled application is obfuscated, YourKit Profiler can automatically restore original names of classes, fields and methods if you specify the path to the obfuscation log file.

Snapshot annotation

The "Summary" view for a snapshot lets you store free-form text descriptions directly in the snapshot file.

See corresponding help topic for more details.


CPU telemetry

The "CPU" tab shows live CPU usage telemetry charts.

Also, you can learn what application was doing at particular moments of time with the help of thread stack traces available in telemetry graphs. This is extremely useful analyzing CPU or other resource consumption peaks that have already happened, without CPU profiling (sampling, tracing) turned on. However, this is not a replacement of CPU profiling when you need most accurate and detailed results.

When profiling is started, the profiling results are immediately available as a call tree with threads merged, as well as method list:

This live view provides only basic information. To perform comprehensive analysis capture performance snapshot.

Read more about CPU profiling.


Sampling and tracing

You can choose either of the two available measurement modes: sampling or tracing.

When sampling is used, the profiler periodically queries stacks of running threads to estimate the slowest parts of the code.

Sampling is typically the best option when your goal is to locate and discover performance bottlenecks. With sampling, the profiler adds virtually no overhead to the profiled application.

When tracing is used, the profiler instruments the bytecode of the profiled application for recording thread CPU time spent inside each profiled method. Both times and invocation counts are available.

Read more about CPU profiling.


CPU views: hot spots, method call tree and method list

CPU view ("View | CPU") shows CPU consumption details.

  • "Call tree (all threads together)" shows top-down call tree with all threads merged:

  • "Call tree (by thread)" shows top-down call tree for each thread:

  • "Hot spots" shows methods that consumed the most of CPU time:

  • "Method list" shows each method's CPU time, own CPU time and, if recorded, invocation count:

Read more about CPU view.


"Callees list" view

"Callees list" view shows which methods were called from certain methods. It is available as a slave view in call tree, hot spots and method list:

See corresponding help topic for more details.


"Merged callees" view

Quickly gain knowledge about behavior of a certain method. The "Merged callees" view shows merged call traces started from the method. This gives a summary of method execution, of its "overall" behavior.

Action "View | Method Merged Callees" opens this view for the currently selected method.

See corresponding help topic for more details.


Method back traces view

"Back traces" view shows all places in code where a certain method was called.

Action "View | Method Back Traces" opens this view for the currently selected method.

See corresponding help topic for more details.


Ability to compare CPU snapshots

With YourKit Profiler, you can compare two arbitrary CPU snapshots.

See corresponding help topic for more details.


Thread telemetry

Use tab Threads to track the live threads.


Memory telemetry

  • The "Memory" tab shows live memory usage statistics:
  • The bottom table on "Memory" tab provides a class instance count statistics - a quick overview of current heap state:

This view provides only basic information. To perform comprehensive analysis capture memory snapshot.

See corresponding help topic for more details.


Unique comprehensive objects view

Objects view allows comprehensively examine all objects in snapshot or certain subset of objects.

"Biggest objects (dominators)" view shows individual objects that retain most of memory. Save time and find the largest problems quickly. The objects are shown as a dominator tree. Read more...

This information can be useful to understand and reduce memory usage. In particular, this is useful to find memory leaks caused by individual objects. Sometimes it can be educative to learn about memory distribution in terms of individual objects.

Unique "Class list" view is a powerful tool for examining how memory is distributed among instances of different classes.

This view provides instant feedback about which classes of the profiled application are consuming the most of the memory, causing memory leaks etc.

Classes whose objects retain most memory are shown at the top, as the list is sorted by retained size.

On opening the view, estimated retained sizes are shown instead of exact sizes, which cannot be immediately calculated. The exact sizes may be obtained by using "Calculate exact retained sizes" balloon above the "Retained Size" column. However, for most classes the estimation is very close to the exact value, so there is almost no need to run exact size calculation.

"Merged paths" view is a tool for examining how objects are retained. It is especially useful when analyzing objects of classes with big number of instances, such as int[] or System.String etc.

"Merged paths" is similar to "Paths from GC roots" view, but unlike it shows not paths through individual objects, but paths from multiple objects grouped by class.

"Object explorer" shows all objects of the set and allows to browse their outgoing references. Outgoing references of an object are fields or array elements of the object that point to other objects.

"Incoming references" shows all objects of the set and allows to browse their incoming references. Incoming references of an object are references to that object.

"Modules" shows objects grouped by module, i.e. DLL or EXE where their classes have been declared. This helps to estimate memory usage by library.

See corresponding help topic for more details.


Easy way to browse instances of particular class

Use "Memory | Instances by Class..." (Ctrl+N) action to browse all instances of particular class. It is also very useful when you want to check whether instances of certain class exist or not.

The camel humps notation is supported.


"Find Paths" helps to find reasons of memory leaks

YourKit Profiler has unique and very powerful means for memory leak detection - calculation of paths between objects in memory. To find the reason of the leak examine path from GC roots to a leaked object.

You can choose number of shown paths from the list above the view.

See corresponding help topic for more details.


Find objects by text pattern

"Memory | Strings by Pattern... (Ctrl+F)" action shows instances of System.String, Char[] and Byte[]/SByte[] that match given text pattern. The objects can be found in entire snapshot or in custom objects set. This can be useful to locate particular objects if their fields refer to a known string.


Optional recording of object allocations

The profiler can optionally record object allocations, i.e. track method call stacks where objects are created. Since recording of allocations can impact performance of application being profiled, you can turn this mode on only for the periods when it is needed.

Object allocation recording is used to find sources of excessive garbage allocation and analyze where live objects are created.

If allocations are recorded, Objects view will appear with additional sections.

"Call tree (all threads together)" section shows top-down call tree with methods where objects from the set were created. Calls from all threads are merged.

"Call tree (by thread)" section shows a per-thread top-down call trees with methods where objects from the set were created.

"Hot spots by object count" section shows methods where biggest number of objects was created.

"Hot spots by object size" section shows methods where objects with biggest total shallow size were created.

"Method list" for each method shows the number and shallow size of objects it had created.

The Garbage Collection view is a good starting point to search for excessive garbage allocation. It shows numbers and shallow sizes of collected objects, i.e. objects created since object allocation recording was started and recycled to the moment of snapshot capture. See Solving performance problems to learn more why one should avoid excessive garbage allocation.

See corresponding help topic for more details.


Automatic inspections

Typical problems can be recognized with the help of the "Inspections" feature. Inspections enable automatic high-level analysis of profiled application snapshots. Each inspection automatically detects a specific issue. Performing this type of analysis by hand would be a very complicated (if at all possible) task.

See corresponding help topic for details.


Object generations

All tabs representing live objects have "Generations" view. In this view, you get objects separated by .NET Framework garbage collector generations:

See corresponding help topic for details.


"Quick Info" view

"Quick Info" view shows useful information about selected object(s), such as:

  • Retained and shallow size
  • Object count
  • Allocation trace, if available
  • Object generation information, if available
  • Primitive array elements

Ability to compare memory snapshots

With YourKit Profiler for .NET, you can compare two arbitrary memory snapshots.

See corresponding help topic for more details.


Values of primitive types

Primitive fields (System.Int32, System.Boolean, System.Double etc.) and primitive array elements are shown in object explorers:

For byte arrays (Byte[] and SByte[]) Quick Info shows text representation in specified encoding:


Exception telemetry

"Exceptions" telemetry shows exceptions which were thrown in the profiled application.

See corresponding help topic for more details.


Garbage collection profiling

"Garbage Collection" telemetry will help you estimate garbage collector load.

See corresponding help topic for more details.


Integration with Microsoft Visual Studio

Easily open source code of profiling results in Visual Studio editor.


Read more...