YourKit Profiler provides zero-overhead profiling for your .NET applications and
makes code profiling and memory usage optimization simple and fast.
- Fastest code profiling for locating bottlenecks and solving application
performance problems
- Real-time, live performance metrics with graphs, stacks and threads
- Memory profiling for optimizing memory usage and discovering memory leaks
- Profiles all types of .NET applications, including standalone .NET applications,
.NET web services, .NET Windows services, .NET DCOM objects, ASP.NET and more
- Supports:
- All .NET frameworks, including 1.x, 2.0 and 3.x
- Microsoft Vista, XP, 2003 Server and 2000
- 32-bit and 64-bit systems
- Tight integration with Microsoft Visual Studio 2003, 2005, and 2008
- User-friendly interface provides results that are easy to interpret
- Smart tools for locating problems automatically
- On-demand profiling lets you profile only when needed to ensure lowest overhead
Features
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
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.
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.
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, captured snapshots, 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.
Telemetry information can be saved to a file and later re-opened in the profiler
UI.
Integration with Microsoft Visual Studio
When profiling applications, you usually need to browse to the related source
code to understand the root of a performance problem. When it is found and
located, you edit the source code to fix it.
Instead of forcing you to tell profiler where the source code of your
application is located and showing the code in a feature-limited home-made
editor surrogate, YourKit provides an alternative approach. When you have a
method, class or field selected in the profiler UI, just click Tools | Open
Declaration in Visual Studio (F7) to automatically open the underlying source
code in the VS editor - the best place to browse and edit the code.
This navigation action always works on the current selection and is available in
both CPU and memory views.
Easy launching of profiled applications
When profiling is enabled (it is so by default after you install the profiler),
simply start the application you wish to profile the way you usually do.
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.
Remote profiling
Snapshot captured on remote host can be automatically transferred via network to
the local machine.
Furthermore, a list of recent values (history) is available to simplify
profiling of e.g. the same server.
Ability to export profiling results
Export all reports and data easily to HTML. "File | Export to HTML..." action
works in all views (except for telemetry view which has its own save
capability).
"File | Copy To Clipboard..." (Ctrl+C shortcut) action copies text of selected
row in all trees and lists.
Two methods of CPU profiling: sampling and tracing
Sampling is the best choice in most cases to locate and discover performance
bottlenecks. With sampling, the profiler adds virtually no overhead to the
profiled application. With sampling, no method invocation counts are available.
Tracing provides times and invocation counts, but in general it is slower than
sampling. To control tracing overhead, runtime filters are used.
CPU views: hot spots, method call tree and method list
CPU view ("View | CPU") shows CPU consumption details.
'Call tree (all threads together)' section shows top-down call tree with all
threads merged.
'Call tree (by thread)' section shows top-down call tree for each thread.
'Hot spots' shows methods that consumed the most of CPU time.
'Method list' for each method shows its CPU time, own CPU time and, if recorded,
invocation count.
Unique "Merged callees" view
Quickly gain knowledge about behavior of a certain method. The view 'Merged
callees' 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.
Method back traces view
'Back traces' shows all places in code where a certain method was called.
Action "View | Method Back Traces" opens this view for the currently selected
method.
Unique comprehensive Objects view
"Objects view" allows comprehensively examine all objects in snapshot or certain
subset of objects.
Innovative 'Biggest objects' view automatically finds individual objects that
retain most of memory. Save time and find the largest problems quickly.
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 tree' is a powerful tool for examining how memory is distributed
between instances of different classes. The benefit of the view is that
information about instances is grouped by namespaces and classes.
This view provides instant feedback about which subsystem of the profiled
application is consuming the most of the memory, causing memory leaks etc.
Since namespaces usually represent subsystems, the good measure of memory
retained by subsystem is the memory retained by objects of classes that belong
to subsystem's namespace.
'Class list' shows number and shallow sizes for objects of all or only
particular classes matching a pattern.
'Outgoing references' shows all objects of the set and allows to browse their
outgoing references. Outgoing references of an object are fields or array
elements of that 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.
Easy way to browse instances of particular class
Use "View | Instances by Class..." 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.
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.
Find strings that match given pattern
"Find | Strings by Pattern... (Ctrl+F)" action shows instances of
System.Stringthat match given pattern. The strings 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.
Quick Info" action
View | Quick Info (Ctrl+Q)" action shows retained and shallow size and object
count for the current selection.
Ability to compare memory snapshots
With YourKit Profiler, you can compare memory snapshot with another memory
snapshot captured during the same launch of profiled application.
It helps locating memory leaks.