• 

  HPROF Viewer and Analyzer

  HPROF is a simple command-line tool that captures CPU/Heap profiles to identify performance bottlenecks in applications. By default, this tool writes the captured profiles to a file with '.hprof ' extension. HPROF file may contain CPU usage, heap allocation statistics, heap dump, thread stack traces and monitor states. It can be either in binary or text format. Heap Hero is a powerful tool to view and analyze HPROF files.

• 

  Universal Memory Dump Analysis

  Heap Hero, a universal tool that will parse and analyze heaps dumps written in any language that runs on the JVM. It will convert Java, Scala, Jython, JRuby heap dumps to useful information to optimize your memory usage.

• 

  Brilliant UI

  Reliably and quickly fix your memory problems through a precision single-page view of your heap dumps. View intuitive data display of heap histogram, largest objects, and memory leak suspects with a concisely brilliant interface.

• 

  Free Service

  Our award-winning heap dump analysis tool is offered as a free service. Our tools help you to fix memory leaks, OutOfMemoryError, memory regression, memory hogs and any memory-related problems. All this power at your fingertip for free.

• 

  Android Memory Analysis

  Android is the world's largest mobile platform. Heap Hero can parse and analyze the heap dumps generated from any Android devices. Heap Hero's deep learning algorithms can report memory leak suspects and objects wasting memory.

• 

  Online Heap Dump Analysis Tool

  Heap Hero is the world's first and the only cloud-based heap dump analysis tool. Registration, download, or installation is not required to use the tool. Just upload your application's heap dumps & review the beautiful reports instantly.

• 

  REST API

  Heap Hero has built the industry's first and only REST API to analyze heap dumps. Stop manually uploading and analyzing heap dumps. Instead, analyze heap dumps from all your JVMs and Android devices in a programmatic manner through HEAP HERO's REST API.

• 

  Deep Learning

  Our award-winning deep learning algorithms have the intelligence to detect memory leaks and isolate the objects that are causing the memory leaks. Save time spent on diagnosing the memory leaks. It's all done automatically.

• 

  Collaboration

  Heap Dump files consume a lot of disk space, making it very hard to share and collaborate with the team. HeapHero provides shareable URL links to heap dump analysis reports, making it a breeze to share and collaborate heap dump analysis with your fellow engineers.

• How to capture Java heap dump?

  There are 8 options to capture heap dumps. jmap tool under <JAVA_HOME>\bin folder is an effective option. It can be invoked using the command:
  jmap -dump:format=b,file=<heap-dump-file-path> <process-id>

• HeapHero isn't able to parse my heap dumps?

  We parse multiple heap dump formats. But still, we keep uncovering new formats of heap dumps. If you can email your heap dump to support@tier1app.com, we will enhance the tool to parse it.

• How to generate an Android heap dump?

  This article walks you through various options and steps to capture android heap dumps.

• Can the tool parse both Java and Android heap dumps?

  Yes, the tool can parse binary and text format of heap dumps generated by both Java and Android platforms.

• Can I look at generated heap dump reports?

  Of course. Here are sample heap dump analysis reports generated by Heap Hero:
  a. Sample Report #1
  b. Sample Report #2
  c. Sample Report #3
  

• What is a Java heap dump and why is analyzing it important?

  A Java Heap Dump is like a photograph of your application's memory. It shows all the objects present in memory, how much space they occupy, who is referencing them, and who they are referencing. It helps answer questions such as:
  
  1. What objects are using the most memory?
  2. Are there duplicate or unnecessary objects?
  3. Are objects being retained that should've been garbage collected?
  4. Are there any memory leaks?
  5. What caused an OutOfMemoryError?
  
  Analyzing a heap dump gives you direct insight into memory problems. Instead of guessing, you can see exactly what was in memory and uncover the root causes of performance issues and crashes.

• How can I generate a Java heap dump? What are the different methods?

  There are 8 different options to generate a heap dump. In summary, they are:
  
  1. yc-360 Open-Source Script: A command-line tool that captures a heap dump and 16 additional artifacts (logs, thread dumps, GC info) to facilitate comprehensive troubleshooting. For triggering instructions, visit the yc-360 Script GitHub page.
  
  2. Jmap: A JDK tool that writes a heap snapshot (in HPROF format) of a running Java process directly to a file. Sample usage: jmap -dump:format=b[,live],file=<path> <pid>
  
  3. -XX:+HeapDumpOnOutOfMemoryError: Add this JVM argument to your app: -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=<file>. This generates a heap dump automatically whenever an OutOfMemoryError occurs.
  
  4. jcmd: A JDK utility for sending commands to a running JVM. Generate a heap dump with: jcmd <pid> GC.heap_dump <file-path>.
  
  5. JVisualVM: A GUI tool bundled with the JDK. Connect to your application and select 'Heap Dump' from the context menu to generate it interactively.
  
  6. JMX (HotSpotDiagnostic MBean): Invoke the dumpHeap(outputFile, live) operation on the HotSpotDiagnostic MBean via JMX. This is accessible using tools like JConsole, Java Mission Control, or via custom scripts.
  
  7. Programmatic Approach: Use Java code and the HotSpotDiagnostic MBean to capture heap dumps at custom points within your application. Ideal for built-in monitoring logic or diagnostics triggers.
  
  8. Application Server Features: Some application servers (e.g., IBM WebSphere) provide admin consoles or command-line utilities (like wsadmin) to create heap dumps. Navigate to sections such as Troubleshooting ? Java dumps and cores in the admin UI to generate them.
  
  To learn more about these options in detail, you may visit this blog post: HOW TO CAPTURE JAVA HEAP DUMPS?

• What is HeapHero and how can it help in heap dump analysis?

  HeapHero is a heap dump analyzer that helps you quickly identify memory issues in Java and Android apps. Here's how it can help:
  
  1. Automatic Leak Detection & Wasted-Memory Insights: HeapHero analyzes heap dumps to highlight memory leaks, detect inefficient data structures, find duplicate objects and strings, and calculate how much memory is being wasted.
  
  2. Intuitive, Shareable Reports with Collaboration Support: Generates user-friendly dashboards featuring tools like the Dominator Tree, REST API to analyzing heap dump analysis programmatically.
  
  4. Machine Learning Powered Recommendations: HeapHero uses ML to automatically flag suspects, such as surprisingly large object graphs or excessive duplicates.
  
  5. Security Since heap dump contains sensitive information such as Credit Card numbers, SSN, email addresses... HeapHero provides HeapDump Sanitization feature, using which all the raw data in the heap dump can be removed, making the analysis more secure.
  
  You can learn more about HeapHero's capabilities from here.

• What are "Leak Suspects" in a heap dump analysis tool, and how do they help?

  Leak Suspects are objects, data structures, or threads that hold unusually large amounts of memory or maintain unexpected references, which may prevent proper garbage collection. Heap dump analysis tools flag these as potential memory leak sources.
  
  

• What is a histogram in the context of heap dumps, and how can I use it to find memory issues?

  A Class Histogram is a summary view of all the classes loaded in the JVM along with the number of objects and the total memory they occupy. It provides a quick and effective way to identify which object types are consuming most of the memory, making it an essential starting point in heap dump analysis.
  
  Key elements of a Class Histogram:
  1. Fully Qualified Class Name: The class's complete name, e.g., java.lang.String.
  2. Instance Count: Total number of object instances for each class. For example: 10,477.
  3. Shallow Size: Memory occupied directly by all instances of a class, excluding referenced objects. For example: 2.39MB.
  4. Retained Size: Total memory that would be reclaimed if a class and everything reachable only through it were removed. For example: 12.46MB.
  
  

• What is the Dominator Tree and how does it help in identifying memory retention problems?

  The Dominator Tree is a powerful analysis view used for identifying memory leaks and diagnosing OutOfMemoryError in Java and Android applications. It visually represents the largest objects in memory, the amount of memory they retain, and the reference paths keeping them alive. By following these chains, you can quickly pinpoint root causes of memory retention and take corrective action.
  
  Key Features of the Dominator Tree:
  1. Largest Objects: Displays the biggest objects in the heap and the amount of memory they occupy, enabling you to immediately spot memory hogs.
  
  2. Incoming References & Outgoing References: Visualizes the object graph for any object in memory. Use Incoming References to see the chain of references that keeps an object alive, and Outgoing References to explore which child objects are held by the current object. This helps you understand both why an object is retained and what it is retaining.
  
  3. Raw Data : The Inspector view allows you to drill down into all member variables, static variables, and their current values for any object, revealing what data is bloating the heap.
  
  

• How can I identify memory leaks by analyzing a heap dump?

  Isolating memory leaks in most business applications can be simplified into three practical steps using heap dump analysis tools:
  
  1. Automatic Memory Leak Detection: Modern heap dump tools (e.g., HeapHero) leverage machine learning algorithms to automatically detect memory leaks. Leaks detected this way are highlighted prominently in the analysis report. Problem statements often contain hyperlinks-clicking them reveals in-depth details such as the leaking objects, their memory footprint, and the reference chains preventing their collection. This accelerates leak identification and investigation.
  
  2. Dominator Tree: The Dominator Tree lists the largest memory-holding objects in your application heap. Objects at the top often indicate leaks because they retain disproportionately large amounts of memory. Use the Incoming References feature to trace which objects or classes are keeping these memory hogs alive. Outgoing References let you inspect child objects and analyze raw data held, which sometimes pinpoints the root of the leak.
  
  3. Growing Objects (Class Histogram Comparison): Take 2-3 heap dump snapshots at different times and use the Class Histogram view to compare object counts. Classes whose instance counts or memory grows steadily between snapshots are strong leak candidates. Ensure snapshots are taken under similar workload or traffic conditions to avoid misinterpreting legitimate usage growth as a memory leak.
  
  

• Once I've identified a memory issue, what are the next steps to fix it?

  Finding a memory problem is just the beginning-addressing and verifying the solution is critical for robust application health. Here are the essential next steps to resolve memory issues after identification:
  
  1. Isolate the Root Cause: Drill down to the origin of the issue using tools such as Dominator Tree, Class Histogram, and GC Root Analysis. Determine if unbounded caches, unclosed listeners, ThreadLocal misuse, or static references are responsible for the retention. Knowing precisely why an object is retained enables you to select the correct fix.
  
  2. Reproduce the Problem in a Controlled Environment: Attempt to recreate the memory issue in a lower environment (like staging or local) under similar load or test scenarios. Reproducing the issue ensures your fix is valid and guards against unintended regressions.
  
  3. Apply the Fix in Code or Configuration: Once the root cause is verified, implement necessary code or configuration changes. Typical solutions include setting cache size limits or eviction policies, removing unused static references, deregistering listeners/callbacks, releasing objects from long-lived collections or sessions, and revising singleton implementations.
  
  4. Validate the Fix: After the change, rerun the application under similar load. Capture a new heap dump and compare it to the previous one. Check for decreased object counts, smaller retained sizes, and the absence of earlier leak suspects.
  
  5. Monitor in Production: Ensure long-term effectiveness by tracking memory KPIs in production - heap usage trends, GC activity, frequency of full GCs, and response times. Use tools like HeapHero, GCeasy, or your APM can help you keep an eye on post-fix behavior.
  

• Can you provide an example of a typical workflow for analyzing a heap dump using HeapHero?

  HeapHero makes heap dump analysis simple and effective - even for advanced memory issues. Here's a step-by-step example of a typical workflow in HeapHero:
  
  1. Upload Your Heap Dump: Start by uploading your Java or Android heap dump file directly to the HeapHero web tool. If automating, use the REST API to submit dumps programmatically. HeapHero will parse the heap dump and display a comprehensive, interactive report.
  
  2. Review ML-Based Problem Detection:HeapHero uses built-in machine learning to scan your heap dump for common issues like memory leaks, duplicate objects, inefficient data structures, and more. These issues are reported right at the top of your report. Just click any of them to get a closer look: you'll see which classes or objects are involved, how much memory they're using, and what keeps them alive. This will point you to the memory leak origination source.
  
  3. Take a closer look at the Dominator Tree: Next go to the Dominator Tree section, which is the most important section in the report. In this section you will see which objects are holding on to the most memory (retained size). Always objects which are holding most of memory are responsible for memory leak. Thus investigate the top nodes in this section. Use the Incoming and Outgoing References to identify who is keeping these objects alive and what objects contain which is causing the memory leak.
  
  4. Use Specialized Views:Dominator Tree should be able to resolve most of the problems. For certain rare special problems you need to use following special views like 'Class Histogram' for a sorted breakdown of object counts by class. If a particular class is creating too many instances, this section will be helpful to spot it, 'OQL' (Object Query Language) to query the objects/classes in the heap dump
  
  5. Share and Collaborate: Once your report is ready, you can generate a secure, shareable link for your teammates. And if you're working in a security-sensitive environment, HeapHero also offers on-premise deployments, so your data never leaves your firewall.
  
  

• Can I install this tool locally?

  Yes, you can install this tool locally so that you don't have to upload the dumps to our servers. Please see the pricing for this plan. You can register here to get a free 14-days trial of our on-prem enterprise edition.

If there are questions that you are looking for, please contact us at support@tier1app.com