Home » Java » Core Java » GC overhead limit exceeded – Java Heap analysis

About Pierre Hugues Charbonneau

Pierre-Hugues Charbonneau (nickname P-H) is working for CGI Inc. Canada for the last 10 years as a senior IT consultant. His primary area of expertise is Java EE, middleware & JVM technologies. He is a specialist in production system troubleshooting, root cause analysis, middleware, JVM tuning, scalability and capacity improvement; including internal processes improvement for IT support teams. P-H is the principal author at Java EE Support Patterns.

GC overhead limit exceeded – Java Heap analysis

This post is the continuation of our original GC overhead limit exceeded problem patterns post. Proper Java Heap analysis is critical in order to eliminate your OutOfMemoryError: GC overhead problem. If you are not familiar with this Java HotSpot 1.6 error, I recommend that you first review my First Article on this subject.
This article will provide you with a sample program and a tutorial on how to analyze your Java HotSpot Heap footprint using Memory Analyzer following an OutOfMemoryError. I highly recommend that you execute and analyse the Heap Dump yourself using this tutorial in order to better understand these principles.
Troubleshooting tools
** all these tools can be downloaded for free **

 

  •  Eclipse Indigo Release
  •  Memory Analyzer via IBM Support Assistant 4.1 (HotSpot Heap Dump analysis)
  • Java VM: Windows HotSpot JRE 1.6.0_24 64-bit
Sample Java program
The simple sample Java program below will be used to triggered an OutOfMemoryError; allowing us to analyze the generated HotSpot Heap Dump file. Simply create a new Java class : JVMOutOfMemoryErrorSimulator.java to the Eclipse project of your choice and either rename or keep the current package as is.
This program is basically creating multiple String instances within a Map data structure until the Java Heap depletion.
GC_overhead_Eclipse_Project
** please make sure your Eclipse compiler and JRE is 1.6 **
package org.ph.javaee.javaheap;

import java.util.Map;
import java.util.HashMap;

/** 
* JVMOutOfMemoryErrorSimulator 
* 
* @author PH 
*  
*/public class JVMOutOfMemoryErrorSimulator {

       private final static int NB_ITERATIONS = 500000;

       // ~1 KB data footprint       
       private final static String LEAKING_DATA_PREFIX = "datadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadat
adatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadat
adatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadat
adatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadat
adatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadat
adatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadatadata";

       // Map used to stored our leaking String instances       
       private static Map<String, String> leakingMap;

       static {              
              leakingMap = new HashMap<String, String>();       
       }

       /**        
        * @param args        
        */       
        public static void main(String[] args) {

              System.out.println("JVM OutOfMemoryError Simulator 1.0");          
              System.out.println("Author: Pierre-Hugues Charbonneau");          
              System.out.println(" http ://javaeesupportpatterns.blogspot.com/");

              try {

                     for (int i = 0; i < NB_ITERATIONS; i++) {

                          String data = LEAKING_DATA_PREFIX + i;

                          // Add data to our leaking Map data structure...      
                          leakingMap.put(data, data);

                     }

              } catch (Throwable any) {                     
                     if (any instanceof java.lang.OutOfMemoryError){
                             System.out.println("OutOfMemoryError triggered! "
                                         + any.getMessage() + " [" + any + "]");

                     } else {                           
                           System.out.println("Unexpected Exception! " + 
                                   any.getMessage() + " [" + any + "]"); 
                            }              
                     }

                     System.out.println("simulator done!");       
            }

}
Step #1 – Setup your JVM start-up arguments
First, setup your Eclipse Java runtime arguments as per below. For our example, we used an external JRE 1.6 outside the Eclipse IDE with a Java Heap maximum capacity of 512 MB.
The key JVM argument allowing us to generate a Heap Dump is -XX:+HeapDumpOnOutOfMemoryError which tells the JVM to generate a Heap Dump following an OutOfMemoryError condition.
GC_overhead_Run_Configuration
GC_overhead_Run_Configuration_JVM
Step #2 – Run the sample Java program
The next step is to run our Java program. Depending on your computer specs, this program will run between 5-30 seconds before existing with an OutOfMemoryError.
GC_overhead_Run_Java_Program_Exec
As you can see, the JVM generated a Heap Dump file java_pid3880.hprof . It is now time to fire the Memory Analyzer tool and analyze the JVM Heap Dump.

Step #3 – Load the Heap Dump
Analyzing a Heap Dump is an analysis activity that can be simple or very complex. The goal of this tutorial is to give you the basics of Heap Dump analysis. For more Heap Dump analysis, please refer to the other case studies of this Blog.
GC_overhead_Heap_Dump_analysis1
GC_overhead_Heap_Dump_analysis2
GC_overhead_Heap_Dump_analysis3
Step #4 – Analyze Heap Dump
Below are the snapshots and analysis steps that you can follow to understand the memory leak that we simulated in our sample Java program.
GC_overhead_Heap_Dump_analysis4
GC_overhead_Heap_Dump_analysis5
GC_overhead_Heap_Dump_analysis6
GC_overhead_Heap_Dump_analysis7
As you can see, the Heap Dump analysis using the Memory Analyzer tool was able to easily identify our primary leaking Java class and data structure.
Conclusion
I hope this simple Java program and Heap Dump analysis tutorial has helped you understand the basic principles of Java Heap analysis using the raw Heap Dump data. This analysis is critical when dealing with OutOfMemoryError: GC overhead problems since those are symptoms of either Java Heap leak of Java Heap footprint / tuning problem.

 

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

 

3 comments

  1. Hi,

    When accessing the link http://javaeesupportpatterns.blogspot.com.br/2011/08/gc-overhead-limit-exceeded-problem-and.html%20, I get “Sorry, the page you were looking for in this blog does not exist.”

    Could you please fix that?

    Thanks!

  2. Hi, thanks for the article. There is a problem with the images, I can’t see them.

Leave a Reply

Your email address will not be published. Required fields are marked *

*


2 + four =

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Want to take your Java Skills to the next level?
Grab our programming books for FREE!
  • Save time by leveraging our field-tested solutions to common problems.
  • The books cover a wide range of topics, from JPA and JUnit, to JMeter and Android.
  • Each book comes as a standalone guide (with source code provided), so that you use it as reference.
Last Step ...

Where should we send the free eBooks?

Good Work!
To download the books, please verify your email address by following the instructions found on the email we just sent you.