Explore
For Enterprise
Join for Free
Log In

Arts and Humanities
Business
Computer Science
Data Science
Information Technology
Health
Math and Logic
Personal Development
Physical Science and Engineering
Social Sciences
Language Learning
Degrees
Certificates

Explore all of Coursera

Browse
Search
For Enterprise
Log In
Join for Free

Unit 1.7: VM Implementation on the Hack Platform

Loading...

Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)

Hebrew University of Jerusalem

5 (228 ratings) | 17K Students Enrolled

In this project-centered course you will build a modern software hierarchy, designed to enable the translation and execution of object-based, high-level languages on a bare-bone computer hardware platform. In particular, you will implement a virtual machine and a compiler for a simple, Java-like programming language, and you will develop a basic operating system that closes gaps between the high-level language and the underlying hardware platform. In the process, you will gain a deep, hands-on understanding of numerous topics in applied computer science, e.g. stack processing, parsing, code generation, and classical algorithms and data structures for memory management, vector graphics, input-output handling, and various other topics that lie at the very core of every modern computer system. This is a self-contained course: all the knowledge necessary to succeed in the course and build the various systems will be given as part of the learning experience. The only prerequisite is knowledge of programming at the level acquired in introduction to computer science courses. All the software tools and materials that are necessary to complete the course will be supplied freely after you enrol in the course. This course is accompanied by the textbook "The Elements of Computing Systems" (Nisan and Schocken, MIT Press). While not required for taking the course, the book provides a convenient coverage of all the course topics. The book is available in either hardcopy or ebook form, and MIT Press is offering a 30% discount off the cover price by using the discount code MNTT30 at https://mitpress.mit.edu/books/elements-computing-systems. The course consists of six modules, each comprising a series of video lectures, and a project. You will need about 2-3 hours to watch each module's lectures, and about 15 hours to complete each one of the six projects. The course can be completed in six weeks, but you are welcome to take it at your own pace. You can watch a TED talk about this course by Googling "nand2tetris TED talk". *About Project-Centered Courses: Project-centered courses are designed to help you complete a personally meaningful real-world project, with your instructor and a community of learners with similar goals providing guidance and suggestions along the way. By actively applying new concepts as you learn, you’ll master the course content more efficiently; you’ll also get a head start on using the skills you gain to make positive changes in your life and career. When you complete the course, you’ll have a finished project that you’ll be proud to use and share.

Skills You'll Learn

Computer Architecture, Compiler Construction, Compiler, Operating System

Reviews

5 (228 ratings)

5 stars
218 ratings
4 stars
10 ratings

RR

Jul 16, 2017

This is an excellent course giving good view of operating system, compiler and fitting the pieces together. Highly recommended

AD

Sep 02, 2018

One of the best computer science courses I ever had. You start understand how actually things like heap, stack, etc. works.

From the lesson

Virtual Machine I: Stack Arithmetic

Unit 1.0: The Road Ahead21:37

Unit 1.1: Program Compilation Preview12:36

Unit 1.2: VM Abstraction: the Stack15:32

Unit 1.3: VM Abstraction: Memory Segments9:57

Unit 1.4: VM Implementation: the Stack17:13

Unit 1.5: VM Implementation: Memory Segments26:36

Unit 1.6: The VM Emulator23:08

Unit 1.7: VM Implementation on the Hack Platform8:57

Unit 1.8: VM Translator: Proposed Implementation12:27

Unit 1.9: Project 7: Building the VM Translator, Part I23:05

Unit 1.10: Perspective17:20

Taught By

Shimon Schocken
Professor

Transcript

In this unit, we are going to discuss how we implement the VM obstruction that we

introduced so far on one specific hardware platform, which is the Hack computer.

Now to begin with,

I would like to refresh your memory about what is the VM translator to begin with.

Well, the VM translator is a program written in some high level

language like Java, or Python, or any other language.

And the program gets its input in other program written in VM code,

VM commands like push, pop and so on.

And then it process this file, it process each individual command.

It breaks it into various lexical elements like push,

constant, and the integer 2.

And then using these lexical elements, it re-expresses

these commands using assembly commands of the target platform.

Which in our case is Hack.

And therefore, we use the Hack Assembly Language.

Now notice that what we have on the right is the output file.

And one thing that I recommend that you do when you get to

develop this translator is that whenever you translate a particular command,

you write a comment that shows this command.

This will help you debug the output of your VM translator down the road.

Now naturally each VM command, which is high level in this

context, is going to be translated into several assembly commands,

as we saw when we talked about translation in previous units.

Now, if you want to write a general purpose program that can translate any

given text in the French language into the Spanish language,

it really helps if you first know these two languages, French and Spanish.

Likewise, if you want to write a VM translator,

you have to be competent in both the source language, the target language.

And you also have to know something about, where should we place the various

virtual data structures like the stack and the segments on the host computer?

And how are we going to translate the high level commands into the assembly commands?

So with that in mind, the source language that we have to deal with

is the VM language consisting of arithmetic/logical, and

memory access commands, as well as branching commands and function commands.

But in this particular project, in project seven, we're going to focus

only on the arithmetic/logical and memory access commands.

And in the next project that will be the centerpiece of the next module,

project eight, we will complete the picture,

and hand in also the branching and the function commands.

The target of our translation is going to be symbolic Hack language.

And we went through this language in module zero.

And this language consists of two major commands, the A command and the C command.

And that's it,

that's all you need in order to translate your VM programs into assembly.

Now another thing that we need to know is what is sometimes called

the standard VM mapping on the target platform.

Now let me explain what I mean by,

you know what, let me first show you the standard mapping.

And then we'll discuss why we actually need it.

So basically, we have to make two decisions,

how to map the VM's data structures on the host RAM, and

also how to express the commands in the host language.

Now the standard mapping gives you all sorts of

information or conventions on how we propose that you achieve this mapping.

Because think about it.

If I tell you to implement a VM translator,

basically you're free to do whatever you want.

I can tell you, here's the RAM, do whatever you want with it.

However, it is convenient and customary to

propose a certain standard mapping that will ensure two things.

First of all, if you agree to put

the various segments in where where we advise to put it in the RAM,

then you are going to conform to generally accepted standards that are also

accepted by developers of other software tools that run on the same computer.

So if everyone respects the same rules,

these programs will not collide in the memory.

And also, if you commit yourself to a certain mapping on the RAM, then

we can write all sorts of test programs that also makes similar assumptions.

And by doing this, the team that tests the software

can be another team, other than that that actually developed the software.

Which always is recommended in order to perform objective testing.

So that's the purpose of the standard mapping.

So here is the standard mapping of the VM on the Hack computer.

Basically, I repeat things that we discussed in previous units.

But I just wanted to put them in one slide, so

you would have all of it in one place.

We use the first five words for the segment pointers.

Then the next eight words serve as the implementation of the temporary,

the temp segment.

Then we have several, I think three, general purpose registers.

Then we have 250 or 240 something static variables.

And the rest of the memory, all the way up to 2K,

is going to serve as the place where we're going to host or

store the stack of the virtual machine.

So all these segments that we mentioned before are going to be mapped

onto this RAM using the logic that you see in this slide.

I don't want to read all this,

it's something that you can go through yourself.

And if we want to achieve this mapping, then when we write the VM translator,

we have to use certain symbols.

Once again, certain agreed upon symbols when we generate the assembly

code that realizes the VM code on Hack.

So in particular, we're going to use SP as a special label that stands for

the stack pointer.

We're going to use LCL, ARG, THIS, and

THAT as the segment pointers of the respective memory segments.

We're going to use R13, R14, R15, whenever we need to use some

general purpose registers.

And finally if you recall,

we described in the previous unit how we are going to use special labels,

specially generated labels, in order to represent static variables.

The fine-line dots and running index will stand for

the static variable that has the same running index.

So your VM translator, when you write it in order to generate assembly code,

your code is going to use these symbols.

You have to be responsible for writing code that generates these labels and

uses them judiciously in order implement,

in order to realize the mapping that we just described.

Now finally, I would like to mention that in project eight, in which we are going to

implement the remaining VM commands that we haven't implemented here.

We're going to extend this mapping somewhat,

and add a few more conventions to it.

So with that, this has been our unit on how to map the VM translator,

or the virtual machine, on the host RAM and the host computer.

And now we'll finally come to discuss how to actually build

this program using a high level language.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2019 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play

Coursera
About
Leadership
Careers
Catalog
Certificates
MasterTrack™ Certificates
Degrees
For Enterprise
For Government

Community
Learners
Partners
Developers
Beta Testers
Translators

Connect
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Tech Blog

More
Terms
Privacy
Help
Accessibility
Press
Contact
Directory
Affiliates