JVM Internals - Garbage Collection & Runtime Optimizations

JVM Internals
Douglas Q. Hawkins

Sunday, August 15, 2010

JVM Internals

Bytecode
Garbage Collection
Optimizations
Compile Time
Run Time


Java Bytecode


Java Bytecode
Local Variables
Stack Based
Operand Stack
Local Variable Space


Java Bytecode
Local Variables
Stack Based
Operand Stack

3


Java Bytecode
Local Variables
Stack Based
Operand Stack

7
3


Java Bytecode
Local Variables
Stack Based
Operand Stack

7 +
3


Java Bytecode
Local Variables
Stack Based
Operand Stack

3+ 7


Java Bytecode
Local Variables
Stack Based
Operand Stack

10


Operation Types
Load and Store
Arithmetic and Logic
Type Conversion
Control Transfer
Object Creation and Manipulation
Operand Stack
Method Invocation


Demo


Garbage Collection


Garbage Collection
Generational Garbage Collection
Segmented into Young, Old, and Permanent
Generations

Types of Collectors
Parallel - across multiple threads
Concurrent - while program runs


Generational Garbage
Collection
Young Generation

Eden

Survivor
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden A B

Survivor
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden A B C D

Survivor
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden A B C D E F G

Survivor
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden A C D G

Survivor
B E F
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden

Survivor
B E F
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden H I J K L M N

Survivor
B E F
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden H I K L M N

Survivor
F B E J
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden

Survivor
B E J
Spaces
Old Generation
Tenured


Collection
Young Generation

Eden

Survivor
Spaces
Old Generation
Tenured B E J


Garbage Collection Pattern
Minor
Major
Major Again - for objects with ﬁnalize
Soft References
Major
Major Again - for objects with ﬁnalize
Throw OutOfMemoryError


Optimizations


Optimizations
Just In Time Compilation
Purely Interpreted
Ahead of Time Compilation

Almost No Compile Time Optimization
Most Optimizations are Runtime


Compile Time Demo


Is This Optimized?
double sumU = 0, sumV = 0;
for ( int i = 0; i < 100; ++i ) {
Vector2D vector = new Vector2D( i, i );
synchronized ( vector ) {
sumU += vector.getU();
sumV += vector.getV();
}
}


Is This Optimized?
for ( int i = 0; i < 100; ++i ) {
sumU += vector.getU(); How many...?
sumV += vector.getV(); Loop Iterations
}
Heap Allocations
}
Method Invocations
Lock Operations


Is This Optimized?
for ( int i = 0; i < 100; ++i ) {
sumV += vector.getV(); Loop Iterations 100
}
Heap Allocations 100
}
Method Invocations 200
Lock Operations 100


Is This Optimized?
for ( int i = 0; i < 100; ++i ) {
sumV += vector.getV(); Loop Iterations 0
}
Heap Allocations 0
}
Method Invocations 0
Lock Operations 0


Common Sub-Expression
Elimination
int x = a + b;
int y = a + b;


Common Sub-Expression
Elimination
int x = a + b;
int y = a + b;

int tmp = a + b;
int x = tmp;
int y = tmp;


Array Bounds Check Elimination
int[] nums = ...
for ( int i = 0; i < nums.length; ++i ) {
System.out.println( “nums[“ + i + “]=” + nums[ i ] );
}


Array Bounds Check Elimination
int[] nums = ...
}

int[] nums = ...
if ( i < 0 || i >= nums.length ) {
throw new ArrayIndexOutOfBoundsException();
}
}


Loop Invariant Hoisting
...
}


Loop Invariant Hoisting
...
}

int length = nums.length;
for ( int i = 0; i < length; ++i ) {
...
}


Loop Unrolling
int sum = 0;
for ( int i = 0; i < 10; ++i ) {
sum += i;
}


Loop Unrolling
int sum = 0;
for ( int i = 0; i < 10; ++i ) {
sum += i;
}

int sum = 0;
sum += 1;
...
sum += 9;


Method Inlining
Vector vector = ...
double magnitude = vector.magnitude();


Method Inlining
Vector vector = ...

Vector vector = ...
double magnitude = Math.sqrt(
vector.u*vector.u + vector.v*vector.v );


Method Inlining
Vector vector = ...

Vector vector = ...

Vector vector = ...
double magnitude;
if ( vector instance of Vector2D ) {
magnitude = Math.sqrt(
} else {
magnitude = vector.magnitude();
}

Method Inlining
Vector vector = ...
static always
Vector vector = ...
ﬁnal always
vector.u*vector.u + vector.v*vector.v ); private always
virtual often
Vector vector = ...
reﬂective sometimes
double magnitude;
if ( vector instance of Vector2D ) { dynamic often
magnitude = Math.sqrt(
} else {
magnitude = vector.magnitude();
}

Lock Coarsening
StringBuffer buffer = ...
buffer.append( “Hello” );
buffer.append( name );
buffer.append( “n” );


Lock Coarsening

lock( buffer ); buffer.append( “Hello” ); unlock( buffer );
lock( buffer ); buffer.append( name ); unlock( buffer );
lock( buffer ); buffer.append( “n” ); unlock( buffer );


Lock Coarsening

lock( buffer ); buffer.append( “Hello” ); unlock( buffer );
lock( buffer ); buffer.append( name ); unlock( buffer );
lock( buffer ); buffer.append( “n” ); unlock( buffer );

lock( buffer );
unlock( buffer );

Other Lock Optimizations
Biased Locking
Adaptive Locking - Thread sleep vs. Spin lock


Escape Analysis
Point p1 = new Point( x1, y1 ), p2 = new Point( x2, y2 );
synchronized ( p1 ) {
synchronized ( p2 ) {
double dx = p1.getX() - p2.getX();
double dy = p1.getY() - p2.getY();
double distance = Math.sqrt( dx*dx + dy*dy );
}
}


Escape Analysis


Escape Analysis

double dx = x1 - x2;
double dx = y1 - y2;


Run Time Demo


Resources
Brian Goetz

Developer Works Articles

Tony Printezis

Garbage Collection in the Java HotSpot Virtual Machine - http://www.devx.com/
Java/Article/21977

Java Specialist Newsletter - http://www.javaspecialists.eu/

http://java.sun.com/javase/6/docs/technotes/guides/vm/cms-6.html

http://java.sun.com/docs/hotspot/gc1.4.2/faq.html

http://www.fasterj.com/articles/G1.html

http://www.informit.com/guides/content.aspx?g=java&seqNum=27


JVM Internals - Garbage Collection & Runtime Optimizations

More Related Content

Similar to JVM Internals - Garbage Collection & Runtime Optimizations

More from Doug Hawkins

Recently uploaded

JVM Internals - Garbage Collection & Runtime Optimizations