Virtual Machine Part I: Stack Arithmetic Foundations of Global - - PowerPoint PPT Presentation
IWKS 3300: NAND to Tetris Spring 2019 John K. Bennett Virtual Machine Part I: Stack Arithmetic Foundations of Global Networked Computing: Building a Modern Computer From First Principles This course is based upon the work of Noam Nisan and
This course is based upon the work of Noam Nisan and Shimon Schocken. More information can be found at (www.nand2tetris.org).
4315
local pointer that 4315
4317 19
local pointer that 4315
local pointer that 4315
4317 19
local pointer that
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 Code
abstract interface
Hardware Platform
abstract interface
Chips & Logic Gates
abstract interface
Human Thought Abstract design
Chapters 9, 12
class Main { static int x; function void main() { // Inputs and multiplies two numbers var int a, b, x; let a = Keyboard.readInt(“Enter a number”); let b = Keyboard.readInt(“Enter a number”); let x = mult(a,b); return; } } // Multiplies two numbers. function int mult(int x, int y) { var int result, j; let result = 0; let j = y; while ~(j = 0) { let result = result + x; let j = j – 1; } return result; } }
Jack code (example)
Translate high-level programs into executable 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 ...
Hack code
requires n m translators
hardware platform 2 hardware platform 1 hardware platform m
language 1 language 2 language n
hardware platform 2 hardware platform 1 hardware platform m
language 1 language 2 language n intermediate language
requires n + m translators
First compilation stage: depends only on the details of the source language Second compilation stage: depends only on the details of the target
RISC machine Intermediate code
with its own 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
platforms VM imp.
platforms
VM imp.
platform
VM emulator Some Other language
Jack language
Some compiler Some Other compiler
Jack compiler
Some language . . .
The interface between
Should be sufficiently
Can be modeled as the
Can typically be
RISC machine VM language
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
platforms VM imp.
platforms VM imp.
platform VM emulator Some Other language
Jack language
Some compiler Some Other compiler
Jack compiler
Some language
1, 2, 3, 4, 5, 6 7, 8 9, 10, 11, 12 Book chapters and course projects: (this, and the next project)
Abstract software engineering view:
Practical software engineering view:
Pragmatic compiler writing view:
Opportunistic empire builder view:
Arithmetic / Boolean commands add sub neg eq gt lt and
not Memory access commands pop x (pop into x, a variable) push y (push y, a variable or constant) Program flow commands
label (declaration) goto (label) if-goto (label)
Function calling commands
function (declaration) call
(a function)
return
(from a function)
Today Next Week
Our game plan today: (a) describe the VM abstraction (above) (b) suggest how to implement it over the Hack platform.
an integer value
(16-bit 2’s complement: -32768, ... , 32767),
a Boolean value
(-1 and 0, representing true and false, respectively), or a
a pointer
(memory address)
A classic LIFO data structure Elegant and powerful Several hardware / software implementation options
SP
121 5 17 Stack static 5 1 12 2 3
3
pop static 0
static 17 1 12 2 3 3
SP
121 5 Stack
SP
121 5 17 Stack static 5 1 12 2 3
3
push static 2
static 5 1 12 2 3 3
SP
121 5 17 3 Stack
Stack
y
SP SP
2 5
9 5 x 5
. . .
9
SP
2
SP
SP
9
SP SP
14
SP
static push x sub push y add sub pop z
SP
Stack push 2 push 5
y x 5 9
static
z
. . .
// z=(2-x)-(y+5) push 2 push x sub push y push 5 add sub pop z
Note: as shown here, the stack pointer is incremented after a push, and is thus “ready” for the next push. Can you think of another option?
Stack
y
SP SP
12 7 false 8 8 x 12
. . .
8
SP
12
SP
false
SP
false 8
SP SP
false true
SP
true
static push x lt push y eq
push 7 push 8
// ((x<7) || (y=8)) push x push 7 lt push y push 8 eq
Class level:
Static variables (class variables) Private variables (sometimes called “fields” or “properties”)
Method / function level:
Local variables Argument variables
When translated into the VM language, The static, private, local and argument variables are mapped
static, this, local, argument
In addition, there are four other memory segments:
that, constant, pointer, temp
Memory access VM commands:
pop memorySegment index push memorySegment index
Where memorySegment is static, this, local, argument, that, constant, pointer, or temp And index is a non-negative integer
The VM abstraction includes 8 separate memory segments named:
All memory segments are accessed in the same way using the same generic syntax:
f3 f1 f2 f4 f5
static static temp constant
argument argument argument local local local this this this that that that pointer pointer pointer
Foo.vm Bar.vm VM files (f = VM function)
(one set of these VM segments for each instance of a running function)
VM Translator
shared by all functions shared by all functions
argument local this that pointer argument local this that pointer
function functionSymbol
// function declaration
label labelSymbol
// label declaration
if-goto labelSymbol
// pop x // if x=true, jump to execute the command after labelSymbol // else proceed to execute the next command in the program
For example, to effect if (x > n) goto loop, we can use the following VM commands:
push x push n gt if-goto loop // Note that x, n, and the truth value are removed from the stack
function mult (x,y) { int result, j; result = 0; j = y; while ~(j = 0) { result = result + x; j = j - 1; } return result; }
High-level code
function mult(x,y) push 0 pop result push y pop j label loop push j push 0 eq if-goto end push result push x add pop result push j push 1 sub pop j goto loop label end push result return
VM code (first approx.)
function mult 2 push constant 0 pop local 0 push argument 1 pop local 1 label loop push local 1 push constant 0 eq if-goto end push local 0 push argument 0 add pop local 0 push local 1 push constant 1 sub pop local 1 goto loop label end push local 0 return
Actual VM code
Just after mult(7,3) returns:
x y
Just after mult(7,3) is entered:
SP SP
21 7 3
argument
1
. . .
sum j
local
1
Stack Stack
. . .
Result j
Compilation:
A Jack application is a set of 1 or more class files (like .java or .cs files), containing one
When we apply the Jack compiler to these files, the compiler creates a corresponding set
VM function written in the VM language Execution:
At any given point of time, only one VM function is executing (the “current function”), while
0 or more functions are waiting for the current function to terminate (the functions up the “calling hierarchy”)
For example, a main function starts running; at some point it call another function, say
factorial, at which point the factorial function starts running; factorial may in turn call mult, at which point the mult function starts running, while both main and factorial are waiting for mult to terminate The stack: a global data structure, used to save and restore the resources (memory segments) of all the VM functions up the calling hierarchy (e.g. main and factorial). The top of this stack is the working stack (called the “stack frame”) of the current function.
Arithmetic / Boolean commands add sub neg eq gt lt and
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)
Project 7 Project 8
Method: (a) specify the VM abstraction (stack, memory segments, commands) (b) propose how to implement this abstraction over the Hack platform.
Software-based
Translator-based (e. g. translate VM programs into the Hack
Hardware-based (realize the VM model using dedicated hardware
3 12
4 5 14 15 1 13 2 THIS THAT SP LCL ARG 16
17 19 20 18 21
Basic idea: the mapping of the stack and global segments onto the RAM is fixed by the VM implementation (you); the mapping
stack: mapped on RAM[256 ... 2047]; The stack pointer is kept in RAM address SP static: mapped on RAM[16 ... 255]; each static variable foo appearing in a VM file named fname.vm is compiled to the assembly language symbol “fname.foo” (recall that the assembler further maps such symbols to RAM, from address 16 onward) local, argument: these function-level segments are mapped into the stack. The base addresses of these segments are kept in RAM addresses LCL and ARG. Access to the i-th entry of any
RAM[LCL/ARG +i] this, that: these method-level segments are mapped into the heap, from addresses 2048-3FFF. The base addresses of these segments are kept in RAM addresses pointer 0 (for the this segment) and pointer 1 for the that segment). Although this and that are segments, we also refer to their base addresses as THIS and THAT. Thus, access to the i-th entry of these segments is implemented by accessing RAM[THIS/THAT + i] constant: a “virtual” segment, i.e., the VM implements “access” to constant i by supplying the constant i. Statics
3 12
4 5 14 15 1 13 2 THIS THAT SP LCL ARG TEMP 255
16 General purpose 2047
256 2048
Stack Heap
R0 R1 R2 R3 R4
SP LCL Base ARG Base THIS Base THAT Base
R5 R6 R7 R8 R9
TEMP
R10 R11 R12 R13 R14
N/A N/A
R15 N/A N/A N/A
N/A Stack Heap
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
256-2047 * 2048-16383 * 16384-24575
Stack Pointer
Pointer 0 (ptr to This segment) Pointer 1 (ptr to That segment) Temp 0 Temp 1 Temp 2 Temp 3 Temp 4 Temp 5 Temp 6 Temp 7 GP register GP register GP register Stack (including LCL and ARG) Heap (including THIS and THAT) Memory-Mapped I/O N/A
Static 16-255 *
static vars. RAM[n] Register n
Use *The memory addresses in purple can be changed if there is a reason to do so.
Statics
3 12
4 5 14 15 1 13 2 THIS THAT SP LCL ARG TEMP 255
16 General purpose 2047
256 2048
Stack Heap
Practice Exercises Now that we know how the memory segments are mapped on the host RAM, let’s write some Hack assembly language that realizes a few VM commands:
1. push constant 1 2. pop static 7 (assume this line appears in practice.vm) 3. push constant 5 4. add 5. pop local 2 6. Eq (i.e., if top two items on stack are = replace with true (-1), otherwise, replace with false (0))
Hints: 1.The implementation of any one of these VM commands requires several Hack assembly commands involving pointer arithmetic (using commands like A=M)
you may use R13, R14, and R15.
// push constant 1 // pop static 7 // push constant 5 // add // pop local 2 // eq: [if top two items on stack are = replace with // true (0), otherwise, replace with false (-1)]
// push constant 1 @1 D=A // D = 1 @SP A=M // push D onto stack M=D @SP M=M+1 // “preincrement” SP // add @SP AM=M-1 // pop stack top into D D=M A=A-1 // SP = SP-1 M=M+D // RAM[SP-1] = RAM[SP-1] + D
// push constant 1 @1 D=A // D = 1 @SP A=M // push D onto stack M=D @SP M=M+1 // “preincrement” SP // pop static 7 @SP AM=M-1 // pop stack top into D D=M @practice.7 // one static segment per file M=D // push constant 5 @5 D=A @SP A=M M=D @SP M=M+1 // add @SP AM=M-1 // pop stack top into D D=M A=A-1 // SP = SP-1 M=M+D // RAM[SP-1] = RAM[SP-1] + D // pop local 2 @LCL D=M // D = LCL @2 D=D+A // D = LCL+2 @R15 // using R15 as a temp to hold local 2 value M=D // R15 = LCL + 2 @SP AM=M-1 // pop stack top into D D=M @R15 A=M // A = LCL + 2 M=D // RAM[LCL + 2] = D // eq: [if top two items on stack are = replace with // true (0), otherwise, replace with false (-1)] @SP A=M-1 // A = SP - 1 A=A-1 // A = SP - 2 D=M // D = RAM[SP - 2] A=A+1 // A = SP – 1 D=D-M // D = RAM[SP - 2] – RAM[SP - 1] @_1 // A = ROM address at label: “_1” D;JEQ // if result == 0, goto “_1”; else fall thru @_2 // A = ROM address at label: “_2” D=0;JMP // D = “false” (0); goto “_2” (_1) D=-1 // D = “true” (-1) (_2) // D is T or F, depending on how we got here @SP AM=M-1 // discard 2 ops., leaving SP post push A=A-1 // Set A to new SP - 1 M=D // push D (T or F) onto stack
Parser: Handles the parsing of a single .vm file, and encapsulates access to the input code. It reads VM commands, parses them, and provides convenient access to their components. In addition, it removes all white space and comments. Routine Arguments Returns Function Constructor Input file / stream
it. hasMoreCommands
Are there more commands in the input? advance
makes it the current command. Should be called
Initially there is no current command. commandType
C_POP, C_LABEL, C_GOTO, C_IF, C_FUNCTION, C_RETURN, C_CALL
Returns the type of the current VM command.
C_ARITHMETIC is returned for all the arithmetic
commands. arg1
Returns the first arg. of the current command. In the case of C_ARITHMETIC, the command itself (add, sub, etc.) is returned. Should not be called if the current command is C_RETURN. arg2
Returns the second argument of the current
command is C_PUSH, C_POP, C_FUNCTION, or
C_CALL.
CodeWriter: Translates VM commands into Hack assembly code. Routine Arguments Returns Function Constructor Output file / stream
ready to write into it. setFileName fileName (string)
writeArithmetic command (string)
translation of the given arithmetic command. WritePushPop command (C_PUSH or
C_POP),
segment (string), index (int)
translation of the given command, where
command is either C_PUSH or C_POP.
Close
Comment: More routines will be added to CodeWriter in Project 8.
enum VM_CommandType { VM_NO_COMMAND = 0, C_ARITHMETIC, C_PUSH, C_POP, C_LABEL, C_GOTO, C_IF, C_FUNCTION, C_RETURN, C_CALL }; switch (commandType) { case VM_CommandType.C_ARITHMETIC: writeArithmetic(); break; case VM_CommandType.C_PUSH: WritePushPop(shortFileName); break; case VM_CommandType.C_POP: WritePushPop(shortFileName); break; case VM_CommandType.C_LABEL: WriteLabel(shortFileName); break; case VM_CommandType.C_GOTO: WriteGoto(shortFileName); break; case VM_CommandType.C_IF: WriteIf(shortFileName); break; case VM_CommandType.C_FUNCTION: functionName = null; // make sure that we are starting fresh WriteFunction(); break; case VM_CommandType.C_RETURN: WriteReturn(); break; case VM_CommandType.C_CALL: WriteCall(); break; case VM_CommandType.VM_NO_COMMAND: // Do nothing. break; default: errorFile.WriteLine("Line No: {0}, illegal command: {1}", lineNo, command); break;
... parseLine(); // sets commandType, vm language command, arg1 and arg2 if valid ...
private void writeArithmetic() { // Write Hack code for arithmetic command switch (command) { case "add": WritePopD(); // Pop top of stack into D; side effect: A = SP
break; case "sub": WritePopD(); // side effect: A = SP
break;
private void WritePopD() { // POP stack top into D Register
}
using System.IO; … if (File.Exists(inFileNameOrDir) { // This path is a file, strip off the ".vm" for the output name shortFileName = inFileNameOrDir.Substring(0, inFileNameOrDir.Length - 3); progOutFile = new StreamWriter(shortFileName + ".asm"); vm = new VirtualMachine(); … ProcessFile(inFileNameOrDir); progOutFile.Close(); } else if (Directory.Exists(inFileNameOrDir)) { // It’s a directory; process all (and only) '.vm' files in the directory; ignore subdirectories int lastSlash = inFileNameOrDir.LastIndexOf("\\", 0); string dirName = inFileNameOrDir.Substring(lastSlash + 1); progOutFile = new StreamWriter(dirName + ".asm"); // Write the initialization code vm = new VirtualMachine(); … string[] fileEntries = Directory.GetFiles(inFileNameOrDir, "*.vm", SearchOption.TopDirectoryOnly); foreach (string fileName in fileEntries) { // Get rid of the ".vm"; we don't look for "vm, we just delete the last two characters int dirSlash = fileName.IndexOf("\\", 0); if ((dirSlash < 0)) { // no leading dir name shortFileName = fileName.Substring(0, fileName.Length - 2); } else { shortFileName = fileName.Substring((dirSlash + 1), fileName.Length - dirSlash - 4); } ProcessFile(fileName); } progOutFile.Close(); } else { Console.WriteLine("{0} is not a valid file or directory.", inFileNameOrDir); Environment.Exit(-1); }
Front-end (translates from a high-level language to a VM language) Back-end (translates from the VM language to the machine
1970’s: p-Code 1990’s: Java’s JVM 2000’s: Microsoft .NET
. . .
VM language
RISC machine language
Hack
CISC machine language
. . .
written in a high-level language
. . .
VM implementation
platforms VM imp.
platforms
Translator
VM emulator Some Other language
Jack
Some compiler Some Other compiler
compiler
. . .
Some language . . .
JVM Java Java compiler JRE CLR C# C# compiler .NET base
class library
VM Jack Jack compiler Jack OS (really
just a runtime system)
7, 8 9 10, 11 12
(Book chapters and course projects)