• https://www.amazon.com/Java-Language-Features-Modules-Expressions/dp/1484233476
• How the JVM compiles bytecode into machine code

references

• https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.5.2
• https://stackoverflow.com/questions/26741925/is-frame-in-jvm-heap-allocated-or-stack-allocated

each thread in a JVM has its own JVM stack

created when thread is created

LIFO

stores frames

holds local variables and partial results

• plays a part in method invocation and return

is never manipulated directly except to push and pop frames

if the computation in a thread requires a larger Java Virtual Machine stack than is permitted, the Java Virtual Machine throws a StackOverflowError

specification permits Java Virtual Machine stacks either to be of a fixed size or to dynamically expand

default stack size (HotSpot): 320k in the 32-bit VM, 1024k in the 64-bit VM

• https://www.oracle.com/technetwork/java/hotspotfaq-138619.html#threads_oom

set stack size: -Xss

references

• https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.6
• 2019 - Krzysztof Chruściel - Kilka wskazówek jak projektować użyteczne interfejsy

frame size: 4 bytes

• as a consequence: operation of adding two ints (2 x 4 bytes) pops 2 frames
• and operation of adding two long (2 x 8 bytes) pops 4 frames
• therefore int sum = 100 + 100L; will not compile, as sum is type of long
• another consequence: boolean (when local variable) takes whole frame - same as int
  • boolean as a class fields - optimisation, boolean as a local variable - no optimisation

is used to store data and partial results, as well as to perform dynamic linking, return values for methods, and dispatch exceptions

new frame is created each time a method is invoked

a frame is destroyed when its method invocation completes, whether that completion is normal or abrupt (it throws an uncaught exception)

represents method invocation (in a given thread)

it is an invocation context of a method

for a given thread only one frame is active at any point

active frame is called current frame , corresponding method - current method, class declaring method - current class

• frame ceases to be current if its method invokes another method or if its method completes

frames are allocated from the Java Virtual Machine stack of the thread creating the frame

each frame has its own array of local variables, its own operand stack, and a reference to the run-time constant pool of the class of the current method

• as arrays in JVM has a fixed size since creation - the sizes of the local variable array and the operand stack are determined at compile-time and are supplied along with the code for the method associated with the frame

lifecycle:

• when a method is invoked, a new frame is created and becomes current when control transfers to the new method
• on method return, the current frame passes back the result of its method invocation, if any, to the previous frame
• the current frame is then discarded as the previous frame becomes the current one

frame created by a thread is local to that thread and cannot be referenced by any other thread

JVM allows to hide some frames for performance reasons

references

• https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.6.1

each frame contains an array of variables known as its local variables

length of the local variable array of a frame is determined at compile-time and supplied in the binary representation of a class or interface along with the code for the method associated with the frame

single local variable can hold a value of type boolean, byte, char, short, int, float, reference, or returnAddress

value of type long or type double occupies two consecutive local variables

on class method invocation, any parameters are passed in consecutive local variables starting from local variable 0

on instance method invocation, local variable 0 is always used to pass a reference to the object on which the instance method is being invoked and other parameters are subsequently passed in consecutive local variables starting from local variable 1

references

• https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.6.2

each frame contains a LIFO stack known as its operand stack

example

iload_0     # Push the value from local variable 0 onto the stack
iload_1     # Push the value from local variable 1 onto the stack
iadd        # Pops those off the stack, adds them, and pushes the result

the iadd instruction adds two int values together - it requires that the int values to be added be the top two values of the operand stack, pushed there by previous instructions.

1. both of the int values are popped from the operand stack.
2. they are added
3. their sum is pushed back onto the operand stack

maximum depth of the operand stack of a frame is determined at compile-time and is supplied along with the code for the method associated with the frame

operand stack is empty when the frame that contains it is created

JVM instructions

• to load constants or values from local variables or fields onto the operand stack
• to take operands from the operand stack, operate on them, and push the result back onto the operand stack

the operand stack is also used to prepare parameters to be passed to methods and to receive method results

an operand stack has an associated depth, where a value of type long or double contributes two units to the depth and a value of any other type contributes one unit

• https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.5.5
• https://stackoverflow.com/questions/10209952/what-is-the-purpose-of-the-java-constant-pool