Companies Trusted and Collaborated with us

HIGHLIGHTS

How Much Memory Your Application Wastes?

Due to inefficient programming, modern applications waste 30% to 70% of memory. HeapHero is the industry's first tool to detect the amount of wasted memory. It reports what lines of source code originating the memory wastage and solutions to fix them.

Android Memory Leak

Android mobile applications can also suffer from memory leaks, which can be attributed to poor programming practices. Memory leaks in mobile apps bare direct consumer impact and dissatisfaction. Memory leak slows down the application's responsiveness, makes it hang or crashes the application entirely. It will leave an unpleasant and negative user experience.

Java Memory Leak

A Memory leak is a type of resource drain that occurs when an application allocates memory and does not release after finish using it. This allocated memory can not be used for any other purpose and it remains wasted. As a consequence, Java applications will exhibit one or more of these non-desirable behaviors: poor response time, long JVM pauses, application hang, or even crash.

OutOfMemoryError

One common indication of a memory problem is the java.lang.OutOfMemoryError. This error is typically thrown when there is insufficient space to create a new object in the Java heap. There are 8 flavors of OutOfMemoryError. Each flavor of OutOfMemoryError has different causes and solutions.

Memory Regression

Sometimes the latest version of an application might be consuming more memory than the previous version. You need to analyze what are the large objects residing in the memory? Where is it being created? Where is it being held up? Answers to all these questions can be found in Heap Hero's Heap Analysis Report.

Memory Hogs

Wrong data structure choice, created but unused data structure, overallocated and underutilized data structure, suboptimal data type usage (i.e., using 'long' instead of 'int'), data duplication - all these can easily waste 30 - 70% of your memory. Heap Hero's intelligence report helps eliminate these memory hogs.

ANALYZER

Universal Memory Analyzer

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.

OPTIMIZER

Android Memory Optimizer

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.

HIGHLIGHTS

Heap Dump Analysis Tool Beauty to the Beast

Analyzing heap dump doesn't have to be a tedious job. it can be fun, and it can be 'wow'.

Optimize Memory

Memory Hogs

OutOfMemory Error

Detect Memory Leak

SERVICES

Our Services

Consulting

We have optimized hundreds of open source and enterprise applications. Please take advantage of our battle-fought experience. We can either come on-site or provide remote consulting services.

Training

Our easy to understand, fun-filled, on-site training programs are a preferred choice for several enterprises to transform thier engineers into performance experts.

Scaling in AWS

Are you looking to port your application to the AWS cloud? Are you following the AWS best practices? Are looking to lower your AWS bills? We are here to help you.

Learn JVM Performance and Troubleshooting
Explore Our Course
TRAINING COURSE

Learn JVM Performance and Troubleshooting

  • Become a world class JVM performance expert
  • Troubleshoot production performance problems in a fraction of time

Instructor: Ram Lakshmanan, Architect of GCeasy

What's included:

  • 9 hours of video series with case studies and real life examples

  • 3 months yCrash tool subscription

  • e-books and study material to complete this course

  • LinkedIn shareable certificate

  • 1 year course subscription

Attended by engineers from all over the world from the premier brands

+ many more
4.8 Stars Learner Rating

Hall Of Fame

yCrash Certified Engineers in
Performance & Troubleshooting

Highlighting engineers certified in diagnosing and
optimizing applications.

Kris Murray

Kris Murray

With over 21 years of professional experience, Kris Murray is currently employed full-time at CloudBees as a Development Support Engineer.

Designation
Development Support Engineer
Experience
21+ yrs
Company
Cloudbees
Kris Murray

Subijay Bhattacharya

Have 18+ years of experience in Telecom and Insurance domain and worked on Java/J2EE, Hybrid Android

Designation
Product Architect
Experience
20+ yrs
Company
Motive
Kris Murray

Brijmohan Singh

Specialties: Agile, SCRUM , Product manager, Portfolio manager, Technical Account Manager (TAM), Collection & Recoveries

Designation
Senior Manager
Experience
16+ yrs
Company
CRsoftware

COOL TOOLS

Check Out Our Other Products

GCeasy

GCeasy

Universal Garbage collection log analysis tool. Tune and troubleshoot memory and GC problems.

Learn More
ycrash

yCrash

Automatically captures & analyzes GC Logs, thread dumps, heap dumps & several more artifacts to identify root cause.

Learn More
FastThread

fastThread

Machine learning algorithms aided tool to analyze the thread dumps, core dumps, and also hs_err_pid dumps.

Learn More
Top Analyzer

Top Analyzer

Parses Unix/Linux/solaris,..etc 'top' command output & generates an intuitive report to optimize the performance.

Learn More
FastThread

BuggyApp

Simulates performance problems like Memory Leak, OutOfMemoryError, CPU spike, StackOverflowError etc.

Learn More

FAQ

Frequently Asked Questions

Java GC Tuning is made to appear as rocket science, but it's a common sense!

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>

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.

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

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

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

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.

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?

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.

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.

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.

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.

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.

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.

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.

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

Want to try HeapHero?

Try 14-day's Trial Youtube Icon Watch a Video