Transcript EECS 252 Graduate Computer Architecture Lec 02

Advanced Computer Architecture
Unit 02: Overview of Instruction Sets,
Pipelines, and Caches
Quick overview of everything you
should have learned
2015/7/17
Adapted from UCB slides
2
Cycles Per Instruction (Throughput)
“Average Cycles per Instruction”
CPI = (CPU Time * Clock Rate) / Instruction Count
= Cycles / Instruction Count
n
CPU time  Cycle Time   CPI j  I j
j 1
n
CPI   CPI j  Fj
j 1
where Fj 
Ij
Instruction Count
“Instruction Frequency”
2015/7/17
Adapted from UCB slides
3
Example: Calculating CPI bottom up
Run benchmark and collect workload characterization (simulate, machine
counters, or sampling)
Base Machine
Op
ALU
Load
Store
Branch
(Reg /
Freq
50%
20%
10%
20%
Reg)
Cycles
1
2
2
2
Typical Mix of
instruction types
in program
CPI(i)
.5
.4
.2
.4
1.5
(% Time)
(33%)
(27%)
(13%)
(27%)
Design guideline: Make the common case fast
MIPS 1% rule: only consider adding an instruction of it is shown to add 1%
performance improvement on reasonable benchmarks.
2015/7/17
Adapted from UCB slides
4
Definition: Performance
• Performance is in units of things per sec
– bigger is better
• If we are primarily concerned with response time
performance(x) =
1
execution_time(x)
• X is n times faster than Y means:
n
2015/7/17
=
Performance(X)
Performance(Y)
= Execution_time(Y)
Execution_time(X)
Adapted from UCB slides
5
ISA Implementation Review
A "Typical" RISC ISA
•
•
•
•
32-bit fixed format instruction (3 formats)
32 32-bit GPR (R0 contains zero, DP take pair)
3-address, reg-reg arithmetic instruction
Single address mode for load/store:
base + displacement
– no indirection
• Simple branch conditions
• Delayed branch
see: SPARC, MIPS, HP PA-Risc, DEC Alpha, IBM PowerPC,
CDC 6600, CDC 7600, Cray-1, Cray-2, Cray-3
2015/7/17
Adapted from UCB slides
7
Example: MIPS ( MIPS)
Register-Register
31
26 25
Op
21 20
Rs1
16 15
Rs2
11 10
6 5
Rd
0
Opx
Register-Immediate
31
26 25
Op
21 20
Rs1
16 15
Rd
immediate
0
Branch
31
26 25
Op
Rs1
21 20
16 15
Rs2/Opx
immediate
0
Jump / Call
31
26 25
Op
2015/7/17
target
Adapted from UCB slides
0
8
Datapath vs Control
Datapath
Controller
signals
Control Points
• Datapath: Storage, FU, interconnect sufficient to perform the
desired functions
– Inputs are Control Points
– Outputs are signals
• Controller: State machine to orchestrate operation on the data
path
2015/7/17
– Based on desired function and signals
Adapted from UCB slides
9
5 Steps of MIPS Datapath
Figure A.2, Page A-8
Instruction
Fetch
Instr. Decode
Reg. Fetch
Execute
Addr. Calc
Next SEQ PC
Adder
4
Zero?
RS1
L
M
D
MUX
Data
Memory
ALU
Imm
MUX MUX
RD
Reg File
Inst
Memory
Address
IR <= mem[PC];
RS2
Write
Back
MUX
Next PC
Memory
Access
Sign
Extend
PC <= PC + 4
Reg[IRrd] <= Reg[IRrs] opIRop Reg[IRrt]
2015/7/17
WB Data
Adapted from UCB slides
10
Simple Pipelining Review
5 Steps of MIPS Datapath
Figure A.3, Page A-9
Execute
Addr. Calc
Instr. Decode
Reg. Fetch
Next SEQ PC
Next SEQ PC
Adder
4
Zero?
RS1
RD
RD
RD
MUX
Sign
Extend
MEM/WB
Data
Memory
EX/MEM
ALU
Imm
MUX MUX
A <= Reg[IRrs];
B <= Reg[IRrt]
ID/EX
IR <= mem[PC];
PC <= PC + 4
Reg File
IF/ID
Memory
Address
RS2
Write
Back
MUX
Next PC
Memory
Access
WB Data
Instruction
Fetch
rslt <= A opIRop B
WB <= rslt
Reg[IRrd] <= WB
2015/7/17
• Data stationary control
– local decode for each instruction phase
/ pipeline
Adaptedstage
from UCB slides
12
Visualizing Pipelining
Figure A.2, Page A-8
Time (clock cycles)
2015/7/17
Reg
DMem
Ifetch
Reg
DMem
Reg
ALU
DMem
Reg
ALU
O
r
d
e
r
Ifetch
ALU
I
n
s
t
r.
ALU
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
Ifetch
Ifetch
Reg
Adapted from UCB slides
Reg
Reg
DMem
Reg
13
Pipelining is not quite that easy!
• Limits to pipelining: Hazards prevent next instruction
from executing during its designated clock cycle
– Structural hazards: HW cannot support this combination of
instructions (single person to fold and put clothes away)
– Data hazards: Instruction depends on result of prior instruction still
in the pipeline (missing sock)
– Control hazards: Caused by delay between the fetching of
instructions and decisions about changes in control flow (branches
and jumps).
2015/7/17
Adapted from UCB slides
14
One Memory Port/Structural Hazards
Figure A.4, Page A-14
Time (clock cycles)
2015/7/17
Reg
DMem
Reg
DMem
Reg
DMem
Reg
ALU
Instr 4
Ifetch
ALU
Instr 3
DMem
ALU
O
r
d
e
r
Instr 2
Reg
ALU
I Load Ifetch
n
s
Instr 1
t
r.
ALU
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
Ifetch
Ifetch
Reg
Ifetch
Adapted from UCB slides
Reg
Reg
Reg
DMem
Reg
15
One Memory Port/Structural Hazards
(Similar to Figure A.5, Page A-15)
Time (clock cycles)
Stall
DMem
Ifetch
Reg
DMem
Reg
ALU
Ifetch
Bubble
Instr 3
Reg
Reg
DMem
Bubble Bubble
Ifetch
Reg
Reg
Bubble
ALU
O
r
d
e
r
Instr 2
Reg
ALU
I Load Ifetch
n
s
Instr 1
t
r.
ALU
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
Bubble
DMem
Reg
How do you “bubble” the pipe?
2015/7/17
Adapted from UCB slides
16
Speed Up Equation for Pipelining
CPIpipelined  Ideal CPI  Average Stall cycles per Inst
Cycle Time unpipeline d
Ideal CPI  Pipeline depth
Speedup 

Ideal CPI  Pipeline stall CPI
Cycle Time pipelined
For simple RISC pipeline, CPI = 1:
Cycle Time unpipeline d
Pipeline depth
Speedup 

1  Pipeline stall CPI
Cycle Time pipelined
2015/7/17
Adapted from UCB slides
17
Example: Dual-port vs. Single-port
• Machine A: Dual ported memory (“Harvard Architecture”)
• Machine B: Single ported memory, but its pipelined
implementation has a 1.05 times faster clock rate
• Ideal CPI = 1 for both
• Loads are 40% of instructions executed
SpeedUpA = Pipeline Depth/(1 + 0) x (clockunpipe/clockpipe)
= Pipeline Depth
SpeedUpB = Pipeline Depth/(1 + 0.4 x 1) x (clockunpipe/(clockunpipe / 1.05)
= (Pipeline Depth/1.4) x 1.05
= 0.75 x Pipeline Depth
SpeedUpA / SpeedUpB = Pipeline Depth/(0.75 x Pipeline Depth) = 1.33
• Machine A is 1.33 times faster
2015/7/17
Adapted from UCB slides
18
Data Hazard on R1
Figure A.6, Page A-17
Time (clock cycles)
and r6,r1,r7
or
r8,r1,r9
Ifetch
DMem
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
ALU
sub r4,r1,r3
Reg
ALU
Ifetch
ALU
O
r
d
e
r
add r1,r2,r3
xor r10,r1,r11
2015/7/17
WB
ALU
I
n
s
t
r.
MEM
ALU
IF ID/RF EX
Adapted from UCB slides
Reg
Reg
Reg
Reg
DMem
Reg
19
Three Generic Data Hazards
• Read After Write (RAW)
InstrJ tries to read operand before InstrI writes it
I: add r1,r2,r3
J: sub r4,r1,r3
• Caused by a “Dependence” (in compiler
nomenclature). This hazard results from an actual
need for communication.
2015/7/17
Adapted from UCB slides
20
Three Generic Data Hazards
• Write After Read (WAR)
InstrJ writes operand before InstrI reads it
I: sub r4,r1,r3
J: add r1,r2,r3
K: mul r6,r1,r7
• Called an “anti-dependence” by compiler writers.
This results from reuse of the name “r1”.
• Can’t happen in MIPS 5 stage pipeline because:
– All instructions take 5 stages, and
– Reads are always in stage 2, and
– Writes are always in stage 5
2015/7/17
Adapted from UCB slides
21
Three Generic Data Hazards
• Write After Write (WAW)
InstrJ writes operand before InstrI writes it.
I: sub r1,r4,r3
J: add r1,r2,r3
K: mul r6,r1,r7
• Called an “output dependence” by compiler writers
This also results from the reuse of name “r1”.
• Can’t happen in MIPS 5 stage pipeline because:
– All instructions take 5 stages, and
– Writes are always in stage 5
• Will see WAR and WAW in more complicated pipes
2015/7/17
Adapted from UCB slides
22
Forwarding to Avoid Data Hazard
Figure A.7, Page A-19
or
r8,r1,r9
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
ALU
and r6,r1,r7
Ifetch
DMem
ALU
sub r4,r1,r3
Reg
ALU
O
r
d
e
r
add r1,r2,r3 Ifetch
ALU
I
n
s
t
r.
ALU
Time (clock cycles)
xor r10,r1,r11
2015/7/17
Adapted from UCB slides
Reg
Reg
Reg
Reg
DMem
Reg
23
HW Change for Forwarding
Figure A.23, Page A-37
NextPC
mux
MEM/WR
EX/MEM
ALU
mux
ID/EX
Registers
Data
Memory
mux
Immediate
What circuit detects and resolves this hazard?
2015/7/17
Adapted from UCB slides
24
Forwarding to Avoid LW-SW Data Hazard
Figure A.8, Page A-20
or
r8,r6,r9
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
ALU
sw r4,12(r1)
Ifetch
DMem
ALU
lw r4, 0(r1)
Reg
ALU
O
r
d
e
r
add r1,r2,r3 Ifetch
ALU
I
n
s
t
r.
ALU
Time (clock cycles)
xor r10,r9,r11
2015/7/17
Adapted from UCB slides
Reg
Reg
Reg
Reg
DMem
Reg
25
Data Hazard Even with Forwarding
Figure A.9, Page A-21
and r6,r1,r7
or
2015/7/17
r8,r1,r9
DMem
Ifetch
Reg
DMem
Reg
Ifetch
Ifetch
Adapted from UCB slides
Reg
Reg
Reg
DMem
ALU
O
r
d
e
r
sub r4,r1,r6
Reg
ALU
lw r1, 0(r2) Ifetch
ALU
I
n
s
t
r.
ALU
Time (clock cycles)
Reg
DMem
Reg
26
Data Hazard Even with Forwarding
(Similar to Figure A.10, Page A-21)
and r6,r1,r7
2015/7/17
or
r8,r1,r9
DMem
Ifetch
Reg
Bubble
Ifetch
Bubble
Reg
Bubble
Ifetch
Adapted from UCB slides
Reg
DMem
Reg
Reg
DMem
ALU
O
r
d
e
r
sub r4,r1,r6
Reg
ALU
lw r1, 0(r2) Ifetch
ALU
I
n
s
t
r.
ALU
Time (clock cycles)
Reg
DMem
27
Software Scheduling to Avoid
Load Hazards
Try producing fast code for
a = b + c;
d = e – f;
assuming a, b, c, d ,e, and f in memory.
Slow code:
LW
LW
ADD
SW
LW
LW
SUB
SW
2015/7/17
Rb,b
Rc,c
Ra,Rb,Rc
a,Ra
Re,e
Rf,f
Rd,Re,Rf
d,Rd
Fast code:
LW
LW
LW
ADD
LW
SW
SUB
SW
Adapted from UCB slides
Rb,b
Rc,c
Re,e
Ra,Rb,Rc
Rf,f
a,Ra
Rd,Re,Rf
d,Rd
28
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
DMem
Ifetch
Reg
ALU
r6,r1,r7
Ifetch
DMem
ALU
18: or
Reg
ALU
14: and r2,r3,r5
Ifetch
ALU
10: beq r1,r3,36
ALU
Control Hazard on Branches
Three Stage Stall
22: add r8,r1,r9
36: xor r10,r1,r11
Reg
Reg
Reg
Reg
DMem
Reg
What do you do with the 3 instructions in between?
How do you do it?
Where is the “commit”?
2015/7/17
Adapted from UCB slides
29
Branch Stall Impact
• If CPI = 1, 30% branch,
Stall 3 cycles => new CPI = 1.9!
• Two part solution:
– Determine branch taken or not sooner, AND
– Compute taken branch address earlier
• MIPS branch tests if register = 0 or  0
• MIPS Solution:
– Move Zero test to ID/RF stage
– Adder to calculate new PC in ID/RF stage
– 1 clock cycle penalty for branch versus 3
2015/7/17
Adapted from UCB slides
30
Pipelined MIPS Datapath
Figure A.24, page A-38
Instruction
Fetch
Memory
Access
Write
Back
Adder
Adder
MUX
Next
SEQ PC
Next PC
Zero?
RS1
RD
RD
RD
MUX
Sign
Extend
MEM/WB
Data
Memory
EX/MEM
ALU
MUX
ID/EX
Imm
Reg File
IF/ID
Memory
Address
RS2
WB Data
4
Execute
Addr. Calc
Instr. Decode
Reg. Fetch
• Interplay of instruction set design and cycle time.
2015/7/17
Adapted from UCB slides
31
Four Branch Hazard Alternatives
#1: Stall until branch direction is clear
#2: Predict Branch Not Taken
–
–
–
–
–
Execute successor instructions in sequence
“Squash” instructions in pipeline if branch actually taken
Advantage of late pipeline state update
47% MIPS branches not taken on average
PC+4 already calculated, so use it to get next instruction
#3: Predict Branch Taken
– 53% MIPS branches taken on average
– But haven’t calculated branch target address in MIPS
» MIPS still incurs 1 cycle branch penalty
» Other machines: branch target known before outcome
2015/7/17
Adapted from UCB slides
32
Four Branch Hazard Alternatives
#4: Delayed Branch
– Define branch to take place AFTER a following instruction
branch instruction
sequential successor1
sequential successor2
........
sequential successorn
branch target if taken
Branch delay of length n
– 1 slot delay allows proper decision and branch target
address in 5 stage pipeline
– MIPS uses this
2015/7/17
Adapted from UCB slides
33
Scheduling Branch Delay Slots (Fig A.14)
A. From before branch
add $1,$2,$3
if $2=0 then
delay slot
becomes
B. From branch target
sub $4,$5,$6
add $1,$2,$3
if $1=0 then
delay slot
becomes
if $2=0 then
add $1,$2,$3
add $1,$2,$3
if $1=0 then
sub $4,$5,$6
C. From fall through
add $1,$2,$3
if $1=0 then
delay slot
sub $4,$5,$6
becomes
add $1,$2,$3
if $1=0 then
sub $4,$5,$6
• A is the best choice, fills delay slot & reduces instruction count (IC)
• In B, the sub instruction may need to be copied, increasing IC
• In B and C, must be okay to execute sub when branch fails
2015/7/17
Adapted from UCB slides
34
Delayed Branch
• Compiler effectiveness for single branch delay slot:
– Fills about 60% of branch delay slots
– About 80% of instructions executed in branch delay slots useful
in computation
– About 50% (60% x 80%) of slots usefully filled
• Delayed Branch downside: As processor go to
deeper pipelines and multiple issue, the branch
delay grows and need more than one delay slot
– Delayed branching has lost popularity compared to more
expensive but more flexible dynamic approaches
– Growth in available transistors has made dynamic approaches
relatively cheaper
2015/7/17
Adapted from UCB slides
35
Evaluating Branch Alternatives
Pipeline speedup =
Pipeline depth
1 +Branch frequency Branch penalty
Assume 4% unconditional branch, 6% conditional branchuntaken, 10% conditional branch-taken
Scheduling
Branch CPI speedup v. speedup v.
scheme
penalty
unpipelined
stall
Stall pipeline
3 1.60
3.1
1.0
Predict taken
1 1.20
4.2
1.33
Predict not taken
1 1.14
4.4
1.40
Delayed branch
0.5 1.10
4.5
1.45
2015/7/17
Adapted from UCB slides
36
Problems with Pipelining
• Exception: An unusual event happens to an
instruction during its execution
– Examples: divide by zero, undefined opcode
• Interrupt: Hardware signal to switch the
processor to a new instruction stream
– Example: a sound card interrupts when it needs more audio
output samples (an audio “click” happens if it is left waiting)
• Problem: It must appear that the exception or
interrupt must appear between 2 instructions (Ii
and Ii+1)
– The effect of all instructions up to and including Ii is totalling
complete
– No effect of any instruction after Ii can take place
• The interrupt (exception) handler either aborts
program or restarts at instruction Ii+1
2015/7/17
Adapted from UCB slides
37
Precise Exceptions in Static Pipelines
Key observation: architected state only
change in memory and register write stages.
2015/7/17
Adapted from UCB slides
38
Memory Hierarchy Review
Since 1980, CPU has outpaced DRAM ...
Performance
(1/latency)
CPU
CPU
60% per yr
2X in 1.5 yrs
Gap grew 50% per
year
DRAM
9% per yr
DRAM
2X in 10 yrs
Year
• How do architects address this gap?
– Put small, fast “cache” memories between CPU and DRAM.
– Create a “memory hierarchy”
1977: DRAM faster than microprocessors
Apple ][ (1977)
CPU: 1000 ns
DRAM: 400 ns
Steve
Jobs
Steve
Wozniak
Memory Hierarchy of a Modern Computer
• Take advantage of the principle of locality to:
– Present as much memory as in the cheapest technology
– Provide access at speed offered by the fastest technology
Processor
Control
1s
Size (bytes): 100s
2015/7/17
On-Chip
Cache
Speed (ns):
Registers
Datapath
Second
Level
Cache
(SRAM)
Main
Memory
(DRAM)
10s-100s
100s
Ks-Ms
Ms
Adapted from UCB slides
Secondary
Storage
(Disk)
Tertiary
Storage
(Tape)
10,000,000s 10,000,000,000s
(10s ms)
(10s sec)
Gs
Ts
42
The Principle of Locality
• The Principle of Locality:
– Program access a relatively small portion of the address space at
any instant of time.
• Two Different Types of Locality:
– Temporal Locality (Locality in Time): If an item is referenced, it will
tend to be referenced again soon (e.g., loops, reuse)
– Spatial Locality (Locality in Space): If an item is referenced, items
whose addresses are close by tend to be referenced soon
(e.g., straightline code, array access)
• Last 15 years, HW relied on locality for speed
2015/7/17
Adapted from UCB slides
43
Memory Address (one dot per access)
Programs with locality cache well ...
Bad locality behavior
Temporal
Locality
Spatial
Locality
Time
Donald J. Hatfield, Jeanette Gerald: Program
Restructuring for Virtual Memory. IBM Systems Journal
10(3): 168-192 (1971)
Memory Hierarchy: Apple iMac G5
Managed
by compiler
Managed
by hardware
Managed by OS,
hardware,
application
07
Reg
L1 Inst
L1 Data
L2
DRAM
Disk
Size
1K
64K
32K
512K
256M
80G
1,
0.6 ns
3,
1.9 ns
3,
1.9 ns
11,
6.9 ns
88,
55 ns
107,
12 ms
Latency
Cycles,
Time
Goal: Illusion of large, fast, cheap memory
Let programs address a memory space that
scales to the disk size, at a speed that is
usually as fast as register access
iMac G5
1.6 GHz
iMac’s PowerPC 970: All caches on-chip
L1 (64K Instruction)
Registers
512K
L2
(1K)
L1 (32K Data)
Memory Hierarchy: Terminology
• Hit: data appears in some block in the upper level
(example: Block X)
– Hit Rate: the fraction of memory access found in the upper level
– Hit Time: Time to access the upper level which consists of
RAM access time + Time to determine hit/miss
• Miss: data needs to be retrieve from a block in the
lower level (Block Y)
– Miss Rate = 1 - (Hit Rate)
– Miss Penalty: Time to replace a block in the upper level +
Time to deliver the block the processor
• Hit Time << Miss Penalty (500 instructions on 21264!)
To Processor
Upper Level
Memory
Lower Level
Memory
Blk X
From Processor
2015/7/17
Blk Y
Adapted from UCB slides
47
4 Questions for Memory Hierarchy
• Q1: Where can a block be placed in the upper level?
(Block placement)
• Q2: How is a block found if it is in the upper level?
(Block identification)
• Q3: Which block should be replaced on a miss?
(Block replacement)
• Q4: What happens on a write?
(Write strategy)
2015/7/17
Adapted from UCB slides
48
Q1: Where can a block be placed in
the upper level?
• Block 12 placed in 8 block cache:
– Fully associative, direct mapped, 2-way set associative
– S.A. Mapping = Block Number Modulo Number Sets
Full Mapped
Direct Mapped
(12 mod 8) = 4
2-Way Assoc
(12 mod 4) = 0
01234567
01234567
01234567
Cache
1111111111222222222233
01234567890123456789012345678901
Memory
2015/7/17
Adapted from UCB slides
49
A Summary on Sources of Cache Misses
• Compulsory (cold start or process migration, first
reference): first access to a block
– “Cold” fact of life: not a whole lot you can do about it
– Note: If you are going to run “billions” of instruction, Compulsory
Misses are insignificant
• Capacity:
– Cache cannot contain all blocks access by the program
– Solution: increase cache size
• Conflict (collision):
– Multiple memory locations mapped
to the same cache location
– Solution 1: increase cache size
– Solution 2: increase associativity
• Coherence (Invalidation): other process (e.g., I/O)
updates memory
2015/7/17
Adapted from UCB slides
50
Q2: How is a block found if it is in the
upper level?
Block Address
Index
Tag
Block
offset
Set Select
Data Select
• Index Used to Lookup Candidates in Cache
– Index identifies the set
• Tag used to identify actual copy
– If no candidates match, then declare cache miss
• Block is minimum quantum of caching
– Data select field used to select data within block
– Many caching applications don’t have data select field
2015/7/17
Adapted from UCB slides
51
Direct Mapped Cache
• Direct Mapped 2N byte cache:
– The uppermost (32 - N) bits are always the Cache Tag
– The lowest M bits are the Byte Select (Block Size = 2M)
• Example: 1 KB Direct Mapped Cache with 32 B Blocks
– Index chooses potential block
– Tag checked to verify block
– Byte select chooses byte within block
9
Cache Tag
Ex: 0x50
Valid Bit
4
Byte Select
Ex: 0x01
Ex: 0x00
Cache Tag
Cache Data
Byte 31
0x50
0
Cache Index
Byte 63
: :
31
Byte 1
Byte 0
0
Byte 33 Byte 32 1
2
3
:
:
Byte 1023
2015/7/17
Adapted from UCB slides
:
:
Byte 992 31
52
Set Associative Cache
• N-way set associative: N entries per Cache Index
– N direct mapped caches operates in parallel
• Example: Two-way set associative cache
– Cache Index selects a “set” from the cache
– Two tags in the set are compared to input in parallel
– Data is selected based on the tag result
31
8
Cache Tag
Valid
:
Cache Tag
:
Compare
4
Cache Index
Cache Data
Cache Data
Cache Block 0
Cache Block 0
:
:
Sel1 1
Mux
0 Sel0
0
Byte Select
Cache Tag
Valid
:
:
Compare
OR
2015/7/17
Hit
Cache
Adapted from UCB
slidesBlock
53
Fully Associative Cache
• Fully Associative: Every block can hold any line
– Address does not include a cache index
– Compare Cache Tags of all Cache Entries in Parallel
• Example: Block Size=32B blocks
– We need N 27-bit comparators
– Still have byte select to choose from within block
31
4
Cache Tag (27 bits long)
0
Byte Select
Ex: 0x01
Valid Bit
=
Cache Data
Byte 31
=
Byte 63
: :
Cache Tag
Byte 1
Byte 0
Byte 33 Byte 32
=
=
=
2015/7/17
:
Adapted from UCB slides
:
:
54
Q3: Which block should be replaced
on a miss?
• Easy for Direct Mapped
• Set Associative or Fully Associative:
– LRU (Least Recently Used): Appealing, but hard to
implement for high associativity
– Random: Easy, but – how well does it work?
Assoc:
2015/7/17
2-way
4-way
8-way
Size
LRU
Ran
LRU
Ran
LRU
Ran
16K
5.2%
5.7%
4.7%
5.3%
4.4%
5.0%
64K
1.9%
2.0%
1.5%
1.7%
1.4%
1.5%
256K
1.15%
1.17%
1.13%
1.13%
1.12%
1.12%
Adapted from UCB slides
55
Q4: What happens on a write?
Write-Through
Policy
Data written to cache
block
Write-Back
Write data only to
the cache
also written to lowerlevel memory
Update lower level
when a block falls
out of the cache
Debug
Easy
Hard
Do read misses
produce writes?
No
Yes
Do repeated
writes make it to
lower level?
Yes
No
Additional option -- let writes to an un-cached address
allocate a new cache line (“write-allocate”).
Write Buffers for Write-Through Caches
Cache
Processor
Lower
Level
Memory
Write Buffer
Holds data awaiting write-through to
lower level memory
Q. Why a write buffer ?
A. So CPU doesn’t stall
Q. Why a buffer, why
not just one register ?
A. Bursts of writes are
common.
Q. Are Read After Write A. Yes! Drain buffer before
(RAW) hazards an issue next read, or check write
for write buffer?
buffers for match on reads
5 Basic Cache Optimizations
•
1.
2.
3.
Reducing Miss Rate
Larger Block size (compulsory misses)
Larger Cache size (capacity misses)
Higher Associativity (conflict misses)
• Reducing Miss Penalty
4. Multilevel Caches
• Reducing hit time
5. Giving Reads Priority over Writes
•
2015/7/17
E.g., Read complete before earlier writes in write buffer
Adapted from UCB slides
58
Virtual Memory
What is virtual memory?
Virtual
Address Space
Physical
Address Space
Virtual Address
10
offset
V page no.
Page Table
Page Table
Base Reg
index
into
page
table
V
Access
Rights
PA
table located
in physical P page no.
memory
offset
10
Physical Address
• Virtual memory => treat memory as a cache for the disk
• Terminology: blocks in this cache are called “Pages”
– Typical size of a page: 1K — 8K
• Page table maps virtual page numbers to physical frames
– “PTE” = Page Table Entry
2015/7/17
Adapted from UCB slides
60
Three Advantages of Virtual Memory
• Translation:
– Program can be given consistent view of memory, even though physical
memory is scrambled
– Makes multithreading reasonable (now used a lot!)
– Only the most important part of program (“Working Set”) must be in
physical memory.
– Contiguous structures (like stacks) use only as much physical memory
as necessary yet still grow later.
• Protection:
– Different threads (or processes) protected from each other.
– Different pages can be given special behavior
» (Read Only, Invisible to user programs, etc).
– Kernel data protected from User programs
– Very important for protection from malicious programs
• Sharing:
– Can map same physical page to multiple users
(“Shared memory”)
2015/7/17
Adapted from UCB slides
61
Large Address Space Support
10 bits
10 bits
Virtual Virtual
Virtual
Address: P1 index P2 index
12 bits
Physical Physical
Address: Page #
Offset
Offset
4KB
PageTablePtr
4 bytes
• Single-Level Page Table Large
– 4KB pages for a 32-bit address  1M entries
– Each process needs own page table!
• Multi-Level Page Table
– Can allow sparseness of page table
– Portions of table can be swapped to disk
2015/7/17
Adapted from UCB slides
4 bytes
62
VM and Disk: Page replacement policy
Page Table
Dirty bit: page
written.
dirty used
Used bit: set to
1 on any
reference
Set of all pages
in Memory
Head pointer
Place pages on free
list if used bit
is still clear.
Schedule pages
with dirty bit set to
be written to disk.
1
1
0
1
0
0
0
1
1
0
...
Tail pointer:
Clear the used
bit in the
page table
Freelist
Architect’s role:
support setting dirty
and used bits
Free Pages
Translation Look-Aside Buffers
• Translation Look-Aside Buffers (TLB)
– Cache on translations
– Fully Associative, Set Associative, or Direct Mapped
hit
PA
VA
CPU
Translation
with a TLB
miss
TLB
miss
Cache
Main
Memory
hit
Translation
data
• TLBs are:
– Small – typically not more than 128 – 256 entries
– Fully Associative
2015/7/17
Adapted from UCB slides
64
What Actually Happens on a TLB Miss?
• Hardware traversed page tables:
– On TLB miss, hardware in MMU looks at current page table to fill TLB
(may walk multiple levels)
» If PTE valid, hardware fills TLB and processor never knows
» If PTE marked as invalid, causes Page Fault, after which kernel
decides what to do afterwards
• Software traversed Page tables (like MIPS)
– On TLB miss, processor receives TLB fault
– Kernel traverses page table to find PTE
» If PTE valid, fills TLB and returns from fault
» If PTE marked as invalid, internally calls Page Fault handler
• Most chip sets provide hardware traversal
– Modern operating systems tend to have more TLB faults since they use
translation for many things
– Examples:
» shared segments
» user-level portions of an operating system
2015/7/17
Adapted from UCB slides
65
Example: R3000 pipeline
MIPS R3000 Pipeline
Dcd/ Reg
Inst Fetch
TLB
I-Cache
RF
ALU / E.A
Memory
Operation
E.A.
TLB
Write Reg
WB
D-Cache
TLB
64 entry, on-chip, fully associative, software TLB fault handler
Virtual Address Space
ASID
6
V. Page Number
20
Offset
12
0xx User segment (caching based on PT/TLB entry)
100 Kernel physical space, cached
101 Kernel physical space, uncached
11x Kernel virtual space
Allows context switching among
64 user processes without TLB flush
2015/7/17
Adapted from UCB slides
66
Reducing translation time further
• As described, TLB lookup is in serial with cache lookup:
Virtual Address
10
offset
V page no.
TLB Lookup
V
Access
Rights
PA
P page no.
offset
10
Physical Address
• Machines with TLBs go one step further: they overlap TLB
lookup with cache access.
– Works because offset available early
2015/7/17
Adapted from UCB slides
67
Overlapping TLB & Cache Access
• Here is how this might work with a 4K cache:
assoc
lookup
32
index
TLB
10 2
disp 00
20
page #
Hit/
Miss
FN
4K Cache
=
1 K
4 bytes
FN Data
Hit/
Miss
• What if cache size is increased to 8KB?
– Overlap not complete
– Need to do something else.
• Another option: Virtual Caches
– Tags in cache are virtual addresses
– Translation only happens on cache misses
2015/7/17
Adapted from UCB slides
68
Problems With Overlapped TLB Access
• Overlapped access requires address bits used to
index into cache do not change as result translation
– This usually limits things to small caches, large page sizes, or high
n-way set associative caches if you want a large cache
• Example: suppose everything the same except that
the cache is increased to 8 K bytes instead of 4 K:
11
cache
index
20
virt page #
2
00
This bit is changed
by VA translation, but
is needed for cache
lookup
12
disp
Solutions:
go to 8K byte page sizes;
go to 2 way set associative cache; or
SW guarantee VA[13]=PA[13]
10
2015/7/17
1K
4
4
Adapted from UCB slides
2 way set assoc cache
69
Summary: Control and Pipelining
• Control VIA State Machines and Microprogramming
• Just overlap tasks; easy if tasks are independent
• Speed Up  Pipeline Depth; if ideal CPI is 1, then:
Cycle Time unpipeline d
Pipeline depth
Speedup 

1  Pipeline stall CPI
Cycle Time pipelined
• Hazards limit performance on computers:
– Structural: need more HW resources
– Data (RAW,WAR,WAW): need forwarding, compiler scheduling
– Control: delayed branch, prediction
• Exceptions, Interrupts add complexity
2015/7/17
Adapted from UCB slides
70
Summary #1/3: The Cache Design Space
• Several interacting dimensions
–
–
–
–
–
–
Cache Size
cache size
block size
associativity
replacement policy
write-through vs write-back
write allocation
Associativity
• The optimal choice is a compromise
– depends on access characteristics
» workload
» use (I-cache, D-cache, TLB)
– depends on technology / cost
• Simplicity often wins
2015/7/17
Block Size
Bad
Good
Adapted from UCB slides
Factor A
Less
Factor B
More
71
Summary #2/3: Caches
• The Principle of Locality:
– Program access a relatively small portion of the address space at any
instant of time.
» Temporal Locality: Locality in Time
» Spatial Locality: Locality in Space
• Three Major Categories of Cache Misses:
– Compulsory Misses: sad facts of life. Example: cold start misses.
– Capacity Misses: increase cache size
– Conflict Misses: increase cache size and/or associativity.
Nightmare Scenario: ping pong effect!
• Write Policy: Write Through vs. Write Back
• Today CPU time is a function of (ops, cache misses)
vs. just f(ops): affects Compilers, Data structures, and
Algorithms
2015/7/17
Adapted from UCB slides
72
Summary #3/3: TLB, Virtual Memory
• Page tables map virtual address to physical address
• TLBs are important for fast translation
• TLB misses are significant in processor performance
– funny times, as most systems can’t access all of 2nd level cache
without TLB misses!
• Caches, TLBs, Virtual Memory all understood by
examining how they deal with 4 questions:
1) Where can block be placed?
2) How is block found?
3) What block is replaced on miss?
4) How are writes handled?
• Today VM allows many processes to share single
memory without having to swap all processes to
disk; today VM protection is more important than
memory hierarchy benefits, but computers insecure
2015/7/17
Adapted from UCB slides
73