Java Jvm Detail

The Java VM Architecture & APIs

2003-12087

Contents
Java VM ArchitectureJava Runtime StructureMemory ManagementExecution RelativesException and Error ManagementClass File StructureClass VerificationNative Method Support(JNI)Java APIsJava Platforms OverviewJava APIs(J2SE)

Java VM Architecture
- Java Runtime Structure
Java VMUsually referred to Java Runtime(JRE)Mainly used to execute programs written in Java
Typical runtime system includes:Execution Engine Virtual(or real hardware ex. ARM) processor for executing bytecodesMemory Manager Allocate memory for instances and arrays and perform garbage collectionError and Exception Manager Deal with exception

- Java Runtime Structure
Typical runtime system includes(contd):Native Method Support for calling c/c++ methodsThreads Interface supporting threads and monitorsClass Loader dynamically load Java classes from Java class filesSecurity Manager verify that classes are safe and controlling access to system resources

- Java Runtime structure

- Memory Management
Memory AreaDivided into cells or slotsSlot can usually hold a single data itemAll addressing is in terms of the logical memory cells.

- Memory Management
The Method AreaType InformationFully qualified name of the type of itself, superclasses, superinterfacesWhether or not the type is a class or an interfaceTypes modifiers(public, abstract, final)Constant Pool(more detail later)Set of constantsSymbolic references, literalsField InformationName, type, modifiersMethod InformationName, return & arg. type, modifiersBytecodes, exception table, stack frame size
(not native or abstract methods)

- Memory Management
The Method AreaClass VariablesClass variables are shared among all instancesNon-finals as part of data for the type that declares themFinals(constants) as part of data for the type that uses them(get a copy)A Reference to Class ClassLoaderA Reference to Class ClassClass information can be accessed through class objectMethod TableData structures that speed up access to the raw data
ex) method table can have references to instance methods inherited from superclass
Method area also can be garbage collected as an unreferenced instance

- Memory Management
The HeapThe memory for the new object is allocated from a single heap.Every application has its own heapBut, All threads share it!So, careful synchronization of multi-threaded access to object is needed.Allocation instruction exists, but freeing instruction doesnt exists!Freeing memory occupied by objects that are no longer referenced is responsible for a garbage collector.Method area and heap may be on the same heap.

- Memory Management
Object Representation in the heapObjects can be freely represented in heap.Two possible solution
(a)
Divides the heap into two parts easy for VM to combat heap
fragmentation
need dereferencing two pointers

- Memory Management
Object Representation in the heap dereference pointer only once make moving objects more complicated
(b)

- Memory Management
Method tableCan play an important role in achieving good VM performance.May not exist in some implementation that have extremely low memory requirements.Method table includes :Size of methods stack frameMethods bytecodesAn exception table

- Memory Management
Arrays in heap

- Memory Management
The Program CounterEach thread has its own PC.Can be a native pointer or an offset from the beginning of methods bytecodes.If a thread is executing a native method, pc is undefined.The StackEach thread has its own stack area too.Local variables and operands are thread safe.Used for local, operand storageReferences, not actual objects can exist in stack.As each method is called, a stack frame is allocated.

- Memory Management
Stack Frame StructureStack depth can be estimated at compile-time(will be discussed later)Locals(include arguments) :Instance method has hidden this reference on its first local slot.Byte, short, char are converted into int
(due to asymmetry of instruction set)
Frame Data :Data to support constant pool resolutionException tableNormal method return address
Stack Frame

Structure

Arguments

Locals

Frame data

Operands

- Memory Management
Possible Implementations of the Java StackExample code :
public static void addAndPrint() {

double result = addTwoTypes(1, 88.88);

System.out.println(result);

}

public static double addTwoTypes(int i, double d) {

return i + d;

}

- Memory Management
Possible Implementations of the Java Stack Right one uses stack area more efficiently. Also saves time because Java VM doesnt need to copy the parameter values.

- Memory Management
Native Method StackA native method can access runtime data areas of VM and also do anything else.Native method calling is just calling another method within itself, at the behest of the running Java program.

- Memory Management
Memory Hierachy

- Execution Relatives
Data Types

Data TypesEach data types are defined according to the values they can have.Every data type except Double and Long needs one word(slot).Boolean typeTreated as integerBoolean arrays are implemented as byte arrayMade by newarray 4, but handled by byte array instructionsReturnAddressNot visible to programmerUsed internally with subroutine instructions(jsr, ret)Array ObjectSpecial object support by instruction setAll of array elements have the same type

Instruction SetAdvantagesStack based ISA - Stack is amenable to platform independence.Increase instruction set encoding density
- No instruction fields are needed for specifying registers
DisadvantagesNon-Orthogonal Instruction Set8-bit opcode can only encode 256 instructions.
some datatypes(short, byte, char) are relegated to second class status and receive less support in ISA
Hard to ExtendExtending the machine to support 96-bit or 128-bit floats and longs cannot be done simply.Use escape or wide opcode to create an extended instruction set.

- Instruction Set
Instruction Set FormatOpcode byte + operand(more than zero)Operand can be either of index, immediate data or PC-relative offset.Wide & escape code can be used to extend instruction set.Each of primitive types has its own instructions that can operate on them.Array access and type conversion instructions can only operate on short, byte, and char type.

- Instruction Set
Data-Movement InstructionsThere can be different instructions for the same function.
- code density, interpretation performance are related
Pushing Constants onto the Stackaconst_null, iconst_, ldc(via constant pool), bipush(direct)Stack ManipulationLocal Variable relativesiload (index), iload_iinc

- Instruction Set
Data-Movement InstructionsArray relativesnewarray, anewarray, multianewarry, aload, astore, arraylengthObject relativesnew (get|put)(static|field)(checkcast|instanceof) Type ConversionFunctional InstructionsOnly operates on int, float, double, long.Operands are converted to standard number representation before calculationConvert back to platforms internal representation and be pushed to stack after calculation.

- Instruction Set
Control Flow InstructionsDesigned to expose all control flow paths within a methodAll control flow instructions use fixed, compile-time PC offset.(no indirection)Also, jump directly to a method via a fixed index into the constant poolThis feature enables both complete code discovery and load-time stack tracking.Method callinvoke(virtual|static|special|interface) Return PC is saved on a stack(in frame data area), but can not be accessed directly(only through return)* Quick instructionsFigure 5.11

- Exceptions and Errors
Exceptions and ErrorsErrors caused by either the application behavior and the limitation of VMException checked or uncheckedchecked exception must be encapsulated by try/catch clause.unchecked(or runtime) exception caused by dynamic behavior of programAll exceptions(and errors) must be handled somwhere.If an exception is not handled by the method that throws the exception, stack frame is popped until the exception is handled by some handler.

Exception handler is implemented by miniature subroutines.Use jsr, ret, goto instruction.athrow throw exception dereferenced by class name on top of the stackUse exception table to specify an exception handler.ex)Internal data structure for exception table
ExceptionTable {

u2from_pc;

u2to_pc;

u2handler_pc;

u2catch_type;

}
FromToTargetType81296Arithmetic Exception

Exception handler exampleExample Java code
public class ExceptionTest {

public static void main(String args[]) {

try {

java.io.FileInputStream x

= new java.io.FileInputStream(myfile);

} catch(java.io.FileNotFoundException e) {

System.out.println(Not found);

} finally {

System.out.println(This must be executed);

}

}

}

- Class File Structure
Magic Number0xCAFEBABE(in big-endian order)Constant Poolconstant - tag(u1) + length(u2) + bytesTag specify type of constantCONST_???DescriptorsBaseType : B, C, D, F, I, J(long), S, Z(boolean)ObjectType : LArrayType : [(BaseType|ObjectType|ArrayType)Method : ()ex) I=> int a;
[[J=>long[][] a;

[Ljava/lang/Object=>java.lang.Object[] a;

[[[Z=>boolean[][][] a;

()I=>int a();

()Ljava/lang/String;=>String a();

([BII)V=>void a(byte[], int, int)

Access FlagsSpecify modifier of class, interface, method, and field - ACC_???This, Super Classes, InterfaceSpecified by indexed constant in constant poolField, Methodaccess_flags(u2) + name_index(u2) + descriptor_index(u2) + attribute_count(u2) + attributes_infoname, descriptor are on the constant pool

AttributeMethod code, constant value for finals, exception that a method may throwInnerclass, LineNumberTable, LocalVariableTable, Source file nameCode attribute max_stack, max_locals, code, exception_tableClass file limitationu2 - constant pool entries, field count, method count, bytecode length(per method), local variables, operand stack, exception table lengthu1 - array dimensions, arg. to a method


ClassStruct.txt

ClassStruct_java.txt

- Class Verification
Class VerificationClass binaries are sometimes unsafe and may crash VM.Must take all control path and prove that the program is safe in each case.Halting ProblemStudied by Alan Turing and Kurt GodelIn general case, it is not possible to take a description of a program and decide whether or not the program will complete, let alone whether is behaves well or not.Operand Stack TrackingFor each alternative way in a method for reaching an instruction X, the stack state and the local variable state must be equivalent.Figure 5.10(b) stack size is different. (c) operand types are different

Operand Stack Trackingex) iconst_4
istore_1

Loop:

aconst_null

iinc 1 1

iload_1

Operand stack is not equivalent at Loop.
Stack tracking can be done in static-timeBecause control flows are determined in static-time.Execution engine doesnt need to perform runtime checks for following items :Stack limitsTypes of arguments to JVM instructionsAccesses or assignments to local variables

Passing verificationStructureCheck that the class file structure is met.ex) this_class field must be the index of a CONSTANT_Class Magic field must be the value 0xCAFEBABECheck also the contents of bytecodeCheck that all byte code offsets are within method boundary.Type of constant and constant referencing instruction must be the same.EnvironmentOther classes that one class depends, and the methods and fields of thoseType conflict and access conflictDoesnt immediately check if the referenced class really exist.The constant pool can also contain references to classes that havent been loaded yet.JVM verifier tries to delay the checks until they are necessary.Speed up the initial loading time for a class

Passing verificationEnvironmentex) invokenonvirtual myclass/funmethod()LFunClass-> putfield myclass/myfield LFunClass;-> putfield myclass/myfield LAnotherClass;ContentEach instruction should bee invoked with the correct types for its operands and stack values.Use pop2, pop to retrieve long value from the stackThe maximum stack length must not be exceeded.Stack size is specified in the Code attributeDont use the stack in complex ways.Only push items onto the stack just before they are needed.

Working of bytecode verifierTrace all the static control flow paths and simulate a stack symbolically.Steps :When instruction is first encountered, stores stack and local var. state in tableseparate entry is maintained in the table for every instruction in bytecodeThen check that Instruction is begin run with the correct typesEmulate the instructions effect on the stack and local var.When a branch instruction is met, look at all the possible destinationsIf a destination has not been seen previously, verifier recursively examines.Else, verifier compares the current state with recorded state

Working of bytecode verifierState comparisonTwo states are identical move forwardTwo states are incompatible verifier complains!Two state are compatible merges two states
merge

incompatible
intfloatDataInputStreamintfloatBufferedInputStreamintfloatVectorintfloatintintfloatFilterInputStream

- Native Method Support
Java Native Interface(JNI)Java side and native side can interoperate each other by JNI.Native side method invocation from Java sideUse native keywords for modifier of functionGenerate header file for native function by javahex) JNITest_java.txt ->JNITest_header.txtJava side method invocation from Native sideCreate JVM and call method through APIex) CreateJVM.txt

Java APIs
- Java Platform Overview
J2SE(Standard Edition)API for developing general user app. or client app. J2EE(Enterprise Edition)API for developing large enterprise software infrastructureex) EJB, servlet, JSP, JMS, etc.J2ME(Micro Edition)Light-weight platform for embedded system

Java APIs
- J2SE APIs
SerializationRMI is used for communicating between objects in different VM.Parameters or return values must be converted to implementation-independent form in RMI.Serialization may be used for object to be saved in persistent storage.In order to serialize an object, it must implements the Serializable interface.ReflectionDetermine class information at run timeClasses in java.lang.reflect packageArray, Constructor, Field, Method, Modifier, etc.Object.getClass() -> Class.get(Fields|Methods| )ex) Method can be called by invoke method of Method class.

Java APIs
- J2SE APIs
ThreadMultithreading support is provided by java.lang.Thread class(and Runnable interface)Libraries can communicate with the underlying OS.Thread execute run() method during its lifetime.Synchronization through monitorSuppported by instructionmonitorenter and monitorexitLocks are associated with each object and each class(through Class object).Class Object declares five methods that enable programmers to access the Java Virtual Machines support for the coordination aspect of synchronization.notify, notifyAll, wait

Java APIs
Synchronization Example

Java Jvm Detail

Documents

Transcript of Java Jvm Detail