Escape Analysis
"Escape analysis" is a memory optimization added to Java SE 6. Java VMs operate on memory in a stack that is independent for each running thread and a heap that is shared by all threads. Memory allocations to the stack are faster because the extra synchronization performed by the heap is not needed. Deallocations are essentially free because stack memory is cleared when an execution block returns to its caller. However, there is no way to explicitly code an object allocation to go to the stack instead of the heap. Java SE 6 adds the ability to identify objects that will not escape the execution block, where they are allocated and directly allocate to the stack. This results in a faster allocation and no accumulation of objects for garbage collection.
Example 2(a) allocates a new Rectangle object 10,000,000,000 times to calculate the area of each size combination. Java 5.0 executes this loop in 212 seconds, while Java SE 6 executes it in 189 seconds. Unnecessary synchronization in Java 5.0 for allocations to the heap is likely the reason for the extra 12 percent in time consumed.
<b>(a)</b>
for (int x = 0; x < 100000; x++) {
for (int y = 0; y < 100000; y++) {
Rectangle rectangle = new Rectangle (x, y);
rectangle.area ();
}
}
<b>(b)</b>
Rectangle rectangle = new Rectangle ();
for (int x = 0; x < 100000; x++) {
for (int y = 0; y < 100000; y++) {
rectangle.setHeight (y);
rectangle.setWidth (x);
rectangle.area ();
}
}
Escape analysis can be applied to many common objects in a typical Java application. An additional improvement would be to reuse the allocated memory for each subsequent pass, but the Java SE 6 runtime does not seem to be doing that for this example. Careful programming can again produce benefits beyond compiler and VM optimizations.
Moving the Rectangle object allocation outside the loop, see Example 2(b), causes the same object to be reused (rather than reallocated) during each loop. This implementation change optimizes the example to run in approximately 20 seconds—one order of magnitude faster. Typical programs will not be allocating in a loop, but usually allocate some object or array temporarily in a method body. If the method were called repeatedly in a thread-safe manner, it would be worthwhile to allocate the object only once and store it in a class field.
Although optimizations in new versions of Java VM are nice, they are still no replacement for careful coding. Enhancements to reuse objects with escape analysis certainly helps with this example, but in general, think seriously about memory allocations if performance is important.
