Read the profiling report. In the Profiler tool window, the collected data is presented on several tabs: Flame Graph, Call Tree, Method List, CPU Timeline, and Events (for JFR). The left-hand part of the tool window lists application threads. By clicking on each thread you can go in more details. Navigate the report. JPROF is a Java profiling agent that responds to events from either the JVM Tool Interface (JVMTI) or the JVM Profiler Interface (JVMPI), based on the invocation options. On Windows, the profiling agent is named jprof.dll. On Linux and z/OS, it is libjprof.so, but on AIX it is libjprof.a.
JRat
| JRat is the Java Runtime Analysis Toolkit. Its purpose is to enable developers to better understand the runtime behavior of their Java programs. The term 'behavior' includes, but is not limited to performance profiling. |
Cougaar Memory Profiler
| The Cougaar memory profiler is a tool for debugging memory usage and leaks in any Java application. It features a scalable 100% Java design that is lighter weight than existing JVMPI-based profilers. |
Extensible Java Profiler
| Extensible Java Profiler (EJP) is an open-source profiling tool for Java with a scalable and extensible architecture, allowing its usage for exotic programming languages that use a Java backend. |
JMemProf
| JMemProf is a live Java memory profiler suitable for deployment in web containers such as JBoss, Tomcat and others. JMemProf allows you to retrieve memory profile information while your application is running. |
JMP
| JMP is a profiler for java that can be used to trace objects usage and method timings. JMP uses the JVMPI interface to gather statistics and interact with the JVM. JMP uses a GTK+ interface to show the status. |
DrMem
| A simple heap profiler for Java, based on JVMPI. The profiler can be attached to a non-interactive JVM, creating heap statistics from time to time. |
JTreeProfiler
| A JVMPI based profiler for Java that collects all methods calls in a XML File and displays them in a TreeMap. |
NetBeans Profiler
| NetBeans Profiler is a project to integrate the JFluid profiling technology, which is being developed by Sun, into the NetBeans IDE. The aim of this project is to provide a powerful and flexible profiling solution that is tightly integrated into the IDE workflow. As the size and complexity of Java applications grow, keeping their performance at the required level becomes progressively difficult. That is why we believe profiling should become a natural part of the development work cycle. To achieve that, we would like to make profiling easy-to-use and as unobtrusive as possible - and the JFluid technology that we use, with dynamic bytecode instrumentation at its heart, suits this goal perfectly. |
JAMon API
| The Java Application Monitor (JAMon) is a free, simple, high performance, thread safe, Java API that allows developers to easily monitor production applications. JAMon can be used to determine application performance bottlenecks, user/application interactions, and application scalability. JAMon gathers summary statistics such as hits, execution times (total, average, minimum, maximum, standard deviation), and simultaneous application requests. JAMon statistics are displayed in the clickable JAMon Report. |
JBoss Profiler
| JBoss Profiler is a log based profiler using the JVMPI system. It uses an agent written in C that captures events from the JVM and logs them to disk. A web application running on JBoss or another machine can be used to analyze these logs through a web browser. |
MessAdmin
| MessAdmin is a notification system and Session administration for J2EE Web Applications, giving detailed statistics and informations on any Web application.It installs as a plug-in to any Java EE WebApp, and requires zero-code modification. |
InfraRED
| nfraRED is a tool for monitoring performance of a J2EE application and diagnosing performance problems.InfraRED uses AOP to weave the performance monitoring code into the application. It comes with out of the box support for AspectJ & Aspectwerkz.Salient Features:* Fully non-intrusive. No coding required by developers.* Layer-wise performance statistics summary (Web, Session, JDBC etc).* API level detailed performance statistics.* Call tree views (like in other profiler tools).* JDBC API and SQL statistics.* Last invocation statistics.* Correlation of statistics across layers.* Support for centralised gathering and presentation of performance data for one or more applications in a cluster.* Remote or local collection of performance metrics.* User-friendly web GUI.* Simplified ant-based integration with application.* Support for multiple application servers* Weblogic* Jboss* Tomcat* Useful for applications with or without use of EJBs.* Export summary of performance statistics into Excel spreadsheets.* Very low overhead, Can be used in production environments.* Ability to save and reload snapshots. |
TomcatProbe
| TomcatProbe is a real-time monitoring and management tool for Apache Tomcat. It is very easy to deploy and requires no modification to either Tomcat or running applications. Tomcatprobe allows real-time monitoring of deployed applications and their status, active http sessions and their attributes, datasources, their details and current usage. It also shows requests that are being executed, sizes of application footprints in memory, enables on-the-fly application deployment with JSP precompilation. System information view displays Java runtime version, graphical memory usage, OS information and system properties. 'Quick check' options allows to check usage of all resources including all datasources, file handles and memory in one click. |
Java Interactive Profiler (JIP)
| JIP is a high performance, low overhead code profiler for Java. It's main features are:1. It's written entirely in Java and needs no native components.2. It allows the developer to filter which classes and packages are profiled.3. There are many options available for controlling the output of the profiler. This makes it easier to manage all of the data that can be generated. There is also an XML output option which makes it easy to manipluate the output using other programs.4. JIP is interactive, allowing the developer to turn the profiler on and off while the JVM is running. This makes it particularly well suited for profiling web applications.5. JIP is available under the BSD license. |
Profiler4j
| Profiler4j is a simple-to-use CPU profiler Java that supports remote profiling and on-the-fly configuration.Its main features are: (1) Based on dynamic bytecode instrumentation. (2) 100% Java. (3) No native library or executable is required. (4) It provides views with call graph, call tree, memory monitor, and class list. (5) Supports fine-grained configuration that can be easily tuned without restarting the profiled JVM. Only the methods you want to profile are instrumented. |
Stopwatch
| Stopwatch is a free, simple, highly extensible, Java API that allows developers to easily monitor whole application or any part of it. By default Stopwatch generate reports about hits, execution times (total, average, minimum, maximum) as well as load but it can be easily extended to measure anything else by providing custom engine. Out of the box Stopwatch uses an in-memory HSQL database. It is able to persist collected data using a 'storage'. There is 'storage' provided to persist intoHSQL database and custom 'storage' can be easily integrated. |
JMeasurement
| JMeasurement is a free and simple java api for monitoring runtime and usage (count, parallel activation, last activation, deviation...) of user defined points in java production code. It an automatically monitor Interface methodes. There are renderers for text, csv and HTML. It is simple to use and extended. |
DJProf
| DJProf is an experimental tool for profiling Java programs which employs AspectJ to insert the necessary instrumentation for profiling rather than, for example, the Java Machine Profiler Interface (JVMPI). DJProf can be used to profile Java programs without modification (i.e. there is no need to recompile them for profiling) and does not require the user to have any knowledge of AspectJ. |
TIJmp
| A small and fast memory profiler for java/6 and later.TIJjmp uses C code to talk to the jvm and it uses swing to show the the tables of information. So tijmp is written in C (using jvmti and jni) and Java.TIJmp runs in the same jvm as the program being profiled. This means that it can easily get access to all things jvmti/jni has to offer. |
Allmon
| Allmon is a generic system collecting and storing metrics used for performance and availability monitoring.The main goal of the project is to create a generic system storing various metrics collections used for system performance, health, quality and availability monitoring purposes. The system also provides a set of> |
| Appsy is a 'user experience profiling tool' :- Monitor how the users actually uses your java applications,- Monitor how your java applications responds to the users requests.Every software need to be improved in term of quality, performance, efficiency ...With Appspy, you will get all the data you need to learn how to improve the value of your software for your users. |
EurekaJ
| EurekaJ is an Open Source, Standards based profiler tool for Java applications. EurekaJ integrates with the Java agent BTrace. BTrace has a large feature set that goes hand in hand with features for EurekaJ. |
japex
| Japex is a simple yet powerful tool to write Java-based micro-benchmarks. It started as a simple project over a year ago, primarily aimed at testing XML and Fast Infoset performance, but has evolved into a rather sophisticated framework with support for XML and HTML output as well as various types of charts for displaying the results. It is similar in spirit to JUnit in that if factors out most of the repetitive programming logic that is necessary to write micro-benchmarks. This logic includes loading and initializing multiple drivers, warming up the VM, forking multiple threads, timing the inner loop, etc. One of the key design goals for Japex was extensibility. Via the use of a simple model of input and output parameters, it is possible to write micro-benchmarks to test practically anything. |
OKTECH Profiler
| OKTECH Profiler is a low-impact, sampling profiler for Java. It doesn't require constant connection from a profiler console, as it dumps the profiled information in a binary file. This file can later processed and report can be generated from the overall information. It can be executed in a local JVM or it can connect to a remote JMX server, allowing to profile any kind of application. The overhead of the profiler is very low (and it can be tuned further if required, e.g. reducing the sampling frequency) compared to instrumentation profilers. |
Perf4j
| Perf4j is a set of utilities for calculating and displaying performance statistics for Java code. It allows to log instructions execution time using popular logging frameworks, generate performance graphs, expose results via servlet or JMX. For most cases simple annotating method with @Profiled is enough to start collecting data. |
In the Profiler tool window, the collected data is presented on several tabs: Flame Graph, Call Tree, Method List, CPU Timeline, and Events (for JFR). The left-hand part of the tool window lists application threads. By clicking on each thread you can go in more details.
Navigate the report
The Profiler tool window allows you to jump between the tabs while staying focused on a specific method. Right-click the necessary method and select another view in which you want to open it.
For a method on any tab, you can open the Merged Callees and Back Traces trees. Right-click the method and select Method Merged Callees or Method Back Traces respectively.
If you want to review a method in the editor, right-click it on any tab and select Jump to Source or press F4.
On the left frame of the Profiler tool window (View | Tool Windows | Profiler ), click .
In the dialog that opens, name the file, specify the folder in which you want to save it, and click Save.
You can import profiling data to the IDE for analysis using the profiling tools. Make sure that the files that you import were created in Async Profiler or have the .jfr extension.
From the main menu, select View | Tool Windows | Profiler and click Open Snapshot.
Alternatively, from the main menu, select File | Open or drag the necessary file from your system file manager to the editor.
Flame Graph
The flame graph visualizes the application call tree with the rectangles that stand for frames of the call stack, ordered by width. Methods that consume more CPU time and memory resources are wider than the others.
The blue color of the blocks stands for native calls, yellow stands for Java calls.
When you read the flame graph, focus on the widest blocks. These blocks are the methods that are presented in the profile most. You can start from the bottom and move up, following the code flow from parent to child methods, or use the opposite direction to explore the top blocks that show the functions running directly on the CPU. In this case, you can use the | Show Icicle Graph option change the graph view.
Flame Graph layout
Each block represents a function in the stack (a stack frame). The width of each block corresponds to the method's CPU time or memory used (or the allocation size, in case of allocation profiling).
On the Y-axis, there is a stack depth going from bottom up. The X-axis shows the stack profile sorted from the most resource-consuming functions to the least consuming ones.
Show details in tooltips
Hover the mouse pointer over a block to display a tooltip.
The tooltips show the fully qualified method name, the percentage of the parent sample time, and the percentage of total sample time.
Zoom the graph
Use the and options to zoom the graph.
To focus on a specific method, double-click the corresponding block on the graph.
To restore the original size of the graph, click 1:1.
Search the graph
If you want to locate a specific method on the graph, start typing its name or click and type the name in the search bar.
The graph highlights all blocks with method names matching your search request.
Use and for fast navigation between search results. You can also search either in the whole graph or just in a specific subtree.
Capture the graph
You can capture and export the graph separately from other data in the report.
Click and select Copy to Clipboard or click Save to export the graph as an image in the .png format.
For more information about flame graphs, see Flame Graphs.
Java Profiler Visual Vm
Call Tree
The Call Tree tab represents information about a program's call stacks that were sampled during profiling. The top-level All threads merged option shows all threads merged together into a single tree. There's also a top-down call tree for each thread.
For each method, the tab shows the following information:
Names of methods
Percentage of total sample time or parent's sample time
The total sample count
To toggle the percentage to the parent's call view, click and select Show Percent of Parent.
Filter Call Tree results
The Call Tree tab allows you to collapse the frames you are not interested in at the moment by applying filters. For example, you can hide library classes or the classes that come from specific frameworks to be able to focus on the application itself.
The blue arrow hyperlink right after the percentage presents a filtered sequence of calls. Click it to expand this sequence.
To quickly disable filtering, click and deselect the Filter Calls option.
In the Settings/Preferences dialog Ctrl+Alt+S, select Build, Execution, Deployment | Java Profiler | Filters.
In this dialog, you can modify the existing rules and add new ones.
Configure the packages or specific classes that you want to be able to hide in the output.
To filter all methods in a class, specify the fully qualified class name (for example:
org.bar.ClassName).To filter specific methods in a class, use the following format: fully qualified class name : method name (for example:
* : myMethod()).
Apply the changes and close the dialog.
Collapse recursive calls
A complex application that has multiple recursive methods may be very difficult to analyze. In a regular Call Tree view, recursive calls are displayed as they are called – one after another, which in case of complex call stacks with multiple recursive calls leads to almost infinite stack scrolling.
IntelliJ IDEA detects a recursion when the same method is called higher up in the call stack. In this case, the subtree is taken out of the call tree and then attached back to the first invocation of that method. This way you can bypass recursion and focus on methods that consume most of the resources and calls that they make.
Collapsing recursive calls allows you to see the total amount of time spent in these calls as if there was no recursion.
Java Profiler Free
Folded recursive calls are marked with the icon on the Call Tree tab. Click it to open the recursive call tree in a separate tab. You can preview the number of merged stacks in a tooltip.
What-if: focus on specific methods
IntelliJ IDEA allows you to examine specific methods in the Call Tree: you can exclude particular methods or other way around, focus only on the methods in which you are interested at the moment.
Right-click the necessary method on the Call Tree tab and select one of the following options to open the results in a dedicated tab:
Focus On Subtree: show only the selected method call. Parent method sample time counter shows only the time spent in the selected subtree.
Focus On Call: show the selected method and the methods that call it. When this option is enabled, every time frame shows only the time spent in the selected method.
Exclude Subtree: ignore the selected method call.
Exclude Call: ignore all calls to the selected method.
Method List
The Method List collects all methods in the profiled data and sorts them by cumulative sample time. Every item in this list has several views:
Back Traces shows the hierarchy of callers. Use this view to trace which methods call the selected method.
Merge Callees tries to summarize all methods that are called by the selected one.
Callees List shows all methods that were called from the selected one.
CPU Timeline
The timeline helps you get full control over multi-threaded applications. It visualizes CPU consumption in your application as well in other running processes so that you can analyze the data in comparison.
The toolbar on the left allows you to zoom in and zoom out the timeline.
Click | Show Chart on the toolbar to display the CPU load graph (currently supported only for Java Flight Recorder).
Java Flight Recorder Events
Java Flight Recorder collects data about events. Events occur in the JVM at a specific point in time. Each has a name, a timestamp, and an optional payload.
