CSE 378 Homework #4: Memory Mapped Devices, Exceptions, the OS, and Address Translation

Due: Wednesday, 2/18/2003

Assignment Goals

You'll do three new things in this assignment:
• Introduce IO to your machine using "memory mapped" device controllers.
• Implement address translation hardware.
• Implement exception/trap handling, in the hardware.
Plus, there's a bonus, optional piece:
• Modify the operating system software.

When you're done, you'll have a processor capable of running an operating system. Fortunately, we've written an operating system, and your machine will run it.

Getting Started

The starting point for this assignment is the single-cycle machine you built in Assignment 3. We are supplying a SMOK container that implements most of the memory mapped architecture required for all three steps - you still have to connect it correctly and expand control to deal with it, but it handles most of the load. While there is more implementation work to do (by far) in this assignment than the last, the majority of your time will probably be spent learning about what is needed, and trying to make sure you understand why. It's best to approach both the learning and the implementing in stages.

To emphasize the advice to work on this assignment piece-by-piece, the bulk of writeup is given on separate pages.

Prologue to Working on the Assignment

We'll present more information about each step in this assignment shortly, but first a repetition of this important message: you can (and should) understand each piece, in the order presented, before moving on to the next. Additionally, you can and should implement each piece and verify that it is working before moving on to the next. What this means is that the assignment is designed so that even if after reading the entire thing now it is confusing, you can safely proceed by ignoring all of it except the piece you need to do next and nothing will go wrong. That is still a challenging prospect, as it's hard to know you understand something without (yet) knowing how it's going to be used.

That said, what follows is a sequence of tasks, including suggested target completion dates, that lead to completion of the entire assignment.

Milestone 0: Understand the Assignment

Goal:	Understand all of the assignment, at least roughly. Understand the first piece enough to begin implementing it.
Details:	This page gives an overview.
See also:	All other pages related to the assignment.
Target completion:	11:59PM, Friday, February 6

Milestone 1: Memory Mapped IO

Goal:	Implement the Cebollita memory mapped IO architecture, enabling programs to read keyboard input, to write character output, and to do disk IO.
Details:	This page with the assignment description for this step.
Building applications:	Consult the assignment details.
RUNNING APPLICATIONS:	SEE the assignment details.
See also:	This description of the memory mapped architecture. This page on the SMOK memory map container. iolib.c, a library that knows how to use the memory mapped IO devices.
Target completion:	11:59PM, Monday, February 9

Milestone 2: Address Translation

Goal:	Implement address translation, using the Cebollita memory mapped architecture components.
Details:	This page with the assignment description for this step.
Building applications:	Consult the assignment details.
See also:	This description of the memory mapped architecture.
Target completion:	11:59PM, Wednesday, February 11

Milestone 3: Exception Handling

Goal:	Implement exception handling, and the syscall and rfe instructions.
Details:	This page with the assignment description for this step.
Building applications:	Consult the assignment details.
See also:	This description of the memory mapped architecture. These lecture notes.
Target completion:	11:59PM, Saturday, February 14

Milestone 4: Running the OS and Shell

Goal:	Demonstrate that everything is working by running the Cebollita OS and shell.
Details:	This page with the assignment description for this step.
Building applications:	Consult the assignment details.
See also:	These lecture notes.
Target completion:	11:59PM, Tuesday, February 17

OPTIONAL What to Do: OPTIONAL Part E

I expect that no one will choose to do this, but here it is, just in case there are some zealots.

In this part you'll modify both the hardware and the software (OS) to provide interrupt-driven buffering of keyboard input. In the hardware you should connect up the Character Controller in the memory mapping container to your exception control logic, so that an interrupt is raised when a new keyboard character becomes ready. In the software, you should implement a new function for this handle this interrupt. The interrupt routine should read the character from the Character Controller and store it in some buffer it owns. It should also echo the character back to the console, so that the user sees s/he has typed something. Then the interrupt routine returns to the running program. (If the buffer overlows, well, too bad, now input data has been lost.)

You also need to modify the function that services the readString system call. It must fetch characters out of the buffer your interrupt handler has been filling. If it manages to find an entire string in there, it's done -- it returns the result to the application. If not, it has to go into a busy loop waiting for more user input.

Files

• A new version of Cebollita: You can work on your SMOK models without this, but there will be a new version coming out shortly. It will overwrite all files from the original distribution (so keep that in mind if you're thinking about modifying any of those files -- i.e., any files you didn't create yourself).
• MemMappedIO.smokcont, Version 4 of the memory map Container file.
• Other files of use in preparing/using test cases are in ...cebollita\apps, including the OS.

Debugging Utilities

• Disassembler utility: part of the Cebollita toolkit. Converts an instruction from hex to assembler. Example use:

  $ java util.Disasm
  > 34084000
  ori     $t0, $0, 16384
  > 8d090000
  lw      $t1, $t0, 0
  > [killed with ^C]
  
  
  $ java util.Disasm 34084000
  ori     $t0, $0, 16384
  

• Attaching the Cebollita debugger UI to your SMOK machine: details are forthcoming.