Wen-mei Hwu Department of ECE University of Illinois

1. Java Virtual Machine: VM Architecture, Software Architecture, Implementations, and Application Programming Interfaces Wen-mei Hwu Department of ECE University of Illinois

2. Objective of the Course • In-depth understanding of unique aspects of Java-based systems • Benefit of Java language features for various applications • Complexities of the Java Bytecode architecture • Functionalities of the Java API and runtime

3. Outline • Introduction • Basic Bytecode Architecture • Java Objects • Java Runtime • Java Core API • Related Technologies • Java Related Developments

4. Java Security • Bytecode Level • Disallows pointer manipulation • Provides array bounds checking • Checks for NULL references (pointers) • Eliminates illegal type casting

5. Java Security • API Level • Prohibits untrusted code from accessing local disk, creating processes, connecting to other hosts, calling native code, etc. • Authentication: verify that bytecode is from a trusted vendor

6. Java Portability/Mobility • Bytecode Level • Binary compatibility: abstracts machine architecture and compiler • Standard module format and compact representation • Dynamic linking and loading

7. Java Portability/Mobility • API Level • Operating system abstraction • Consistent support for • Threads • I/O and Network interface • Database Interface • Graphical User interface

8. Development Environment • Language features • Automatic memory management • Structured exception handling • Object-oriented design

9. Development Environment • Modular development and 3rd-party software components • Standard, dynamically linked modules • Packages (related class file naming) • Avoid naming conflicts • Control access between modules

10. Key Application Areas • Network-based devices • Mobility - applet downloading and software agents • Portability - code server has no knowledge of client platform • Security - code cannot be trusted

11. Key Application Areas • Distributed applications • Common development environment across tiers • Same code can run on all machines • Software can be repartitioned as hardware/requirements change

12. Database Application Development • Can safely extend server software with Java bytecode • Traditional approach: may crash server or corrupt database • Java worst case: query fails or ties-up resources

13. Database Application Development • Removes barriers between client and server development (same language/tools on both platforms) • Easy linkage with server code (no binary compatibility issues) • Run server on multiple platforms/easy migration

14. Incorporating Object Data Types • Objects can be serialized and delivered to client • Same code can manipulate an object on both server and client • Different situations may call for either approach • Bytecode can be loaded directly from the database

15. Database Example • Each employee record contains a Java address object • Custom logic can be incorporated in methods of the Java class Address • Example: Using just street and zip, the Address initialization method computes city and state to ensure consistent address

16. Database Example • Database designers can exploit inheritance to handle address idiosyncrasies • Subclasses of type US_Address and CanadianAddress • A different Java method computes short zip code depending on type

17. Database Example Insert new rows using inheritance: INSERT INTO employees (id, name, address) VALUES (1001, “Bill Clinton”, new US_Address (‘1600 Pennsylvania Ave’, ‘22042-1234’)) INSERT INTO employees (id, name, address) VALUES (1002, “Jim Carrey”, new CanadianAddress(‘75 John Street’, ‘N2L 3X2’))

18. Database Example • Query cities and short zip codes • Method to calculate short zip code runs on server SELECT name, address.city, address.shortZip() FROM employees

19. Database Example • Query an address • Short zip method runs on client SELECT name, address FROM employees WHERE ID = ‘1001’ INTO cust_name, cust_address IF cust_address.state = “IL” THEN PRINT “Local Customer:” + cust_name + “ Zip:” + cust_address.shortZip()

20. Challenges Presented By Java • Translation to native architecture • Instruction set translation • Stack based to register based conversion • Dynamic Linking - delay translation or manage binary dependencies

21. Challenges Presented By Java • Barriers to optimization • Run-time checks (null ptr/array bounds) and exception handling constrain code motion • Heavily object-oriented code - unable to resolve calls/inline • Dynamic loading inhibits analysis (code base extended at runtime)

22. Challenges Presented By Java • Security features add overhead • Overhead of run-time checking instructions (null ptr/array bounds) • Additional code and control flow to protect resource access

23. Bytecode Architecture Overview • Load-store stack architecture • All operands pushed on value stack before use • Source operands are fetched from stack and the result is pushed on • Equivalent to register file in load-store architectures

24. Bytecode Architecture Overview • Extensive support for Java Language and Dynamic Linking • Object manipulation instructions • Method invocation instructions • Exception handling support

25. Bytecode Architecture Overview • Opcode space • 202 assigned, 25 quick, 3 reserved • Load-store stack architecture • avoid register file size assumption • smaller code size • 73.3% of the assigned opcodes are a single byte

26. Stack Computation Model Example: add Translated code push A push B r2 ¬ pop(B) r1¬ pop(A) r3 ¬ r1+r2 push r3 Stack operation push A push B add

27. Bytecode Modules (Class Files) • Java language compiler produces separate module (class file) for each class defined in program • All references across classes (and most within a class) • compiled as symbolic references • stored in a data structure inside class file ( constant pool)

28. Bytecode Modules (Class Files) • Bytecode with operands (27.7% of total assigned opcodes) • typically indexes into the constant pool or local variable table

29. Bytecode operands • As VM executes a method its stack frame holds a pointer to the constant pool of the method’s class • When constant pool entry is first referenced by an instruction, the Java VM resolves the symbolic link

30. Simple example Invokevirtual 0x0005 Constant Pool ... ... Method ref 5 Constant pool ... ... 8 class ref Stack frame ... Name & type a ... d “add” ... ‘(‘ ‘I’ ‘I’ ‘)’ ‘I’ 11

31. Bytecode operation types • Stack Manipulations • push, pop, duplicate, swap • Local Variable accessing • load, store • Arrays • create, store, retrieve

32. Bytecode operation types • Objects • create, access, set • Arithmetic and Type Conversion • add, subtract, multiply, divide, shift, AND, OR, XOR

33. Bytecode operation types • Control Flow and Exceptions • conditional, unconditional, goto, local returns, tables, throws • Method Calls and Returns • virtual, special, static, interface, returns

34. Quick Opcodes • Patented by Sun • Interpreter based runtime optimization • Not part of VM spec, never appear in class files • Patched over normal instructions at runtime the first time they are executed

35. Quick Opcodes • When a constant pool entry is resolved, the symbolic is reference replaced with direct reference • Quick opcode signifies constant pool entry already contains a direct reference to target, and VM does not have to perform certain checks

36. Java Objects Outline • Classes and Interfaces • Polymorphism and Dynamic Method Resolution • Method Tables • Bytecode Ops for Method Invocation • Bytecode Ops for Object Manipulation

37. Language Terms • Class: Data structure and associated functions to manipulate the data • Object: An instance of a class (Object creation=Class instantiation) • Method: Behavior associated with a class (function to manipulate object) • Field: Individual elements of data defined by a class (object state)

38. Language Terms • Polymorphism: Objects of different classes can be passed to the same client code. When the client code invokes a method on the object, the code executed depends on the object’s run-time class (requires dynamic method resolution, or late binding)

39. Basic Java Types • Primitive Types • byte, short, int, long, char, float, double, boolean • range of values for each type constant across platforms • Reference Types (non-primitive) • Declare pointers to objects on the Java Heap

40. Reference Types • Java language requires that each reference variable has a declared type (statically typed) • At runtime a reference may be assigned to different types of objects • If a type-cast is potentially unsafe, compiler inserts run-time checks to insure type “compatibility”

41. Reference Types • Interface: Set of guaranteed method declarations without any implementation • Class: Set of guaranteed methods and fields including method implementation • Only classes can be instantiated (objects always belong to a class)

42. Class Hierarchy • A class may extend one other class, its superclass. A class inherits the fields and methods of its superclass including their implementation. • A class may implement multiple interfaces, and must provide code for all methods guaranteed by those interfaces.

43. Extending Classes: Method Overriding • A subclass contains both the methods “inherited” from its superclass and any new methods defined in the class • A subclass may override a method in its superclass by redefining the method with same name, parameter types and return type

44. Abstract Classes • A class may defer implementing a method by declaring it abstract • A class with abstract methods cannot be instantiated • Any non-abstract subclass that has an abstract class ancestor must provide the implementation for the ancestor’s abstract methods

45. Inheritance Hierarchy Printer • A class has only one superclass, but may have many ancestors • Implementation of a single class can then be treated as multiple interfaces Class Interface DotMatrix LaserPrinter Copier FaxMachine Extends Implements OfficeMatePlus

46. Class/Interface Definition Example // Interfaces contain no code interface Copier { void makeCopies(); } interface FaxMachine { void sendFax(); } // Provide code for Copier and // FaxMachine interfaces // Inherit code from LaserPrinter class OfficeMatePlus extends LaserPrinter implements Copier, FaxMachine { void makeCopies() { // code to make copies ...} void sendFax() { // code to send a fax ... } } // Defer Printer implementation abstract class Printer { abstract void print(); } // Override Printer.print() class DotMatrix extends Printer void print() { // dot matrix printer code ... }} // Override Printer.print() class LaserPrinter extends Printer { void print() { // laser printer code ... }}

47. Dynamic Method Resolution • Dynamic resolution ensures that the correct code will be invoked based on the object’s runtime class • Interface Calls • If reference type is an interface, method resolution locates the method’s implementation based on the object’s runtime class

48. Dynamic Method Resolution • Virtual Calls • If the reference type is a class, method resolution must determine which implementation to use - the object’s runtime class may override a method defined in a base class

49. Revisiting Class/Interface Example // More office equipment class QuickCopier implements Copier { public void makeCopies() { … } } class EasyFax implements FaxMachine { public void sendFax() { … } } // Can use three types of machines class TrainedEmployee { void PrintDocument( Printer p) { p.print(); // Virtual call } void replicateDocument( Copier c) { // Interface call c.makeCopies(); } void faxDocument( FaxMachine f) { // Interface call f.sendFax(); } }

50. Revisiting Class/Interface Example // Upgrade to the OfficeMatePlus OfficeMatePlus o = new OfficeMatePlus(); // Trained employee can do // everything with one machine // by using different interfaces // depending on the situation e.printDocument(o); e.replicateDocument(o); e.faxDocument(o); // Polymorphism means you // don’t have to retrain your // employee // Create a new TrainedEmployee TrainedEmployee e = new TrainedEmployee(); // Create office equipment objects DotMatrix dm = new DotMatrix(); QuickCopier qc = new QuickCopier(); EasyFax ef = new EasyFax(); // TrainedEmployee can use all // three machines e.printDocument(dm); e.replicateDocument(qc); e.faxDocument(ef);