Inside the Machine Meetup

1. @Work_at_Murex

2. •
•

3. • https://community.oracle.com/groups/beirut-java-user-group

5. •
•

6. •
•
•
•






7. Java code
Java
compiler
Bytecode
JVM
Windows Unix Mac
JVM JVM

8. 1.



2.



•
•

9. •


•




•




10. •




11. •
•

12. int long2
Local variables
long1
Operand stack
long
objectref

13. •
 Finding class representation and creating runtime representation of class in the
JVM (in the method area)
 Done by a class loader, and triggered by another type referencing the class in
its run-time constant pool

14. •
 Bootstrap class loader (built into the JVM)
 User-defined class loaders (subclass of ClassLoader)
•
•
1. Its fully qualified name
2. Its defining class loader

15. •
 verifying correct structure of class representation
 creating and initializing static fields
 Resolves symbolic references from the constant pool
 Examples:
iconst_0
istore_0
aload_0  VerifyError due to wrong type

16. •
 Triggered upon execution of new, getstatic, putstatic, invokestatic; or
upon initialization of a subclass
 JVM synchronizes the initialization to avoid multiple threads initializing the
same class or recursive initialization.

17. ClassFile {
magic (4 bytes)
minor_version (2 bytes)
major_version (2 bytes)
constant_pool_count (2 bytes)
constant_pool[constant_pool_count-1] (cp_info structure)
access_flags (2 bytes)
this_class (2 bytes)
super_class (2 bytes)
interfaces_count (2 bytes)
interfaces[interfaces_count] (2 bytes)
fields_count (2 bytes)
fields[fields_count] (field_info structure)
methods_count (2 bytes)
methods[methods_count] (method_info structure)
attributes_count (2 bytes)
attributes[attributes_count] (attribute_info structure)
}
Stream of bytes stored in big-endian format, without padding or alignment

18. • Acts as a symbol table containing constants and symbolic references to classes,
fields and methods
• Every entry has the syntax:
• CONSTANT_Utf8, CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long,
CONSTANT_Double, CONSTANT_Class, CONSTANT_String, CONSTANT_Fieldref,
CONSTANT_Methodref, CONSTANT_MethodType, CONSTANT_Package,
CONSTANT_Module, …
• Example: CONSTANT_MethodType_info
String toString(int x)
tag entry_info
(1 byte) (>= 2 bytes)
16 -> (I)Ljava/lang/String;
(tag) (index to method descriptor)

19. access_flags (2 bytes)
name_index (2 bytes)
descriptor_index (2 bytes)
attributes_count (2 bytes)
attributes[attributes_count] (attribute_info)
• Access flags:
ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, ACC_VOLATILE,
ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM

20. access_flags (2 bytes)
name_index (2 bytes)
descriptor_index (2 bytes)
attributes_count (2 bytes)
attributes[attributes_count] (attribute_info)
• Access flags:
ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, ACC_SYNCHRONIZED,
ACC_BRIDGE, ACC_VARARGS, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT, ACC_SYNTHETIC

21. •


•



22. objectref
invokevirtual indexbyte1 indexbyte2
Invokes an instance method based on the object reference on the operand stack
1. indexbyte1 and indexbyte2 are used to fetch method from constant pool
2. The method is looked up from the class containing the method
3. The actual method invoked depends on the actual class C of objectref (could be declared
in C, its superclass or superinterfaces)
arg2
arg1
objectref
. . .
New
frame
. . .
arg1 arg2
Local variables

23. invokestatic indexbyte1 indexbyte2
Invokes a static method based
 indexbyte1 and indexbyte2 are used to fetch method from constant pool
 Class or interface declaring the method is initialized if not already done
arg2
arg1
(double)
. . .
New
frame
. . . arg1 arg2
Local variables
arg1
arg1

24. invokespecial indexbyte1 indexbyte2
Invokes:
 private methods
 methods on superclass
 instance initialization methods (<init>)
objectref
arg2
arg1
objectref
. . .
New
frame
. . .
arg1 arg2
Local variables

25. invokeinterface indexbyte1 indexbyte2 count 0
Invokes interface methods
 count contains number of arguments (for historical reasons)
objectref
arg2
arg1
objectref
. . .
New
frame
. . .
arg1 arg2
Local variables

26. •
•
•

29. Interpreter
Native
execution
C1 C2
Code
cache

30. public void foo() {
int sum = add(8, 10);
// ...
}
public int add(int x, int y) {
return x + y;
}
-XX:InlineSmallCode=n
-XX:MaxInlineSize=35
-XX:FreqInlineSize=n

31. public void foo() {
int[] input = getInput();
int value = computeValue(input);
// we don’t use value
}
public int computeValue(int[] array) {
...
}

32. public void loopInvariantHosting(int size) {
for (int i = 0; i < 1000; i++) {
int x = 3;
int result = size * x;
// ...
}
}
public void loopInvariantHosting(int size) {
int x = 3;
int result = size * x;
for (int i = 0; i < 1000; i++) {
// ...
}
}

33. public void loopUnswitching(int[] array, boolean condition) {
for (int i = 0; i < array.length; i++) {
if(condition) {
// branch1
} else {
// branch2
}
}
}
public void loopUnswitching(int[] array, boolean condition) {
if(condition) {
for (int i = 0; i < array.length; i++) {
// branch1
}
} else {
for (int i = 0; i < array.length; i++) {
// branch2
}
}
}

34. public void escapeAnalysis() {
BooleanContainer obj = new BooleanContainer(false);
// ...
}
class BooleanContainer {
boolean f;
}
public void escapeAnalysis() {
// equivalent to boolean b = false;
// ...
}

36. 8 bytes
Compressed
oop
obj1
obj2
. . .

37. •
•

38. • Allocate and deallocate memory to the program
• Determine areas of heap memory that are used by the program
• Free unused memory to be reused for subsequent allocations
• Available GC algorithms in HotSpot:
1. Serial collector (-XX:+UseSerialGC)
2. Parallel collector (-XX:+UseParallelGC)
3. Concurrent Mark Sweep (CMS) collector (-XX:+UseConcMarkSweepGC)
4. G1 collector (-XX:+UseG1GC) (default since Java 9)
• All collectors parallelize their workload, except the serial GC
• Serial collector is suitable for small programs: heap size < 100 MB
• G1 is suitable for large, multithreaded programs running on a machine with high
amount of memory

39. • Measured in three key aspects:
1. Pause time: time it takes to stop the application and run GC
Controlled using -XX:MaxGCPauseMillis=millis
2. Throughput: ratio of GC time / application time
Controlled using -XX:GCTimeRatio=nn
 Maximum 1 / (1 + nn) of the application execution time be spent in the
collector
e.g. value of 19 means desired GC time ratio is 1/20 or 5%
3. Footprint: size of heap. GC can adjust heap size based on behavior

40. • There is usually a trade-off between pause time and throughput
• High throughput is suitable for a web server
• Short pause time is suitable for GUI application
• In an ideal situation the heap will grow to a value (less than the maximum) that will support
the chosen throughput goal.
• -verbose:gc or (-XX:+PrintGC) can be used to print GC messages
• -XX:-PrintGCDetails for more details

41. • Heap memory is composed of generations holding objects by age:
1. Young generation
2. Old generation
• Young gen triggers minor collection; old gen triggers major collection
Young gen
Eden
S
1
S
2
Old gen
Serial GC
generational
collection
Minor GC Major GC

42. • Unless you have problems with pauses, try granting as much memory as possible to the virtual
machine. The default size is often too small.
• Setting -Xms and -Xmx to the same value increases predictability by removing the most
important sizing decision from the virtual machine. However, the virtual machine is then unable
to compensate if you make a poor choice.
• In general, increase the memory as you increase the number of processors, because allocation
can be made parallel.
–XX:NewRatio: Ratio of old/new generation sizes. The default value is 2.
-XX:MinHeapFreeRatio=40: Minimum percentage of heap free after GC to avoid expansion.
-XX:MaxHeapFreeRatio=70: Maximum percentage of heap free after GC to avoid shrinking.

43. • Default GC for server VM (until Java 9)
• Uses multiple threads to collect unused memory
• Number of threads used for GC is a fraction of hardware threads (hardware configuration). It can
be changed using -XX:ParallelGCThreads=<N>
• Goal priority:
1. maximum pause-time goal
2. throughput goal
3. footprint goal
• Throws OutOfMemoryError in > 98% of time spent on GC and < 2% of object heap is claimed
(GC overhead limit)

45. • jcmd:
 Identify Java process
 Heap / thread dump
 View internal stats
• JVisualVM
• jmap
• JConsole