1 / 44

The Java VM Architecture & APIs

The Java VM Architecture & APIs. 2003-12087 이 원 찬. 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

lysa
Download Presentation

The Java VM Architecture & APIs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. The Java VM Architecture & APIs 2003-12087 이 원 찬

  2. 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. 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 and arrays and perform garbage collection • Error and Exception Manager – Deal with exception

  4. Java VM Architecture - Java Runtime Structure • Typical runtime system includes(cont’d): • 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 and controlling access to system resources

  5. Java VM Architecture - Java Runtime structure

  6. 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. Java VM Architecture - Memory Management • The Method Area • Type Information • Fully qualified name of the type of itself, superclasses, superinterfaces • Whether or not the type is a class or an interface • Type’s 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. Java VM Architecture - Memory Management • 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(constants) as part of data for the type that uses them(get a copy) • A Reference to Class ClassLoader • A Reference to Class Class • Class information can be accessed through class object • Method Table • Data 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

  9. Java VM Architecture - Memory Management • The Heap • The memory for the new object is allocated from a single heap. • Every application has its own heap • But, All threads share it! • So, careful synchronization of multi-threaded access to object is needed. • Allocation instruction exists, but freeing instruction doesn’t 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. Java VM Architecture - Memory Management • Object Representation in the heap • Objects can be freely represented in heap. • Two possible solution • Divides the heap into two parts • easy for VM to combat heap • fragmentation • need dereferencing two pointers (a)

  11. (b) Java VM Architecture - Memory Management • Object Representation in the heap • dereference pointer only once • make moving objects more complicated

  12. Java VM Architecture - Memory Management • Method table • Can 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 method’s stack frame • Method’s bytecodes • An exception table

  13. Java VM Architecture - Memory Management • Arrays in heap

  14. Java VM Architecture - Memory Management • The Program Counter • Each thread has its own PC. • Can be a native pointer or an offset from the beginning of method’s bytecodes. • If a thread is executing a native method, pc is undefined. • The Stack • Each thread has its own stack area too. • Local variables and operands 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. Arguments Locals Frame data Operands Java VM Architecture - Memory Management • Stack Frame Structure • Stack 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 resolution • Exception table • Normal method return address Stack Frame Structure

  16. Java VM Architecture - Memory Management • 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. Java VM Architecture - Memory Management • Possible Implementations of the Java Stack • Right one uses stack area more efficiently. • Also saves time because Java VM doesn’t need to copy the parameter values.

  18. Java VM Architecture - Memory Management • Native Method Stack • A 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.

  19. Java VM Architecture - Memory Management • Memory Hierachy

  20. Java VM Architecture - Execution Relatives • Data Types

  21. Java VM Architecture - Execution Relatives • 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. Java VM Architecture - Execution Relatives • Instruction Set • Advantages • Stack based ISA - Stack is amenable to platform independence. • Increase instruction set encoding density - No instruction fields are needed for specifying registers • Disadvantages • Non-Orthogonal Instruction Set • 8-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 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. Java VM Architecture - Instruction Set • Instruction Set Format • Opcode 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.

  24. Java VM Architecture - Instruction Set • 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_<n>, ldc(via constant pool), bipush(direct) • Stack Manipulation • Local Variable relatives • iload (index), iload_<n> • iinc

  25. Java VM Architecture - Instruction Set • Data-Movement Instructions • Array relatives • newarray, anewarray, multianewarry, <x>aload, <x>astore, arraylength • Object relatives • new <index(to constant pool)> • (get|put)(static|field) • (checkcast|instanceof) <index(to constant pool)> • Type Conversion • Functional Instructions • Only operates on int, float, double, long. • Operands are converted to standard number representation before calculation • Convert back to platform’s internal representation and be pushed to stack after calculation.

  26. Java VM Architecture - Instruction Set • Control Flow Instructions • Designed to expose all control flow paths within a method • All control flow instructions use fixed, compile-time PC offset.(no indirection) • Also, jump directly to a method via a fixed index into the constant pool • This feature enables both complete code discovery and load-time stack tracking. • Method call • invoke(virtual|static|special|interface) <index1,2> • Return PC is saved on a stack(in frame data area), but can not be accessed directly(only through return) • * Quick instructions • Figure 5.11

  27. Java VM Architecture - Exceptions and Errors • Exceptions and Errors • Errors – caused by either the application behavior and the limitation of VM • Exception – checked or unchecked • checked exception must be encapsulated by try/catch clause. • unchecked(or runtime) exception caused by dynamic behavior of program • All 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.

  28. Java VM Architecture - Exceptions and Errors • Exception handler is implemented by miniature subroutines. • Use jsr, ret, goto instruction. • athrow – throw exception dereferenced by class name on top of the stack • 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; }

  29. Java VM Architecture - Exceptions and Errors • 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. Java VM Architecture - Class File Structure • Magic Number • 0xCAFEBABE(in big-endian order) • Constant Pool • constant - tag(u1) + length(u2) + bytes • Tag specify type of constant • CONST_??? • Descriptors • BaseType : B, C, D, F, I, J(long), S, Z(boolean) • ObjectType : L<classname> • ArrayType : [(BaseType|ObjectType|ArrayType) • Method : (<argument_types>)<return_types> • 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. Java VM Architecture - Class File Structure • Access Flags • Specify modifier of class, interface, method, and field - 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. Java VM Architecture - Class File Structure • Attribute • Method code, constant value for finals, exception that a method may throw • Innerclass, LineNumberTable, LocalVariableTable, Source file name • Code attribute – max_stack, max_locals, code, exception_table • Class file limitation • u2 - constant pool entries, field count, method count, bytecode length(per method), local variables, operand stack, exception table length • u1 - array dimensions, arg. to a method

  33. Java VM Architecture - Class File Structure ClassStruct_java.txt ClassStruct.txt

  34. 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. • Halting Problem • Studied by Alan Turing and Kurt Godel • In 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 Tracking • For 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

  35. Java VM Architecture - Class Verification • Operand Stack Tracking • ex) 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-time • Because control flows are determined in static-time. • Execution engine doesn’t need to perform runtime checks for following items : • Stack limits • Types of arguments to JVM instructions • Accesses or assignments to local variables

  36. Java VM Architecture - Class Verification • 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 • Doesn’t immediately check if the referenced class really exist. • The constant pool can also contain references to classes that haven’t been loaded yet. • JVM verifier tries to delay the checks until they are necessary. • Speed up the initial loading time for a class

  37. Java VM Architecture - Class Verification • 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 types for 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 • Don’t use the stack in complex ways. • Only push items onto the stack just before they are needed.

  38. Java VM Architecture - Class Verification • 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 local var. state in table • separate entry is maintained in the table for every instruction in bytecode • Then check that Instruction is begin run with the correct types • Emulate the instruction’s effect on the stack and local var. • When a branch instruction is met, look at all the possible destinations • If a destination has not been seen previously, verifier recursively examines. • Else, verifier compares the current state with recorded state

  39. Java VM Architecture - Class Verification • 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 merge incompatible

  40. Java VM Architecture - Native Method Support • Java Native Interface(JNI) • Java side and native side can interoperate each other 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. 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 infrastructure • ex) EJB, servlet, JSP, JMS, etc. • J2ME(Micro Edition) • Light-weight platform for embedded system

  42. Java APIs- J2SE APIs • Serialization • RMI 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. • Reflection • Determine class information at run time • Classes in java.lang.reflect package • Array, Constructor, Field, Method, Modifier, etc. • Object.getClass() -> Class.get(Fields|Methods| …) • ex) Method can be called by invoke method of Method class.

  43. 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() method during its lifetime. • Synchronization through monitor • Suppported by instruction • monitorenter and monitorexit • Locks are associated with each object and each class(through Class object). • Class Object declares five methods that enable programmers to access the Java Virtual Machine’s support for the coordination aspect of synchronization. • notify, notifyAll, wait

  44. Java APIs • Synchronization Example

More Related