# CS 211 - Lecture 16

## Computer Architecture

###  Memory

Bernhard Firner

2025-10-22

---

## What is Memory?

* We've talked about different types
  * Program, stack, register, etch
* What are these things?
  * Physical things!

---

## Athlon XP

* https://commons.wikimedia.org/w/index.php?title=Special:ListFiles&user=Birdman86

---

## Register Memory

* Register memory sits closest to the CPU "core"
  * This is why it is fast, but also limited
  * Chip designers can only squeeze so much space in here

---

## Other Memory

* All other memory is only cached near the CPU core
  * Meaning that a copy is fetched when needed and discarded later
    * For example, a `mov` operation from memory first checks the local cache
    * If the cache does not have that address stored, it needs to fetch it from somewhere else
* For many workflows, the bottleneck is not processing speed but memory bandwidth and latency

---

## GPUs Vs CPUs

* You may wonder how GPUs get so much done if bandwidth and latency are such concerns
* GPU (graphical processing units) specialize in doing many operations in parallel
  * Originally for graphics, more recently for machine learning
* Why are they different from CPUs?
* And how do they process so much data if the CPU is bandwidth limited?

---

## Early Bandwidth Differences

* (before deep learning)
* GPUs would take in a relatively small amount of data
  * mesh information for objects, lighting settings
* And would do a lot of internal processing before outputting a result
  * The pixels to render to the screen

---

## Latency

* GPUs have their own output ports, going directly to screens
  * This obviously reduces latency, and allows them to synchronize to an exact framerate
* But GPUs weren't cheating latency; they could just do more processing with less input than a CPU
  * No branching with matrix multiplies in the render pipeline, no uncertainty about what to load next

---

## Expanding CPU capabilities

* So CPUs won't be consuming the GPU market any time soon
* Not true for many other coprocessors
  * For sound, encryption, etc
* Those external chips are still available, but are only used with underpowered microcontrollers
  * e.g. your talking toaster may use a sound coprocessor

---

## Usurped Capabilities

* The CPU has usurped functionality over time
  * Encryption in your phone CPU, for example

</div>
<div class="col">

</div>
</div>

---

## Future Constraints?

* So if the CPU has done more and more, will registers go away in the future?
* Could we simply work in memory directly?
  * Probably not
* Adding a section to the chip die to handle encryption is okay
  * The long delay sending it data and getting it back is a small price to pay for the hardware encryption

---

## 2D Space

* Add more registers and some of them will get farther away
  * This means more, and longer, wires to transmit data
  * Those wires eat more space and take more time
* Since clock cycles can only be as fast as the slowest part, eventually you'll slow down the clock rate

---

## Locality

* Because of that, the locality of memory is (likely) going to be a concern for the foreseeable future
  * Learning to write memory aware code is the best way to speed up large programs
* And that's where we'll pick up after the midterm

---

## Let's Talk Debugging

* So let's briefly talk about a different topic: debugging
* We've already used gdb to look at programs, but did you know that you can use it with assembly too?

---

## Loading Assembly Files

* Build an assembly file with `gcc -S <filename.c>`
  * That builds an assembly file
* Now edit the file at the line like this:
  * `	.file	"<filename.c>"`
  * Change it to the .s file that you just created
* Now run gdb on that file

---

## Breakpoints in ASM

* You can use line numbers
* Or you can set breakpoints by tags
  * `(gdb) break add_sum6_02.S:addSum`

---

## Looking at Functions

* `disassemble <func>` will spit out the assembly for that function
* Even gives an indication of the current line

<pre>
Dump of assembler code for function addSum:
   0x0000555555555230 <+0>:	endbr64
   0x0000555555555234 <+4>:	push   %r12
=> 0x0000555555555236 <+6>:	mov    %rdi,%r8
   0x0000555555555239 <+9>:	mov    %esi,%r12d
   0x000055555555523c <+12>:	push   %rbp
   0x000055555555523d <+13>:	lea    -0x7(%rsi),%ebp
</pre>

---

## Registers

* `info registers`

```asm
(gdb) info registers
rax            0xa                 10
rbx            0x7fffffffdde8      140737488346600
rcx            0x7fffffffe1c2      140737488347586
rdx            0x0                 0
rsi            0xa                 10
rdi            0x7fffffffdcb0      140737488346288
rbp            0x7fffffffdd60      0x7fffffffdd60
rsp            0x7fffffffdca0      0x7fffffffdca0
r8             0x1999999999999999  1844674407370955161
r9             0x0                 0
r10            0x7ffff7db1fc0      140737351720896
r11            0x7ffff7db28c0      140737351723200
r12            0x2                 2
r13            0x0                 0
r14            0x555555557da8      93824992247208
r15            0x7ffff7ffd000      140737354125312
rip            0x555555555236      0x555555555236 <addSum+6>
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
k0             0x80000000          2147483648
k1             0x8040              32832
k2             0x0                 0
k3             0x0                 0
k4             0x0                 0
k5             0x0                 0
k6             0x0                 0
k7             0x0                 0
fs_base        0x7ffff7fa6740      140737353770816
gs_base        0x0                 0
```

---

## Print Format

* We can query individual registers with print
  * Use `\d`, `\x`, etc to specify format
  * d for decimal, x for hex, t for binary, c for char, f for float

```asm
(gdb) print/d $rax
$1 = 10
(gdb) print/x $rax
$2 = 0xa
(gdb) print/t $rax
$3 = 1010
(gdb) print/c $rax
$5 = 10 '\n'
```

---

## Printing Memory

* You can also inspect memory in the program
* `x/<format><length> <location>`
  * `x/12c $42` to print twelve characters at $42, for example

---

##  Watching a Variable

* Let's say you want to keep an eye on rbp:
  * `display $rbp`
* We can even watch the current instruction pointer:
  * `display/i $rip`

---

## Changing a Register

* What if we want to change something?

```asm
(gdb) set $rax=9
(gdb) print/x $rax
$6 = 0x9
```

---

## Multimedia Registers

* Remember those `xmm` registers from the `-O3` optimization?
  * Those are "multimedia" registers, that hold larger values
  * Also used for blocks of floating point numbers

```asm
(gdb) print $xmm0
$15 = {v8_bfloat16 = {0, 2.342e-38, 0, 0, 0, 0, 0, 0}, v8_half = {0, 1.5199e-05, 0, 0, 0, 0, 0, 0}, v4_float = {2.34180515e-38, 0, 0, 0}, v2_double = {8.256666972292243e-317, 0}, v16_int8 = {0, 0, -1, 0 <repeats 13 times>}, v8_int16 = {0, 255, 0, 0, 0, 
    0, 0, 0}, v4_int32 = {16711680, 0, 0, 0}, v2_int64 = {16711680, 0}, uint128 = 16711680}
```

---

## Checking flags

* Printing out the status register gives more information
  * We can see how a branch will go

```asm
(gdb) break *main+4
Breakpoint 1 at 0x10c4: file add_sum6_02.S, line 118.
(gdb) run
Starting program: examples/add_sum6_02_asm
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Breakpoint 1, main () at add_sum6_02.S:118
118	in add_sum6_02.S
(gdb) display/i $rip
1: x/i $rip
=> 0x5555555550c4 <main+4>:	sub    $0x18,%rsp
(gdb) step
120	in add_sum6_02.S
1: x/i $rip
=> 0x5555555550c8 <main+8>:	mov    %fs:0x28,%rax
(gdb) print $eflags
$2 = [ IF ]
(gdb) step
121	in add_sum6_02.S
1: x/i $rip
=> 0x5555555550d1 <main+17>:	mov    %rax,0x8(%rsp)
(gdb) step
122	in add_sum6_02.S
1: x/i $rip
=> 0x5555555550d6 <main+22>:	xor    %eax,%eax
(gdb) step
123	in add_sum6_02.S
1: x/i $rip
=> 0x5555555550d8 <main+24>:	cmp    $0x1,%edi
(gdb) print $eflags
$5 = [ PF ZF IF ]
(gdb) print $edi
$6 = 1
(gdb) set $eflags &= ~(1<<6)
(gdb) print $eflags
$7 = [ PF IF ]
```

---

## Common Flags

* ZF: Zero flag
* SF: Sign flag
* CF: Carry flag
* OF: Overflow flag

---

## Checking Stack memory

```asm
Breakpoint 1, main () at add_sum6_02.S:118
118	in add_sum6_02.S
1: x/i $rip
=> 0x5555555550c4 <main+4>:	sub    $0x18,%rsp
(gdb) display/x $rsp
2: /x $rsp = 0x7fffffffdcc8
(gdb) display/x $rbp
3: /x $rbp = 0x7fffffffdd60
(gdb) break addSum
Breakpoint 2 at 0x555555555230: file add_sum6_02.S, line 9.
(gdb) continue
Continuing.

Breakpoint 2, addSum () at add_sum6_02.S:9
9	in add_sum6_02.S
1: x/i $rip
=> 0x555555555230 <addSum>:	endbr64
2: /x $rsp = 0x7fffffffdca8
3: /x $rbp = 0x7fffffffdd60
(gdb) step
10	in add_sum6_02.S
1: x/i $rip
=> 0x555555555234 <addSum+4>:	push   %r12
2: /x $rsp = 0x7fffffffdca8
3: /x $rbp = 0x7fffffffdd60
(gdb) step
13	in add_sum6_02.S
1: x/i $rip
=> 0x555555555236 <addSum+6>:	mov    %rdi,%r8
2: /x $rsp = 0x7fffffffdca0
3: /x $rbp = 0x7fffffffdd60
(gdb) step
14	in add_sum6_02.S
1: x/i $rip
=> 0x555555555239 <addSum+9>:	mov    %esi,%r12d
2: /x $rsp = 0x7fffffffdca0
3: /x $rbp = 0x7fffffffdd60
(gdb) step
15	in add_sum6_02.S
1: x/i $rip
=> 0x55555555523c <addSum+12>:	push   %rbp
2: /x $rsp = 0x7fffffffdca0
3: /x $rbp = 0x7fffffffdd60
(gdb) step
18	in add_sum6_02.S
1: x/i $rip
=> 0x55555555523d <addSum+13>:	lea    -0x7(%rsi),%ebp
2: /x $rsp = 0x7fffffffdc98
3: /x $rbp = 0x7fffffffdd60
(gdb) x/1xw $rsp
0x7fffffffdc98:	0xffffdd60
```

---

## Why?

* More fine-grained debugging
* See how your computer works
* Help you review for the midterm
* Will need to know this for the next homework

---

## Review

* Let's review a couple of things before getting to example questions

---

## Names and Sizes

* Registers can be used at different sizes
  * `rax` is 64-bits, `eax` is the lower 32-bits of the same register
* You cannot go directly from a 32-bit number to a 64-bit number
  * e.g. `addq %rax, %ebx`
  * The instruction even has the width in it
  * The value in %ebx needs to be sign extended before using %rbx

---

## The Stack

* "the stack" is a conceptually special piece of memory
  * It is accessed so frequently that it is very likely to be cached
  * It is the workspace for temporary data that won't fit into a register

---

## Stack Registers

* `rsp` is the stack pointer
  * Holds the value to the stop of the stack
* `rbp` is the base pointer (or sometimes frame pointer)
  * Remembers where the "local" top of the stack is

---

## Stack Instructions

* `push` adds something to the 'top' of the stack
  * `push src` is like doing `memory[--%rsp] = src`
* `pop` removes something from the stack
  * `pup dst` is like doing `dst = memory[%rsp++]`
* The stack goes down from the top!
  * Subtracting from rsp adds space on top of the stack
* The area of stack that is being used locally is called the frame

---

## Other special registers

* rip: the current instruction pointer
* rax: where a return value is stored
* rdi, rsi, rdx, rcx, r8, r9: registers for passing arguments to a function

---

## Addressing modes

* Immediate: `mov $0x10, dst`
* Register: `mov %rax, dst`
* Direct: `mov 0xffffdd60, dst
* Indirect: `mov (%rax), dst)`

---

## More Indirect

* Indirect addressing is like pointer access
* It also supports scaling and displacement (and both at the same time)
* Indirect with displacement: `mov 8(%rax), dst)`
  * Like `dst = memory[rax + 8]`
* Indirect with scaling: `mov (%rax, %rbx, 4), dst`
  * Like `dst = memory[rax + rbx*4]`

---

## Example Question

<pre>
pushq %rbp
movq %rsp, %rbp
</pre>

**Q** Which statement accurately describes the code above?

a. Before calling a function, the caller adds an argument onto the stack.

b. This allocates memory on the stack.

c. In a called function, the code saves the caller's base stack pointer before replacing it with the function's new base stack pointer.

d. This frees memory on the stack.
</div>

---

## Example Question

**Q** Which statement **does not** accurately describe the code above?

a. In a called function, this restores the callers %rbp and entry %rsp, restoring the frame of the caller.

b. This code prevents a stack overflow when stack-using functions are called repeatedly.

c. This allocates memory on the stack.

d. This frees memory on the stack.
</div>

---

## Example Question

**Q** Which of these is **not** an advantage of floating point values over fixed point?

a. Floating point operations are supported directly in hardware.

b. Floating point values can express much greater ranges given the same number of bits.

c. Floating point formats are standardized, making them easily shared between systems.

d. Floating point values can represent fractional values.
</div>

---

## Example Question

**Q** Two consecutive addq instructions use the same destination operand. What is **true** about this situation?

a. In a non-pipelined CPU, there is no hazard.

b. In a pipelined CPU, there is a data hazard.

c. Consecutive instructions of that type are not allowed.

d. The instructions will need to be reordered.
</div>

---

## Example Question

**Q** The instruction '`movq (%rax), %rax`' is issued during the instruction fetch stage on clock cycle 0. In the five stage pipeline discussed in class, which is the **earliest stage** after which the new value of %rax will be **available for forwarding** to a subsequent instruction?

</div>
<div class="right">

</div>
</div>

a. Move instructions cannot be forwarded.

b. Clock cycle 2.

c. Clock cycle 4.

d. None of the above.
</div>

---

## Example Question

**Q** Consider the five stage pipeline shown. A designer tells you that they plan to split the execution phase into two steps, with each step taking half of the current 10ms clock period. All of the other stages run in less than 5ms. However, the two new execution stages will require a pipeline buffer with a delay of 0.1ms.

Which of the following is true?

</div>
<div class="right">

</div>
</div>

a. The execution stage cannot be split because it would make forwarding too complicated.

b. A new clock rate can be used that is twice the current clock rate.

c. A new clock rate can be used that is slightly less than twice the current clock rate.

d. A new clock rate can be used that is slightly faster than twice the current clock rate.
</div>

---

## Example Question

**Q** Consider a superscalar pipeline two instructions wide and 10 instructions deep. Through prefetching, the pipeline is always filled with instructions. If a data hazard causes an unavoidable bubble of two instructions before the next instruction can run, but does not affect any other instructions, what is the lowest that CPU utilization will drop to because of the bubble?

</div>
<div class="right">

</div>
</div>

a. 20%

b. 50%

c. 80%

d. 90%
</div>

---

## Example Question

**Q** Consider this code:
<pre>
float mathFloats(float a, float b) {
    return a + b - a;
}
</pre>
Which statement about this code is **true**?

a. `return b;` would return the same value as the function.

b. `return a - a + b;` would return the same value as the function.

c. This code will not compile.

d. None of the above are true.
</div>

---

## Example Question

<div style="text-align: left;">
Write a function that returns nothing and accepts two arguments: a pointer to an int array and the number of elements of that array.
The function should set every element in the array with the index of that element squared (e.g. $0^2, 1^2, ...$)
</div>

---

## Example Question

<div style="text-align: left;">
This code will push a value onto the stack:
<pre>
long long value;
asm("push %0" : : "r" (value) :);
</pre>
This code will retrieve a value from the stack:
<pre>
long long out;
asm("pop %0" : "=r" (out) : :);
</pre>
Write a function that returns nothing and accepts two arguments: a pointer to a long long array and the number of elements of that array.
Use the stack to reverse the array. Use no variables other than loop counters and the stack.

</div>

---

## Exam Hints

* Study the quiz
* Study the example questions
* Study the homeworks
* Be careful if you have some LLM summarize the slides
  * I repeat the things I believe are important
  * The LLM will happily condense things into a single bullet, removing the emphasis
  * Also, you're smarter than an LLM. Believe in yourself.