Modular Virtual Machine Architecture on a Meta-Circular JVM

Transcript

1. Modular Virtual Machine Architecture on a Meta-Circular JVM Wei Zhang

   1

2. 张Җ / Wei Zhang Department: EECS Program: Computer Systems &

   Software 2 Committee: Professor Michael Franz, Chair Professor Pai Chou Professor Rainer Doemer Professor Kwei-Jay Lin Professor Harry Xu

3. Virtual machines on mobile devices... Motivation 3 Android Dalvik V8

   ActionScript VM

4. 4 Motivation Duplicated modules between VMs Dalvik V8 ActionScript VM

   Parser Interp Parser Parser GC GC JIT GC JIT Interp JIT

5. Drawbacks: - Big footprint for multiple language implementations - Expensive

   investment for new VMs 5 Motivation

6. Objectives: + Smaller footprint for multiple language implementations + Simplify

   implementation for new VMs 6 Motivation JavaScript Python Ruby Host VM

7. 7 • Interpreter • Targeting a Host VM • Meta-Circular

   VM • Early Results Outline

8. + Easy to implement and maintain + Fast edit-compile-run cycle

   + More portable + More memory efficient 8 Interpreter

9. - But it’s slow... 9 Interpreter

10. 10 Interpreter Inefficient Interpreter 1000X Efficient Interpreter 10X Optimizing Compiler

    1X Performance slowdown[1] [1]: M. Anton Ertl and D. Gregg, Journal of Instruction-Level Parallelism 2003

11. 11 Cost of interpretation[1] Instruction dispatch Operand access Performing the

    computation [1]: D. Gregg et al., The Case for Virtual Register Machines, IVME 2003 IF ID EX ME WB IF ID EX ME WB IF ID EX ME WB IF ID EX ME WB

12. for (;;) switch(program[ip++]){ /*...*/ case add: sp[1]=sp[0]+sp[1]; sp++; break; /*...*/

    } 12 Instruction Dispatch Instruction stream Dispatching loop Instruction implementations Switch-based dispatch IF ID EX ME WB

13. Inst thread[]= {&add, &pop...}; goto *thread++; add: sp[1]=sp[0]+sp[1]; sp++; goto

    *thread++; /*...*/ 13 Instruction Dispatch Threaded-code Instruction implementations Direct Threading[1] [1]: James R. Bell, Threaded Code, CACM, 1973 IF ID EX ME WB

14. 14 thread: &get &a &get &b &add thread: &i_get_a &i_get_b

    &i_add i_get_a: &get &a i_get_b: &get &b i_add: &add get: sp[0]=*(*ip+1); sp++; goto *(*ip++); add: sp[0]=sp[1]+sp[0]; goto *(*ip++); Direct Threading Indirect Threading Indirection Operation Routine Indirect Threading Instruction Dispatch IF ID EX ME WB

15. 15 thread: call get_a call get_b call add Subroutine Threading

    Instruction Dispatch Threaded-code Instruction implementations IF ID EX ME WB

16. 16 Operand Access 1:push 1 2:push 2 3:push 4 4:mul

    5:add 6:set a To perform: a = 1+2*4 1 1 2 1 2 4 1 8 9 1 push 1 push 1 push 2 pop,1 push 2 pop,1 push 1 pop Bytecode Stack Stack ops 10 stack ops IF ID EX ME WB

17. 17 Operand Access 1:push 1 2:push 2 3:push 4 4:mul

    5:add 6:set a 0 0 1 push 1 pop 0 0 Bytecode Stack Stack ops 2 stack ops Stack caching[1] : keep top-of-stack in registers 1 1 1 2 2 4 1 8 9 [1]: M. Anton Ertl, Stack Caching for Interpreters, PLDI 1995 IF ID EX ME WB

18. Stack-based vs. Register-based architecture 18 Operand Access 1:get a 2:get

    b 3:add 4:set c 1:add c a b With register-based architecture: -35% native instruction count[1] +45% code size[1] [1]: Yunhe Shi et al., Virtual Machine Showdown: Stack versus registers, TACO 2008 IF ID EX ME WB

19. 19 1 + 2 -> 3 ‘a’ + ‘b’ ->

    ‘ab’ 1 + ‘a’ -> ‘1a’ ‘1’ + 2 -> ‘12’ ... Possibilities of : a + b Runtime Overhead of Dynamic Typing IF ID EX ME WB

20. 20 if (Num && Num) { return a + b;

    } else if (String && String) return a.concat(b); } else if (Num && String) return a.toString().concat(b); } else if (String && Num) return a.concat(b.toString()); } ... Runtime overhead of Dynamic Typing Implementation of : add IF ID EX ME WB

21. Quickening[1] 21 Instruction Stream Generic Instruction Quickened Instruction Stream Specialized

    Instruction [1]: S. Brunthaler, Inline Caching Meets Quickening, ECOOP 2010 IF ID EX ME WB Performing the Computation get a get b add get a get b nadd generic add number add guard To fallback

22. 22 • VM offers benefits for hosted applications • Can

    we utilize those benefits while building our VM? Targeting a Host VM

23. + Cross platform + Automatic memory management + Libraries +

    Better IDE support 23 Targeting a Host VM (JVM/CLR)

24. Compile to Java bytecode: - Same complexity as writing compiler

    - Need to emulate language semantics which do not map well with JVM 24 Targeting JVM: Option #1 x.js x.class JVM

25. Interpreter running on JVM: - Lack of low level machine

    control - Overhead of double interpretation 25 Targeting JVM: Option #2 x.js Interpreter JVM

26. Restricted by well defined JVM interface 26 Problem Application Guest

    VM JVM

27. 27 Meta-Circular VM [1]: John McCarthy, LISP 1.5 Programmer’s Manual

    1961 [2]: A. Goldberg & D. Robson, Smalltalk-80: the Language and Its Implementation 1983 • Meta-Circular virtual machine is written in the same language it implements • Original idea: meta-circular evaluator in LISP[1] • Smalltalk: the blue book reference implementation[2]

28. 28 Meta-Circular JVM Conventional JVM Maxine VM[1] [1]: B. Titzer

    et al., VEE 2010 Courtesy Bernd Mathiske Application JDK OS Native library JVM Java code Application JDK OS Native library JVM Native code

29. 29 Meta-Circular JVM Guest VM Maxine Compiler Garbage collector Runtime

    system

30. 30 Meta-Circular JVM Word target = ArrayAccess.getWord(threadedCode, index); Intrinsics.jump(target.asAddress()); ...

    Jump to an address using Maxine internal:

31. Modular VM Guest VMs Host VM 31 Ruby Python JavaScript

    Runtime JIT GC Execution Parser Execution Parser Execution Parser

32. 32 Current Progress • MBS JavaScript VM • Parser generated

    using ANTLR • Two interpreters • No regex yet • 19/26 SunSpider benchmarks run

33. 33 Managed Bytecode Script VM Output Parser JavaScript AST walker

    ANTLR Runtime Baseline interpreter Optimized interpreter Bytecode

34. 34 •Baseline Interpreter Standard Java Switch-based dispatching •Optimized Interpreter Direct

    call threading +30% Quickening +8% Managed Bytecode Script VM

35. 35 Comparator: Rhino JavaScript VM • Open source JavaScript VM

    written in Java from Mozilla Foundation • Compile JavaScript source to Java classfile • Interpretation mode is included (AST) MBS Maxine VM Rhino Maxine VM

36. 36 Performance: MBS vs. Rhino on Maxine 0% 20% 40%

    60% 80% 100% 120% 140% 160% 3d_cube.js 3d_morph.js 3d_raytrace.js access_binary_trees.js access_fannkuch.js access_nbody.js access_nsieve.js bitops_3bit_bits_in_byte.js bitops_bits_in_byte.js bitops_bitwise_and.js bitops_nsieve_bits.js controlflow_recursive.js crypto_md5.js crypto_sha1.js math_cordic.js math_partial_sums.js math_spectral_norm.js string_base64.js string_fasta.js arithmetic mean geometry mean Geometric Mean -25% Arithmetic Mean -18%

37. 37 MBS versus Rhino • MBS is 10X smaller than

    Rhino (jar file size) • MBS is written in a very short period • MBS’s performance is comparable with that of Rhino .jar 4 MB .jar 400 KB MBS Rhino

38. 38 Future Work •Threaded Code Dispatch Direct threading / Subroutine

    threading Jython / JRuby •Quickening Dynamic derivative generation Automation

39. Thanks 39

40. 40 MBS versus Rhino: LOC LOC MBS Rhino Front-end 20k

    7k Interpreter 5.6k 3k Runtime 3.4k ~21k Classfile generation - ~22k Other - ~20k Total 29k 73k Total w/o front-end 9k 66k

41. 41 •LLVM[1] Framework for building optimizing compilers Persistent low level

    intermediate representation •Tracing PyPy’s interpreter[2] Running Python interpreter on Python tracing JIT Trace hot code in work load Modular VM: Related Work [1]: Chris Lattner and Vikram Adve, LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation, CGO 2004 [2]: C.F. Bolz et al., Tracing the Meta-Level: PyPy’s Tracing JIT Compiler, ICOOOLPS

42. 42 •Customize object layout for dynamic languages Customizable scheme for

    object layout Efficient resizable object layout[1] Memory Optimization on Maxine [1]: C. Chamers et al., An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Language Based on Prototypes, OOPSLA 1989