CS 61C: Computer Architecture on

Number Representation

Mon, 01 Jan 0001 00:00:00 +0000

Bases and Bits #

In Arabic numerals, we use base 10. So for example, $533 = 5 \times 10^2 + 3 \times 10^1 + 3 \times 10^0$.

There are also other common bases, where we multiply each digit by a different value. The most common are binary (base 2), octal (base 8), and hexadecimal (base 16).

💡 Bits are bits. They can represent literally whatever you want!

🔥 With $n$ bits, we can represent $2^n$ different things!

Intro to C

Mon, 01 Jan 0001 00:00:00 +0000

![[/cs61c/img/Intro-to-C/Untitled.png]]

C: The Universal Assembly Language #

What’s the big deal with C?

It’s wildly popular. C and its derivatives have been around for 40+ years and won’t be going away anytime soon.
It’s highly configurable. Whatever you want to do, C can probably do it.
It’s good if you have limited memory. Microprocessors are best used when running C because memory allocation is a must when you only have like 4kb of RAM.

Compilation #

C compilers map programs directly into machine code (bitstrings). In comparison:

Memory, Pointers, Addresses

Mon, 01 Jan 0001 00:00:00 +0000

TL;DR #

All data is in memory. Each memory has an address and a value.

Pointers are an abstraction of a data address. (Because C does no bounds checking on pointer arithmetic, the model described here is the direct enabler of the attacks studied in [[cs161/Memory Safety Vulnerabilities]].)

Use * to get a value from a pointer.
Use & to get the address of a value.

Memory #

In C, all memory is in one single, large array of bytes

Memory Management

Mon, 01 Jan 0001 00:00:00 +0000

Main #

int main(int argc, char *argv[])

Arguments #

argc contains the number of strings inputted. The executable is one, and each argument is one.

argv is a pointer to an array with the argument strings. Can also be represented as char **argv

Memory Management #

![[/cs61c/img/Memory-Management/Untitled.png]]

The Stack #

The stack contains local variables (exist inside functions).

Grows from the top down
Last in first out (LIFO)
Memory is freed when the function returns.
main() is treated like a function
Automatic memory management: deleted without manual deletion
A new stack frame gets created every time a new function is called
- Return address (parent)
- Arguments
- Local variables

The Heap #

The heap contains memory that is specifically requested. It grows dynamically upwards.

Floating Point

Mon, 01 Jan 0001 00:00:00 +0000

Some Number Representations #

First, some cool bit stuffs #

Easy way to check equality of x and y: x - y == 0 or x ^ y == 0
Logical vs. arithmetic right shift:
- Logical doesn’t preserve leftmost bit (always just adds 0 to the end)
- Arithmetic preserves most significant bit (so that it’s better for Two’s complement)
Left shift to multiply by 2
Right shift to divide by 2

Alternative representations #

Sign/Magnitude representation: The most significant bit is always the sign, no numerical information is stored here. (Different from Two’s complement in that there are now two zeroes, and the ranges of positive and negative numbers are symmetric)

RISC-V

Mon, 01 Jan 0001 00:00:00 +0000

Quick Reference #

[[RISC-V Quick Reference]]

Intro to Assembly Language #

![[/cs61c/img/RISC-V/Untitled.png]]

Assembly Language is one level closer to the hardware than most programming languages. It has human-readable instructions (add, etc), which directly correspond to numerical representations in machine code.

Instruction Set Architecture (ISA) #

The job of a CPU is to execute instructions, which are primitive operations. Each instruction is simple and does a small amount of work, but if we chain together many instructions, we can create a program.

CALL

Mon, 01 Jan 0001 00:00:00 +0000

![[/cs61c/img/CALL/Untitled 2.png]]

The Language Execution Continuum #

![[/cs61c/img/CALL/Untitled.png]]

As languages get more high level, they tend to become easier to write but run more slowly.

An interpreter is a program that executes other programs. Higher level languages are less efficient to interpret since they optimize for readability or accessibility rather than performance.

One alternative to interpreting is translation, which is when a high level language is converted into a lower level language.

Hardware Design

Mon, 01 Jan 0001 00:00:00 +0000

Synchronous Digital Systems #

Synchronous: there is a fixed global clock that determines the rate at which everything runs.

Asynchronous systems are insanely difficult to debug so we don’t use them (yet).

Digital: made up of discrete 1’s and 0’s (unlike analog systems, which are a range).

High voltage is 1 (true, asserted), low voltage is 0 (false, unasserted).

Synchronous Digital Systems consist of two basic types of circuits:

RISC-V Processor Datapath

Mon, 01 Jan 0001 00:00:00 +0000

The State #

Each instruction reads and updates the state during execution. The state includes:

Registers (x0 to x31)
- Find rs1 and rs2
- Write to rd (destination)
- Writes to x0 are ignored
Program counter (PC)
- Holds address of current instruction
Memory (MEM)
- Holds both instructions and data in a 32-bit byte addressed memory space
- Separate memory for instructions (IMEM) and data (DMEM)
- Instructions are read from IMEM, load and store instructions access DMEM

![[/cs61c/img/RISC-V-Processor-Datapath/Untitled.png]]

Caching

Mon, 01 Jan 0001 00:00:00 +0000

The Problem #

Over time, the processor-DRAM latency gap has been increasing, such that instructions relying on DRAM access greatly reduce the number of instructions that can be processed, and therefore the overall performance of a CPU.

![[/cs61c/img/Caching/Untitled.png]]

A Solution: Caching #

Since programs only care about a very small subset of the total information available, if we identify this subset and place it into more local memory, then we can efficiently perform most memory accesses.

Operating Systems

Mon, 01 Jan 0001 00:00:00 +0000

Introduction #

The OS is a large piece of software that acts as a layer between hardware and user programs. Some of its functions include: (For a much deeper treatment of every topic on this page — processes, threads, scheduling, virtual memory, file systems — see the CS 162 notes, starting with [[cs162/Chapter 1 OS Basics]].)

Loading on boot
Managing IO devices via drivers
Starts services for managing filesystems, network, etc.
Loads, runs, and manages multiple programs and resources simultaneously and safely
Mediates interactions between running programs, processes, and hardware
Makes interaction with the outside world uniform, even if the underlying hardware may be different

The OS gives each process isolation: even though multiple processes might need to share hardware, each process gets its own view that it owns the whole machine:

Parallelism

Mon, 01 Jan 0001 00:00:00 +0000

Using Parallelism for Performance #

In recent times, the performance improvements with single-threaded performance have been small, and CPU clock rates are no longer increasing. Therefore, we must turn to parallel processing to improve speed.

There are two main ways to do so:

Multiprogramming: Run multiple programs at the same time. This is how multi-core systems work (e.g. use one core for one program, another core for another). This is handled by the OS and is relatively easy to handle.

Dependability

Mon, 01 Jan 0001 00:00:00 +0000

Dependability via Redundancy #

Redundancy of Time and Space #

Spatial Redundancy: replicating data across machines, or storing extra information or hardware to handle failures

Temporal Redunancy: Retrying an operation in the hopes that it was a transient (soft) failure

Dependability Measures #

Mean time to Failure (MTTF): Reliability

Mean Time to Repair (MTTR): Service interruption

Mean Time Between Failures (MBTF) = MTTF + MTTR

Availability: MTTF / (MTTF + MTTR)

Mon, 01 Jan 0001 00:00:00 +0000

[[Number Representation]] - bits are bits! Two’s complement, binary math [[Intro to C]] - C syntax and motivation. [[Memory, Pointers, Addresses]] - What are pointers, and how do we use them in C? [[Memory Management]] - Stack, heap, alignment, and endianness. [[Floating Point]] - The IEEE Floating Point Standard, and how to convert between it and decimal. [[RISC-V]] - Intro to RISC-V syntax and assembly. [[CALL]] - Compiler, Assembler, Linker, Loader chain. [[Hardware Design]] - Logic gates, transistors, registers, boolean algebra. [[RISC-V Processor Datapath]] - How hardware is designed to process assembly instructions. [[Caching]] - Creating and analyzing caches and their performance. [[Operating Systems]] - high level introduction to OS’s, networking, IO, and virtual memory. [[Parallelism]] - SIMD, OpenMP, MOESI caches, Flynn Taxonomy. [[Dependability]] - Error correcting and RAID.

Exam Problem Guide

Mon, 01 Jan 0001 00:00:00 +0000

Number Representation #

Convert -29 to Two’s Complement binary and -127 biased binary. (8 bits)

Two’s Complement:

First, represent +29 in binary with an extra sign bit:

0b00011101

Now, negate all bits:

0b11100010

Add one:

0b11100011

Biased:

First, add 127 to -29 to get 98.

Represent 98 in binary:

0b01100010
Number Representation Facts

A $n$ digit two-complement number stores $2^n$ negative numbers and $2^{n-1}$ positive numbers.

![[/cs61c/img/Exam-Problem-Guide/Untitled.png]]
Endianness

Supposing we have a 32-bit integer a = 0xABCD_EFGH.

RISC-V Quick Reference

Mon, 01 Jan 0001 00:00:00 +0000

![[/cs61c/img/RISC-V-Quick-Reference/Untitled.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 1.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 2.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 3.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 4.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 5.png]]

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 6.png]]

opcodes #

R: 0110011
I: 0010011
S: 0100011
B: 1100011

registers #

![[/cs61c/img/RISC-V/Untitled 5.png]]

Registers

![[/cs61c/img/RISC-V-Quick-Reference/Untitled 7.png]]

Example instruction

j vs jr vs jal vs jalr #

j label is a pseudoinstruction for jal x0, label

ret = jr ra = jalr x0, ra, 0

jal ra, label calls function within $2^{18}$ instructions of PC

CS 61C: Computer Architecture on

Number Representation

Bases and Bits #

Intro to C

C: The Universal Assembly Language #

Compilation #

Memory, Pointers, Addresses

TL;DR #

Memory #

Memory Management

Main #

Arguments #

Memory Management #

The Stack #

The Heap #

Floating Point

Some Number Representations #

First, some cool bit stuffs #

Alternative representations #

RISC-V

Quick Reference #

Intro to Assembly Language #

Instruction Set Architecture (ISA) #

CALL

The Language Execution Continuum #

Hardware Design

Synchronous Digital Systems #

RISC-V Processor Datapath

The State #

Caching

The Problem #

A Solution: Caching #

Operating Systems

Introduction #

Safe Sharing of Resources #

Parallelism

Using Parallelism for Performance #

Dependability

Dependability via Redundancy #

Redundancy of Time and Space #

Dependability Measures #

Exam Problem Guide

Number Representation #

RISC-V Quick Reference

opcodes #

registers #

j vs jr vs jal vs jalr #