Java Virtual Machine Instruction Set Architecture

1. Java Virtual MachineInstruction Set Architecture Justin Dzeja

2. What is a Java Virtual Machine? • JVM is an abstract computing machine • Like an actual computing machine, it has an instruction set and manipulates various memory areas at run time • A JVM enables a set of computer software programs and data structures to use a virtual machine model for the execution of other computer programs and scripts • Not just Java, JVM now supports many languages • Ada, C, LISP, Python

3. Why a Virtual Machine? • The Java platform was initially developed to address the problems of building software for networked consumer devices • It was designed to support multiple host architectures and to allow secure delivery of software components • To meet these requirements, compiled code had to survive transport across networks, operate on any client, and assure the client that it was safe to run • "Write Once, Run Anywhere"

4. Java Timeline • 1991 – James Gosling begins work on Java project • Originally, the language is named “Oak” • 1995 – Sun releases first public implementation as Java 1.0 • 1998 - JDK 1.1 release downloads top 2 million • 1999 - Java 2 is released by Sun • 2005 - Approximately 4.5 million developers use Java technology • 2007 – Sun makes all of Java’s core code available under open-source distribution terms

5. Java Principles • Sun set five primary goals in the creation of the Java language,: • It should be "simple, object oriented, and familiar". • It should be "robust and secure". • It should be "architecture neutral and portable". • It should execute with "high performance". • It should be "interpreted, threaded, and dynamic".

6. JVM Instruction Set Architecture • Instructions • A Java virtual machine instruction consists of a one-byte opcode specifying the operation to be performed, followed by zero or more operands supplying arguments or data that are used by the operation • Operands are not required, there are many instructions that consist of only the opcode • One-byte instructions allow for up to 256 instructions but only about 200 are used in class files, leaving room for more instructions to be added • Each instruction has a mnemonic name which is mapped to the binary one-byte opcode

7. JVM Instruction Set Architecture • Instruction Format • The mnemonic operation names often include the data type followed by the operation name • iadd, ladd, fadd, dadd • int, long, float, double • JVM supports conversion operations that convert from one data type to another, these include both data types in the operation name • i2l, i2f, i2d, l2f, l2d, f2d

8. Operation Types • The JVM ISA is a CISC architecture, thus having many instructions • They can be classified into broad groups • Load and store • Arithmetic and logic • Type conversion • Object creation and manipulation • Operand stack management • Control transfer • Method invocation and return

9. Operation Types • Load and store • Used to move values from local variable array or heap to the operand stack • iload, istore • Arithmetic and logic • JVM supports addition, subtraction, division, multiplication, remainder, negation, increment • irem, idiv, iinc • Type conversion • Allows converting from one primitive data type to another • i2l, i2f, i2d, l2f, l2d, f2d • Object creation and manipulation • Instantiating objects and manipulating fields • new, putfield • Operand stack management • swap, dup2 • Control transfer • ifeq, goto • Method invocation and return • invokespecial, areturn

10. JVM Data Types • The Java virtual machine operates on two kinds of types: primitive types and reference types • Integral Types: • Byte - 8-bit signed two's-complement integers • Short - 16-bit signed two's-complement integers • Int - 32-bit signed two's-complement integers • Long - 64-bit signed two's-complement integers • Char - 16-bit unsigned integers representing Unicode characters

11. JVM Data Types

12. JVM Data Types • Floating Point Types: • Float - values are elements of the float value set (typically 32-bit single-precision but may vary with implementation) • Double - values are elements of the double value set(64-bit double-precision) • Boolean - values true and false • JVM has very little support for the Boolean data type • Boolean variables in a Java program are compiled to use values of the JVM int data type • returnAddress - are pointers to the opcodes of Java virtual machine instructions

13. JVM Data Types • Three kinds of reference types • Class types • Array types • Interface types • These reference dynamically created classes, arrays, or interface implementations • Can be set to null when not referencing anything and then cast to any type

14. JVM Data Types • The basic unit of size for data values in the Java virtual machine is the word • a fixed size chosen by the designer of each Java virtual machine implementation • The word size must be large enough to hold a value of type byte, short, int, char, float, returnAddress, or reference • at least 32 bits

15. JVM Runtime Data Areas • Since JVM is a virtual machine it doesn’t have any physical registers , instead it defines various runtime data areas that are used during execution of a program • One of the areas defined is the program counter register • Each thread of control has its own PC register • The register is wide enough to contain a returnAddress or a native pointer on the specific platform

16. JVM Runtime Data Areas • JVM Stack • Each thread gets its own JVM stack when it is created • Stacks store frames which hold data and play a role in method invocation and return • The actual memory for a JVM stack does not need to be contiguous • The stack can be either of a fixed size or dynamically contracted and expanded as needed

17. JVM Runtime Data Areas • JVM Frames • A frame is used to store data and partial results, as well as to perform dynamic linking , return values for methods, and dispatch exceptions • A new frame is created each time a method is invoked and destroyed when the method is completed • Only one frame, for the executing method, is active at any point • Each frame contains a local variable array • Local variables can store primitive or reference data types • Variables are addressed by index, starting from zero • Data types long and double occupy two consecutive local variables • Frames also contains an operand stack • Last-in-first-out (LIFO) • JVM loads values from local variables or fields onto the stack • Then JVM instructions can take operands from the stack, operate on them, and the push the result back onto the stack • The operand stack size is fixed at compile time based on method associated with the frame

18. JVM Operand Stack • Code: • iload_0 // push the int in local variable 0 • iload_1 // push the int in local variable 1 • iadd // pop two ints, add them, push result • istore_2 // pop Int, store into local variable 2

19. JVM Runtime Data Areas • JVM Heap • The heap is a data area shared by all JVM threads • Memory from the heap is allocated for instances of classes and arrays • Can be either of fixed size or dynamic • Does not to be in contiguous memory space • Maintained by an automatic storage management system or garbage collector

20. JVM Runtime Data Areas • Method Area • The method area is also shared among all JVM threads • It stores per-class structures • such as the runtime constant pool, field and method data, code for methods and constructors, including the special methods used in class and instance initialization • The method area is logically part of the heap, but depending on the implementation it may or may not be garbage collected or compacted

21. JVM Runtime Data Areas • Runtime Constant Pool • The runtime constant pool is a per-class runtime representation of the constant pool table in a class file • It contains numeric constants as well as method and field references that are resolved at runtime • This is similar to a symbol table for a conventional programming language, although it stores a wider range of data

22. JVM Addressing Modes • JVM supports three addressing modes • Immediate addressing mode • Constant is part of instruction • Indexed addressing mode • Accessing variables from local variable array • Stack addressing mode • Retrieving values from operand stack using pop

23. JVM Method Calls • Sample Code • Compiles to int add12and13() { return addTwo(12, 13); } Method int add12and13() 0 aload_0 // Push local variable 0 (this) 1 bipush 12 // Push int constant 12 3 bipush 13 // Push int constant 13 5 invokevirtual #4 // Method Example.addtwo(II)I 8 ireturn // Return int on top of operand stack; it //is the int result of addTwo()

24. Design Principles • Simplicity favors regularity • Examples of this principle can be found throughout the JVM specification • Instructions are all a standard opcode that is one byte in size • The naming conventions for opcode mnemonics are standard across different types of operations • Smaller is faster • Data areas such as the heap are dynamic in size resulting in memory space saved when not in use • JVM has a large instruction set, which results in a smaller code size when converted to byte code

25. Design Principles • Make the common case fast • JVM includes instructions to increment variables or to arithmetically shift values for fast execution of common operations • Good design demands good compromises • The JVM finds a good balance between high performance and being secure and robust

26. JVM Advantages/Disadvantages • A self-contained operating environment as if it’s a separate computer, this gives JVM two main advantages • System Independence – a Java application will run the same on any JVM, regardless of the underlying system • Security – Since a Java program operates in a self-contained environment there is less risk to files and other applications • The disadvantage is that running the virtual machine is extra overhead on the system, which can impair performance in some situations

27. Sources • http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html • http://www.cis.cau.edu/121/lecture05-2.htm • http://www.particle.kth.se/~lindsey/JavaCourse/Book/Part1/Supplements/Chapter01/JVM.html