Fully featured low overhead profiler for Java EE and Java SE platforms.
Performance monitoring and profiling of Jenkins, TeamCity, Gradle, Maven, Ant, JUnit and TestNG.
Easy to use performance and memory profiler for .NET framework.

Changes in Version 2016.02

User interface

  • Table columns with percents now also show graphical bars to make most important information immediately visible.
  • Optimization: connection to a profiling application, especially remote, completes faster thanks to merging multiple requests to one
  • Welcome screen: list of local applications: Windows, Linux, macOS: new column "CPU" shows CPU utilization percent for each listed process
  • Automatic updates to maintenance builds.

CPU profiling

  • Hot spot methods are indicated with a fire icon in the call tree: small one for methods calling the hot spots, and big one for the hot spots themselves.
  • Optimization: the range of trivial methods excluded from CPU tracing instrumentation for performance consideration has been extended
  • Optimization: less memory is needed to open performance snapshots
  • CPU tracing: bug fixed: adaptive tracing could exclude calls too aggressively thus resulting in missing nodes in the call tree
  • CPU tracing: bug fixed: bogus line numbers for calls from skipped (non-instrumented, filtered by adaptive tracing) methods
  • CPU tracing: optimization: line numbers are not recorded by default for calls made from the methods automatically generated for a JSP page. These line numbers are generally useless because they do not correspond to the JSP source lines, but instead to the automatically generated Java code. As the result of the change, profiled results for individual calls to out.write(...) are aggregated, which simplifies the result interpretation as well as slightly reduces profiling overhead and memory footprint. To revert back to the old behavior please specify the startup option _jsp_with_lines.

Memory profiling

  • The profiler needs up to 20% less memory to load a memory snapshot. Thanks to this improvement the profiler is now able to open huge snapshots that could not be opened on the same machine with the previous versions of the profiler.
  • Memory snapshots are loaded up to 15% faster
  • "Duplicate objects" inspection detects duplicates of higher order. It now performs multiple passes to identify objects referencing different instances with the same value, recursively. For example, it can detect if the same XML document is parsed and kept in memory multiple times.

    Also, the estimated memory waste is now calculated from the duplicate objects' retained size. This puts the biggest higher level duplicates, like lists or maps, to the top of the list.

  • Object allocation recording: hot spot methods are indicated with a fire icon in the call tree: small one for methods calling the hot spots, and big one for the hot spots themselves.
  • Object allocation recording: objects allocated in a thread or at a stack trace whose detail the JVM cannot provide at the moment for some reason are no longer skipped, but recorded and presented under artificial nodes "<Thread could not be retrieved>" and "<Stack trace could not be retrieved>"
  • Object allocation recording: it is now possible to filter recorded objects only by their size by setting the record-each parameter to 0
  • Added handling of java.lang.ClassValue maps. This class introduced in Java 7 allows to associate a computed value with a class.

    For Java 7 and Java 8, the maps are shown referenced from corresponding java.lang.Class instances via an instance field reference classValueMap . In latest Java 9 there is unfortunately no means to identify which particular class each map belongs to, and we instead show the maps as being GC roots of type "Held by JVM".

    This feature works with HPROF format snapshots only. JVM's JVMTI API used to create the profiler format snapshot files does not provide enough information to let the feature work.

  • UI: Quick info: optimization: export of a byte array to a binary file now works much faster
  • UI: optimization: Class list and other object-grouping views now open up to 2 times faster
  • UI: object explorer: class constant pool presentation cleanup: <constant pool> entries are not shown for the references that are also accessible from static fields of the same class
  • UI: object explorer: class-specific object presentation: more information is shown for thread objects (instances of java.lang.Thread and subclasses): in addition to the thread name, also shown are tid, status and whether the thread is daemon
  • UI: object explorer: class-specific object presentation: for instances of java.nio.Buffer the buffer capacity is immediately shown
  • New memory inspection "NIO direct buffers native memory usage" shows how much native memory is allocated to direct byte buffers (java.nio.DirectByteBuffer and java.nio.DirectByteBufferR). Note that other kinds of direct buffers, like java.nio.DirectLongBuffer, delegate to underlying ("attached") byte buffers and thus do not allocate native memory directly.
  • UI: "GC Roots" view (Memory | GC Roots): methods under "Roots by thread" are sorted according to the call stack order
  • UI: improvement: in "Threads" tab of a HPROF snapshot captured on OutOfMemoryError the thread in which the OutOfMemoryError had happened is now shown first
  • UI: improvement: "Threads" tab of a HPROF snapshot: added link "Open object" to open corresponding instance of java.lang.Thread
  • Bug fixed: java.lang.TypeNotPresentException when opening particular snapshot


  • GC telemetry: new "GC Pauses" graph added under the "Basic telemetry" node in the "Performance counters" tab. Also, "GC Pauses" graph, if corresponding data is available (currently - on Sun/Oracle Java 7 and newer), replaces a less informative "Time Spent in GC" in "Memory & GC telemetry" in the "Memory" tab. Note: time spent in GC curve is also available in the CPU usage graph in the "CPU" tab.

Event recording with probes

  • New feature: higher-level profiling of MongoDB (Java driver version 3.0 and newer are supported). MongoDB request information is available in:
    • "Java EE statistics" view, Database section
    • "Events" tab (new built-in probe com.yourkit.probes.builtin.MongoDB)
    • "Performance charts" tab (new built-in probe com.yourkit.probes.builtin.MongoDBLW)
  • New feature: higher-level profiling of Java persistence (JPA). Supported implementations: Hibernate, EclipseLink, OpenJPA, DataNucleus. JPA information is available in:
    • "Java EE statistics" view, Database section
    • "Events" tab (new built-in probes com.yourkit.probes.builtin.JPA_Hibernate, com.yourkit.probes.builtin.JPA_EclipseLink, com.yourkit.probes.builtin.JPA_OpenJPA), com.yourkit.probes.builtin.JPA_DataNucleus)
  • New feature: higher-level profiling of Cassandra database. Cassandra request information is available in:
    • "Java EE statistics" view, Database section
    • "Events" tab (new built-in probe com.yourkit.probes.builtin.Cassandra)
    • "Performance charts" tab (new built-in probe com.yourkit.probes.builtin.CassandraLW)
  • New feature: higher-level profiling of HBase database. HBase request information is available in:
    • "Java EE statistics" view, Database section
    • "Events" tab (new built-in probe com.yourkit.probes.builtin.HBase)
    • "Performance charts" tab (new built-in probe com.yourkit.probes.builtin.HBaseLW)
  • New feature: higher-level profiling of AsynchronousChannel. The information is available in "Events" tab (new built-in probe com.yourkit.probes.builtin.AsyncChannels)
  • Built-in probes rewritten to solve different class loading issues affecting, in particular, some JBoss configurations, as well as the new module system introduced in Java 9 ("Project Jigsaw").
  • Probe overhead reduced by optimizing reflection calls performed in some built-in probes
  • "Events" tab: the table selector tree improvement: to save vertical space and simplify interpretation of the view, the nodes for empty tables are by default collapsed
  • "Events" tab: selecting a table in the selector tree navigates to the nearest event from this table in the Timeline, if the Timeline is visible and the table is included. To disable the navigation specify -Dyjp.timeline.select.event=false in <user home>/.yjp/ui.ini
  • "Performance charts" tab: the chart selector tree improvement: to save vertical space and simplify interpretation of the view, the nodes for empty charts are by default collapsed and moved to the bottom
  • "Events" and "Performance counters" tabs: other multiple UI improvements
  • Inspection "Threads created but not started": improvement: a false alarm is no longer reported for known JVM internal threads that are actually started and running, but the start event is not available

IDE integration

  • Bug fixed: JBoss might not start from within an IDE due to an improper initialization sequence of its custom MBeans.

    Previously, until this fix was made, it was required to specify -Djboss.platform.mbeanserver -Djavax.management.builder.initial=org.jboss.system.server.jmx.MBeanServerBuilderImpl as a workaround.

  • Bug fixed: internal error when action "Tools | Open in IDE (F7)" was applied in object explorers to a field referencing an instance of java.lang.Class
  • IntelliJ IDEA: bug fixed: action "Tools | Open in IDE (F7)" might navigate to a wrong anonymous class in some non trivial cases


  • Caveat: legacy, pre-v2015 license keys are no longer accepted. New, v2015-style license keys are required. The profiler will suggest you to get a new key from YourKit if you're using an old one.
  • Agent: multiple stability improvements
  • Agent: optimization: reduced thread event processing overhead when no active profiling is running
  • Agent: probes are never applied (instrumentation is not performed) to in-runtime generated lambda proxy classes for the purpose of micro-optimization, as well as to avoid bytecode instrumentation issues in some corner cases which might lead to verification errors
  • Agent: Java 9 support: optimization: native methods annotated with @HotSpotIntrinsicCandidate are not instrumented by default (and thus are not visible in CPU tracing or probes should any be applicable), to avoid profiling overhead and get rid of JVM warnings like "Method [java.lang.reflect.Array.getLength(Ljava/lang/Object;)I] is annotated with @HotSpotIntrinsicCandidate but no compiler intrinsic is defined for the method." To instrument such methods please specify the agent startup option "_with_intrinsic_candidates".
  • Java 9 support: JEP 254: Compact Strings introduced in Java 9 b93 supported
  • Java 9 support: added handling of new class jdk.internal.misc.Unsafe
  • Export: improvement: size of generated HTML files significantly reduced
  • UI: bug fixed: the profiler suggested to choose whether to open a huge snapshot as a performance snapshot or as a memory snapshot not only when opening a memory snapshot (which is correct), but also when opening already a performance snapshot (which is incorrect)
  • 64-bit Windows: the installer by default offers to install the profiler to the 64-bit program directory, e.g. C:\Program Files, instead of the 32-bit program directory, e.g. C:\Program Files (x86).
  • Profiler UI settings file ui.ini was moved from the profiler installation directory to the user home, now being <user home>/.yjp/ui.ini, to make changes in this file persistent after upgrading to a newer build and simplify editing in when the profiler directory requires root access to modify files.
  • Internal improvements and cleanup