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 Java Profiler optimizes the process by profiling where, when and what is needed. CPU profiling adds no performance overhead to the application being profiled until profiling is explicitly started. You can start and stop CPU profiling during execution of Java application as many times as you wish.

YourKit Java Profiler streamlines the memory profiling process by making object allocation monitoring an option. This greatly reduces the amount of system resources needed to profile an application, and increases the overall performance and speed of the profiling job in general. It 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

Commercial license allows running of an unlimited number of Java applications with the profiler agent in development, testing or production stages.

J2EE support

Action "Tools | Integrate with J2EE Server..." automatically enables profiling in a number of popular application servers. The wizard supports:

• Tomcat
• Tomcat 6
• WebLogic 7.x/8.x
• WebLogic 9.x
• WebLogic 10
• JBoss
• JRun
• Resin
• Orion
• Sun Java System Application Server (previously named SunONE) 7.x/8.x
• Sun Java System Application Server 9.x (GlassFish)
• Apache Geronimo
• Oracle Application Server 10g
• Jetty (Java HTTP Server and Servlet Container)
• IBM WebSphere Application Server 6.1

Many other servers can be easily profiled with some minor manual configuration.

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, methods and fields. Currently, we support RetroGuard and Zelix KlassMaster.

Java 5 support

If profiled application runs on Java 5, YourKit Java Profiler uses new profiling capabilities introduced in Java 5. The profiler benefits from using new JVMTI API, allowing for analysis of very large memory heaps and leading to increased stability when profiling large projects.

Full Java 6 support

If profiled application runs on Java 6, YourKit Java Profiler uses new profiling capabilities introduced in Java 6:

• Memory snapshot is captured automatically on OutOfMemoryError
• Native methods are included in CPU profiling results
• Lengths of arrays are exact in memory snapshots

Rich multiplatform support

Both YourKit Java Profiler and the profiled application can run on the following platforms:

• Windows NT/2000/2003/XP/Vista, 32-bit Java and 64-bit Java (AMD64)
• Linux, 32-bit Java (x86) and 64-bit Java (AMD64)
• Mac OS X 10.4 and newer/10.5 (PPC and Intel)
• Solaris SPARC, 32-bit and 64-bit Java
• Solaris 10 x86, 32-bit and 64-bit Java

It is even possible to have 'mixed' configurations.

For example, you can start profiler on a Windows desktop and profile server running Linux or any combination thereof.

Supported Java vendors:

At the moment, the profiler supports profiling on:

• Sun Java: versions 1.3, 1.4, 5 and 6
• BEA JRockit 5 (read about known issues)
• IBM Java 5 SR1 and newer (see comments...)

64-bit Java support

64-bit Java is supported on Windows (AMD64), Linux (AMD64), Solaris SPARC and Solaris 10 x86.

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 and deadlocks, captured snapshots, as well as JVM 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:

• The "CPU" tab shows live CPU consumption statistics:
  [open in new window]
• When the profiling is started, the bottom table on "CPU" tab shows top-down call tree with calls from all threads merged:
  [open in new window]

Memory telemetry:

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

GC telemetry

[open in new window]

Automatic deadlock detection

Profiler API

Our Profiler API allows users to integrate YourKit Java Profiler programmatically. Create extra value by integrating memory and CPU utilization profiling ability into your application.

See corresponding help topic for more details.

IDE integration

IDE integration provides:

Ability to launch profiled applications from within the IDE thus making CPU and memory optimization a part of your development process

Easy navigation from profiling results to underlying source code of profiled application -- "Tools | Open Declaration in IDE Editor (F7)" action opens currently selected class, field or method in IDE editor

Supported IDEs:

Eclipse 3.2/3.3 (read more)

IntelliJ IDEA 4.5/5.x/6.0/7.0 (read more)

NetBeans 5.0/5.5/6.0 (read more)

JBuilder 7/8/9/X/2005/2006 (read more)

JDeveloper 10g (read more)

When profiled application is launched from IDE, the profiler UI automatically opens and connects to the application (If found obtrusive, this option can be turned off from plugin UI)

If profiled application launched from IDE ends quickly, the profiler UI will anyway show the application's profiling results.

Filters in CPU and memory views

Filters can be used in YourKit Java 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.

Custom user interface

On Windows and Mac OS X, the profiler uses your current desktop settings for fonts and current browser, providing consistent interface out of the box.

On Linux and Solaris, where the desktop settings cannot be automatically retrieved, you can adjust them via "Settings | User Interface..." action, available on these platforms.

Easy way to connect to running applications

Click link "Connect to locally running profiled applications..." on the "Welcome" screen to choose profiled application from list.

Remote profiled applications, started with default settings, can be connected given host only. This dramatically simplifies connection, avoiding necessity to find out and manually specify port number as well.

See corresponding help topic for more details.

Welcome screen

Welcome screen is a good starting point to begin work with profiler.

Improved learnability

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

Context-related hints give short description and explain purpose of each of the profiling views:

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.

[open in new window]

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

[open in new window]

"Useful actions" shows some useful actions available in current context (note that each of the actions is also available in main or popup menu):

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.

See corresponding help topic for more details.

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 or another platform specific shortcut) action copies text of selected row in all trees and lists.

General snapshot info and deobfuscator configuration

New in version 7.0: Get general information about snapshot or, if needed, configure automatic deobfuscation (1) to easily recover names of classes, fields and methods, in the "Summary" view:

The "Summary" view for allows to store free-form text descriptions directly in snapshot file (2).

See corresponding help topic for more details.

Improved CPU profiling

CPU profiling has been greatly improved in version 7.0:

• live CPU profiling results
• CPU tracing overhead reduced
• dramatically improved quality of profiling results on Linux and Mac OS X
• ...and other changes

Read more about CPU profiling

Live CPU profiling results

New in version 7.0: When the profiling is started, the bottom table on "CPU" telemetry tab shows top-down call tree with calls from all threads merged:

[open in new window]

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

Read more about CPU profiling

J2EE high-level profiling

YourKit Java Profiler provides means for profiling J2EE applications in high-level terms like SQL statements and URLs.

Execution time and invocation counts are available for particular SQL and HTTP queries.

'SQL' section shows list of SQL statements and back traces for all methods invoked with these statements.

[open in new window]

'JSPs and Servlets' section shows list of URLs, corresponding to JSPs and Servlets calls, and merged callees for all methods invoked with these URLs.

[open in new window]

'JNDI' section shows list of URLs, corresponding to JNDI calls, and back traces for all methods invoked with these URLs.

[open in new window]

See corresponding help topic for more details.

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.

[open in new window]

'Call tree (by thread)' section shows top-down call tree for each thread.

[open in new window]

'Hot spots' shows methods that consumed the most of CPU time.

[open in new window]

'Method list' for each method shows its CPU time, own CPU time and, if recorded, invocation count.

[open in new window]

See corresponding help topic for more details.

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.

[open in new window]

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' shows all places in code where a certain method was called.

[open in new window]

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 Java Profiler, you can compare two arbitrary CPU snapshots.

[open in new window]

See corresponding help topic for more details.

Threads and deadlocks

When you are connected to profiled application, use tab "Threads and Deadlocks" to track the live threads.

[open in new window]

Automatic deadlock detection

If a Java-level deadlock happens in the profiled application, it will be automatically detected:

See corresponding help topic for more details.

Monitor profiling

New in version 7.0: Monitor profiling allows analysis of synchronization issues:

• which threads were calling wait(), and for how long
• which threads were blocked on attempt to aquire monitor held by another thread (synchronized methods/blocks), and for how long

Monitor profiling results are shown in the "Monitor Usage" view. Results can be grouped by waiting thread, by blocker thread and by monitor class name.

[open in new window]

See corresponding help topic for more details.

Live memory profiling results

New in version 7.0: When you are connected to profiled application, the "Memory" tab provides immediate class instance count statistics:

[open in new window]

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' 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.

[open in new window]

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.

With the help of "Class list" you can find classes whose objects retain most of memory, in one click. Use the balloon above the "Retained Size" column to start calculation. After calculation the classes will be sorted by retained size in descending order.

[open in new window]

'Class tree' view is a tool for examining how memory is distributed among instances of different classes grouped by packages.

[open in new window]

'Merged paths' view is a tool for examining how objects are retained. It is especially useful analyzing objects of classes with big number of instances, such as int[] or java.lang.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.

For example, see the picture below. The 'Merged paths' view shows that the memory hold by int[] instances is mostly retained by VelocityCharStream instances, which in their turn are retained by Parser and ParserTokenManager.

[open in new window]

'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.

See corresponding help topic for more details.

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.

The camel humps notation is supported.

"Find Paths" helps to find reasons of memory leaks

YourKit Java 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.

[open in new window]

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

You can also find paths between defined sets of objects.

See corresponding help topic for more details.

Find strings that match given pattern

"Memory | Strings by Pattern... (Ctrl+F)" action shows instances of java.lang.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.

[open in new window]

[open in new window]

Optional recording of object allocations

YourKit Java 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 allocations can be recorded adaptively, skipping allocation events for some percent of objects in order to keep moderate overhead. Adaptive recording is especially useful profiling excessive garbage allocation. It allows finding garbage allocation hot spots with the same efficiency as if all object allocations were recorded, whereas profiling overhead is dramatically smaller.

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.

[open in new window]

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

[open in new window]

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

[open in new window]

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

[open in new window]

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

[open in new window]

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 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.

[open in new window]

See corresponding help topic for more details.

Automatic inspections

New in version 7.0: Share experience of typical memory related problems recognition with the help of the "Inspections" feature, which provides means for automatic high level analysis of application memory. Each inspection automatically detects specific memory oddities. Doing such analysis by hand would be a very complicated (if ever possible) task.

With the help of inspections you can easily find causes and possible solutions of usual memory related problems:

• "Duplicate Strings"
• "Null Fields"
• "Self Referencing Objects"
• "Classes without Instances": results are grouped by class loader. One of intended usages is finding orphaned class loaders.
• "Sparse Arrays"
• "Highly Referenced Objects"
• "Classes without Instances"
• "Zero Length Arrays" finds if there are large numbers of zero length arrays of same type
• "Objects Retained by Inner Classes" finds objects only referenced via inner class synthetic backpointers (easy to do this unintentionally, and may cause leak)

"Inspections" view is added to any tab representing objects, such as "All Objects" or any subset. Inspections for all objects (i.e. for the entire snapshot) are also available via top-level tab "Inspections'.

[open in new window]

See corresponding help topic for details.

Object Generations

New in version 7.0: The generations distribute objects by time of their creation, and thus they are very helpful finding memory leaks and doing other analysis of how heap content evolves in time.

When each object is created, it is associated with current generation number. The generation represents object's age: the smaller the generation number, the older the object.

All tabs representing live objects have "Generations" view. In this view, you get objects separated by time of their creation:

[open in new window]

See corresponding help topic for details.

Dead objects view

New in version 7.0: "Dead objects" shows objects that are not accessible from GC roots but still present in snapshot (i.e. not collected yet). The view can be used to analyze excessive garbage allocation, especially if the snapshot doesn't contain recorded object allocation information.

[open in new window]

See corresponding help topic for details.

"Quick Info" action

"View | Quick Info (Ctrl+Q)" action shows retained and shallow size and object count for the current selection. If a single object is selected, its allocation trace is also shown if available.

Also stack traces will be shown if there are local variables referencing to this object. If corresponding debug info is available, the names of these variables will be shown too.

New in version 7.0: If object generation information is available it will be shown as well.

Ability to automatically capture memory snapshots

You can instruct the profiler to trigger capturing of memory snapshots.

There are 3 kinds of triggers available:

• Capture snapshot on low memory
• Capture on OutOfMemoryError
• Capture snapshots periodically

The triggers can be set up and later altered during profiled application run time.

When triggered memory snapshot is captured notification is shown in UI:

See corresponding help topic for more details.

Ability to compare memory snapshots

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

[open in new window]

See corresponding help topic for more details.

Unique descriptive language for memory analysis

YourKit's descriptive XML based language allows users to declare custom sets of objects in order to find memory leaks and examine memory distribution.

[open in new window]

See corresponding help topic for more details.

Automated comprehensive memory tests

The descriptive language for memory analysis and profiler API allow to write comprehensive memory tests.

Support of HPROF format snapshots

Java has a built-in feature - under certain circumstances, to save memory dumps into files in so-called HPROF format. You can analyze these files using all of the powerful features that YourKit Java Profiler provides for its own memory snapshots.

HPROF format memory dumps can be created in the following ways:

• On OutOfMemory
• Explicitly from within the profler UI (Java 6)

  

• Explicitly via jmap utility (Java 6)
• Explicitly via jconsole utility (Java 6)

See corresponding help topic for more details.

Values of primitive types

Values of primitive fields are shown in object explorers

Values of primitive type arrays are shown in "Memory | Quick Info (Ctrl+Q)"

See corresponding help topic for more details.