Assignments for CS 221, Fall 2024

Readings

Memory:
- N2T: Section 3 Intro, 3.1 (Memories/RAM), 3.2.3, 3.3 (RAM8, n-Register Memory), 3.4, 3.5 (slides 31-46, 52-58, 60-end)
Assembly Language:
- Examples: sum_1toN.asm, sum_array.asm
- ARM Reference: ARM Quick Reference

Description

This assignment will focus on the following tasks:

building the main memory units
writing programs in Assembly (at the end)

Build the RAM circuits described in Project 3:

N2T: Project 3

Chapters 3 provides the contract for each chip, i.e. description of its behavior, names and number inputs, names and state of outputs. The API is available here:

The Hack Chipset

Assembly Language Programming

vvv
vvv Scroll to the bottom. Consider starting with the Assembly section.
vvv

Design in Logisim

Note the following requirements:

arrange the circuits one after the other in the given order
label the input pins as specified in the contract
if there are multiple circuits on the canvas add the circuit index (for example a0,b0,out0)
save the Logisim files in folder projects/3/a7

Here are additional specific requirements:

RAMxx:
- save in individual files named RAMxx.circ replacing xx accordingly
- RAM8 should be built out of 8 Logisim Register components (under Memory)
- RAMxx should be built out of as few as possible previously built smaller RAMyy; use the Logisim RAM component (under Memory) and pick the right values under Properites:
  - for example, if you are looking for RAM128 equivalent adjust the properties so that at the top it says RAM 128 x 16
  - hint: how many bit addresses do you need in order to enumerate 128 different cells?
- make sure to set the "Appearance" property to "Classic Logisim; this will make the chip more compact
- for testing need to attach a clock
- minimal use of basic gates
Test Images: Show evidence of testing for each RAM as described below:
- RAM8
  - 1st, 5th, last register with values AA,BB,CC respectively
  - submit a single screenshot named RAM8.png
- RAM64, RAM512, RAM4k, RAM16k
  - next-to-last bank (memory chip right before the one for the hihgest addresses):
    - 1st, mid, last cell with values AA,BB,CC respectively
    - take separate screenshots; each screenshot should show what address and value was used to achieve the effect
    - name the screenshots RAMxx-first.png, RAMxx-mid.png, RAMxx-last.png
  - to see last cell in a bank: click on the Hand, click on a cell in the bank, PageDown all the way; the last cell is the one in bottom-right corner
  - here 1st cell means, whichever happens to be first so that we can see the last cell; mid cell is the one between 1st and last (integer division)

Design in HDL

Here are additional specific requirements:

Implement one circuit at a time. For circuit X copy X.hdl, X.cmp, X.tst to folder projects/3/a7.
do not copy Register.hdl (if you do, testing will be very slow)
RAMxx:
- RAM8 should be built out of 8 Register chips
- RAMxx should be built out of as few as possible RAMyy
- minimal use of basic gates

Assembly Language Programming

If you have implemented Bubble Sort previously, do not refer to your previous work.

Implement the Bubble Sort algorithm. Briefly the algorithm works as follows:

1. Go through the whole array examining each pair of items. Exchange the items in a pair if the first is bigger than the second.
2. Repeat Step 1. n-1 times, where n is the size of the array.

// does one run of the bubble sort algorithm -- every
// pair of neighbors that are out of order are swapped
void bubbleRun(int[] numbers)
{
    for (int i = 0; i < numbers.length-1; i = i + 1)
    {
        if (numbers[i] > numbers[i+1])     // if out of order:
        {
            int temp = numbers[i];         // swap them    
            numbers[i] = numbers[i+1];
            numbers[i+1] = temp;
        }
    }
}

// sorts an array in increasing order -- simply executes *n-1* 
// bubble runs through the array, where *n* is the array length
void bubbleSort(int[] numbers)
{
    int n = numbers.length;
    for (int run = 1; run <= n-1; run = run + 1)
    {
        bubbleRun(numbers);
    }
}

Here is a visualization of the process from Wikipedia:

Hint: Ensure that SP is loaded with 0x100 (see array example at top).

Hint: Instead of size you might find it more convenient to have a variable that represents number of pairs.

Hint: In general, the meaning of a comparison should be flipped from what it would be in CS111.

Hint: An if statement is set up similar to a loop. It still has a jump/branch that is designed to skip over the section that normally would have been executed. The same structure was used for the loop, where the focus was on when to stop looping and to skip the body.

Part I

In file bubbleRunSimple.asm write a program that only implements Step 1. of Bubble Sort. Create an array of 6 elements at the top and check if the array was modified correctly.

To view the contents of the main memory, at the top select "Tools:=View memory contents". This will show the section of main memory where the array is located. It may be good to select Dec at the bottom to see the decimal versions of the cells.

As you step through the code both the register and main memory will update and you can check if the code behaves as expected.