Computer Architecture

Nguyn Tr Thnh
Information Systems Department Faculty of Technology College of Technology [email protected]

10/11/2011

Instructions: Language of the Computer

10/11/2011

Instruction Set
The repertoire of instructions of a computer Early computers had very simple instruction sets
Simplified implementation

Many modern computers also have simple instruction sets Instructions operate using registers

10/11/2011

The MIPS Instruction Set

Used as the example throughout the book Stanford MIPS commercialized by MIPS Technologies (www.mips.com) Large share of embedded core market
Applications in consumer electronics, network/storage equipment, cameras, printers,

Typical of many modern ISAs

See MIPS Reference Data tear-out card, and Appendixes B and E

10/11/2011

CPU Abstract / Simplified View

Data Register # Registers Register # Register # Data

PC

Address Instruction memory

Instruction

ALU

Address Data memory

10/11/2011

Main Types of Instructions

Arithmetic
Integer Floating Point

Memory access instructions

Load & Store

Control flow
Jump Conditional Branch Call & Return
10/11/2011 6

Arithmetic Operations
Add and subtract, three operands
Two sources and one destination

add a, b, c # a gets b + c All arithmetic operations have this form Design Principle 1: Simplicity favours regularity
Regularity makes implementation simpler Simplicity enables higher performance at lower cost
10/11/2011 7

Arithmetic Example
C code:
f = (g + h) - (i + j);

Compiled MIPS code:

add t0, g, h add t1, i, j sub f, t0, t1 # temp t0 = g + h # temp t1 = i + j # f = t0 - t1

10/11/2011

Register Operands
Arithmetic instructions use register operands MIPS has a 32 64-bit register file
Use for frequently accessed data Numbered 0 to 31 32-bit data called a word

Assembler names
$t0, $t1, , $t9 for temporary values $s0, $s1, , $s7 for saved variables
10/11/2011 9

Register Operand Example

High-level language program (in C)

C code:
f = (g + h) - (i + j); f, , j in $s0, , $s4

swap(int v[], int k) {int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; }

C compiler

Compiled MIPS code:

add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0, $t1

Assembly language program (for MIPS)

swap: muli $2, $5,4 add $2, $4,$2 lw $15, 0($2) lw $16, 4($2) sw $16, 0($2) sw $15, 4($2) jr $31

Assembler

Binary machine language program (for MIPS)

10/11/2011

00000000101000010000000000011000 00000000100011100001100000100001 10001100011000100000000000000000 10001100111100100000000000000100 10 10101100111100100000000000000000 10101100011000100000000000000100 00000011111000000000000000001000

Memory Operands
Main memory used for composite data
Arrays, structures, dynamic data

To apply arithmetic operations

Load values from memory into registers Store result from register to memory

Memory is byte addressed

Each address identifies an 8-bit byte

Words are aligned in memory

Address must be a multiple of 4

MIPS is Big Endian

Most-significant byte at least address of a word c.f. Little Endian: least-significant byte at least address
10/11/2011 11

Memory Operand Example 1

C code:
g = h + A[8]; g in $s1, h in $s2, base address of A in $s3

Compiled MIPS code:

Index 8 requires offset of 32
4 bytes per word

lw $t0, 32($s3) add $s1, $s2, $t0

offset
10/11/2011

# load word

base register
12

Memory Operand Example 2

C code:
A[12] = h + A[8]; h in $s2, base address of A in $s3

Compiled MIPS code:

Index 8 requires offset of 32 lw $t0, 32($s3) # load word add $t0, $s2, $t0 sw $t0, 48($s3) # store word

10/11/2011

13

Registers vs. Memory

Registers are faster to access than memory Operating on memory data requires loads and stores
More instructions to be executed

Compiler must use registers for variables as much as possible

Only spill to memory for less frequently used variables Register optimization is important!
10/11/2011 14

Immediate Operands
Constant data specified in an instruction
addi $s3, $s3, 4

No subtract immediate instruction

Just use a negative constant
addi $s2, $s1, -1

Design Principle 3: Make the common case fast

Small constants are common Immediate operand avoids a load instruction
10/11/2011 15

The Constant Zero

MIPS register 0 ($zero) is the constant 0
Cannot be overwritten

Useful for common operations

E.g., move between registers add $t2, $s1, $zero

10/11/2011

16

2.4 Signed and Unsigned Numbers

Unsigned Binary Integers

Given an n-bit number n 1 n2 1 0 x = x n1 2 + x n2 2 + L + x1 2 + x 0 2 Range: 0 to +2n 1 Example
0000 0000 0000 0000 0000 0000 0000 10112 = 0 + + 123 + 022 +121 +120 = 0 + + 8 + 0 + 2 + 1 = 1110

Using 32 bits
0 to +4,294,967,295
10/11/2011 17

2s-Complement Signed Integers

Given an n-bit number
x = x n1 2n1 + x n2 2n2 + L + x1 21 + x 0 20

Range: 2n 1 to +2n 1 1 Example

1111 1111 1111 1111 1111 1111 1111 11002 = 1231 + 1230 + + 122 +021 +020 = 2,147,483,648 + 2,147,483,644 = 410

Using 32 bits
2,147,483,648 to +2,147,483,647
10/11/2011 18

Sign Extension
Representing a number using more bits
Preserve the numeric value

In MIPS instruction set

addi: extend immediate value lb, lh: extend loaded byte/halfword beq, bne: extend the displacement

Replicate the sign bit to the left

c.f. unsigned values: extend with 0s

Examples: 8-bit to 16-bit

+2: 0000 0010 => 0000 0000 0000 0010 2: 1111 1110 => 1111 1111 1111 1110
10/11/2011 19

Representing Instructions
Instructions are encoded in binary
Called machine code

MIPS instructions
Encoded as 32-bit instruction words Small number of formats encoding operation code (opcode), register numbers, Regularity!

Register numbers
$t0 $t7 are regs 8 15 $t8 $t9 are regs 24 25 $s0 $s7 are regs 16 23
10/11/2011 20

MIPS R-format Instructions

op
6 bits

rs
5 bits

rt
5 bits

rd
5 bits

shamt
5 bits

funct
6 bits

Instruction fields
op: operation code (opcode) rs: first source register number rt: second source register number rd: destination register number shamt: shift amount (00000 for now) funct: function code (extends opcode)
10/11/2011 21

R-format Example
op
6 bits

rs
5 bits

rt
5 bits

rd
5 bits

shamt
5 bits

funct
6 bits

add $t0, $s1, $s2

special 0 000000 $s1 17 10001 $s2 18 10010 $t0 8 01000 0 0 00000 add 32 100000

000000100011001001000000001000002 = 0232402016
10/11/2011 22

Hexadecimal
Base 16
Compact representation of bit strings 4 bits per hex digit
0 1 2 3 0000 0001 0010 0011 4 5 6 7 0100 0101 0110 0111 8 9 a b 1000 1001 1010 1011 c d e f 1100 1101 1110 1111

Example: eca8 6420

1110 1100 1010 1000 0110 0100 0010 0000
10/11/2011 23

MIPS I-format Instructions

op
6 bits

rs
5 bits

rt
5 bits

constant or address
16 bits

Immediate arithmetic and load/store instructions

rt: destination or source register number Constant: 215 to +215 1 Address: offset added to base address in rs

Design Principle 4: Good design demands good compromises

Different formats complicate decoding, but allow 32-bit instructions uniformly Keep formats as similar as possible
10/11/2011 24

Stored Program Computers

Instructions represented in binary, just like data Instructions and data stored in memory Programs can operate on programs
e.g., compilers, linkers,

Binary compatibility allows compiled programs to work on different computers

Standardized ISAs
10/11/2011 25

Logical Operations
Instructions for bitwise manipulation
Operation Shift left Shift right Bitwise AND Bitwise OR Bitwise NOT C << >> & | ~ Java << >>> & | ~ MIPS sll srl and, andi or, ori nor

Useful for extracting and inserting groups of bits in a word

10/11/2011 26

Shift Operations
op
6 bits

rs
5 bits

rt
5 bits

rd
5 bits

shamt
5 bits

funct
6 bits

shamt: how many positions to shift Shift left logical

Shift left and fill with 0 bits sll by i bits multiplies by 2i

Shift right logical

Shift right and fill with 0 bits srl by i bits divides by 2i (unsigned only)
10/11/2011 27

AND Operations
Useful to mask bits in a word
Select some bits, clear others to 0 and $t0, $t1, $t2
$t2 $t1 $t0 0000 0000 0000 0000 0000 1101 1100 0000 0000 0000 0000 0000 0011 1100 0000 0000 0000 0000 0000 0000 0000 1100 0000 0000

10/11/2011

28

OR Operations
Useful to include bits in a word
Set some bits to 1, leave others unchanged or $t0, $t1, $t2
$t2 $t1 $t0 0000 0000 0000 0000 0000 1101 1100 0000 0000 0000 0000 0000 0011 1100 0000 0000 0000 0000 0000 0000 0011 1101 1100 0000

10/11/2011

29

NOT Operations
Useful to invert bits in a word
Change 0 to 1, and 1 to 0

MIPS has NOR 3-operand instruction

a NOR b == NOT ( a OR b ) nor $t0, $t1, $zero
$t1 $t0
Register 0: always read as zero

0000 0000 0000 0000 0011 1100 0000 0000 1111 1111 1111 1111 1100 0011 1111 1111

10/11/2011

30

Conditional Operations
Branch to a labeled instruction if a condition is true
Otherwise, continue sequentially

beq rs, rt, L1

if (rs == rt) branch to instruction labeled L1;

bne rs, rt, L1

if (rs != rt) branch to instruction labeled L1;

j L1
unconditional jump to instruction labeled L1
10/11/2011 31

Compiling If Statements
C code:
if (i==j) f = g+h; else f = g-h; f, g, in $s0, $s1,

Compiled MIPS code:

bne add j Else: sub Exit:
10/11/2011

$s3, $s4, Else $s0, $s1, $s2 Exit $s0, $s1, $s2
Assembler calculates addresses
32

Compiling Loop Statements

C code:
while (save[i] == k) i += 1; i in $s3, k in $s5, address of save in $s6

Compiled MIPS code:

Loop: sll add lw bne addi j Exit:
10/11/2011

$t1, $t1, $t0, $t0, $s3, Loop

$s3, 2 $t1, $s6 0($t1) $s5, Exit $s3, 1

33

Basic Blocks
A basic block is a sequence of instructions with
No embedded branches (except at end) No branch targets (except at beginning) A compiler identifies basic blocks for optimization An advanced processor can accelerate execution of basic blocks
10/11/2011 34

More Conditional Operations

Set result to 1 if a condition is true
Otherwise, set to 0

slt rd, rs, rt

if (rs < rt) rd = 1; else rd = 0;

slti rt, rs, constant

if (rs < constant) rt = 1; else rt = 0;

Use in combination with beq, bne

slt $t0, $s1, $s2 bne $t0, $zero, L
10/11/2011

# if ($s1 < $s2) # branch to L

35

Branch Instruction Design

Why not blt, bge, etc? Hardware for <, , slower than =,
Combining with branch involves more work per instruction, requiring a slower clock All instructions penalized!

beq and bne are the common case This is a good design compromise

10/11/2011

36

Signed vs. Unsigned

Signed comparison: slt, slti Unsigned comparison: sltu, sltui Example
$s0 = 1111 1111 1111 1111 1111 1111 1111 1111 $s1 = 0000 0000 0000 0000 0000 0000 0000 0001 slt $t0, $s0, $s1 # signed
1 < +1 $t0 = 1

sltu $t0, $s0, $s1

10/11/2011

# unsigned
37

+4,294,967,295 > +1 $t0 = 0

Program structure
.data
#Data declaration op1: .word 9 msg: .asciiz "The result is: "

.text
#Program codes la $t1, op1 lw $t1, 0($t1)
10/11/2011 38

Exercise
Write a program to present the if statement: if (a>b) c=a-b; else c=b-a; Write a program to present the while statement: while (a!=b)if(a>b) a=a-b; else b=b-a; Write a program to present the for statement: for(s=0,i=1;i<N;i++) s=s+i;

10/11/2011

39

Exercise
Write a program to add two numbers located in memory, write the result into another variable in memory Write a program to multiply two numbers located in memory, write the result into another variable in memory

10/11/2011

40

Procedure Calling
Steps required
1. 2. 3. 4. 5. 6. Place parameters in registers Transfer control to procedure Acquire storage for procedure Perform procedures operations Place result in register for caller Return to place of call

10/11/2011

41

Register Usage
$a0 $a3: arguments (regs 4 7) $v0, $v1: result values (regs 2 and 3) $t0 $t9: temporaries (regs 8-15, 24, 25)
Can be overwritten by callee

$s0 $s7: saved

Must be saved/restored by callee

$gp: global pointer for static data (reg 28) $sp: stack pointer (reg 29) $fp: frame pointer (reg 30) $ra: return address (reg 31)
10/11/2011 42

Procedure Call Instructions

Procedure call: jump and link
jal ProcedureLabel Address of following instruction put in $ra Jumps to target address

Procedure return: jump register

jr $ra Copies $ra to program counter Can also be used for computed jumps
e.g., for case/switch statements
10/11/2011 43

Procedure declaration
Just like main procedure
.data msg: .asciiz "The sum of the two numbers is: " .text la $a0, msg # load address of print heading li $v0, 4 # specify Print String service syscall # print the message .. # codes jr $ra # return
10/11/2011 44

Leaf Procedure Example

C code:
int leaf_example (int g, h, i, j) { int f; f = (g + h) - (i + j); return f; } Arguments g, , j in $a0, , $a3 f in $s0 (hence, need to save $s0 on stack) Result in $v0
10/11/2011 45

Leaf Procedure Example

MIPS code:
leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra
10/11/2011

Save $s0 on stack

Procedure body Result Restore $s0 Return

46

Non-Leaf Procedures
Procedures that call other procedures For nested call, caller needs to save on the stack:
Its return address Any arguments and temporaries needed after the call

Restore from the stack after the call

10/11/2011

47

Non-Leaf Procedure Example

C code:
int fact (int n) { if (n < 2) return 1; else return n * fact(n - 1); } Argument n in $a0 Result in $v0

10/11/2011

48

Non-Leaf Procedure Example

MIPS code:
fact: addi sw sw slti beq addi addi jr L1: addi jal lw lw addi mul jr $sp, $ra, $a0, $t0, $t0, $v0, $sp, $ra $a0, fact $a0, $ra, $sp, $v0, $ra $sp, -8 4($sp) 0($sp) $a0, 2 $zero, L1 $zero, 1 $sp, 8 $a0, -1 0($sp) 4($sp) $sp, 8 $a0, $v0 # # # # # # # # # # # # # # adjust stack for 2 items save return address save argument test for n < 2 if so, result is 1 pop 2 items from stack and return else decrement n recursive call restore original n and return address pop 2 items from stack multiply to get result and return

10/11/2011

49

Memory Layout
Text: program code Static data: global variables
e.g., static variables in C, constant arrays and strings $gp initialized to address allowing offsets into this segment

Dynamic data: heap

E.g., malloc in C, new in Java

Stack: automatic storage

10/11/2011

50

Exercise
Write a program to print the fibonaci sequence, the number of sequence is located in memory Write a program to print the sum of the first N natural numbers (1+2+3+..+N) Write a program to print the value of factorial N (N!) Write a program to print the sum of an array of integer
10/11/2011 51

Exercise
Write a program to print the value of factorial N (N!) in a recursive procedure Write a program to print the product of two integer numbers (a*b) by an addition procedure Write a program to print the dividend of two integer numbers (a/b) by a recursive subtraction procedure Write a program to print the first N items of the fibonaci sequence by a recursive procedure
Hint: use two parameters instead of one

10/11/2011

52

Character Data
Byte-encoded character sets
ASCII: 128 characters
95 graphic, 33 control

Latin-1: 256 characters

ASCII, +96 more graphic characters

Unicode: 32-bit character set

Used in Java, C++ wide characters, Most of the worlds alphabets, plus symbols UTF-8, UTF-16: variable-length encodings
10/11/2011 53

Byte/Halfword Operations
Could use bitwise operations MIPS byte/halfword load/store
String processing is a common case
lb rt, offset(rs) lbu rt, offset(rs) sb rt, offset(rs) lh rt, offset(rs) lhu rt, offset(rs) sh rt, offset(rs)

Sign extend to 32 bits in rt Zero extend to 32 bits in rt Store just rightmost byte/halfword
10/11/2011 54

String Copy Example

C code (nave):
Null-terminated string void strcpy (char x[], char y[]) { int i = 0; while ((x[i]=y[i])!='\0') i += 1; } Addresses of x, y in $a0, $a1 i in $s0
10/11/2011 55

String Copy Example

MIPS code:
strcpy: addi sw add L1: add lbu add sb beq addi j L2: lw addi jr
10/11/2011

$sp, $s0, $s0, $t1, $t2, $t3, $t2, $t2, $s0, L1 $s0, $sp, $ra

$sp, -4 0($sp) $zero, $zero $s0, $a1 0($t1) $s0, $a0 0($t3) $zero, L2 $s0, 1 0($sp) $sp, 4

# # # # # # # # # # # # #

adjust stack for 1 item save $s0 i = 0 addr of y[i] in $t1 $t2 = y[i] addr of x[i] in $t3 x[i] = y[i] exit loop if y[i] == 0 i = i + 1 next iteration of loop restore saved $s0 pop 1 item from stack and return
56

32-bit Constants
Most constants are small
16-bit immediate is sufficient

For the occasional 32-bit constant lui rt, constant

Copies 16-bit constant to left 16 bits of rt Clears right 16 bits of rt to 0
lhi $s0, 61
0000 0000 0111 1101 0000 0000 0000 0000

ori $s0, $s0, 2304 0000 0000 0111 1101 0000 1001 0000 0000
10/11/2011 57

Branch Addressing
Branch instructions specify
Opcode, two registers, target address

Most branch targets are near branch

Forward or backward
op
6 bits

rs
5 bits

rt
5 bits

constant or address
16 bits

PC-relative addressing
Target address = PC + offset 4 PC already incremented by 4 by this time
10/11/2011 58

Jump Addressing
Jump (j and jal) targets could be anywhere in text segment
Encode full address in instruction
op
6 bits

address
26 bits

(Pseudo)Direct jump addressing

Target address = PC3128 : (address 4)

10/11/2011

59

Target Addressing Example

Loop code from earlier example
Assume Loop at location 80000
Loop: sll add lw bne $t1, $s3, 2 $t1, $t1, $s6 $t0, 0($t1) $t0, $s5, Exit 80000 80004 80008 80012 80016 80020 80024
60

0 0 35 5 8 2

0 9 9 8 19

19 22 8 21 19

9 9

4 0 0 2 1

0 32

addi $s3, $s3, 1 j Exit:

10/11/2011

Loop

20000

Branching Far Away

If branch target is too far to encode with 16bit offset, assembler rewrites the code Example
beq $s0,$s1, L1 bne $s0,$s1, L2 j L1 L2:

10/11/2011

61

Addressing Mode Summary

Find a sample for each of the above case

10/11/2011

62

The Sort algorithm in C

int i, j; for (i = 0; i < n; i += 1) { for (j = i+1;j < n;j++) if(v[i] > v[j]) swap(v,j,i); } }
v in $a0, k in $a1, i in $s0, j in $s1, n in $s3

Implement the above algorithm in MIPS

10/11/2011

63

Concluding Remarks
Measure MIPS instruction executions in benchmark programs
Consider making the common case fast Consider compromises
Instruction class Arithmetic Data transfer Logical Cond. Branch Jump
10/11/2011

MIPS examples add, sub, addi lw, sw, lb, lbu, lh, lhu, sb, lui and, or, nor, andi, ori, sll, srl beq, bne, slt, slti, sltiu j, jr, jal

SPEC2006 Int 16% 35% 12% 34% 2%

SPEC2006 FP 48% 36% 4% 8% 0%

64

End of chapter
Try to practice programming with MIPS as much as possible The more you practice programming the higher score you may achieve!

10/11/2011

65