鍾誠 陳鍾誠, profile picture
Uploaded by鍾誠 陳鍾誠
PDF, PPTX268 views

Lecture 08 virtual machine ii

The document discusses the virtual machine (VM) model and language. It explains that the VM acts as an abstract interface between software and hardware, providing a standardized programming model. The VM language specification includes arithmetic, boolean, memory access, and program flow commands. It also discusses how a two-tier compilation model can be used to translate a high-level language to VM code and then to machine language through a compiler and VM translator. The lecture will focus on how to implement the program flow commands in the VM language by emitting appropriate assembly code commands.

Embed presentation

Download as PDF, PPTX
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 1 www.nand2tetris.org Building a Modern Computer From First Principles Virtual Machine Part II: Program Control
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 2 Where we are at: Assembler Chapter 6 H.L. Language & Operating Sys. abstract interface Compiler Chapters 10 - 11 VM Translator Chapters 7 - 8 Computer Architecture Chapters 4 - 5 Gate Logic Chapters 1 - 3 Electrical Engineering Physics Virtual Machine abstract interface Software hierarchy Assembly Language abstract interface Hardware hierarchy Machine Language abstract interface Hardware Platform abstract interface Chips & Logic Gates abstract interface Human Thought Abstract design Chapters 9, 12
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 3 The big picture . . . RISC machine VM language other digital platforms, each equipped with its VM implementation RISC machine language Hack computer Hack machine language CISC machine language CISC machine . . . written in a high-level language Any computer . . . VM implementation over CISC platforms VM imp. over RISC platforms VM imp. over the Hack platform VM emulator Some Other language Jack language Some compiler Some Other compiler Jack compiler . . .Some language . . . Chapters 1-6 Chapters 7-8 Chapters 9-13 A Java-based emulator is included in the course software suite Implemented in Projects 7-8
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 4 The VM langauge Goal: Complete the specification and implementation of the VM model and language Method: (a) specify the abstraction (model’s constructs and commands) (b) propose how to implement it over the Hack platform. Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture this lecture
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 5 The compilation challenge class Main { static int x; function void main() { // Inputs and multiplies two numbers var int a, b, c; let a = Keyboard.readInt(“Enter a number”); let b = Keyboard.readInt(“Enter a number”); let c = Keyboard.readInt(“Enter a number”); let x = solve(a,b,c); return; } } // Solves a quadearic equation (sort of) function int solve(int a, int b, int c) { var int x; if (~(a = 0)) x=(-b+sqrt(b*b–4*a*c))/(2*a); else x=-c/b; return x; } } class Main { static int x; function void main() { // Inputs and multiplies two numbers var int a, b, c; let a = Keyboard.readInt(“Enter a number”); let b = Keyboard.readInt(“Enter a number”); let c = Keyboard.readInt(“Enter a number”); let x = solve(a,b,c); return; } } // Solves a quadearic equation (sort of) function int solve(int a, int b, int c) { var int x; if (~(a = 0)) x=(-b+sqrt(b*b–4*a*c))/(2*a); else x=-c/b; return x; } } Source code (high-level language) Our ultimate goal: Translate high-level programs into executable code. Compiler 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 ... 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 ... Target code
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 6 The compilation challenge / two-tier setting if (~(a = 0)) x = (-b+sqrt(b*b–4*a*c))/(2*a) else x = -c/b if (~(a = 0)) x = (-b+sqrt(b*b–4*a*c))/(2*a) else x = -c/b Jack source code push a push 0 eq if-goto elseLabel push b neg push b push b call mult push 4 push a call mult push c call mult call sqrt add push 2 push a call mult div pop x goto contLable elseLabel: push c neg push b call div pop x contLable: push a push 0 eq if-goto elseLabel push b neg push b push b call mult push 4 push a call mult push c call mult call sqrt add push 2 push a call mult div pop x goto contLable elseLabel: push c neg push b call div pop x contLable: Compiler VM (pseudo) code 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010010 1110001100000001 ... 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010010 1110001100000001 ... VM translator Machine code We’ll develop the compiler later in the course We now turn to describe how to complete the implementation of the VM language That is -- how to translate each VM command into assembly commands that perform the desired semantics.
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 7 // Computes x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b // Computes x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b Typical compiler’s source code input: The compilation challenge arithmetic expressions function call and return logic boolean expressions program flow logic (branching) How to translate such high-level code into machine language? In a two-tier compilation model, the overall translation challenge is broken between a front-end compilation stage and a subsequent back-end translation stage In our Hack-Jack platform, all the above sub-tasks (handling arithmetic / boolean expressions and program flow / function calling commands) are done by the back-end, i.e. by the VM translator. (previous lecture)(previous lecture)(this lecture) (this lecture)
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 8 Lecture plan Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 9 Program flow commands in the VM language How to translate these three abstractions into assembly? Simple: label declarations and goto directives can be effected directly by assembly commands More to the point: given any one of these three VM commands, the VM Translator must emit one or more assembly commands that effects the same semantics on the Hack platfrom How to do it? see project 8. label c // label declaration goto c // unconditional jump to the // VM command following the label c if-goto c // pops the topmost stack element; // if it’s not zero, jumps to the // VM command following the label c label c // label declaration goto c // unconditional jump to the // VM command following the label c if-goto c // pops the topmost stack element; // if it’s not zero, jumps to the // VM command following the label c In the VM language, the program flow abstraction is delivered using three commands: VM code example: function mult 1 push constant 0 pop local 0 label loop push argument 0 push constant 0 eq if-goto end push argument 0 push 1 sub pop argument 0 push argument 1 push local 0 add pop local 0 goto loop label end push local 0 return function mult 1 push constant 0 pop local 0 label loop push argument 0 push constant 0 eq if-goto end push argument 0 push 1 sub pop argument 0 push argument 1 push local 0 add pop local 0 goto loop label end push local 0 return
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 10 Lecture plan Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 11 Subroutines Subroutines = a major programming artifact Basic idea: the given language can be extended at will by user-defined commands ( aka subroutines / functions / methods ...) Important: the language’s primitive commands and the user-defined commands have the same look-and-feel This transparent extensibility is the most important abstraction delivered by high-level programming languages The challenge: implement this abstraction, i.e. allow the program control to flow effortlessly between one subroutine to the other “A well-designed system consists of a collection of black box modules, each executing its effect like magic” (Steven Pinker, How The Mind Works) // Compute x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b // Compute x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 12 Subroutines in the VM language The invocation of the VM’s primitive commands and subroutines follow exactly the same rules: The caller pushes the necessary argument(s) and calls the command / function for its effect The called command / function is responsible for removing the argument(s) from the stack, and for popping onto the stack the result of its execution. function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop push argument 0 push constant 0 eq if-goto end // if arg0 == 0, jump to end push argument 0 push 1 sub pop argument 0 // arg0-- push argument 1 push local 0 add pop local 0 // result += arg1 goto loop label end push local 0 // push result return function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop push argument 0 push constant 0 eq if-goto end // if arg0 == 0, jump to end push argument 0 push 1 sub pop argument 0 // arg0-- push argument 1 push local 0 add pop local 0 // result += arg1 goto loop label end push local 0 // push result return Called code, aka “callee” (example) ... // computes (7 + 2) * 3 - 5 push constant 7 push constant 2 add push constant 3 call mult push constant 5 sub ... ... // computes (7 + 2) * 3 - 5 push constant 7 push constant 2 add push constant 3 call mult push constant 5 sub ... Calling code (example) VM subroutine call-and-return commands
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 13 Function commands in the VM language Q: Why this particular syntax? A: Because it simplifies the VM implementation (later). function g nVars // here starts a function called g, // which has nVars local variables call g nArgs // invoke function g for its effect; // nArgs arguments have already been pushed onto the stack return // terminate execution and return control to the caller function g nVars // here starts a function called g, // which has nVars local variables call g nArgs // invoke function g for its effect; // nArgs arguments have already been pushed onto the stack return // terminate execution and return control to the caller
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 14 Function call-and-return conventions function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop ... // rest of code ommitted label end push local 0 // push result return function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop ... // rest of code ommitted label end push local 0 // push result return called function aka “callee” (example) function demo 3 ... push constant 7 push constant 2 add push constant 3 call mult ... function demo 3 ... push constant 7 push constant 2 add push constant 3 call mult ... Calling function Call-and-return programming convention The caller must push the necessary argument(s), call the callee, and wait 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, the caller’s state is re-instated, execution continues from the command just after the call Caller’s net effect: the arguments were replaced by the return value (just like with primitive commands) Behind the scene Recycling and re-instating subroutine resources and states is a major headache Some agent (either the VM or the compiler) should manage it behind the scene “like magic” In our implementation, the magic is VM / stack-based, and is considered a great CS gem. Although not obvious in this example, every VM function has a private set of 5 memory segments (local, argument, this, that, pointer) These resources exist as long as the function is running.
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 15 The function-call-and-return protocol The caller’s view: When I start executing, my argument segment has been initialized with actual argument values passed by the caller My local variables segment has been allocated and initialized to zero The static segment that I see has been set to the static segment of the VM file to which I belong, and the working stack that I see is empty Before exiting, I must push a value onto the stack and then use the command return. When I start executing, my argument segment has been initialized with actual argument values passed by the caller My local variables segment has been allocated and initialized to zero The static segment that I see has been set to the static segment of the VM file to which I belong, and the working stack that I see is empty Before exiting, I must push a value onto the stack and then use the command return. Before calling a function g, I must push onto the stack as many arguments as needed by g Next, I invoke the function using the command call g nArgs After g returns: The arguments that I pushed before the call have disappeared from the stack, and a return value (that always exists) appears at the top of the stack All my memory segments (local, argument, this, that, pointer) are the same as before the call. Before calling a function g, I must push onto the stack as many arguments as needed by g Next, I invoke the function using the command call g nArgs After g returns: The arguments that I pushed before the call have disappeared from the stack, and a return value (that always exists) appears at the top of the stack All my memory segments (local, argument, this, that, pointer) are the same as before the call. The callee’s (g ‘s) view: Blue = VM function writer’s responsibility Black = black box magic, delivered by the VM implementation Thus, the VM implementation writer must worry about the “black operations” only. function g nVars call g nArgs return function g nVars call g nArgs return
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 16 When function f calls function g, the VM implementation must: Save the return address within f ‘s code: the address of the command just after the call Save the virtual segments 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, the VM implementation must: Clear g ’s arguments and other junk from the stack Restore the virtual segments of f Transfer control back to f (jump to the saved return address). Q: How should we make all this work “like magic”? A: We’ll use the stack cleverly. The function-call-and-return protocol: the VM implementation view function g nVars call g nArgs return function g nVars call g nArgs return
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 17 The implementation of the VM’s stack on the host Hack RAM Global stack: the entire RAM area dedicated to hold the stack Working stack: from SP onwards: the stack that the current function sees At any point of time, only one function (the current function) is executing; other functions may be waiting up the calling chain Shaded areas: irrelevant to the current function The current function sees only the working stack, as well as its virtual memory segments The rest of the stack holds the frozen states of all the functions up the calling hierarchy.
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 18 Implementing the call g nArgs command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. // In the course of implementing the code of f // (the caller), we arrive to the command call g nArgs. // we assume that nArgs arguments have been pushed // onto the stack. What do we do next? // We generate a symbol, let’s call it returnAddress; // Next, we effect the following logic: push returnAddress // saves the return address push LCL // saves the LCL of f push ARG // saves the ARG of f push THIS // saves the THIS of f push THAT // saves the THAT of f ARG = SP-nArgs-5 // repositions SP for g LCL = SP // repositions LCL for g goto g // transfers control to g returnAddress: // the generated symbol // In the course of implementing the code of f // (the caller), we arrive to the command call g nArgs. // we assume that nArgs arguments have been pushed // onto the stack. What do we do next? // We generate a symbol, let’s call it returnAddress; // Next, we effect the following logic: push returnAddress // saves the return address push LCL // saves the LCL of f push ARG // saves the ARG of f push THIS // saves the THIS of f push THAT // saves the THAT of f ARG = SP-nArgs-5 // repositions SP for g LCL = SP // repositions LCL for g goto g // transfers control to g returnAddress: // the generated symbol call g nArgscall g nArgs None of this code is executed yet ... At this point we are just generating code (or simulating the VM code on some platform)
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 19 Implementing the function g nVars command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. function g nVarsfunction g nVars // to implement the command function g nVars, // we effect the following logic: g: repeat nVars times: push 0 // to implement the command function g nVars, // we effect the following logic: g: repeat nVars times: push 0
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 20 Implementing the return command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. // In the course of implementing the code of g, // we arrive to the command return. // We assume that a return value has been pushed // onto the stack. // We effect the following logic: frame = LCL // frame is a temp. variable retAddr = *(frame-5) // retAddr is a temp. variable *ARG = pop // repositions the return value // for the caller SP=ARG+1 // restores the caller’s SP THAT = *(frame-1) // restores the caller’s THAT THIS = *(frame-2) // restores the caller’s THIS ARG = *(frame-3) // restores the caller’s ARG LCL = *(frame-4) // restores the caller’s LCL goto retAddr // goto returnAddress // In the course of implementing the code of g, // we arrive to the command return. // We assume that a return value has been pushed // onto the stack. // We effect the following logic: frame = LCL // frame is a temp. variable retAddr = *(frame-5) // retAddr is a temp. variable *ARG = pop // repositions the return value // for the caller SP=ARG+1 // restores the caller’s SP THAT = *(frame-1) // restores the caller’s THAT THIS = *(frame-2) // restores the caller’s THIS ARG = *(frame-3) // restores the caller’s ARG LCL = *(frame-4) // restores the caller’s LCL goto retAddr // goto returnAddress returnreturn
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 21 Bootstrapping SP = 256 // initialize the stack pointer to 0x0100 call Sys.init // call the function that calls Main.main SP = 256 // initialize the stack pointer to 0x0100 call Sys.init // call the function that calls Main.main A high-level jack program (aka application) is a set of class files. By a Jack convention, one class must be called Main, and this class must have at least one function, called main. The contract: when we tell the computer to execute a Jack program, the function Main.main starts running Implementation: After the program is compiled, each class file is translated into a .vm file The operating system is also implemented as a set of .vm files (aka “libraries”) that co-exist alongside the program’s .vm files One of the OS libraries, called Sys.vm, includes a method called init. The Sys.init function starts with some OS initialization code (we’ll deal with this later, when we discuss the OS), then it does call Main.main Thus, to bootstrap, the VM implementation has to effect (e.g. in assembly), the following operations:
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 22 Extends the VM implementation described in the last lecture (chapter 7) The result: a single assembly program file with lots of agreed-upon symbols: VM implementation over the Hack platform
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 23 Proposed API
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 24 Perspective Benefits of the VM approach Code transportability: compiling for different platforms requires 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 Some virtues of the modularity implied by the VM approach to program translation: 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 . . . VM language RISC machine language Hack CISC machine language . . . written in a high-level language . . . VM implementation over CISC platforms VM imp. over RISC platforms TranslatorVM emulator Some Other language Jack Some compiler Some Other compiler compiler . . .Some language . . . Benefits of managed code: Security Array bounds, index checking, … Add-on code Etc. VM Cons Performance.

More Related Content

PDF
Lecture 07 virtual machine i
by鍾誠 陳鍾誠
 
PDF
통신사의 차별화된 메시징 서비스 아키텍처를 소개합니다 - 정영준 AWS 솔루션즈 아키텍트 / 강성원, 나상화 소프트웨어 엔지니어 무선사업부...
byAmazon Web Services Korea
 
PPTX
UnityによるHoloLens用UWPアプリケーション開発の勘所
byTakahiro Miyaura
 
PDF
유니티 - 물리엔진(Physics Engine) 개념 잡기
by주형 고
 
PPT
레가시 프로젝트의 빌드 자동화
byJaehoon Choi
 
PDF
김혁, <드래곤 하운드>의 PBR과 레이트레이싱 렌더링 기법, NDC2019
bydevCAT Studio, NEXON
 
PDF
06_게임엔진구성
bynoerror
 
PDF
머피의 머신러닝: Undirencted Graphical Model
byJungkyu Lee
 
Lecture 07 virtual machine i
by鍾誠 陳鍾誠
 
통신사의 차별화된 메시징 서비스 아키텍처를 소개합니다 - 정영준 AWS 솔루션즈 아키텍트 / 강성원, 나상화 소프트웨어 엔지니어 무선사업부...
byAmazon Web Services Korea
 
UnityによるHoloLens用UWPアプリケーション開発の勘所
byTakahiro Miyaura
 
유니티 - 물리엔진(Physics Engine) 개념 잡기
by주형 고
 
레가시 프로젝트의 빌드 자동화
byJaehoon Choi
 
김혁, <드래곤 하운드>의 PBR과 레이트레이싱 렌더링 기법, NDC2019
bydevCAT Studio, NEXON
 
06_게임엔진구성
bynoerror
 
머피의 머신러닝: Undirencted Graphical Model
byJungkyu Lee
 

What's hot

PPTX
D2 Hdr
byYoupyo Choi
 
PPTX
Shader Programming With Unity
byMindstorm Studios
 
PDF
Unity3D로 풀3D web mmorpg 만들기
byJP Jung
 
PDF
레퍼런스만 알면 언리얼 엔진이 제대로 보인다
byLee Dustin
 
PDF
[IGC2018] 청강대 이득우 - 언리얼에디터확장을위해알아야할것들
by강 민우
 
PPT
NVIDIA OpenGL 4.6 in 2017
byMark Kilgard
 
PDF
NDC 2010 이은석 - 마비노기 영웅전 포스트모템 1부
byEunseok Yi
 
PDF
BKK16-315 Graphics Stack Update
byLinaro
 
PDF
ドキュメントシステムはこれを使え2015年版
byKeiichiro Shikano
 
PDF
Oculus Quest で点群を見る
bymatsunoh
 
PDF
Ndc11 이창희_hdr
bychangehee lee
 
PPTX
CPS - Week 1.pptx
bySantiagoBrito20
 
PPT
Introduction to gdb
byOwen Hsu
 
PDF
C# ゲームプログラミングはホントにメモリのことに無頓着でいいの？
by京大 マイコンクラブ
 
PDF
Process' Virtual Address Space in GNU/Linux
byVarun Mahajan
 
PDF
Q2.12: Debugging with GDB
byLinaro
 
PPTX
리플렉션과 가비지 컬렉션
byQooJuice
 
PDF
디지털 트윈:현실 세계의 미러링, 그 가능성과 한계
bySANGHEE SHIN
 
PPTX
Android media codec 사용하기
byTaehwan kwon
 
PPTX
win32 app에서 UWP API호출하기
byYEONG-CHEON YOU
 
D2 Hdr
byYoupyo Choi
 
Shader Programming With Unity
byMindstorm Studios
 
Unity3D로 풀3D web mmorpg 만들기
byJP Jung
 
레퍼런스만 알면 언리얼 엔진이 제대로 보인다
byLee Dustin
 
[IGC2018] 청강대 이득우 - 언리얼에디터확장을위해알아야할것들
by강 민우
 
NVIDIA OpenGL 4.6 in 2017
byMark Kilgard
 
NDC 2010 이은석 - 마비노기 영웅전 포스트모템 1부
byEunseok Yi
 
BKK16-315 Graphics Stack Update
byLinaro
 
ドキュメントシステムはこれを使え2015年版
byKeiichiro Shikano
 
Oculus Quest で点群を見る
bymatsunoh
 
Ndc11 이창희_hdr
bychangehee lee
 
CPS - Week 1.pptx
bySantiagoBrito20
 
Introduction to gdb
byOwen Hsu
 
C# ゲームプログラミングはホントにメモリのことに無頓着でいいの？
by京大 マイコンクラブ
 
Process' Virtual Address Space in GNU/Linux
byVarun Mahajan
 
Q2.12: Debugging with GDB
byLinaro
 
리플렉션과 가비지 컬렉션
byQooJuice
 
디지털 트윈:현실 세계의 미러링, 그 가능성과 한계
bySANGHEE SHIN
 
Android media codec 사용하기
byTaehwan kwon
 
win32 app에서 UWP API호출하기
byYEONG-CHEON YOU
 

Similar to Lecture 08 virtual machine ii

PDF
Introduction
by鍾誠 陳鍾誠
 
PDF
Lecture 11 compiler ii
by鍾誠 陳鍾誠
 
PDF
Machine language
by鍾誠 陳鍾誠
 
PPT
assembler from system programming intro lelend beck book course
bynakamokachro
 
PPTX
Assembly chapter One.pptx
byssuserb78e291
 
PDF
nand2tetris 舊版投影片 -- 第四章 機器語言
by鍾誠 陳鍾誠
 
PDF
Lecture 06 assembler
by鍾誠 陳鍾誠
 
PPT
lessssssssssssssssssssssssssson01 (1).ppt
bysuhailkhan321619
 
PPT
Assembly Langauge Assembly Langauge Assembly Langauge
bymustafkhalid
 
PDF
introduction to virtual machine and awareness
byhgame779
 
PPT
Assembler.ppt
byycelgemici1
 
PDF
Linux KVM のコードを追いかけてみよう
byTsuyoshi OZAWA
 
PDF
Machine language/nandtotetris/lecture_4
byArchilZhghenti
 
PPT
VIRTUAL MACHINE VERSATILE PLATFORM01~chapter 1 (1).ppt
bynagarajans87
 
PDF
Introduction to nand2 tetris
byYodalee
 
PDF
Assembler turorial for computers one.pdf
bysheltonmutambirwa
 
PPTX
2ProgrammerViewOfComputerAndInstructionCycle.pptx
byNnoor1
 
PPTX
Lecture 1-vs.pptx.......................
byHassamShahid2
 
PPTX
How to build a virtual machine
byTerence Parr
 
PPT
Introduction to Computer Organization and Architecture
bybansidhar11
 
Introduction
by鍾誠 陳鍾誠
 
Lecture 11 compiler ii
by鍾誠 陳鍾誠
 
Machine language
by鍾誠 陳鍾誠
 
assembler from system programming intro lelend beck book course
bynakamokachro
 
Assembly chapter One.pptx
byssuserb78e291
 
nand2tetris 舊版投影片 -- 第四章 機器語言
by鍾誠 陳鍾誠
 
Lecture 06 assembler
by鍾誠 陳鍾誠
 
lessssssssssssssssssssssssssson01 (1).ppt
bysuhailkhan321619
 
Assembly Langauge Assembly Langauge Assembly Langauge
bymustafkhalid
 
introduction to virtual machine and awareness
byhgame779
 
Assembler.ppt
byycelgemici1
 
Linux KVM のコードを追いかけてみよう
byTsuyoshi OZAWA
 
Machine language/nandtotetris/lecture_4
byArchilZhghenti
 
VIRTUAL MACHINE VERSATILE PLATFORM01~chapter 1 (1).ppt
bynagarajans87
 
Introduction to nand2 tetris
byYodalee
 
Assembler turorial for computers one.pdf
bysheltonmutambirwa
 
2ProgrammerViewOfComputerAndInstructionCycle.pptx
byNnoor1
 
Lecture 1-vs.pptx.......................
byHassamShahid2
 
How to build a virtual machine
byTerence Parr
 
Introduction to Computer Organization and Architecture
bybansidhar11
 

More from 鍾誠 陳鍾誠

PDF
用十分鐘瞭解 新竹科學園區的發展史
by鍾誠 陳鍾誠
 
PDF
用十分鐘搞懂 λ-Calculus
by鍾誠 陳鍾誠
 
PDF
交⼤資訊⼯程學系備審資料 ⾱詠祥
by鍾誠 陳鍾誠
 
PDF
smallpt: Global Illumination in 99 lines of C++
by鍾誠 陳鍾誠
 
PDF
西洋史 (你或許不知道但卻影響現代教育的那些事)
by鍾誠 陳鍾誠
 
PDF
區塊鏈 (比特幣背後的關鍵技術) -- 十分鐘系列
by鍾誠 陳鍾誠
 
PDF
區塊鏈 (比特幣背後的關鍵技術) -- 十分鐘系列
by鍾誠 陳鍾誠
 
PDF
梯度下降法 (隱藏在深度學習背後的演算法) -- 十分鐘系列
by鍾誠 陳鍾誠
 
PDF
用十分鐘理解 《微分方程》
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 前言
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 附錄
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 12 章 系統軟體實作
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 11 章 嵌入式系統
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 10 章 作業系統
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 9 章 虛擬機器
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 8 章 編譯器
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 7 章 高階語言
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 6 章 巨集處理器
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 5 章 連結與載入
by鍾誠 陳鍾誠
 
DOCX
系統程式 -- 第 4 章 組譯器
by鍾誠 陳鍾誠
 
用十分鐘瞭解 新竹科學園區的發展史
by鍾誠 陳鍾誠
 
用十分鐘搞懂 λ-Calculus
by鍾誠 陳鍾誠
 
交⼤資訊⼯程學系備審資料 ⾱詠祥
by鍾誠 陳鍾誠
 
smallpt: Global Illumination in 99 lines of C++
by鍾誠 陳鍾誠
 
西洋史 (你或許不知道但卻影響現代教育的那些事)
by鍾誠 陳鍾誠
 
區塊鏈 (比特幣背後的關鍵技術) -- 十分鐘系列
by鍾誠 陳鍾誠
 
區塊鏈 (比特幣背後的關鍵技術) -- 十分鐘系列
by鍾誠 陳鍾誠
 
梯度下降法 (隱藏在深度學習背後的演算法) -- 十分鐘系列
by鍾誠 陳鍾誠
 
用十分鐘理解 《微分方程》
by鍾誠 陳鍾誠
 
系統程式 -- 前言
by鍾誠 陳鍾誠
 
系統程式 -- 附錄
by鍾誠 陳鍾誠
 
系統程式 -- 第 12 章 系統軟體實作
by鍾誠 陳鍾誠
 
系統程式 -- 第 11 章 嵌入式系統
by鍾誠 陳鍾誠
 
系統程式 -- 第 10 章 作業系統
by鍾誠 陳鍾誠
 
系統程式 -- 第 9 章 虛擬機器
by鍾誠 陳鍾誠
 
系統程式 -- 第 8 章 編譯器
by鍾誠 陳鍾誠
 
系統程式 -- 第 7 章 高階語言
by鍾誠 陳鍾誠
 
系統程式 -- 第 6 章 巨集處理器
by鍾誠 陳鍾誠
 
系統程式 -- 第 5 章 連結與載入
by鍾誠 陳鍾誠
 
系統程式 -- 第 4 章 組譯器
by鍾誠 陳鍾誠
 

Recently uploaded

PDF
Fanatics of LDM a Time Capsule By LDMMIA
by©LDMMIA, ©Reiki Yoga
 
PDF
Overview of Ethiopian Agriculture: Systems and Economic Impact.pdf
byinebaseifu
 
PPTX
Allow Quantity Modification in Combo in Odoo 19 pos
byCeline George
 
PPTX
Blood, Blood Composition, Blood Groups, Disorders of Blood.pptx
byAshish Umale
 
PPTX
THEORIES OF LEARNING Shilpa Hotakar.pptx
bySHILPA HOTAKAR
 
PPTX
Complete Overview of Roles in Odoo 18 Planning
byCeline George
 
PDF
The Unique Wildlife of Ethiopia: From the Simien to the Bale Mountains
byfirtunagebremicheal
 
PPTX
VITAMINS CHAPTER NO.05 PHARMACOGNOSY D. PHARMACY
byGanu Gavade
 
PDF
CHUYÊN ĐỀ ÔN LUYỆN TUYỂN SINH 9 LÊN 10 - MÔN TOÁN - CÓ LỜI GIẢI CHI TIẾT - TH...
byNguyen Thanh Tu Collection
 
PPTX
Sci8-Q3-W29-Tides_Science 8 Matatag.pptx
byOliverVillanueva13
 
PPTX
How to Add or Remove Multiple Followers in a Records
byCeline George
 
PDF
Freshman Geography Chapter 7-Population of Ethiiopia
bytfeven44
 
PPTX
ANTI-TUSSIVE CHAPTER NO.05 PHARMACOGNOSY
byGanu Gavade
 
PPTX
OXYGEN ADMINISTRATION/THERAPY ......pptx
byAneetaSharma15
 
PDF
Types of Artificial Intelligence: Capabilities and Functionality Explained
byARTHIDEVARANIP
 
PPTX
An Complete Overview of Survey in Odoo 18
byCeline George
 
PDF
BÀI GIẢNG POWERPOINT CHÍNH KHÓA PHIÊN BẢN AI TIẾNG ANH 6 CẢ NĂM, THEO TỪNG BÀ...
byNguyen Thanh Tu Collection
 
PPTX
Redox Titration - Oxidation and Reduction
byKhushbu Shah
 
PPTX
Complete and Detailed Overview of Odoo 18 Contact
byCeline George
 
PDF
Bedah Permendikdasmen Nomor 6 Tahun 2026_Budaya Sekolah Aman dan Nyaman_Rev.pdf
byHappyLaila
 
Fanatics of LDM a Time Capsule By LDMMIA
by©LDMMIA, ©Reiki Yoga
 
Overview of Ethiopian Agriculture: Systems and Economic Impact.pdf
byinebaseifu
 
Allow Quantity Modification in Combo in Odoo 19 pos
byCeline George
 
Blood, Blood Composition, Blood Groups, Disorders of Blood.pptx
byAshish Umale
 
THEORIES OF LEARNING Shilpa Hotakar.pptx
bySHILPA HOTAKAR
 
Complete Overview of Roles in Odoo 18 Planning
byCeline George
 
The Unique Wildlife of Ethiopia: From the Simien to the Bale Mountains
byfirtunagebremicheal
 
VITAMINS CHAPTER NO.05 PHARMACOGNOSY D. PHARMACY
byGanu Gavade
 
CHUYÊN ĐỀ ÔN LUYỆN TUYỂN SINH 9 LÊN 10 - MÔN TOÁN - CÓ LỜI GIẢI CHI TIẾT - TH...
byNguyen Thanh Tu Collection
 
Sci8-Q3-W29-Tides_Science 8 Matatag.pptx
byOliverVillanueva13
 
How to Add or Remove Multiple Followers in a Records
byCeline George
 
Freshman Geography Chapter 7-Population of Ethiiopia
bytfeven44
 
ANTI-TUSSIVE CHAPTER NO.05 PHARMACOGNOSY
byGanu Gavade
 
OXYGEN ADMINISTRATION/THERAPY ......pptx
byAneetaSharma15
 
Types of Artificial Intelligence: Capabilities and Functionality Explained
byARTHIDEVARANIP
 
An Complete Overview of Survey in Odoo 18
byCeline George
 
BÀI GIẢNG POWERPOINT CHÍNH KHÓA PHIÊN BẢN AI TIẾNG ANH 6 CẢ NĂM, THEO TỪNG BÀ...
byNguyen Thanh Tu Collection
 
Redox Titration - Oxidation and Reduction
byKhushbu Shah
 
Complete and Detailed Overview of Odoo 18 Contact
byCeline George
 
Bedah Permendikdasmen Nomor 6 Tahun 2026_Budaya Sekolah Aman dan Nyaman_Rev.pdf
byHappyLaila
 

Lecture 08 virtual machine ii

  • 1.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 1 www.nand2tetris.org Building a Modern Computer From First Principles Virtual Machine Part II: Program Control
  • 2.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 2 Where we are at: Assembler Chapter 6 H.L. Language & Operating Sys. abstract interface Compiler Chapters 10 - 11 VM Translator Chapters 7 - 8 Computer Architecture Chapters 4 - 5 Gate Logic Chapters 1 - 3 Electrical Engineering Physics Virtual Machine abstract interface Software hierarchy Assembly Language abstract interface Hardware hierarchy Machine Language abstract interface Hardware Platform abstract interface Chips & Logic Gates abstract interface Human Thought Abstract design Chapters 9, 12
  • 3.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 3 The big picture . . . RISC machine VM language other digital platforms, each equipped with its VM implementation RISC machine language Hack computer Hack machine language CISC machine language CISC machine . . . written in a high-level language Any computer . . . VM implementation over CISC platforms VM imp. over RISC platforms VM imp. over the Hack platform VM emulator Some Other language Jack language Some compiler Some Other compiler Jack compiler . . .Some language . . . Chapters 1-6 Chapters 7-8 Chapters 9-13 A Java-based emulator is included in the course software suite Implemented in Projects 7-8
  • 4.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 4 The VM langauge Goal: Complete the specification and implementation of the VM model and language Method: (a) specify the abstraction (model’s constructs and commands) (b) propose how to implement it over the Hack platform. Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture this lecture
  • 5.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 5 The compilation challenge class Main { static int x; function void main() { // Inputs and multiplies two numbers var int a, b, c; let a = Keyboard.readInt(“Enter a number”); let b = Keyboard.readInt(“Enter a number”); let c = Keyboard.readInt(“Enter a number”); let x = solve(a,b,c); return; } } // Solves a quadearic equation (sort of) function int solve(int a, int b, int c) { var int x; if (~(a = 0)) x=(-b+sqrt(b*b–4*a*c))/(2*a); else x=-c/b; return x; } } class Main { static int x; function void main() { // Inputs and multiplies two numbers var int a, b, c; let a = Keyboard.readInt(“Enter a number”); let b = Keyboard.readInt(“Enter a number”); let c = Keyboard.readInt(“Enter a number”); let x = solve(a,b,c); return; } } // Solves a quadearic equation (sort of) function int solve(int a, int b, int c) { var int x; if (~(a = 0)) x=(-b+sqrt(b*b–4*a*c))/(2*a); else x=-c/b; return x; } } Source code (high-level language) Our ultimate goal: Translate high-level programs into executable code. Compiler 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 ... 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 ... Target code
  • 6.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 6 The compilation challenge / two-tier setting if (~(a = 0)) x = (-b+sqrt(b*b–4*a*c))/(2*a) else x = -c/b if (~(a = 0)) x = (-b+sqrt(b*b–4*a*c))/(2*a) else x = -c/b Jack source code push a push 0 eq if-goto elseLabel push b neg push b push b call mult push 4 push a call mult push c call mult call sqrt add push 2 push a call mult div pop x goto contLable elseLabel: push c neg push b call div pop x contLable: push a push 0 eq if-goto elseLabel push b neg push b push b call mult push 4 push a call mult push c call mult call sqrt add push 2 push a call mult div pop x goto contLable elseLabel: push c neg push b call div pop x contLable: Compiler VM (pseudo) code 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010010 1110001100000001 ... 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010000 1110111111001000 0000000000010001 1110101010001000 0000000000010000 1111110000010000 0000000000000000 1111010011010000 0000000000010010 1110001100000001 0000000000010000 1111110000010000 0000000000010001 0000000000010010 1110001100000001 ... VM translator Machine code We’ll develop the compiler later in the course We now turn to describe how to complete the implementation of the VM language That is -- how to translate each VM command into assembly commands that perform the desired semantics.
  • 7.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 7 // Computes x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b // Computes x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b Typical compiler’s source code input: The compilation challenge arithmetic expressions function call and return logic boolean expressions program flow logic (branching) How to translate such high-level code into machine language? In a two-tier compilation model, the overall translation challenge is broken between a front-end compilation stage and a subsequent back-end translation stage In our Hack-Jack platform, all the above sub-tasks (handling arithmetic / boolean expressions and program flow / function calling commands) are done by the back-end, i.e. by the VM translator. (previous lecture)(previous lecture)(this lecture) (this lecture)
  • 8.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 8 Lecture plan Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture
  • 9.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 9 Program flow commands in the VM language How to translate these three abstractions into assembly? Simple: label declarations and goto directives can be effected directly by assembly commands More to the point: given any one of these three VM commands, the VM Translator must emit one or more assembly commands that effects the same semantics on the Hack platfrom How to do it? see project 8. label c // label declaration goto c // unconditional jump to the // VM command following the label c if-goto c // pops the topmost stack element; // if it’s not zero, jumps to the // VM command following the label c label c // label declaration goto c // unconditional jump to the // VM command following the label c if-goto c // pops the topmost stack element; // if it’s not zero, jumps to the // VM command following the label c In the VM language, the program flow abstraction is delivered using three commands: VM code example: function mult 1 push constant 0 pop local 0 label loop push argument 0 push constant 0 eq if-goto end push argument 0 push 1 sub pop argument 0 push argument 1 push local 0 add pop local 0 goto loop label end push local 0 return function mult 1 push constant 0 pop local 0 label loop push argument 0 push constant 0 eq if-goto end push argument 0 push 1 sub pop argument 0 push argument 1 push local 0 add pop local 0 goto loop label end push local 0 return
  • 10.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 10 Lecture plan Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Arithmetic / Boolean commands add sub neg eq gt lt and or not Memory access commands pop x (pop into x, which is a variable) push y (y being a variable or a constant) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) Program flow commands label (declaration) goto (label) if-goto (label) Function calling commands function (declaration) call (a function) return (from a function) previous lecture
  • 11.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 11 Subroutines Subroutines = a major programming artifact Basic idea: the given language can be extended at will by user-defined commands ( aka subroutines / functions / methods ...) Important: the language’s primitive commands and the user-defined commands have the same look-and-feel This transparent extensibility is the most important abstraction delivered by high-level programming languages The challenge: implement this abstraction, i.e. allow the program control to flow effortlessly between one subroutine to the other “A well-designed system consists of a collection of black box modules, each executing its effect like magic” (Steven Pinker, How The Mind Works) // Compute x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b // Compute x = (-b + sqrt(b^2 -4*a*c)) / 2*a if (~(a = 0)) x = (-b + sqrt(b * b – 4 * a * c)) / (2 * a) else x = - c / b
  • 12.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 12 Subroutines in the VM language The invocation of the VM’s primitive commands and subroutines follow exactly the same rules: The caller pushes the necessary argument(s) and calls the command / function for its effect The called command / function is responsible for removing the argument(s) from the stack, and for popping onto the stack the result of its execution. function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop push argument 0 push constant 0 eq if-goto end // if arg0 == 0, jump to end push argument 0 push 1 sub pop argument 0 // arg0-- push argument 1 push local 0 add pop local 0 // result += arg1 goto loop label end push local 0 // push result return function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop push argument 0 push constant 0 eq if-goto end // if arg0 == 0, jump to end push argument 0 push 1 sub pop argument 0 // arg0-- push argument 1 push local 0 add pop local 0 // result += arg1 goto loop label end push local 0 // push result return Called code, aka “callee” (example) ... // computes (7 + 2) * 3 - 5 push constant 7 push constant 2 add push constant 3 call mult push constant 5 sub ... ... // computes (7 + 2) * 3 - 5 push constant 7 push constant 2 add push constant 3 call mult push constant 5 sub ... Calling code (example) VM subroutine call-and-return commands
  • 13.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 13 Function commands in the VM language Q: Why this particular syntax? A: Because it simplifies the VM implementation (later). function g nVars // here starts a function called g, // which has nVars local variables call g nArgs // invoke function g for its effect; // nArgs arguments have already been pushed onto the stack return // terminate execution and return control to the caller function g nVars // here starts a function called g, // which has nVars local variables call g nArgs // invoke function g for its effect; // nArgs arguments have already been pushed onto the stack return // terminate execution and return control to the caller
  • 14.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 14 Function call-and-return conventions function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop ... // rest of code ommitted label end push local 0 // push result return function mult 1 push constant 0 pop local 0 // result (local 0) = 0 label loop ... // rest of code ommitted label end push local 0 // push result return called function aka “callee” (example) function demo 3 ... push constant 7 push constant 2 add push constant 3 call mult ... function demo 3 ... push constant 7 push constant 2 add push constant 3 call mult ... Calling function Call-and-return programming convention The caller must push the necessary argument(s), call the callee, and wait 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, the caller’s state is re-instated, execution continues from the command just after the call Caller’s net effect: the arguments were replaced by the return value (just like with primitive commands) Behind the scene Recycling and re-instating subroutine resources and states is a major headache Some agent (either the VM or the compiler) should manage it behind the scene “like magic” In our implementation, the magic is VM / stack-based, and is considered a great CS gem. Although not obvious in this example, every VM function has a private set of 5 memory segments (local, argument, this, that, pointer) These resources exist as long as the function is running.
  • 15.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 15 The function-call-and-return protocol The caller’s view: When I start executing, my argument segment has been initialized with actual argument values passed by the caller My local variables segment has been allocated and initialized to zero The static segment that I see has been set to the static segment of the VM file to which I belong, and the working stack that I see is empty Before exiting, I must push a value onto the stack and then use the command return. When I start executing, my argument segment has been initialized with actual argument values passed by the caller My local variables segment has been allocated and initialized to zero The static segment that I see has been set to the static segment of the VM file to which I belong, and the working stack that I see is empty Before exiting, I must push a value onto the stack and then use the command return. Before calling a function g, I must push onto the stack as many arguments as needed by g Next, I invoke the function using the command call g nArgs After g returns: The arguments that I pushed before the call have disappeared from the stack, and a return value (that always exists) appears at the top of the stack All my memory segments (local, argument, this, that, pointer) are the same as before the call. Before calling a function g, I must push onto the stack as many arguments as needed by g Next, I invoke the function using the command call g nArgs After g returns: The arguments that I pushed before the call have disappeared from the stack, and a return value (that always exists) appears at the top of the stack All my memory segments (local, argument, this, that, pointer) are the same as before the call. The callee’s (g ‘s) view: Blue = VM function writer’s responsibility Black = black box magic, delivered by the VM implementation Thus, the VM implementation writer must worry about the “black operations” only. function g nVars call g nArgs return function g nVars call g nArgs return
  • 16.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 16 When function f calls function g, the VM implementation must: Save the return address within f ‘s code: the address of the command just after the call Save the virtual segments 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, the VM implementation must: Clear g ’s arguments and other junk from the stack Restore the virtual segments of f Transfer control back to f (jump to the saved return address). Q: How should we make all this work “like magic”? A: We’ll use the stack cleverly. The function-call-and-return protocol: the VM implementation view function g nVars call g nArgs return function g nVars call g nArgs return
  • 17.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 17 The implementation of the VM’s stack on the host Hack RAM Global stack: the entire RAM area dedicated to hold the stack Working stack: from SP onwards: the stack that the current function sees At any point of time, only one function (the current function) is executing; other functions may be waiting up the calling chain Shaded areas: irrelevant to the current function The current function sees only the working stack, as well as its virtual memory segments The rest of the stack holds the frozen states of all the functions up the calling hierarchy.
  • 18.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 18 Implementing the call g nArgs command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. // In the course of implementing the code of f // (the caller), we arrive to the command call g nArgs. // we assume that nArgs arguments have been pushed // onto the stack. What do we do next? // We generate a symbol, let’s call it returnAddress; // Next, we effect the following logic: push returnAddress // saves the return address push LCL // saves the LCL of f push ARG // saves the ARG of f push THIS // saves the THIS of f push THAT // saves the THAT of f ARG = SP-nArgs-5 // repositions SP for g LCL = SP // repositions LCL for g goto g // transfers control to g returnAddress: // the generated symbol // In the course of implementing the code of f // (the caller), we arrive to the command call g nArgs. // we assume that nArgs arguments have been pushed // onto the stack. What do we do next? // We generate a symbol, let’s call it returnAddress; // Next, we effect the following logic: push returnAddress // saves the return address push LCL // saves the LCL of f push ARG // saves the ARG of f push THIS // saves the THIS of f push THAT // saves the THAT of f ARG = SP-nArgs-5 // repositions SP for g LCL = SP // repositions LCL for g goto g // transfers control to g returnAddress: // the generated symbol call g nArgscall g nArgs None of this code is executed yet ... At this point we are just generating code (or simulating the VM code on some platform)
  • 19.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 19 Implementing the function g nVars command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. function g nVarsfunction g nVars // to implement the command function g nVars, // we effect the following logic: g: repeat nVars times: push 0 // to implement the command function g nVars, // we effect the following logic: g: repeat nVars times: push 0
  • 20.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 20 Implementing the return command Implementation: If the VM is implemented as a program that translates VM code into assembly code, the translator must emit the above logic in assembly. // In the course of implementing the code of g, // we arrive to the command return. // We assume that a return value has been pushed // onto the stack. // We effect the following logic: frame = LCL // frame is a temp. variable retAddr = *(frame-5) // retAddr is a temp. variable *ARG = pop // repositions the return value // for the caller SP=ARG+1 // restores the caller’s SP THAT = *(frame-1) // restores the caller’s THAT THIS = *(frame-2) // restores the caller’s THIS ARG = *(frame-3) // restores the caller’s ARG LCL = *(frame-4) // restores the caller’s LCL goto retAddr // goto returnAddress // In the course of implementing the code of g, // we arrive to the command return. // We assume that a return value has been pushed // onto the stack. // We effect the following logic: frame = LCL // frame is a temp. variable retAddr = *(frame-5) // retAddr is a temp. variable *ARG = pop // repositions the return value // for the caller SP=ARG+1 // restores the caller’s SP THAT = *(frame-1) // restores the caller’s THAT THIS = *(frame-2) // restores the caller’s THIS ARG = *(frame-3) // restores the caller’s ARG LCL = *(frame-4) // restores the caller’s LCL goto retAddr // goto returnAddress returnreturn
  • 21.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 21 Bootstrapping SP = 256 // initialize the stack pointer to 0x0100 call Sys.init // call the function that calls Main.main SP = 256 // initialize the stack pointer to 0x0100 call Sys.init // call the function that calls Main.main A high-level jack program (aka application) is a set of class files. By a Jack convention, one class must be called Main, and this class must have at least one function, called main. The contract: when we tell the computer to execute a Jack program, the function Main.main starts running Implementation: After the program is compiled, each class file is translated into a .vm file The operating system is also implemented as a set of .vm files (aka “libraries”) that co-exist alongside the program’s .vm files One of the OS libraries, called Sys.vm, includes a method called init. The Sys.init function starts with some OS initialization code (we’ll deal with this later, when we discuss the OS), then it does call Main.main Thus, to bootstrap, the VM implementation has to effect (e.g. in assembly), the following operations:
  • 22.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 22 Extends the VM implementation described in the last lecture (chapter 7) The result: a single assembly program file with lots of agreed-upon symbols: VM implementation over the Hack platform
  • 23.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 23 Proposed API
  • 24.
    Elements of ComputingSystems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 8: Virtual Machine, Part II slide 24 Perspective Benefits of the VM approach Code transportability: compiling for different platforms requires 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 Some virtues of the modularity implied by the VM approach to program translation: 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 . . . VM language RISC machine language Hack CISC machine language . . . written in a high-level language . . . VM implementation over CISC platforms VM imp. over RISC platforms TranslatorVM emulator Some Other language Jack Some compiler Some Other compiler compiler . . .Some language . . . Benefits of managed code: Security Array bounds, index checking, … Add-on code Etc. VM Cons Performance.