inf 212 analysis of prog. langs virtual machines instructors: crista lopes copyright © instructors

INF 212ANALYSIS OF PROG. LANGSVirtual Machines

Instructors: Crista LopesCopyright © Instructors.

What is a Virtual Machine?

Runs as a normal application inside an OS and supports a single process.

Created when the process is started and destroyed when it exits.

A software implementation of a machine (i.e. a computer) that executes programs like a physical machine.

Types of Virtual Machines

Application Virtual Machines Allows application byte code to be run on

different architectures and operating systems. Eg. JVM, CLR, Dalvik, Squeak (Smalltalk), etc…

System (Platform) Virtual Machines Emulation of entire physical machine Eg. VMWare, VirtualBox, etc…

We will be focusing on process virtual machines!!

Example -- JVM

Benefits of VMs

Compatibility: Virtual machines are compatible with various hardware platforms.

Isolation: Virtual machines are isolated from each other as if physically separated.

Encapsulation: Virtual machines encapsulate a complete computing environment.

Hardware Independence: Virtual machines run independently of underlying hardware.

Machine Model

Stacks vs Registers Stack-based machine: Operands are pushed

and popped off the stack. Register-based machine: Operands stored in

register. The most popular VMs use stack architectures.

Costs of executing VM instructions Dispatching the instruction Accessing the operands Performing the computation

Machine Model (cont)

Costs of executing a VM instruction Dispatching the instruction

A given task can often be expressed using fewer register machine instructions than stack ones.

Accessing the operands Stack code is smaller than register code, and

requires fewer memory fetches to execute. This is the main reason why stack architectures

are popular for VMs.

Machine Model (cont)

Costs of executing a VM instruction (cont) Performing the computation

Usually the smallest part of cost. Has to be performed regardless of intermediate

representation. However, eliminating invariant and common

expressions is much easier on a register machine.

Memory Management

Managed (eg. JVM) Safe automatic memory management. Disallow manually constructed pointers to

memory. Unmanaged (eg. LLVM)

Allow direct use and manipulation of pointers.

But no automated garbage collection.

Memory Management (cont) Hybrid (eg. Dot.NET)

Offering both controlled use of memory, while also offering an “unsafe” mode that allows direct manipulation of pointers in ways that can violate type boundaries and permission.

Just-In-Time Compilation

AKA Dynamic Translation A method to improve the runtime

performance of computer programs Hybrid of two previous approaches

Interpretation: Translated from a high-level language to machine code continuously during every execution

Static (ahead-of-time) compilation: Translated into machine code before execution, and only requires this translation once.

Just-In-Time Compilation

JIT compilers in JRE (JVM) and .NET runtimes

Just-In-Time Compilation (cont) At the time of code execution, the JIT

compiler will compile some or all of it to native machine code for better performance.

Can be done per-file, per-function or even on any arbitrary code fragment.

The compiled code is cached and reused later without needing to be recompiled (unlike interpretation).

Just-In-Time Compilation(cont) Offers other advantages over statically

compiled code at development time, such as handling of late-bound data types and the ability to enforce security guarantees.

Most VMs rely on JIT compilation for high speed code execution

JIT for Android: Dalvik JIT http://www.youtube.com/watch?v=Ls0tM-

c4Vfo

Comparison of Various VMs

http://en.wikipedia.org/wiki/Comparison_of_application_virtual_machines

Smalltalk

Brief History Developed by Alan Kay et al. in Xerox PARC

(Palo Alto Research Center Incorporated) Generally recognized as the second Object

Programming Language (OPL) (After Simula) The first Pure OPL Variants: Smalltalk-71, Smalltalk-72, Smalltalk-

76, Smalltalk-80(First made available outside PARC), Squeak (Most popular version today)

Smalltalk (cont)

Two major components The virtual image

Stores the heap and all the objects in it on disk In Java, the heap conceptually starts out empty

and is discarded after program termination The virtual machine

Reads the image from disk into memory and executes the code it contains.

Smalltalk (cont)

The image can be saved at the user’s discretion (“taking a snapshot”).

If the system crashes, the user may restart the system, going back to the exact state of the heap from the snapshot.

This feature is more commonly seen nowadays in system VMs instead of process VMs.

The image makes Smalltalk more portable than Java

Java

1991 - James Gosling begins work on Java project (Originally named “Oak” for the oak tree outside his office.)

1995 - Sun releases first public implementation as Java 1.0

1998 - JDK 1.1 release downloads tops 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.

Java

Java is a general-purpose, concurrent, class-based, object oriented language that is specifically designed to have as few implementation dependencies as possible.

It is intended to let application developers “write once, run anywhere”.

Currently one of the most popular programming languages in use.

Java

Why this design? Familiarity

Bytecode interpreter/compilers were used before Eg. Pascal “pcode”; Smalltalk bytecode

Minimize machine-dependency Do optimization on bytecode when possible Keep bytecode interpreter simple

Portability Transmit bytecode across network “Compile once, run anywhere”

Java Code Overview

JVM Architecture

Class Load Subsystem

Bootstrap class loader User-defined class loader

Method Area & Heap

Method Area

Type Information Constant pool Field information Method table Method information Class variable Reference to class loader and class

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Fully qualified type’s name.

Fully qualified direct super class name.

Whether class or an interface

Type’s modifiers List of fully qualified

names of any direct super interfaces

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Ordered set of constants string integer floating point final variables

Symbolic references to Types Fields Methods

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Field’s name Field’s type Field’s modifiers

(subset) public private protected static final volatile transient

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Method’s name Method’s return type Number and type of

parameters Modifiers (subset)

public private protected static final synchronized native abstract

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Ordered set of class variables Static variables

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

Reference to class loader is used for dynamic linking.

Instance java.lang.Class is created every type for the following info. getName(); getSuperClass(); isInterface(); getInterfaces(); getClassLoader();

Method Area

Type Informatio

n

Constant Pool

Field Informatio

n

Method Informatio

n

Class Variables

Reference to class loader

and class

Method Table

User for quick ref. to method.

Contains name and index in symbol ref. array

Example

class abc { public int a = 10;  String str;  abc() {     str = “string1”;  }

  public void print() {     System.out.print(a+” “+str);   }}

a str <init> print

Symbol ref. array

10     “string1”

Constant poolabcjava.lang.ObjectIsclass=truemodifier=4

Type info

name Type Modifier

a        int          5             0

str      String      4              1

indexField info

name ret.type npar modifier parlist

<init>     void        0        1 print      void       0         5

codeptr

Method infoMethod Table

null

Class variablesname Index

<init> 2

print 3

Example

Heap

Objects and arrays are allocated in a single, shared heap.

Each application has its own heap (isolation). However, two different threads of the same

application could trample on each other’s heap data.

Used when memory allocated with new operator.

Runtime environment automatically frees up memory on heap occupied by objects that are no longer referenced (garbage collection).

Heap (Object Representation)

Heap (Arrays as Objects)

PC register & Java Stacks & Native Mehtod Stacks

Java Stack

Java stack stores a thread’s state in discrete frames.

Each frame contains Local variables area. Operant stack Frame data

Local Variable Area

Organized as a zero-based array of cells. Variables area accessed through their

indices. Values of type int, float, reference, and

return address occupy one cell. Values of type byte, short, and char also

occupy one cell. Values of type long and double occupy

two consecutive cells in the array.

Example

class Example3a { public static int runClassMethod(int i, long l, float f, double d, Object o, byte b) { return 0; }

public int runInstanceMethod(char c, double d, short s, boolean b) { return 0; }}

Operand Stack

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

Java .class File

10 basic sections to the Java Class File structure: Magic Number Version of Class File Format Constant Pool Access Flags This Class Super Class Interfaces Fields Methods Attributes

Java .class File

Magic Number (4 bytes) Class files are identified by the following 4 byte header :

CAFEBABE

Version of Class File Format (4 bytes) minor version number of the class file format being used(2 bytes) major version number of the class file format being used(2 bytes)

J2SE 6.0 = 50 (0x32 hex)

J2SE 5.0 = 49 (0x31 hex)JDK 1.4 = 48 (0x30 hex)JDK 1.3 = 47 (0x2F hex)JDK 1.2 = 46 (0x2E hex)JDK 1.1 = 45 (0x2D hex)

Java .class File

Constant Pool(2 bytes) number of entries in the following constant pool table, say N At least one greater than the actual number of entries (N-1)

Constant Pool[1]….[N-1]

Access Flag(2 bytes) flags that represent modifiers of the class or interface defined

by this file. ACC_PUBLIC is 0x0001 ACC_FINAL is 0x0010 both public and final is (ACC_PUBLIC | ACC_FINAL)

Java .class File

This Class(2 bytes) index into the constant pool to a "Class"-type entry

Super Class(2 bytes) index into the constant pool to a "Class"-type entry

Interfaces(2 bytes) the number of interfaces implemented by this class. (N)

Java .class File

Fields(2 bytes) the number of fields (class or instance variables) declared by

this class.

Methods(2 bytes) the number of methods defined by this class. The count does

not include any methods inherited from superclasses, only those methods explicitly defined in this class.

the instance initialization method, <init>(), is generated by the compiler.

Attributes(2 bytes) The number of attributes (N)

Conceptual Stack Frame Structure Each time a method is invoked a new stack frame

is created. The frame consists of an operand stack, an array of local variables, and a reference to the runtime constant pool of the class of the current method.

Bytecode- opcode

Basic Opcode const (push constant onto the stack)

iconst_1: push integer constant value 1 onto the stack Store(pop to local variables)

istore_1: store the integer in local position one Load(push variable onto the stack)

iload_1: push integer from local variable position one

Java opcodes generally indicate the type of their operands. Opcodes iload, lload, fload, and dload push local variables of

type int, long, float, and double, respectively, onto the stack

ByteCode

 javap -c print out the bytecode

javap -c -s –verbose Print out the constant pool

http://arhipov.blogspot.com/2011/01/java-bytecode-fundamentals.html

Bytecode

Example-Example.java

public class Example

{

public int plus(int a)

{

int b = 1;

return a + b;

}

}

Bytecode

Javap –c Example

ByteCode

Local variable Table for Example.java

References

http://www.artima.com/insidejvm/ed2/ http://rockfish-cs.cs.unc.edu/COMP144/

lect32a.ppt http://web.cecs.pdx.edu/~harry/

musings/SmalltalkOverview.html http://www.cse.iitk.ac.in/users/vkirankr/

Memory%20Architecture.ppt