SMOK SLOOP

---

CSE 378 Project 1

Winter 2001

Due: Monday 2/19/01

Purpose

Getting Started

Exercise 0

while (A != 0) {
  Product = Product + B;
  A = A - 1;
}

Exercise 1

while (A != 0) {
  if (A % 2 == 1)              // If A is odd
    Product = Product + B;
  B = B << 1;                  // Multiply B by two
  A = A >> 1;                  // Divide A by two
}

Exercise 2: Return of the HW3 Machine

The machine you'll simulate (called the HW3 machine) is a 32-bit machine with an extremely simple architecture. There are only eight instructions, no general purpose registers, and no explicit addressing of memory. Instead, data memory is organized as a stack of 32-bit integers, and all instructions refer to the top of the stack for operands. (There is also a separate memory to hold instructions, addressable only through the HW3 PC.) The HW3 CPU has an internal register, the SP, to keep track of the top of the stack. The user's program can affect the SP only indirectly, by adding to or removing from the stack.

The table below lists the set of instructions available (as well as some other info to be explained shortly). A user of the HW3 machine would write a program using those instructions. (Please note: the opcodes have changed from the original HW3 definition. Once you get started, you'll see why we did this.)

Stop indicates the end of a program. Clear indicates that the stack should be cleared, that is, set to empty. Show requests that the integer at the top of the stack be printed. Push adds a new integer to the top of the stack. Add, Sub, Mult, and Div replace the top two integers on the stack with the single integer result of the operation specified. For example, if the stack contains (from bottom to top) {1 2 3}, a Sub instruction would result in {1 -1}. Notice that only the Push instruction specifies an operand.

HW3 instructions are encoded as 32-bit values. The high order four bits (bits 28 through 31) specify the opcode, as shown in the table. In all instructions other than Push, the low order 28 bits are ignored. In the Push instruction, the low order 28 bits contain a signed integer.

Your machine will implement a fetch-increment-execute loop: it fetches the instruction specified by the PC, increments the PC to point to the next instruction, and then performs the operation given by the instruction just fetched.

Although this machine seems to be too simple to do anything useful, we could turn it into a fully general purpose machine by adding just a few instructions (such as Load/Store/Branch).

Implementing the HW3 Machine in SMOK

Designing the datapath and control is totally up to you, but here are some hints:

• Every cycle, your machine should fetch, decode, and execute one instruction from memory. During decoding you'll want to tear apart the incoming instruction into its important fields (ie. opcode, immediate, etc). Some instructions write to the stack (PUSH, and the arithmetic operators), while others do not. Figuring out where and when to write to the stack is a matter of control.
• You'll need to implement control. Fortunately it isn't that bad: you'll want a control line that decides whether or not to write onto the stack and a control line to select between an ALU result and an immediate extracted from the instruction.
• You'll want to represent an Instruction Memory. To do that you'll use a Memory component and an IF component.
• There are a variety of ways to represent a stack. The most general way is to add another interface to your Memory component. The easier way is to just use a register file. Your stack pointer then holds the number of a register that is the "top" of the stack. We recommend the latter approach. Your stack should be large enough to hold up to 8 items.

Running and Testing

// Comment line
<starting address in decimal>
<word1 in hex>
<word2 in hex>
...
<wordN in hex>

// My first program
0
F0000002
F0000003
F0000004
F0000005
A0000000
80000000
90000000
00000000

Implementation

• Do not just sit down in front of SMOK and start building.
• You'll have a much better experience if you draw your design on paper first. Figure out what units you need, what the control lines should be, what the control functions are.
• Be iterative: Don't try to do everything on the first cut. A good starting point is to design a machine that just reads instructions from memory until it sees a STOP. Next add PUSH. This will mean adding a stack to your system. Next add the arithmetic operators. This will mean adding an ALU to your system, and more control.
• To implement SHOW, use a DebugOutput component.

Error Checking

It is possible for the HW3 machine to encounter error conditions. You should deal with stack overflow (pushing more data onto the stack than it can hold) and underflow (performing more operations than there are elements on the stack to serve as operands for). Your machine should halt and place a value into a status register indicating what happened: 0 means normal termination, 1 means stack underflow, 2 means stack overflow.

Evaluating Your Design

The SMOK system provides you with some important metrics that you should keep in mind. The first is the cycle time of your machine and the second is the "cost", which is a measure of how many transistors your components would consume. The person(s) who get the lowest cycle time and cost will receive a special prize!

Turn-In

Please turn in the following:

• A printout of your machine for exercises 1 and 2 above.
• The .sloop file for exercises 1 and 2 above. We only want electronic versions of these and we'll send out more details as the due-date approaches.
• Two questions about the course.

This is Too Easy