Skip to main content

JDK7 do escape analysis by default

Posted by forax on October 6, 2009 at 1:56 PM PDT

During the JVM Summit, I was doing some tests for
my presentation with the latest
jdk7 binaries
when I've seen some *BIG* performance improvement between jdk7 b71 and jdk7 b72.

A quick look to the summary of changes, hum,
Escape Analysis is now enabled by default.

On my tests, I got a 3x improvement, Wow !

With a quick micro-benchmark, it's even better, as always :)

  class DoubleSlot {
    final int value1;
    final int value2;
    public DoubleSlot(int value1, int value2) {
      this.value1 = value1;
      this.value2 = value2;
  static int slotValue(DoubleSlot slot) {
    return slot.value1 + slot.value2;
  static int sum(int[] values) {
    int sum = 0;
    int length = values.length;
    for(int i=1; i<length; i++) {
      DoubleSlot slot = new DoubleSlot(values[i-1], values[i]);
      sum += slotValue(slot);
    return sum;

  static void test(int[] values) {
    long start = System.nanoTime();
    int value = sum(values);
    long end = System.nanoTime();
    System.out.println("time "+(end-start)+" "+value);
  public static void main(String[] args) {
    int[] values = new int[1000000];
    for(int i=0; i      values[i] = i;
    for(int i=0; i<100; i++)
    for(int i=0; i<100; i++)

With Escape Analysis, the allocation of DoubleSlot is not done anymore.

  $ /usr/jdk/jdk1.7.0b71/bin/java -server EscapeAnalysisTest
  time 8889261

  $ /usr/jdk/jdk1.7.0b73/bin/java -server EscapeAnalysisTest
  time 1408140

I love this kind of optimisation, you don't change your program,
just use a newer VM, and got a 3x improvement :)




JDK7 do escape analysis by

I just ran the test using JDK 6u23 which I believe uses version 19 of the hotspot vm.
Firstly I ran the test without specifying any jvm options and got timings of c. 7000000
I then ran the test with -server -XX:+DoEscapeAnalysis and again for timings of 7000000
I then ran the test with -server -XX:-DoEscapeAnalysis and got timings of 22000000
this reproduces the performance improvement seen in the original post (as
you would expect since JDK6u23 uses a later vm than that used in the JDK 7
based tests of the original post).
It should also be noted that the results suggest that escape analysis is switched on by default. Moving to
JDK/JRE 6u23 for production environments from previous JDK 6 releases might be a VERY big and easy win!
In addition there are other performance options available (string operation optimizations).

JDK7 do escape analysis by

With this in mind I did another micro benchmark (again with JDK 6u23):

static void test2() {
        long start = System.nanoTime();
        for( int i = 1; i&lt;1000000; i++)
          String message = &quot;hello&quot;;
          message = message + i;
        long end = System.nanoTime();
        System.out.println(&quot;time &quot; + (end - start));

    public static void main(String[] args) {

And tried

  1. no options
  2. -XX:+OptimizeStringConcat
  3. -XX:-OptimizeStringConcat

With (1) I got c. 130000000 ns, (2) I got c.80000000 ns and (3) got 130000000 ns
So the conclusion is that the option is having an effect but that it is not enabled by default .
There seems to be a 40% improvement using the option for the test case

Great but not perfect

Escape analysis is a great feature indeed, as it can alleviate the dilemma between writing fast code or flexible, object-oriented code. For example, knowing that an array wrapped into a temporary list object using Arrays.asList is as fast as accessing the array itself, one would never have to think whether to choose a List or an array when making an API for one's own components, as a List is far more flexible.

I made a benchmark with two classes: one, named EscapeAnalysisTest, was the same as in the benchmark in the blog, except that I replaced the time printing statement

System.out.println("Time "+(end-start)*1E-6+" ms. Checksum: "+value);

for better readability. In the other one, named NoEscapeAnalysisNeeded, I removed the class DoubleSlot and replaced the sum method with the following one:

static int sum(int[] values) {
int sum = 0;
int length = values.length;
for(int i=1; i<length; i++) {
int value1 = values[i-1];
int value2 = values[i];
sum += value1 + value2;
return sum;

The results are following (on my AMD Sempron 3000+ with 64-bit openSuse 11.1 with Sun's 32-bit Java 1.6.0_15): java -server EscapeAnalysisTest had times around 49 ms, java -server -XX:+DoEscapeAnalysis EscapeAnalysisTest had times around 6.0 ms (8 times improvement!) and java -server NoEscapeAnalysisNeeded had times around 4.8 ms independent of the -XX:+DoEscapeAnalysis option.

I also tried 64-bit openjdk (containing OpenJDK 64-Bit Server VM 14.0-b16) on the same machine: java -server EscapeAnalysisTest improved to 43 ms and NoEscapeAnalysisNeeded improved to 3.4 ms but java -server -XX:+DoEscapeAnalysis EscapeAnalysisTest stayed at 6.0 ms.

So although escape analysis already provides a big performance boost, for some reason code with objects eliminated by EA is still not as exactly as fast code without objects in the first place. I guess here is a little room for further improvement.

Great start, but

I hope gets fixed soon. Then my benchmark will improve too ;-)

Will also become available in JDK6

Hi, Escape analysis and compressed references have been enabled by default in HS17 (HotSpot version) and this will eventually be available in JDK6 too (JDK6u18 early access includes HS16, so probably sometime next year). Best, Ismael

... will eventually be available in JDK6 too

To my understanding, Escape analysis with respect to scalar replaceable object allocations from the heap is available since build 1.6.0_14

Yes, but not by default.

Yes, but not by default.

Does/will EA get applied by

Does/will EA get applied by the C1 compiler? (I've just started using the C1-only 'embedded' SE Sun HotSpot JRE!) Rgds Damon

EA is not done by C1

Hi Damon,

Escape analysis is a C2 feature only.
Will it be included in C1 ? I don't know.