Question

This is homework, not going to lie. I need to write a program which will generate “java.lang.OutOfMemoryError: PermGen space” error.

Since I wasn’t able to attend the lecture, I did hours of research yesterday and this is what I have so far.

At first I created a program and I got constantly this error:

java.lang.OutOfMemoryError: GC overhead limit exceeded

Okay, so I did some more research and understood that I didn’t get PermGen error because, although that I created objects(String objects) I didn’t use them again, so they were considered Garbage. So I changed my code and got constantly this:

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

So this is the code I had at that point:

import java.util.ArrayList;
import java.util.List;

public class Test {

public static void main(String[] args) {
    List<String> test = new ArrayList<String>();
    test.add(new String(""));

    for (;;) {
        for (int i = 0; i<test.size(); i++){
            test.add(test.get(i));
        }
    }
}
}

Also under VM arguments I had “-XX:PermSize=2m” (I have tried different values).
I was told that my code is wrong because it uses the same String over and over. So I tried to change that but I was still unsuccessful.
Then I found this code: (Algorithms that lead to java.lang.OutOfMemoryError: PermGen space error)

Random rnd = new Random();
List<String> interned = new ArrayList<String>();
for (;;) {
    int length = rnd.nextInt(100);
    StringBuilder builder = new StringBuilder();
    String chars = "abcdefghijklmnopqrstuvwxyz";
    for ( int i = 0; i < length; i++ ) {
        builder.append(chars.charAt(rnd.nextInt(chars.length())));
    }
    interned.add(builder.toString().intern());
}

So if I understand correctly this should give me PermGen error? But I still get java heap error.

Also I found this:
http://javaeesupportpatterns.blogspot.com/2011/10/java-7-features-permgen-removal.html
Again if I understand correctly, then when using java7 maybe the java heap space error is the one I should be getting? That it’s not possible to get PermGen error anymore? Okay, so I’ve tried to change the compiler and project version to java 6. But still got Java heap space error.

I know it’s my fault that I didn’t attend the lecture, but I could use some help to understand what am I doing wrong here or what am I missing?

Answer 1

First, simple one liner how you can reproduce perm gen error (just recursively call main):

public class PermGenError {
    public static void main(String[] args) {
        main(new String[] { (args[0] + args[0]).intern() });
    }
}

Should be launched with parameters:

whatever -XX:PermSize=8M -XX:MaxPermSize=8M

Second, why your example its not producing perm gen error? You usage of string intern is correct. However in latest JMV specification java virtual machine can move internalized strings out from permanent generation to another one. Real life scenario (happened on production 🙂 ) is that you could see perm gen 99% full, application extremely slow and jvm not throwing any erros because its constantly reshuffling objects between generations.

Third, the best paper which I’ve read and constantly referring to for any GC/Memory issue is Tuning Garbage Collection with the 5.0 Java[tm] Virtual Machine

EDIT:

Update to question is:

Example works fine, but still doesn’t work when I’m specifying large perm
size – getting ‘Java heap space’

Update to answer is:

There are two aspets you need to be aware when specifying larger perm gen size:

1. All objects first go to one of younger generations. Therefore if your perm gen size is bigger than size of first generation Java heap space will be thrown first. In this particular example I’m using one large string which exceeds perm gen size in order to reproduce error. If you want to reproduce ‘PermGen space’ then you need to specify heap size as well. For example:

   • -Xms2048m -Xmx2048m -XX:PermSize=512M -XX:MaxPermSize=512M – will result in ‘PermGen space’ (large heap, small perm gen)
   • -Xms512m -Xmx512m -XX:PermSize=2048M -XX:MaxPermSize=2048M – will result in ‘Java heap space’ (small heap, large perm gen)

2. Second aspect is that the heap is divided into generations and memory in heap itself is fragmented. So when you specifying heap size of 512M you cant fit string of half a gigabyte long into memory (because string internally implemented as array and need to be stored as one sequential chunk in memory). The largest you could fit is probably around half that size(it depends on how badly memory is fragmented).