Chapter 8: Virtual Machine II: Program Control

Transcription

1 Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005 Chapter 8: Virtual Machine II: Program Control Usage and Copyright Notice: Copyright 2005 Noam Nisan and Shimon Schocken This presentation contains lecture materials that accompany the textbook The Elements of Computing Systems by Noam Nisan & Shimon Schocken, MIT Press, The book web site, features 13 such presentations, one for each book chapter. Each presentation is designed to support about 3 hours of classroom or self-study instruction. You are welcome to use or edit this presentation for instructional and non-commercial purposes. If you use our materials, we will appreciate it if you will include in them a reference to the book s web site. And, if you have any comments, you can reach us at tecs.ta@gmail.com Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 1

2 Efi Arazi School of Computer Science Digital Systems Construction Virtual Machine Part II: Program Control Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 2

3 Where we are at: Human Thought Abstract design Chapters 9, 12 abstract interface H.L. Language & Operating Sys. Compiler Chapters abstract interface Virtual Machine Software hierarchy VM Translator Chapters 7-8 abstract interface Assembly Language Assembler Chapter 6 abstract interface Machine Language Computer Architecture Chapters 4-5 Hardware hierarchy abstract interface Hardware Platform Gate Logic Chapters 1-3 abstract interface Chips & Logic Gates Electrical Engineering Physics Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 3

4 The big picture Some language Some Other language Jack language Some compiler Some Other compiler Jack compiler Chapters 9-13 VM language Implemented in Projects 7-8 VM implementation over CISC platforms VM imp. over RISC platforms VM emulator VM imp. over the Hack platform Chapters 7-8 CISC machine language RISC machine language A Java-based emulator is included in the course software suite written in a high-level language Hack machine language Chapters 1-6 CISC machine RISC machine other digital platforms, each equipped with its VM implementation Any computer Hack computer Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 4

5 Lecture plan Goal: Specify and implement a VM model and language Arithmetic // Boolean commands add add sub sub neg neg eq eq gt gt Previous lt lt lecture and and or or not not Memory access commands pop pop segment i push segment i Program flow flow commands label (declaration) goto goto (label) (label) if-goto (label) (label) Function calling commands function (declaration) call (a (a function) function) This lecture return (from (from a function) function) Method: (a) specify the abstraction (model s constructs and commands) (b) propose how to implement it over the Hack platform. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 5

6 Program structure and translation path (on the Hack-Jack platform) Jack source code: (example): class class Foo Foo static staticslist; static int staticslist; int x1, x1, x2, x2, x3; x3; Compiler method f1(argslist) f1(argslist) method int int f1(int f1(int x) x) var localslist; var int localslist; int a, a, b; b; method f2(argslist) f2(argslist) method void void f2(int f2(int x, x, int int y) y) var localslist; var int localslist; int a, a, b, b, c; c; function f3(argslist) f3(argslist) function int int f3(int f3(int u) u) var localslist; var int localslist; int x; x; class class Bar Bar static staticslist; static int staticslist; int y1, y1, y2; y2; function f1(argslist) function void f1(argslist) void f1(int f1(int u, u, int int v) v) method f2(argslist) f2(argslist) method void void f2(int f2(int x) x) var localslist; var int localslist; int a1, a1, a2; a2; Following compilation: Foo.vm argument local this that pointer Bar.vm f1 f2 f3 f1 f2 static argument local this that pointer VM translator argument local this that pointer temp constant VM translator argument local this that pointer Hack machine language code static argument local this that pointer VM files (one set of virtual segments for each instance of a running function) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 6

7 The challenge ahead 2 x = ( b + b 4 a c) / 2a if if ~(a ~(a = 0) 0) x = (-b (-b + sqrt(power(b,2) 4 * a * c)) c)) / (2 (2 * a) a) else else x = - c / b In order to enable such high-level code we have to know how to handle: Arithmetic operations (previous lecture) Boolean operations (previous lecture) Program flow (this lecture, easy) Subroutines (this lecture, medium/rare) In the Jack/Hack platform: all these abstractions are delivered by the VM level. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 7

8 Program flow label c goto c if-goto c (pop (pop the the topmost element from from the the stack. If If it s it s not not zero, zero, jump) Implementation (by translation to assembly): Simple. label declarations and goto directives can be effected directly by assembly commands. Example: function function mult mult 2 push push constant constant 0 pop pop local local 0 push push argument argument 1 pop pop local local 1 label label loop loop push push local local 1 push push constant constant 0 eq eq if-goto if-goto end end push push local local 0 push push argument argument 0 add add pop pop local local 0 push push local local 1 push push constant constant 1 sub sub pop pop local local 1 goto goto loop loop label label end end push push local local 0 return return Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 8

9 Subroutines if if ~(a ~(a = 0) 0) x = (-b (-b + sqrt(power(b,2) 4 * a * c)) c)) / (2 (2 * a) a) else else x = - c / b Subroutines = a major programming artifact The primitive (given) language can be extended at will by user-defined commands ( AKA subroutines / functions / methods...) The primitive commands and the user-defined commands have the same look-and-feel Perhaps the most important abstraction delivered by programming languages. The challenge: to make the implementation of this abstraction as transparent as possible: A well-deigned system consists of a collection of black box modules, each executing its effect like magic (Steven Pinker, How The Mind Works) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 9

10 Subroutines usage at the VM level (pseudo code) Call-and-return convention The caller pushes the arguments, calls the callee, then waits for it to return Before the callee terminates (returns), it must push a return value At the point of return, the callee s resources are recycled, and the caller s state is re-instated Caller s net effect: the arguments were replaced by the return value (just like with primitive operations) Behind the scene Recycling and re-instating subroutine resources and states is a major headache The VM implementation should manage it like magic The magic is stack-based, and is considered a great CS gem. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 10

11 Subroutine commands function g nvars (Here starts a function called g, g, which has has nvars local local variables) call g nargs (Invoke function g for for its its effect; nargs arguments have have been been pushed onto onto the the stack) Return (Terminate execution and and return control to to the the calling function) Implementation: Next few slides. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 11

12 Aside: The VM emulator (Java-based, included in the course software suite) Calling hierarchy Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 12

13 The calling protocol The caller s view: Before Before calling calling the the function, function, I must must push push as as many many arguments arguments as as necessary necessary onto onto the the stack stack Next, Next, I invoke invoke the the function function using using the the call callcommand command After After the the called called function function returns: returns: The The arguments arguments that that I pushed pushed before before the the call call have have disappeared from from the the stack, stack, and and a a return return value value (that (that always always exists) exists) appears appears at at the the top top of of the the stack stack All All my my memory memory segments segments (argument, (argument, local, local, static, static, ) ) are are the the same same as as before before the the call. call. function g nvars call call g nargs return Blue = function writer s responsibility Black = black box magic, supplied by the VM implementation. The callee s view: When When I start start executing, executing, my my argument argumentsegment has has been been initialized initialized with with actual actual argument argument values values passed passed by by the the caller caller My My local localvariables segment segment has has been been allocated allocated and and initialized initialized to to zero zero The The static staticsegment segment that that I see see has has been been set set to to the the static staticsegment segment of of the the VM VM file file to to which which I belong, belong, and and the the working working stack stack that that I see see is is empty empty Before Before returning, returning, I must must push push a a value value onto onto the the stack. stack. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 13

14 VM implementation view of the calling protocol When function f calls function g, I must: function g nvars call call g nargs return Save the return address Save the segment pointers of f Allocate, and initialize to 0, as many local variables as needed by g Set the local and argument segment pointers of g Transfer control to g. When g terminates and control should return to f, I must: Clear the arguments and other junk from the stack Restore the segments of f Transfer control back to f (jump to the saved return address). Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 14

15 The VM implementation housekeeping storage = the stack ARG LCL SP frames of all the functions up the calling chain argument 0 argument 1 argument n-1 return address saved LCL saved ARG saved THIS saved THAT local 0 local 1 local k-1 arguments pushed for the current function saved state of the calling function, used to return to and restore the segments of, the calling function upon returning from the current function local variables of the current function working stack of the current function Remember: at any typical point of time, some functions are waiting, and only the current function is running Shaded areas: irrelevant to the current function The current function sees only the top of the stack (AKA working stack) The rest of the stack holds the frozen states of all the functions up the calling hierarchy Physical storage details depend on the VM implementation. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 15

16 Example: a typical calling scenario function p(...) fact(4)... function fact(n) vars result,j; result=1; j=1; while j<=n result=mult(result,j); return result; function mult(x,y) vars sum,j; sum=0; j=y; while j>0 sum=sum+x; return sum; p call fact(4) waiting time call mult(1,2) call mult(2,3) call mult(6,4) 24 fact waiting waiting waiting return mult return mult return mult return Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 16

17 Behind the scene: just before "call mult" just after mult is entered just after mult returns ARG argument 0 (fact) argument 0 (fact) ARG argument 0 (fact) return addr (p) return addr (p) return addr (p) function p(...) fact(4)... LCL (p) ARG (p) THIS (p) THAT (p) LCL (p) ARG (p) THIS (p) THAT (p) LCL (p) ARG (p) THIS (p) THAT (p) LCL local 0 (fact) local 0 (fact) LCL local 0 (fact) function fact(n) vars result,j; result=1; j=1; while j<=n result=mult(result,j); return result; SP local 1 (fact) working stack (fact) argument 0 (mult) argument 1 (mult) ARG local 1 (fact) working stack (fact) argument 0 (mult) argument 1 (mult) return addr (fact) LCL (fact) SP local 1 (fact) working stack (fact) return value function mult(x,y) vars sum,j; sum=0; j=y; while j>0 sum=sum+x; return sum; LCL SP ARG (fact) THIS (fact) THAT (fact) local 0 (mult) local 1 (mult) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 17

18 Implementing the call f n command frames of all the functions up the calling chain ARG argument 0 argument 1 argument n-1 return address saved LCL saved ARG saved THIS saved THAT LCL SP local 0 local 1 local k-1 Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 18

19 Implementing the function f k command frames of all the functions up the calling chain ARG argument 0 argument 1 argument n-1 return address saved LCL saved ARG saved THIS saved THAT LCL SP local 0 local 1 local k-1 Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 19

20 Implementing the return command frames of all the functions up the calling chain ARG argument 0 argument 1 argument n-1 return address saved LCL saved ARG saved THIS saved THAT LCL SP local 0 local 1 local k-1 Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 20

21 One more detail: bootstrapping A high-level jack program (AKA application) is a set of class files. By convention, one class must be called Main, and this class must have at least one function called main. The contract is such that when we tell the computer to execute the program, the function Main.main starts running Implementation: After the program is compiled, each class file is translated into a.vm file From the host platform s standpoint, the operating system is also a set of.vm files (AKA libraries ) that co-exist alongside the user s.vm files One of the OS libraries is called Sys.vm, which includes a function called init. This function starts with some OS initialization code (explained in Ch. 12), then it does call f and enters an infinite loop; if the code originates from Jack, f is Main.main Thus, to bootstrap, the VM implementation has to effect (e.g. in assembly), the following operations: SP SP = // // initialize the the stack pointer to to 0x0100 call call Sys.init // // the the initialization function Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 21

22 VM implementation over the Hack platform Extends the VM implementation proposed in the last lecture (Chapter 7) The result: a big assembly program with lots of agreed-upon symbols: Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 22

23 Proposed API Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 23

24 Perspective Benefits of the VM approach Code transportability: compiling for different platforms require replacing only the VM implementation Language inter-operability: code of multiple languages can be shared using the same VM Common software libraries Code mobility: Internet VM implementation over CISC platforms Some language Some compiler VM language VM imp. over RISC platforms Some Other language Some Other compiler CISC RISC machine machine language language VM emulator Jack compiler Translator written in a high-level language Hack Modularity: Improvements in the VM implementation are shared by all compilers above it Every new digital device with a VM implementation gains immediate access to an existing software base New programming languages can be implemented easily using simple compilers Benefits of managed code: Security VM Cons Array bounds, index checking, Add-on code Etc. Performance. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 8: VM II: Program Control slide 24