2. The Architecture Question
ā¢ How do we build computer from contemporary
silicon device technology that executes general-
purpose programs quickly, efļ¬ciently, and at
reasonable cost?
ā¢ i.e. How do we build the computer on your
desk.
2
3. In the beginning...
ā¢ Physical conļ¬guration speciļ¬es the computation
3
The Difference Engine ENIAC
4. The Stored Program Computer
ā¢ The program is data
ā¢ i.e., it is a sequence of numbers that machine interprets
ā¢ A very elegant idea
ā¢ The same technologies can store and manipulate
programs and data
ā¢ Programs can manipulate programs.
4
5. The Stored Program Computer
ā¢ A very simple model
ā¢ Several questions
ā¢ How are program
represented?
ā¢ How do we get
algorithms out of our
brains and into that
representation?
ā¢ How does the the
computer interpret a
program?
5
Processor IO
Memory
Data Program
6. Representing Programs
ā¢ We need some basic building blocks -- call them
āinstructionsā
ā¢ What does āexecute a programā mean?
ā¢ What instructions do we need?
ā¢ What should instructions look like?
ā¢ Is it enough to just specify the instructions?
ā¢ How complex should an instruction be?
6
7. Program Execution
7
Instruction
Fetch
Instruction
Decode
Operand
Fetch
Execute
Result
Store
Next
Instruction
Read instruction from program storage (mem[PC])
Determine required actions and instruction size
Locate and obtain operand data
Compute result value
Deposit results in storage for later use
Determine successor instruction (i.e. compute next PC).
Usually this mean PC = PC + <instruction size in bytes>
ā¢ This is the algorithm for a stored-program
computer
ā¢ The Program Counter (PC) is the key
8. Motivating Code segments
ā¢ a = b + c;
ā¢ a = b + c + d;
ā¢ a = b & c;
ā¢ a = b + 4;
ā¢ a = b - (c * (d/2) - 4);
ā¢ if (a) b = c;
ā¢ if (a == 4) b = c;
ā¢ while (a != 0) a--;
ā¢ a = 0xDEADBEEF;
ā¢ a = foo[4];
ā¢ foo[4] = a;
ā¢ a = foo.bar;
ā¢ a = a + b + c + d +... +z;
ā¢ a = foo(b); -- next class
8
9. What instructions do we
need?
ā¢ Basic operations are a good choice.
ā¢ Motivated by the programs people write.
ā¢ Math: Add, subtract, multiply, bit-wise operations
ā¢ Control: branches, jumps, and function calls.
ā¢ Data access: Load and store.
ā¢ The exact set of operations depends on many,
many things
ā¢ Application domain, hardware trade-offs, performance,
power, complexity requirements.
ā¢ You will see these trade-offs ļ¬rst hand in the ISA project
and in 141L.
9
10. What should instructions look like?
ā¢ They will be numbers -- i.e., strings of bits
ā¢ It is easiest if they are all the same size, say 32
bits
ā¢ We can break up these bits into āļ¬eldsā -- like members
in a class or struct.
ā¢ This sets some limits
ā¢ On the number of different instructions we can have
ā¢ On the range of values any ļ¬eld of the instruction can
specify
10
11. Is specifying the instructions sufļ¬cient?
ā¢ No! We also must what the instructions operate on.
ā¢ This is called the āArchitectural Stateā of the
machine.
ā¢ Registers -- a few named data values that instructions can
operate on
ā¢ Memory -- a much larger array of bytes that is available for
storing values.
ā¢ How big is memory? 32 bits or 64 bits of addressing.
ā¢ 64 is the standard today for desktops and larger.
ā¢ 32 for phones and PDAs
ā¢ Possibly fewer for embedded processors
ā¢ We also need to specify semantics of function calls
ā¢ The āStack Discipline,ā āCalling convention,ā or āApplication
binary interface (ABI)ā.
11
12. How complex should instructions be?
ā¢ More complexity
ā¢ More different instruction types are required.
ā¢ Increased design and veriļ¬cation costs
ā¢ More complex hardware.
ā¢ More difļ¬cult to use -- Whatās the right instruction in this context?
ā¢ Less complexity
ā¢ Programs will require more instructions -- poor code density
ā¢ Programs can be more difļ¬cult for humans to understand
ā¢ In the limit, decremement-and-branch-if-negative is sufļ¬cient
ā¢ Imagine trying to decipher programs written using just one
instruction.
ā¢ It takes many, many of these instructions to emulate simple
operations.
ā¢ Today, what matters most is the compiler
ā¢ The Machine must be able to understand program
ā¢ A program must be able to decide which instructions to use
12
13. Big āAā Architecture
ā¢ The Architecture is a contract between the
hardware and the software.
ā¢ The hardware deļ¬nes a set of operations, their
semantics, and rules for their use.
ā¢ The software agrees to follow these rules.
ā¢ The hardware can implement those rules IN ANYWAY IT
CHOOSES!
ā¢ Directly in hardware
ā¢ Via a software layer
ā¢ Via a trained monkey with a pen and paper.
ā¢ This is a classic interface -- they are everywhere
in computer science.
ā¢ āInterface,ā āSeparation of concerns,ā āAPI,ā āStandard,ā
ā¢ For your project you are designing an
Architecture -- not a processor.
13
14. From Brain to Bits
14
Your brain
Programming
Language (C, C++, Java)
Brain/
Fingers/
SWE
Compiler
Assembly language
Machine code
(i.e., .o ļ¬les)
Assembler
Executable
(i.e., .exe ļ¬les)
Linker
15. C Code
15
int i;
int sum = 0;
int j = 4;
for(i = 0; i < 10; i++) {
sum = i * j + sum;
}
16. In the Compiler
16
Function
decl: i decl: sum = 0 decl: j = 4 Loop
init: i = 0 test: i < 10 inc: i++ Body
statement: =
lhs: sum rhs: expr
sum *
+
j i
17. In the Compiler
17
sum = 0
j = 4
i = 0
t1 = i * j
sum = sum + t1
i++;
...
i < 10?
false true
Control ļ¬ow graph
w/high-level
instructions
addi $s0, $zero, 0
addi $s1, $zero, 4
addi $s2, $zero, 0
mult $t0, $s1, $s2
add $s0, $t0
addi $s2, $s2, 1
...
addi $t0, $zero, 10
bge $s2, $t0
true false
Control ļ¬ow graph
w/real instructions
18. Out of the Compiler
18
addi $s0, $zero, 0
addi $s1, $zero, 4
addi $s2, $zero, 0
top:
addi $t0, $zero, 10
bge $s2, $t0, after
body:
mult $t0, $s1, $s2
add $s0, $t0
addi $s2, $s2, 1
br top
after:
...
addi $s0, $zero, 0
addi $s1, $zero, 4
addi $s2, $zero, 0
mult $t0, $s1, $s2
add $s0, $t0
addi $s2, $s2, 1
...
addi $t0, $zero, 10
bge $s2, $t0
true false
Assembly language
19. Labels in the Assembler
19
addi $s0, $zero, 0
addi $s1, $zero, 4
addi $s2, $zero, 0
top:
addi $t0, $zero, 10
bge $s2, $t0, after
mult $t0, $s1, $s2
add $s0, $t0
addi $s2, $s2, 1
br top
after:
...
āafterā is deļ¬ned at 0x20
used at 0x10
The value of the immediate for the branch
is 0x20-0x10 = 0x10
ātopā is deļ¬ned at 0x0C
used at 0x1C
The value of the immediate for the branch
is 0x0C-0x1C = 0xFFFF0 (i.e., -0x10)
20. Labels in the Assembler
19
addi $s0, $zero, 0
addi $s1, $zero, 4
addi $s2, $zero, 0
top:
addi $t0, $zero, 10
bge $s2, $t0, after
mult $t0, $s1, $s2
add $s0, $t0
addi $s2, $s2, 1
br top
after:
...
0x00
0x04
0x08
0x0C
0x10
0x14
0x18
0x1C
0x20
āafterā is deļ¬ned at 0x20
used at 0x10
The value of the immediate for the branch
is 0x20-0x10 = 0x10
ātopā is deļ¬ned at 0x0C
used at 0x1C
The value of the immediate for the branch
is 0x0C-0x1C = 0xFFFF0 (i.e., -0x10)
21. Assembly Language
20
ā¢ āText sectionā
ā¢ Hold assembly language instructions
ā¢ In practice, there can be many of these.
ā¢ āData sectionā
ā¢ Contain deļ¬nitions for static data.
ā¢ It can contain labels as well.
ā¢ The addresses in the data section have no
relation to the addresses in the data section.
ā¢ Pseudo instructions
ā¢ Convenient shorthand for longer instruction sequences.
22. .data and pseudo instructions
21
void foo() {
static int a = 0;
a++;
...
}
.data
foo_a:
.word 0
.text
foo:
lda $t0, foo_a
ld $s0, 0($t0)
addi $s0, $s0, 1
st $s0, 0($t0)
after:
...
23. .data and pseudo instructions
21
void foo() {
static int a = 0;
a++;
...
}
.data
foo_a:
.word 0
.text
foo:
lda $t0, foo_a
ld $s0, 0($t0)
addi $s0, $s0, 1
st $s0, 0($t0)
after:
...
lda $t0, foo_a
becomes these instructions (this is not assembly language!)
andi $t0, $zero, ((foo_a & 0xff00) >> 16)
sll $t0, $t0, 16
andi $t0, $t0, (foo_a & 0xff)
24. .data and pseudo instructions
21
void foo() {
static int a = 0;
a++;
...
}
.data
foo_a:
.word 0
.text
foo:
lda $t0, foo_a
ld $s0, 0($t0)
addi $s0, $s0, 1
st $s0, 0($t0)
after:
...
lda $t0, foo_a
becomes these instructions (this is not assembly language!)
andi $t0, $zero, ((foo_a & 0xff00) >> 16)
sll $t0, $t0, 16
andi $t0, $t0, (foo_a & 0xff)
The assembler computes and inserts these values.
25. .data and pseudo instructions
21
void foo() {
static int a = 0;
a++;
...
}
.data
foo_a:
.word 0
.text
foo:
lda $t0, foo_a
ld $s0, 0($t0)
addi $s0, $s0, 1
st $s0, 0($t0)
after:
...
lda $t0, foo_a
becomes these instructions (this is not assembly language!)
andi $t0, $zero, ((foo_a & 0xff00) >> 16)
sll $t0, $t0, 16
andi $t0, $t0, (foo_a & 0xff)
If foo is address 0x0,
where is after?
The assembler computes and inserts these values.
26. .data and pseudo instructions
21
void foo() {
static int a = 0;
a++;
...
}
.data
foo_a:
.word 0
.text
foo:
lda $t0, foo_a
ld $s0, 0($t0)
addi $s0, $s0, 1
st $s0, 0($t0)
after:
...
lda $t0, foo_a
becomes these instructions (this is not assembly language!)
andi $t0, $zero, ((foo_a & 0xff00) >> 16)
sll $t0, $t0, 16
andi $t0, $t0, (foo_a & 0xff)
If foo is address 0x0,
where is after?
0x00
0x0C
0x10
0x14
0x18
The assembler computes and inserts these values.
27. ISA Alternatives
ā¢ MIPS is a 3-address, RISC ISA
ā¢ add rs, rt, rd -- 3 operands
ā¢ RISC -- reduced instruction set. Relatively small number
of operation. Very regular encoding. RISC is the ārightā
way to build ISAs.
ā¢ 2-address
ā¢ add r1, r2 --> r1 = r1 + r2
ā¢ + few operands, so more bits for each.
ā¢ - lots of extra copy instructions
ā¢ 1-address
ā¢ Accumulator architectures
ā¢ add r1 -> acc = acc + rI
22
28. Stack-based ISA
ā¢ A push-down stack holds arguments
ā¢ Some instruction manipulate the stack
ā¢ push, pop, swap, etc.
ā¢ Most instructions operate on the contents of the
stack
ā¢ Zero-operand instructions
ā¢ add --> t1 = pop; t2 = pop; push t1 + t2;
ā¢ Elegant in theory.
ā¢ Clumsy in hardware.
ā¢ How big is the stack?
ā¢ Java byte code is a stack-based ISA
ā¢ So is the x86 ļ¬oating point ISA
23
29. 24
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
30. 24
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
31. 25
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
32. 25
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
33. 26
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
C
B
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
34. 26
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
C
B
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
35. 27
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
36. 27
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
37. 28
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
38. 28
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
39. 29
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
X
B*C
Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
40. 29
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
X
B*C
Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
41. 30
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
- Store -- Store the top of the stack
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
X*Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
42. 30
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
- Store -- Store the top of the stack
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
B*C
X*Y
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
43. 31
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
X
Y
B
C
A
SP
+4
+8
+12
+16
X*Y-B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
44. 31
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
X*Y-B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
45. 32
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
- Store -- Store the top of the stack
X
Y
B
C
A
SP
+4
+8
+12
+16
X*Y-B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
46. 32
compute A = X *Y - B * C
ā¢ Stack-based ISA
- Processor state: PC, āoperand stackā, āBase ptrā
- Push -- Put something from memory onto the stack
- Pop -- take something off the top of the stack
- +, -, *,ā¦ -- Replace top two values with the result
- Store -- Store the top of the stack
Push 8(BP)
Push 12(BP)
Mult
Push 0(BP)
Push 4(BP)
Mult
Sub
Store 16(BP)
Pop
X
Y
B
C
A
SP
+4
+8
+12
+16
X*Y-B*C
ā¢
ā¢
ā¢
0x1000
Memory
Base ptr (BP)
PC
47. ā¢ Functions are an essential feature of modern
languages
ā¢ What does a function need?
ā¢ Arguments.
ā¢ Storage for local variables.
ā¢ To return control to the the caller.
ā¢ To execute regardless of who called it.
ā¢ To call other functions (that call other functions...that
call other functions)
ā¢ There are not instructions for this
ā¢ It is a contract about how the function behaves
ā¢ In particular, how it treats the resources that are shared
between functions -- the registers and memory
33
Supporting Function Calls
48. Register Discipline
ā¢ All registers are the
same, but we assign
them different uses.
34
Name number use saved?
$zero 0 zero n/a
$v0-$v1 2-3 return value no
$a0-$a3 4-7 arguments no
$t0-$t7 8-15 temporaries no
$s0-$7 26-23 saved yes
$t8-$t9 24-25 temporaries no
$gp 26 global ptr yes
$sp 29 stack ptr yes
$fp 30 frame ptr yes
$ra 31 return address yes
49. Arguments
ā¢ How many arguments can
function have?
ā¢ unbounded.
ā¢ But most functions have just a
few.
ā¢ Make the common case fast
ā¢ Put the ļ¬rst 4 argument in
registers ($a0-$a3).
ā¢ Put the rest on the āstackā
35
int Foo(int a, int b, int c, int d, int e) {
...
}
a$a0
b$a1
c$a2
d$a3
0x1DEA$sp
e0x1DEA
Stack (in memory)Register ļ¬le
50. Storage for LocalVariables
ā¢ Local variables
go on the stack
too.
36
int Foo(int a, int b, int c, int d, int e) {
int bar[4];
...
}
a$a0
b$a1
c$a2
d$a3
0 x1D EA
$sp
e0 x1D EA
Stack (in memory)Register ļ¬le
bar[3 ]
0 x1D EA + 16
$fp
bar[2 ]
bar[1]
bar[0 ]
52. Saving Registers
ā¢ Some registers are preserved across function calls
ā¢ If a function needs a value after the call, it uses one of these
ā¢ But it must also preserve the previous contents (so it can
honor its obligation to its caller)
ā¢ Push these registers onto the stack.
ā¢ See ļ¬gure 2.12 in the text.
38