Lab 11
CSCI 127: Introduction to Computer Science
Hunter College, City University of New York
Fall 2024

Learning Objectives:

• Students will write programs in Simplified Machine Language: WeMIPS
• Students will write programs with loops in WeMIPS
• Students will use Unix Pipe commands

Software tools needed: web browser and a graphical editor, such as gEdit.

Download the Skeletal Notes and Focus Questions to guide you while studying this lab.
These are a useful tool for note taking and you can keep these handy to study for and refer to during the final exam.

References:

• WeMIPS Emulator
• U Idaho reference sheet
• Setia's slides
• Wikibooks

Using Python, Gradescope, and Blackboard

See Lab 1 for details on using Python, Gradescope, and Blackboard.

Simplified Machine Language

In today's lab, we will explore a programming language that is very "low level" in that it maps very closely to the actual commands that are used by the computer's processor.

We will use an emulator, WeMIPS, to emulate what a machine-level language would do for a popular class of computer processors, MIPS. Processors with MIPS are a Reduced Instructor Set Computer (RISC), meaning they have fewer different types of instructions that the processor knows (and thus fewer that have to be implemented, leading to faster processors).

Let's start by looking at a program that will print "Hello World":

If you would like to follow along, using the emulator, open the window and toggle the "Show/Hide Demos" button and then click on the "Hello World" demo.

Just as we did with PythonTutor, we can "step" or go through the code line-by-line to see what it does:

• The first line is a comment. Like in Python, everything after a '#' on a line is ignored by the simulator.
• The next line says to add -13 to $sp, which stands for the stack pointer. The stack is a region of memory where we can store information (it is very common-- more details in future computer science courses).
  We are using 13, because to allow enough room to store the message "Hello World" (plus a null character to signal the end of the string).
• The next line, SB $t0, 0($sp) moves the number we stored to the register $t0 to the stack pointer address (with 0 offset). Since it is moving a byte of information, SB stands for "Store Byte".
• We repeat with each letter in our message, loading it to register $t0 and then moving the contents of that register to the next empty memory location. This contninues until the entire message is loaded.
• Next, we place 4 into the register $v0. That register is used to tell the simulator what type of system call we would like to make. 4 is used for printing strings.
• Next, we place the location of the start of our message in $a0 (that's where the system looks for the location of the string to print).
• Lastly, we call syscall. Since we have loaded 4 into $v0, it will print whatever string starts at the memory location in $a0.
• If the messages are not displaying, toggle to the "Log". You will see the message in green on the stack.

Try changing the program in the WeMIPS window to print out "Mihi cura futuri". Once it does, copy the program into a text window:

#Name: YOUR NAME HERE
#Email: YOUR EMAIL HERE
#My first MIPS program that prints: Mihi cura futuri

... put your machine language program here ....

and see the Programming Problem List.

Loops in Machine Language

To create loops in our machine language, we use two additional instructions:

• BEQ or "Branch When Equal" which, when two values are equal, lets you go to a different part of the program (which you specify), and
• J or "J" which always go to a different part of the program, and is incredibly useful for setting up loops.

Here is a sample of setting up loops in the MIPS machine language (you can copy it into the emulator to step through the code):

#Sample program that loops from 10 down to 0
ADDI $s0, $zero, 10 #set s0 to 10
ADDI $s1, $zero, 1  #use to decrement counter, $s0
AGAIN: SUB $s0, $s0, $s1
BEQ $s0, $zero, DONE
J AGAIN
DONE:  #To break out of the loop

Here's a translation of the code into pseudocode:

1. Set $s0 to 10.
2. Set $s1 to 1.
3. Subtract $s1 from $s0 and store result in $s0 (i.e. $s0 = $s0 - $s1).
4. If $s0 equals 0, go to line 6.
5. Else, go back to Line 3 and repeat.
6. Program ends here.

This program counts down from 10 to 0. How could you modify it to count from 1 to 10? When you have it running, see the Programming Problem List.

(Hint: store the value 10 in a register to use in the comparison)

Challenge

As a final machine language challenge, modify the "Interactive" demo (the first lines are in the image above) to use the current year when computing the ages. When you have it running, see the Programming Problem List.

A Note on Grading Simplified Machine Language

We're going to use just a few commands that move values into registers (physical memory locations), do simple arithmetic, and jump (or branch) to another part of our program. There are many commands that can be used in the full MIPS machine language. We are working with only a few of them:

ADD, ADDI, ADDIU, BEQ, J, SB, SUB, SUBU, syscall

As such, the grading script only recognizes the commands above and the '#' style comments. Anything else will confuse it greatly.

The general format for simplified machine language programs is:

#Name: YOUR NAME HERE
#Email: YOUR EMAIL HERE
#My first MIPS program that prints: Mihi cura futuri

Code goes here...

To submit your program for grading:

• Run and debug your program using WeMIPS
• Once it works, copy the text into a text editor and save. Make sure your file has a comment at the top with your name.
• Drag and drop the text file onto the gradescope page for the given program.

More on Unix: Using Pipes

In Lab 6, we introduced making short programs, or scripts, of Unix commands. In this lab, we introduce a very useful construct to let you glue together simple commands to perform more complex actions.

The command '|' is called a pipe since it takes the data flowing out of a command and directs it to flow into the next command, much like a pipe directing the flow of water.

For example, if you type:

ls -l

at the prompt, you will see the 'long' listing for every file in your current directory. (Note that it's the letter "L", not the number "1" that it looks like on some browsers). For example, if I ran this command in my directory for Program 44, I get:

showing 7 files, 6 of which were created in October. Names with '/' after them are directories or folders. '*' indicates files that can be executed (see Lab 6 for how to change the permissions of a file).

Let's use a pipe to count the number of files from October. First, we need to take the output from ls and direct it into a program that can find patterns. A popular one on Unix is called grep (it searches for patterns, which are also called regular expressions or 're'-- the name comes from global search for regular expressions program). Let's have it look for 'Oct':

ls -l | grep "Oct"

Note that between the ls -l and the grep "Oct" is a pipe ('|') that directs the outflow from the ls command to the inflow of the grep command:

We can use the pipe to take the output of the grep command and send it to a program that counts the number of lines. This program, wc, counts characters (option -m), words (option -w), and lines (option -l). We'll use the -l option to count lines:

ls -l | grep "Oct" | wc -l

which gives:

the number of files in the directory that were last modified.

How could you make a script that counted the number of .py files in the directory?

When you have the answer, put the single line into a script. Remember to use Unix end-of-lines, since gradescope will run what you submit as a Unix script and will be very confused if you have non-Unix (i.e. Windows-style) end-of-lines. See Programming Problem List.