Navigation
Main Page
Community portal
Current events
Recent changes
Random page
Help

Eclipse Memory Analyzer Mat
Eclipse Memory Analyzer Java Heap Space

Release Date: Wednesday, June 27, 2018. Deliverables: Check and fix Memory Analyzer running under Java 9 or Java 10. Check and fix the loading and indexing of dumps from Java 9 and Java 10. Fix queries including collections and Equinox bundles for new releases of Java and Eclipse. Fix some reproducible bugs reported by end users.
The Eclipse Memory Analyzer tool (MAT) is a fast and feature-rich heap dump analyzer that helps you find memory leaks and analyze high memory consumption issues. With Memory Analyzer one can easily. Find the biggest objects, as MAT provides reasonable accumulated size (retained size) explore the object graph, both inbound and outbound.
It is not necessary to download the source of Memory Analyzer to be able to write extensions. A recent binary version is sufficient. Have a copy of an Eclipse Java Development environment installed; Download a recent copy of of Memory Analyzer from October 2010 or later Download Memory Analyzer 1.12.0 Download site.

Memory Analyzer; Memory Analyzer (Charts) optional In Eclipse MARS these can be found under Performance, Profiling and Tracing Tools. Reading a heap dump. Opening a.hprof file in Eclipse will load it into the Memory Analyzer plugin. Select “Leak Suspect Report” and click Finish to see an analysis of the heap dump.

Toolbox
Page information
Permanent link
Printable version
Special pages
Related changes
What links here

2Getting Started
3Getting a Heap Dump

About

The Eclipse Memory Analyzer tool (MAT) is a fast and feature-rich heap dump analyzer that helps you find memory leaks and analyze high memory consumption issues.

With Memory Analyzer one can easily

find the biggest objects, as MAT provides reasonable accumulated size (retained size)
explore the object graph, both inbound and outbound references
compute paths from the garbage collector roots to interesting objects
find memory waste, like redundant String objects, empty collection objects, etc...

Getting Started

Installation

See the download page for installation instructions.

Basic Tutorials

Both the Basic Tutorial chapter in the MAT documentation and the Eclipse Memory Analyzer Tutorial by Lars Vogel are a good first reading, if you are just starting with MAT.

Further Reading

Check MemoryAnalyzer/Learning Material. You will find there a collection of presentations and web articles on Memory Analyzer, which are also a good resource for learning. These pages Querying Heap Objects (OQL)OQL SyntaxMemoryAnalyzer/OQL also explain some of the ways to use Object Query Language (OQL)

Getting a Heap Dump

HPROF dumps from Sun Virtual Machines

The Memory Analyzer can work with HPROF binary formatted heap dumps. Those heap dumps are written by Sun HotSpot and any VM derived from HotSpot. Depending on your scenario, your OS platform and your JDK version, you have different options to acquire a heap dump.

Non-interactive

If you run your application with the VM flag -XX:+HeapDumpOnOutOfMemoryError a heap dump is written on the first Out Of Memory Error. There is no overhead involved unless a OOM actually occurs. This flag is a must for production systems as it is often the only way to further analyze the problem.

As per this article, the heap dump will be generated in the 'current directory' of the JVM by default. It can be explicitly redirected with -XX:HeapDumpPath= for example -XX:HeapDumpPath=/disk2/dumps . Note that the dump file can be huge, up to Gigabytes, so ensure that the target file system has enough space.

Interactive

As a developer, you want to trigger a heap dump on demand. On Windows, use JDK 6 and JConsole. On Linux and Mac OS X, you can also use jmap that comes with JDK 5.

Via MAT:

tutorial here

Via Java VM parameters:

-XX:+HeapDumpOnOutOfMemoryError writes heap dump on OutOfMemoryError (recommended)
-XX:+HeapDumpOnCtrlBreak writes heap dump together with thread dump on CTRL+BREAK
-agentlib:hprof=heap=dump,format=b combines the above two settings (old way; not recommended as the VM frequently dies after CTRL+BREAK with strange errors)

Via Tools:

Sun (Linux, Solaris; not on Windows) JMap Java 5: jmap -heap:format=b <pid>
Sun (Linux, Solaris; Windows see link) JMap Java 6: jmap.exe -dump:format=b,file=HeapDump.hprof <pid>
Sun (Linus, Solaris) JMap with Core Dump File: jmap -dump:format=b,file=HeapDump.hprof /path/to/bin/java core_dump_file
Sun JConsole: Launch jconsole.exe and invoke operation dumpHeap() on HotSpotDiagnostic MBean
SAP JVMMon: Launch jvmmon.exe and call menu for dumping the heap

Heap dump will be written to the working directory.

Vendor / Release	VM Parameter	VM Tools
On OoM	On Ctrl+Break	Agent	JMap	JConsole
Sun, HP
1.4.2_12	Yes	Yes	Yes
1.5.0_07	Yes	Yes (Since 1.5.0_15)	Yes	Yes (Only Solaris and Linux)
1.6.0_00	Yes	Yes	Yes	Yes
SAP
1.5.0_07	Yes	Yes	Yes	Yes (Only Solaris and Linux)

System Dumps and Heap Dumps from IBM Virtual Machines

Memory Analyzer may read memory-related information from IBM system dumps and from Portable Heap Dump (PHD) files with the IBM DTFJ feature installed. Once installed, then File > Open Heap Dump should give the following options for the file types:

All known formats
HPROF binary heap dumps
IBM 1.4.2 SDFF
IBM Javadumps
IBM SDK for Java (J9) system dumps
IBM SDK for Java Portable Heap Dumps

For a comparison of dump types, see Debugging from dumps. System dumps are simply operating system core dumps; therefore, they are a superset of portable heap dumps. System dumps are far superior than PHDs, particularly for more accurate GC roots, thread-based analysis, and unlike PHDs, system dumps contain memory contents like HPROFs. Older versions of IBM Java (e.g. < 5.0SR12, < 6.0SR9) require running jextract on the operating system core dump which produced a zip file that contained the core dump, XML or SDFF file, and shared libraries. The IBM DTFJ feature still supports reading these jextracted zips; however, newer versions of IBM Java do not require jextract for use in MAT since DTFJ is able to directly read each supported operating system's core dump format. Simply ensure that the operating system core dump file ends with the .dmp suffix for visibility in the MAT Open Heap Dump selection. It is also common to zip core dumps because they are so large and compress very well. If a core dump is compressed with .zip, the IBM DTFJ feature in MAT is able to decompress the ZIP file and read the core from inside (just like a jextracted zip). The only significant downsides to system dumps over PHDs is that they are much larger, they usually take longer to produce, they may be useless if they are manually taken in the middle of an exclusive event that manipulates the underlying Java heap such as a garbage collection, and they sometimes require operating system configuration (Linux, AIX) to ensure non-truncation.

In recent versions of IBM Java (> 6.0.1), by default, when an OutOfMemoryError is thrown, IBM Java produces a system dump, PHD, javacore, and Snap file on the first occurrence for that process (although often the core dump is suppressed by the default 0 core ulimit on operating systems such as Linux). For the next three occurrences, it produces only a PHD, javacore, and Snap. If you only plan to use system dumps, and you've configured your operating system correctly as per the links above (particularly core and file ulimits), then you may disable PHD generation with -Xdump:heap:none. For versions of IBM Java older than 6.0.1, you