reveal.js

## Introduction to
# MIPS

---

CS 130 // 2021-09-29

## Administrivia
- Exam 1 is being graded
    + Hopefully will be returned by Monday

# Questions
## ...about anything?

# Course Themes

## Overarching Theme
- Learning how a high-level program is actually executed on your computer's processor

![Compiler-Assembler Diagram](/teaching/2021f/cs130/assets/images/COD/compiler-assembler.png)

## Trajectory of the Course
1. The C Programming Language
2. **Assembly language programming**
3. Digital logic
4. Processor architecture

# Assembly Languages

## Assembly Languages
- Every CPU architecture implements an **instruction set** which are the operations it natively supports
- 
 The most common CPU architectures are:
    + x86 (Intel/AMD)
    + 
 ARM (Mobile phones, tablets, Apple's M1 chip, ...)

## RISC vs. CISC
- CPU architectures are usually categorized as either "RISC" or "CISC"
- 
 RISC (Reduced Instruction Set Computing)
    + Simplified instructions which "do less"
    + ...but each instruction is highly optimized

## RISC vs. CISC
- CISC (Complicated Instruction Set Computing)
    + Larger instruction set each of which "does more"
    + Optimized so that a program can be implemented with few instructions---even though those instructions may take longer to execute

# MIPS

## MIPS Architecture
- In this course, we will be learning the MIPS instruction set
    + "Microprocessor without Interlocked Pipelined Stages"
- MIPS is a RISC processor with a minimalistic number of instructions
- Is very similar to ARM

## MIPS Architecture
- Has 32 registers, each of which are 32-bits
    + 
 CPU instructions operate on registers, so values in memory must be loaded into a register before applying instructions to them
- 
 Why not include more registers?
    + 
 Cost; registers are more expensive than RAM
    + 
 Performance; more registers means slower clock
    + 
 Instruction size; more registers means each instruction needs more bits to identify registers

## MIPS Architecture
- Has $2^{32}$ memory addresses, each of which contain one **byte** (8 bits)
    + 
 How much memory is this?
    + 
 4 GB
- 
 A **word** consists of 4 bytes (32 bits)
    + 
 These are the size of the buses that the CPU operates on
- 
 We usually refer to memory using array notation:
    + 
 `Memory[0]`, `Memory[4]`, `Memory[8]`, ...

## MIPS Register Conventions

<div class="twocolumn">
<div>
<table style="font-size: 60%">
  <tbody>
    <tr> <th>Name</th> <th>Reg #</th> <th>Usage</th></tr>
    <tr><td>$zero</td> <td>0</td> <td>Constant 0</td></tr>
    <tr><td>$v0,...</td><td>2-3</td> <td>Values</td></tr>
    <tr><td>$a0,...</td><td>4-7</td> <td>Arguments</td></tr>
    <tr><td>$t0,...</td><td>8-15</td> <td>Temporaries</td></tr>
    <tr><td>$s0,...</td><td>16-23</td> <td>Saved (variables)</td></tr>
    <tr><td>$t8,...</td><td>24-25</td> <td>More temporaries</td></tr>
    <tr><td>$gp</td><td>28</td> <td>global pointer</td></tr>
    <tr><td>$sp</td><td>29</td> <td>stack pointer</td></tr>
    <tr><td>$fp</td><td>30</td> <td>frame pointer</td></tr>
    <tr><td>$ra</td><td>31</td> <td>return address</td></tr>
  </tbody>
</table>
</div>
<div>
<ul>
    <li class="fragment"> Register 1 is reserved for the assembler
    <li class="fragment"> Registers 26-27 are reserved for the OS
    <li class="fragment"> Only 8 $s registers (0..7)
    <li class="fragment"> Only 10 $t registers (0..9)
</ul>
</div>
</div>

## MIPS Arithmetic
- Translate the following C code into assembly:
    ```c
    f = (g + h) - (i + j);
    ```

<div  style="font-size: 75%">
<table class="fragment">
  <tbody>
    <tr> <th>Variable</th> <th>Register</th></tr>
    <tr> <td>f</td> <td>$s0</tr>
    <tr> <td>g</td> <td>$s1</td></tr>
    <tr> <td>h</td> <td>$s2</td></tr>
    <tr> <td>i</td> <td>$s3</td></tr>
    <tr> <td>j</td> <td>$s4</td></tr>
  </tbody>
</table>
</div>

<div>

```mips
add $t0, $s1, $s2  # g + h
add $t1, $s3, $s4  # i + j
sub $s0, $t0, $t1
```

</div>

## MIPS Arithmetic
- What if `g` and `j` are pointers?
    ```c
        f = (*g + h) - (i + *j);
    ```

<div class="twocolumn">
<div  style="font-size: 75%">
<table>
  <tbody>
    <tr> <th>Variable</th> <th>Register</th></tr>
    <tr> <td>f</td> <td>$s0</tr>
    <tr> <td>g</td> <td>$s1</td></tr>
    <tr> <td>h</td> <td>$s2</td></tr>
    <tr> <td>i</td> <td>$s3</td></tr>
    <tr> <td>j</td> <td>$s4</td></tr>
  </tbody>
</table>
</div>

<div>

```mips
lw $t2, 0($s1)     # loads g
add $t0, $t2, $s2  # *g + h
lw $t2, 0($s4)     # loads j
add $t1, $s3, $t2  # i + *j
sub $s0, $t0, $t1
```

</div>

## MIPS Arithmetic
- What if there are constants involved?
    ```c
    x = 1;
    x = x + 1;
    ```

```mips
    addi $s0, $zero, 1
    addi $s0, $s0, 1
    ```

## MIPS Arithmetic
- What if the variable `x` was an array?

```c
x[3] = 1;           // assume that x is an
x[3] = x[3] + 1;    // array of int values
```

```mips
addi $t0, $zero, 1
sw $t0, 12($s0)
lw $t1, 12($s0)
addi $t1, $t1, 1
sw $t1, 12($s0)
```

## What's in that register?
- Determine the final value of `$s1`

<div class="twocolumn">
<div  style="font-size: 50%">
<table>
  <tbody>
    <tr> <th>Memory Address</th> <th>Memory Value</th></tr>
    <tr> <td>140</td> <td>11</tr>
    <tr> <td>136</td> <td>109</td></tr>
    <tr> <td>132</td> <td>-11</td></tr>
    <tr> <td>128</td> <td>101</td></tr>
    <tr> <td>124</td> <td>2</td></tr>
    <tr> <td>120</td> <td>23</td></tr>
    <tr> <td>116</td> <td>46</td></tr>
    <tr> <td>112</td> <td>12</td></tr>
    <tr> <td>108</td> <td>33</td></tr>
    <tr> <td>104</td> <td>36</td></tr>
    <tr> <td>100</td> <td>9</td></tr>
  </tbody>
</table>
</div>

<div>

```mips
addi $s0, $zero, 11
addi $s1, $zero, 108
addi $s2, $zero, 3
addi $s3, $zero, 100
addi $t0, $zero, 12
addi $t1, $zero, -22
addi $t2, $zero, 24
addi $t3, $zero, 13
lw $t0, 8($s3)
sub $t1, $t0, $t1
lw $t4, 4($s1)
add $t4, $t4, $t4
add $s1, $t1, $t4
```

</div>