Products
 
 
 
Fully featured low overhead profiler for Java EE
and Java SE platforms.
Easy to use performance and memory profiler for .NET framework.
Supports ASP.NET, Silverlight, .NET Windows services and more.
Early Access Program

YourKit Early Access Program (EAP) is the easiest way to get in touch with the latest technologies from YourKit. You can have early access to new products and internal builds.

NOTE: THIS IS PREVIEW SOFTWARE AIMED AT PROVIDING YOU WITH AN OPPORTUNITY TO TEST THE NEWEST FEATURES SCHEDULED FOR THE NEXT MAJOR RELEASE. YOURKIT DOES NOT GUARANTEE THAT THIS SOFTWARE WILL RUN TROUBLE-FREE. USING THIS SOFTWARE IS AT YOUR OWN DISCRETION AND DOES NOT ENTITLE YOU TO ANY CUSTOMER SUPPORT.

Feedback

Your comments, suggestions and bug reports are welcome. In the forum you can discuss product features with YourKit developers and post bug reports.


Download YourKit Java Profiler 2014 EAP, build 14082 (July 25, 2014)

Version 2014 will be the next release of YourKit Java Profiler. See change list.

You don't need a license key to use EAP build. Just install the build and use it.

Windows (x86, x64) Download and run installer
Mac OS X (Intel) Download and unpack zipped application
Linux
(x86, x64, ARM, ppc, ppc64)
Download tar.bz2 archive
Unpack: tar xfj <archive name>.tar.bz2
Launch bin/yjp.sh
Solaris (SPARC, x86, x64) Download and unpack ZIP archive
Launch bin/yjp.sh
HP-UX (IA64)
AIX (ppc, ppc64)
FreeBSD (x86, x64)

Actually, the ZIP archive is all-in-one: it contains files for all supported platforms, including Windows, Mac OS X, and Linux. However, to ensure easiest installation and best user experience, it is strongly recommended to use a dedicated download option for these platforms instead: Windows bundle provides convenient installer and bundled JRE, Mac OS X - a Mac-style application, Linux - bundled Oracle JRE for x86/x64 which is superior to OpenJDK when it runs UI applications.


Changes in build 14082

  • Probes: class loading probe: caveat: events are not recorded for core classes loaded during JVM initialization to avoid a race condition which might lead to a crash on startup
  • Threads view: CPU usage estimation: new option "Selected thread only"
  • Memory profiling: bug fixed: possible exception in GC roots view
  • Force GC action now uses JVMTI call instead of System.gc() to let it work even if -XX:+DisableExplicitGC is specified. For the old behavior use the agent startup option "_no_jvmti_gc".
  • Bug fixed: attempt to attach the agent to a running IBM JVM might crash it. Note: the attach mode is not supported for IBM Java (and never was), IBM Java should be started with the profiler agent instead. This fix prevents an attempt to attach which is technically possible but results in an internal JVM crash.
  • Memory profiling: "HashMap hash code distribution" inspection: Java 8 supported
  • Memory profiling: "Duplicate strings" inspection: bug fixed: the inspection might provide no results for snapshots captured in attach mode
  • UI: bug fixed: live CPU usage graph was missing kernel usage curve, it was shown in snapshots only (regression in EAP)

Changes in build 14080

  • Probes: UI: Events tab: new feature: "Event Timeline Chart" view has been added to graphically present events. This new view is complementary to the existing "Event Timeline" view showing event sequence in a table form.

    Usage hints:

    • change scale with the toolbar control or Ctrl + mouse wheel
    • to see particular event detail in a tooltip hover the event with the mouse cursor
    • to open particular event in other views use a popup menu
  • Probes: agent: bug fixed: class verification error for custom probes under certain circumstances

Changes in build 14078

  • IDE integration: Tools | Open in IDE (F7) action: improved navigation by line number to non-Java source code (e.g. Scala) and field initializers
  • Probes: built-in probe Threads: new dependent table "Run" records time span of Thread.run(); if the method throws an uncaught exception it will be recorded
  • Memory profiling: object allocation recording: garbage statistics is now always collected per class thanks to optimizations which eliminated additional overhead of this mode.

    Startup option noperclassgc has been deprecated, it has no effect anymore and is ignored if specified.

    API method Controller.startAllocationRecording() signature didn't change for compatibility, but the parameter boolean perClassGarbage has no effect anymore, its value is ignored.

  • Memory profiling: HPROF snapshots: "Threads" view shows stack traces with line numbers, if available

Changes in build 14076

  • Memory profiling: Merged paths view: improvement: in addition to existing column "Objects" showing the number of target objects which belong to particular path, a new column "Dominators" has been added to show the number of objects retaining those target objects. These dominators can be opened by using the popup menu action "Selection dominators".
  • IDE integration: navigation action was renamed to "Open in IDE" in the profiler UI
  • IDE integration: IntelliJ IDEA: Tools | Open in IDE (F7) feedback improved: on success, IntelliJ IDEA icon flashes on Windows and jumps on Mac OS X to draw user attention
  • IDE integration: Tools | Open in IDE (F7) action: bug fixed: success notification popup was not shown in some contexts
  • IDE integration: Tools | Open in IDE (F7) action: bug fixed: navigation to some methods with generic parameters did not work
  • IDE integration: NetBeans: bug fixed: navigation to source code might not work in Deadlock detector
  • Memory profiling: allocation recording: UI: bug fixed: altered "Record each" value was ignored under certain circumstances

Changes in build 14074

  • Bug fixed: snapshot comparison failed (regression related with source code line number support)
  • IDE integration: Tools | Open in IDE (F7) action can open exact line inside method body in NetBeans too
  • Other line number support related bug fixes and improvements

Changes in build 14072

  • UI: exact source code line numbers in back traces views too. In particular, this enables line numbers in:

    • exception telemetry;
    • monitor profiling

Changes in build 14070

  • Problem solved: Java 8 and newer might crash when starting CPU tracing or object allocation recording in attach mode, if profiled application used Java 8 lambdas

Changes in build 14068

  • New feature: profiling results are available with exact source code line numbers for:

    • CPU sampling;
    • event stacks;
    • thread stack telemetry;
    • object allocation recording

    Known issue: the Tools | Open in IDE (F7) action can open exact line inside method body in Eclipse, IntelliJ IDEA and NetBeans (since build 14074) plugins. JDeveloper plugin still does not offer this new functionality, it always opens method declaration instead; this limitation will be addressed in the future.

  • Bug fixed: problems with sampled allocation recording
  • Memory telemetry: bug fixed: limit 0 was shown for memory pools with unknown limit

Changes in builds 14000-14066

CPU Profiling

  • Improved UI responsiveness when the profiler is connected to live profiled application
  • Scalability improvement: UI works much faster when presenting profiling results for a big number (hundreds or even thousands) of threads
  • UI: improved presentation of methods with time less than 1 millisecond.

    Background: the profiler stores measured times with nanosecond precision (however, note that actual accuracy depends on platform and CPU profiling settings), but UI presents them as milliseconds in call tree, method list and other views.

    In previous versions, any methods with time greater than 0 but less than 1 millisecond were not shown at all, unless the property -Dyjp.show.shortest.methods=true was specified. In that case their time was presented as 0.

    Now such methods are always (i.e. the property is no longer effective and is ignored if specified) shown with time having one digit after the period, e.g. "0.7" or "< 0.1". The latter means that the time is greater than 0 but less than 0.1 millisecond.

  • Java EE high-level statistics view: added support of executeBatch()
  • Java EE high-level statistics view: other improvements, bug fixes
  • CPU tracing: adaptive tracing parameter "adaptive_min_tracing_duration_ms" has been dropped as redundant
  • Bug fixed: snapshots with certain EE profiling data failed opening
  • Bug fixed: CPU tracing in attach mode: some method invocations might have been lost under certain circumstances in case of exceptions thrown in classes from java.lang and some other packages

Memory Profiling

  • Memory snapshots are opened faster and require less memory to load thanks to:
    • significantly improved dominator tree computing, which is the most time and memory intensive part of a memory snapshot loading;
    • improved algorithms of web application processing;
    • new snapshot format (note: snapshots from older versions still can be opened);
    • many other improvements and optimizations.
  • Snapshot capture takes less time in some cases
  • UI: memory snapshot capture progress advances more smoothly
  • Usability improvement: 64-bit HPROF snapshots with compressed object pointers are now detected automatically, without user interaction
  • Usability improvement: Android HPROF snapshots can be loaded directly; it's no longer needed to manually convert them to the standard format with hprof-conv before opening
  • New feature: the profiler format .snapshot file can be converted to HPROF binary format. You may want to have a HPROF file to use the Object Query Language (OQL) feature of the MAT tool, or other tools supporting HPROF.

    The following command creates a new HPROF file from existing .snapshot:

    On Windows:
    <Profiler Installation Directory>\bin\snapshot2hprof.bat <source_snapshot> <target_hprof>

    On other platforms:
    <directory with unpacked content>/bin/yjp.sh -snapshot2hprof <source_snapshot> <target_hprof>

    Known issues:

    • class references to its constant pool entries are not exported;
    • HPROF generated from a 64-bit application snapshot will always be detected as having compressed OOPS, i.e. the object reference size will be 4 bytes.
  • UI: object explorer: float values are shown without intermediate conversion to double, which might result in showing "noise" digits beyond the float data type precision
  • UI: object explorer: enum values are now marked with a special icon (E)
  • UI: object explorer: class-specific object presentation: if a class has only one instance field, and the field is primitive, its value is immediately shown for the class instances
  • UI: object explorer: class-specific object presentation: enum value names are immediately shown
  • UI: object explorer: class-specific object presentation: added support of java.util.UUID
  • UI: object views performance improved
  • UI: Garbage Collection -> (Statistics) Class list -> Object ages: bug fixed: existing object statistics does not respect selection in the upper table
  • Memory | Strings by Pattern... (Ctrl+F) action now allows to choose between simplified and full regex pattern syntax
  • Memory inspections: sets of options for some inspections streamlined, inspections themselves re-grouped
  • Memory inspections: new inspection "Duplicate objects" finds identical objects and arrays wasting memory. It supersedes the previously existed inspection "Duplicate arrays" which worked with arrays only.
  • Memory inspections: inspection "Highly referenced objects": result presentation improved: maximum reference count among class instances is shown for class grouping nodes

Telemetry

  • Performance charts: overhead reduced
  • Performance charts: the default activity mode of underlying probes probe_disable=com.yourkit.probes.builtin.*LW has been changed from Auto to On, thus making the results available even when CPU profiling is not running
  • Performance charts: bug fixed: connections created with Driver.connect() might be skipped
  • Daemon threads are indicated in Threads view and stack traces
  • Snapshot comparison: new feature: per-class object counts and sizes are now compared for performance snapshots too; the numbers to compare are taken from the class instance count telemetry in memory telemetry.

    Note: the reachability scope of objects to compare can be chosen only when comparing two memory snapshots. If at least one of the snapshots is a performance snapshot, objects of all reachability scopes (i.e. all existing objects) are taken into account.

  • Bug fixed: telemetry started approximately 1 second (i.e. one telemetry period) later

Probes

  • Probe overhead reduced
  • UI: the probe results are now shown in the tab named "Events". The old name of the tab was "Probes".
  • UI: "Event Timeline" view reworked:

    • nested events are now shown as tree nodes;
    • column cleanup;
    • new "Time (ms)" column shows event duration;
    • new columns to explicitly show event thread and stack, if available;
    • new popup menu actions.
  • UI: on attempt to open in Timeline an event from an excluded table the profiler now offers to include it automatically, thus significantly improving usability
  • UI: objects associated with events can be opened in object explorer by clicking the link in "Object" column, if they still exist, i.e. have not yet been collected. This feature is available for memory snapshots only.
  • Improved and streamlined support of resource-like entities such as files, database connections and statements. The resource itself is presented with a master table, and related events such as open, read, write, query, close are presented in a dependent table, i.e. at the same level. Previously, the open event was merged with the resource itself, while all other events including close located in a dependent table, which was difficult to interpret and process.
  • Built-in probes: some tables were given shorter names to improve readability in the UI
  • Built-in probe JSP/Servlets: bug fixed: events corresponding to method calls which failed on exception were never closed
  • Built-in probe Databases: added handling of connections created when the probe was inactive. Note: the probe's default activity mode is Auto, thus the probe is inactive until CPU profiling is started.
  • Built-in probe Databases: bug fixed: events corresponding to method calls which failed on exception were never closed
  • Built-in probe Databases: bug fixed: connections created with Driver.connect() might be skipped
  • Built-in probe Files: added support of the standard streams System.in, System.out and System.err
  • Built-in probe Files: added handling of files opened when the probe was inactive. Note: the probe's default activity mode is Auto, thus the probe is inactive until CPU profiling is started.
  • Built-in probe Files: all file I/O operations are now presented in a single table "File I/O"; new column "Class" was added to easily help identifying file input streams, file output streams and random access files
  • Built-in probe Sockets: bug fixed: possible java.lang.NullPointerException
  • Reworked and simplified event model. Each single event now corresponding to only one method call. Resources such as files or sockets which can be created, used and eventually closed in different methods and event threads are now handled as such:

    • resource opening event is stored in a master table
    • resource operations (e.g. reads, writes) are stored in dependent tables
    • resource close event is also stored in a dependent table "Close"

    This change simplifies and improves event presentation in time-line views (new ones to come in upcoming builds), event correlation/intersection, allows to measure open and close durations by themselves, as well as gives the following new time metrics:

    • event own time, which is the duration of a lasting event by itself (example: the duration of a resource-opening operation)
    • event aggregate time, which is its own time summed with own times of all dependent events, recursively (example: total time of all operations with the resource: open, read, write, close)
    • event life time, which is the time span between event start time and one of the following points, whichever comes last: event end time, or latest end time of dependent events, recursively (example: for how long the resource was in use, from open to close)
  • If a lasting event ends on exception, the exception detail can be stored and presented in the UI.

    Probe API: this new functionality is implemented with a new method com.yourkit.probes.Table.closeRow(int row, @Nullable Throwable exception). Calling Table.closeRow(row) is the same as Table.closeRow(row, null).

  • API: new callback onExit can be used instead of two separate callbacks onReturn and onUncaughtException. It helps avoiding code duplication in when a lasting event created in onEnter should be closed on normal return as well as on exception. See source code of built-in probes as its usage example.
  • API: new column class com.yourkit.probes.ObjectColumn is intended to record a persistent object ID, allowing to associate a memory snapshot's objects with events. Examples of use: resources in built-in probes such as database and file objects; objects whose method calls were recorded with the trigger action "Record Method Invocation".
  • API: to simplify writing a single probe handling a family of methods with different parameter or return types, @Param and @ReturnValue annotations now allow to use a "bigger" primitive type to store "smaller" values:

    • int can store byte, short, char
    • long can store byte, short, char, int
    • double can store float

    For example, if there are two methods int read(X) and long read(Y), a single probe with a long parameter annotated with @ReturnValue can be written. Previously, it was required to write 2 different probes, one for the method returning int and another for the method returning long, or use an Object to wrap the value.

  • API: caveat: a number of com.yourkit.probes.Table methods and constants were removed:

    • setFrequentSamplingThreshold() removed; use the startup option telemetryperiod instead
    • isRowClosed() removed as redundant and non-complying with the synchronization-related optimizations described above. Instead, rows remaining opened should be explicitly stored in a container like HashSet. See the source code of the built-in probe Processes for example.
    • MASK_FOR_GENERIC_LASTING_EVENTS and MASK_FOR_SINGLE_METHOD_CALL_LASTING_EVENTS removed - see the notes about the probe model change above; use the new constant MASK_FOR_LASTING_EVENTS instead
  • Bug fixed: stack traces of events recorded during CPU tracing were missing the top method
  • Inspections on probe results: bug fixes

Triggers

  • Method invocation: "Record Method Invocation" action improved:

    • to improve sorting and grouping capabilities, new columns "Class" and "Method Name" were added
    • the object for which the method was called ('this') is recorded and can be opened if a memory snapshot is captured
  • Snapshot file name macros are now surrounded with { and } instead of < and > to simplify specification of the new startup option snapshot_name_format=<format> (see corresponding change for detail) in command line, because < and > mean stream redirection in most command shells and must be escaped
  • Snapshot file name macro {pid} was added

IDE Integration

  • 32-bit vs 64-bit JRE plugin settings now offer 3 options:
    • detect bitness automatically (default);
    • force using 32-bit JRE;
    • force using 64-bit JRE.
    This allows to start profiled applications right out of the box in most cases, as well as to address those rare cases when it's technically impossible to automatically provide the correct answer.
  • Eclipse plugin is now digitally signed, preventing unsigned content warning on installation
  • IntelliJ IDEA: to avoid unnecessary changes in project files, the default profiling settings are stored as an empty XML element
  • Bug fixed: "Open in IDE" action might not navigate to a method having a variadic parameter
  • Bug fixed: the profiler UI automatically launched via the "Profile" action on Java 6 might hang

Java EE Integration

  • Java EE integration wizard: Tomcat 8 supported

Miscellaneous

  • Agent: new synchronization mechanism significantly reduces overhead when profiling multithreaded applications. In particular, this improvement affects:
    • CPU tracing
    • probes
    • object allocation recording
    • monitor profiling
    • exception telemetry
  • Agent: new startup option snapshot_name_format=<format> allows to specify alternate rule to compose snapshot file names.

    Available macros:

    • {sessionname} - session name
    • {date} - snapshot capture date in format 'yyyy-MM-dd'
    • {datetime} - snapshot capture date and time in format 'yyyy-MM-dd-HH-mm'
    • {pid} - profiled process ID

    The default format is {sessionname}-{date}.

    The text after the macro expansion will be used as is, except for the characters not allowed in file names which will be replaced with '-'.

  • Agent: IBM Java 7 Release 1 supported
  • Agent: FreeBSD: attach mode supported
  • Agent: bytecode instrumentation bug fixes
  • Agent: bug fixed: some class names in monitor and exception profiling results might be incorrect under certain rare conditions
  • Remote profiling: reduced overhead of connecting the profiler UI to a remote profiling application. The agent is no longer blocked until all data is transferred to the profiler UI on each update, which might cause performance issues in case of slow network connections.
  • Remote profiling: "Connect to Remote Application" dialog now offers a built-in support for SSH tunneling.

    Use the following syntax:

    user@ssh_server[:ssh_port] [host][:agent_port]

    • user and ssh_server are the credentials for the SSH connection to establish
    • ssh_port - specify if the server does not use the standard SSH port 22
    • host - the host on which the profiled application is running; ssh_server will create a tunnel to that host. If the profiled application runs directly on ssh_server, omit this parameter.
    • agent_port - profiler agent port. If not specified, all applications with agents listening on ports from the standard range will be discovered (the same as for a non-tunnelled connection).

    Authentication with a password or a private key is supported.

    You will be asked to provide the password each time you connect. The password is not stored anywhere, and is securely erased from memory once the SSH connection is established.

    Note: known hosts are not currently checked, and StrictHostKeyChecking SSH parameter is set to no.

    Examples:

    • john@server1 - connect to profiling application(s) running on host server1; SSH will connect as john
    • john@server1 :12345 - connect to the profiling application running on server1 with the profiler agent listening on a custom port 12345; SSH will connect as john.
    • john@server1 server2 - connect to profiling application(s) running on host server2, via SSH connection to server1 as john
    • john@server1 server2:12345 - connect to the profiling application running on server2 with the profiler agent listening on a custom port 12345, via SSH connection to server1 as john.
  • UI: improvement: connect to profiled applications and opening snapshots is now faster thanks to lazy construction of some heavy components
  • UI: Inspections: new UI component layout uses available space more effectively, and better suits low resolution displays
  • UI: Mac: Dark color theme support added on Mac OS X. To switch the theme use corresponding main menu items under Settings. Known issue: the main menu is inside the frame.
  • UI: "Open Snapshot" dialog: improved handling of already opened snapshots:

    • opened snapshots are explicitly indicated in the list;
    • applying the "Open Snapshot" action to an opened snapshot now navigates to the snapshot tab and closes the dialog window instead of showing a message that the action is not applicable.
  • UI: capture snapshot dialog: new snapshot file name macro {pid}
  • UI: Export: the file chooser dialog remembers the previously chosen output format
  • UI: tables and trees performance improved
  • UI: bug fixed: excluded by adaptive CPU tracing method marks were shown in non-CPU profiling views too
  • Windows: the installer and the profiler executable files are now digitally signed
  • Mac: the application is now digitally signed, and is no longer blocked by Gatekeeper in its default mode "Allow applications downloaded from: Mac App Store and identified developers"
  • Mac: application launcher now tries to use installed JDK in the following priority: Java 7 (offers most stable UI library at the moment), Java 8, Java 6
  • UI: Mac: bug fixed: poorly visible (black) text in a selected row in some tables
  • UI: Mac: bug fixed: possible java.lang.ArrayIndexOutOfBoundsException when plugging an additional display
  • Export: plain lists are exported to text more compactly, without intermediate empty lines and tree node markers
  • Export: bug fixed: export to text might improperly align text inside column
  • Caveat: although profiling of Java 6 remains fully supported on all platforms, the profiler UI itself now requires Java 7 or newer to run. The exception is Mac OS X on which the profiler UI still can run on Java 6.

    The profiler downloads for Windows, Linux and newest Mac OS X contain appropriate Java 7 JRE bundled, thus the profiler UI will work out of the box on these platforms, even if you have only Java 6 installed.

  • Caveat: the profiler UI settings file has been renamed to bin/ui.ini (was bin/yjp.ini)
What's new
February 18, 2014
YourKit Java Profiler 2014 Early Access Program (EAP) launched
October 30, 2013
YourKit Profiler 2013 for .NET released
Awards
JDJ Editors' Choice Award Winner YourKit Java Profiler received the Java Developer's Journal Editors' Choice Award.
Customers