1004 chap05 2 the java vm architecture

8/6/2019 1004 Chap05 2 the Java VM Architecture

1/44

The Java VMArchitecture & APIs

2003-12087


2/44

Contents

Java VM Architecture Java Runtime Structure

Memory Management

Execution Relatives Exception and Error Management

Class File Structure

Class Verification

Native Method Support(JNI)

Java APIs Java Platforms Overview

Java APIs(J2SE)


3/44

Java VM Architecture- Java Runtime Structure

Java VM

Usually 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 bytecodes

Memory Manager Allocate memory for instances andarrays and perform garbage collection

Error and Exception Manager Deal with exception


4/44

Java VM Architecture- Java Runtime Structure

Typical runtime system includes(contd):

Native Method Support for calling c/c++ methods

Threads Interface

supporting threads and monitors Class Loader dynamically load Java classes from Java

class files

Security Manager verify that classes are safe andcontrolling access to system resources


5/44

Java VM Architecture- Java Runtime structure


6/44

Java VM Architecture- Memory Management

Memory Area

Divided into cells or slots

Slot can usually hold a single data item

All addressing is in terms of the logical memory cells.


7/44


The Method Area Type Information

Fully qualifiedname of the type of itself, superclasses,superinterfaces

Whether or not the type is a class or an interface

Types modifiers(public, abstract, final)

Constant Pool(more detail later) Set of constants

Symbolic references, literals

Field Information Name, type, modifiers

Method Information Name, return & arg. type, modifiers

Bytecodes, exception table, stack frame size(not native or abstract methods)


8/44


The Method Area Class Variables

Class variables are shared among all instances

Non-finals as part of data for the type that declares them

Finals(c

onstants) as part

ofdata f

or the type that uses them(get acopy)

A Reference toClass ClassLoader A Reference toClass Class

Class information can be accessed through class object

Method Table D

ata structures that speed

up access tothe raw

dataex) method table can have references to instance methods inherited

from superclass

Method area also can be garbage collected as an unreferencedinstance


9/44


The Heap The memory for the new object is allocated from a single

heap.

Every application

has itso

wn

heap But, All threads share it!

So, careful synchronizationof multi-threaded access toobject is needed.

Allocation instruction exists, but freeing instructiondoesnt

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.


10/44


Object Representation in the heap Objects can be freely represented in heap.

Two possible solution

(a)

- Divides the heap into two parts- easy for VM to combat heapfragmentation

- needdereferencing two pointers


11/44


Object Representation in the heap

(b)

- dereference pointer only once- make moving objects morecomplicated


12/44


Method table

Can play an important role in achieving good VMperformance.

May not exist in some implementation that haveextremely low memory requirements.

Method table includes :

Size of methods stack frame

Methods bytecodes

An exception table


13/44


Arrays in heap


14/44


The Program Counter

Each thread has its own PC.

Can be a native pointer or anoffset from the beginning of

methods bytecodes. If a thread is executing a native method, pc is undefined.

The Stack

Each thread has its own stack area too.

Local variables andoperands are thread safe. Used for local, operand storage

References, not actual objects can exist in stack.

As each method is called, a stack frame is allocated.


15/44


Stack Frame Structure Stack depth can be estimated at compile-

time(will be discussed later)

Locals(include arguments) : Instance method has hidden this referenceon its first local slot.

Byte, short, char are converted into int

(due to asymmetry of instruction set) Frame Data :

Data to support constant pool resolution

Exception table

Normal method return address

Arguments

Locals

Frame data

Operands

Stack Frame

Structure


16/44


Possible Implementations of the Java Stack

Example 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;

}


17/44


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.


18/44


Native Method Stack

A native method can access runtime data areas of VM andalsodo anything else.

Native method calling is just calling another method withinitself, at the behest of the running Java program.


19/44


Memory Hierachy


20/44

Java VM Architecture- Execution Relatives

Data Types


21/44


Data Types Each data types are defined according to the values they

can have. Every data type except Double and Long needs one

word(slot). Boolean type

Treated as integer Boolean arrays are implemented as byte array

Made by newarray 4, but handled by byte array instructions

ReturnAddress Not visible to programmer Used internally with subroutine instructions(jsr, ret)

Array Object Special object support by instruction set All of array elements have the same type


22/44


Instruction Set Advantages

Stack based ISA - Stack is amenable to platformindependence.

Increase instruction set encoding density- No instruction fields are needed for specifying registers

Disadvantages Non-Orthogonal Instruction Set

8-bit opcode canonly encode 256 instructions. some datatypes(short, byte, char) are relegated to second class

status and receive less support in ISA

Hard to Extend Extending 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.


23/44

Java VM Architecture- Instruction Set

Instruction Set Format

Opcode byte + operand(more than zero)

Operand can be either of index, immediate data orPC-relative offset.

Wide & escape code can be used to extend instructionset.

Each of primitive types has its own instructions

that canoperate on them. Array access and type conversion instructions canonlyoperate on short, byte, and char type.


24/44


Data-Movement Instructions

There can be different instructions for the same function.

- code density, interpretation performance are related

Pushing Constants onto the Stack

aconst_null, iconst_, ldc(via constant pool), bipush(direct)

Stack Manipulation

Local Variable relatives

iload (index), iload_ iinc


25/44


Data-Movement Instructions Array relatives

newarray, anewarray, multianewarry, aload, astore,arraylength

Object relatives new (get|put)(static|field) (checkcast|instanceof)

Type Conversion Functional Instructions

Only operates on int, float, double, long. Operands are converted to standardnumber representation

before calculation

Convert back to platforms internal representation and be

pushed to stack after calculation.


26/44


Control Flow Instructions Designed to expose all control flow paths within a method

All control flow instructions use fixed, compile-time PCoffset.(noindirection)

Also, jump directly to a method via a fixed index into theconstant pool

This feature enables both complete code discovery and load-timestack tracking.

Method call invoke(virtual|static|special|interface)

Return PC is savedon a stack(in frame data area), but cannotbe accesseddirectly(only through return)

* Quick instructions

Figure 5.11


27/44

Java VM Architecture

- Exceptions and Errors

Exceptions and Errors Errors caused by either the application behavior and the

limitationof VM

Exception

checked

o

r un

checked

checked exception must be encapsulated by try/catch clause.

unchecked(or runtime) exception caused by dynamicbehavior of program

All exceptions(and errors) must be handled somwhere.

If an

exception

isno

t hand

ledby the meth

odthat thr

owsthe exception, stack frame is popped until the exception is

handled by some handler.


28/44



Exception handler is implemented by miniature subroutines. Use jsr, ret, goto instruction.

athrow throw exceptiondereferenced by class name on top of thestack

Use exception table to specify an exception handler. ex)

Internal data structure for exception table

ExceptionTable {u2 from_pc;u2 to_pc;u2 handler_pc;

u2 catch_type;}

From To Target Type

8 12 96 ArithmeticException


29/44



Exception handler example

Example 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);

}}

}


30/44

Java VM Architecture- Class File Structure

Magic Number 0xCAFEBABE(in big-endianorder)

Constant Pool constant - tag(u1) + length(u2) + bytes

Tag specify typeo

f con

stan

t CONST_??? Descriptors

BaseType : B, C, D, F, I, J(long), S, Z(boolean)

ObjectType : L

ArrayType : [(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)


31/44


Access Flags

Specify modifier of class, interface, method, andfield - ACC_???

This, Super Classes, Interface Specified by indexed constant in constant pool

Field, Method

access_flags(u2) + name_index(u2) +

descriptor_index(u2) + attribute_count(u2) +attributes_info

name, descriptor are on the constant pool


32/44


Attribute

Method code, constant value for finals, exceptionthat a method may throw

Innerclass, LineNumberTable, LocalVariableTable,Source file name

Code attribute max_stack, max_locals, code,exception_table

Class file limitation

u2 - con

stant p

ool e

ntries, fiel

dcount, meth

odcount,bytecode length(per method), local variables, operand

stack, exception table length

u1 - array dimensions, arg. to a method


33/44


ClassStruct.txtClassStruct_java.txt


34/44

Java VM Architecture- Class Verification

Class Verification Class binaries are sometimes unsafe and may crash VM. Must take all control path and prove that the program is safe in

each case.

Haltin

g Pro

blem Studied by Alan Turing and Kurt Godel In general case, it is not possible to take a descriptionof a

program anddecide whether or not the program will complete,let alone whether is behaves well or not.

Operand Stack Tracking

For each alternative way in a method for reaching an instructionX, the stack state and the local variable state must be equivalent. Figure 5.10

(b) stack size is different. (c) operand types are different


35/44


Operand Stack Tracking ex) iconst_4

istore_1Loop:

aconst_nulliinc 1 1iload_1

Operand stack is not equivalent at Loop.

Stack tracking can be done in static-time Because control flows are determined in static-time. Execution engine doesnt need to perform runtime checks for

following items :

Stack limits

Types of arguments to JVM instructions Accesses or assignments to local variables


36/44


Passing verification Structure

Check 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 0xCAFEBABE

Check also the contents of bytecode Check that all byte code offsets are within method boundary.

Type of constant and constant referencing instruction must be the same.

Environment Other classes that one class depends, and the methods and fields of

those

Type conflict and access conflict Doesnt immediately check if the referenced class really exist.

The constant pool can also contain references to classes that havent beenloaded yet.

JVM verifier tries todelay the checks until they are necessary. Speed up the initial loading time for a class


37/44


Passing verification

Environment

ex) invokenonvirtual myclass/funmethod()LFunClass

-> putfield myclass/myfield LFunClass; -> putfield myclass/myfield LAnotherClass;

Content

Each instruction should bee invoked with the correct typesfor its operands and stack values.

Use pop2, pop to retrieve long value from the stack

The maximum stack length must not be exceeded.

Stack size is specified in the Code attribute

Dont use the stack in complex ways.

Only push items onto the stack just before they are needed.


38/44


Working of bytecode verifier Trace all the static control flow paths and simulate a stack

symbolically. Steps :

When instruction is first encountered, stores stack and localvar. state in table separate entry is maintained in the table for every instruction in

bytecode

Then check that Instruction is begin run with the correcttypes

Emulate the instructions effect on the stack and local var. When a branch instruction is met, look at all the possibledestinations If a destination has not been seen previously, verifier recursively

examines.

Else, verifier compares the current state with recorded state


39/44


Working of bytecode verifier

State comparison

Two states are identical move forward

Two states are incompatible verifier complains! Two state are compatible merges two states

int

float

DataInputStream

int

float

BufferedInputStream

int

float

Vector

int

float

int

merge

incompatible

int

float

FilterInputStream


40/44

Java VM Architecture- Native Method Support

Java Native Interface(JNI)

Java side andnative side can interoperate eachother by JNI.

Native side method invocation from Java side

Use native keywords for modifier of function

Generate header file for native function by javah

ex) JNITest_java.txt ->JNITest_header.txt

Java side method invocation from Native side

Create JVM and call method through API

ex) CreateJVM.txt


41/44

Java APIs- Java Platform Overview

J2SE(Standard Edition)

API for developing general user app. or client app.

J2EE(Enterprise E

dition

) API for developing large enterprise software

infrastructure

ex) EJB, servlet, JSP, JMS, etc.

J2ME(Micro Edition) Light-weight platform for embedded system


42/44

Java APIs- J2SE APIs

Serialization RMI is used for communicating betweenobjects indifferent 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. Inorder to serialize anobject, it must implements the

Serializable interface.

Reflection Determine class information at run time C

lasses in

java.lang.reflect package

Array, Constructor, Field, Method, Modifier, etc.

Object.getClass() ->Class.get(Fields|Methods| ) ex) Method can be called by invoke methodof Method class.


43/44

Java APIs- J2SE APIs

Thread Multithreading support is provided by java.lang.Thread

class(and Runnable interface)

Libraries can communicate with the underlying OS.

Thread execute run() methodduring its lifetime.

Synchronization through monitor Suppported by instruction

monitorenter and monitorexit

Locks are associated with each object and eachclass(through Class object).

Class Object declares five methods that enable programmersto access the Java Virtual Machines support for thecoordination aspect of synchronization.

notify, notifyAll, wait


44/44

Java APIs

Synchronization Example

1004 chap05 2 the java vm architecture

Documents