CS740
Virtual Memory
October 2, 2000
Topics
•
•
•
•
Motivations for VM
Address Translation
Accelerating with TLBs
Alpha 21X64 memory system
Motivation 1: DRAM a “Cache” for Disk
The full address space is quite large:
• 32-bit addresses:
~4,000,000,000 (4 billion) bytes
• 64-bit addresses: ~16,000,000,000,000,000,000 (16 quintillion) bytes
Disk storage is ~30X cheaper than DRAM storage
• 8 GB of DRAM: ~ $12,000
• 8 GB of disk:
~ $400
To access large amounts of data in a cost-effective
manner, the bulk of the data must be stored on disk
4 MB: ~$400
SRAM
–2–
256 MB: ~$400
DRAM
8 GB: ~$400
Disk
CS 740 F’00
S’99
Levels in Memory Hierarchy
cache
CPU
regs
Register
size:
speed:
$/Mbyte:
block size:
200 B
3 ns
8B
8B
C
a
c
h
e
32 B
Cache
virtual memory
Memory
8 KB
Memory
32 KB / 4MB128 MB
6 ns
60 ns
$100/MB
$1.50/MB
32 B
8 KB
disk
Disk Memory
20 GB
8 ms
$0.05/MB
larger, slower, cheaper
–3–
CS 740 F’00
S’99
DRAM vs. SRAM as a “Cache”
DRAM vs. disk is more extreme than SRAM vs. DRAM
• access latencies:
– DRAM is ~10X slower than SRAM
– disk is ~100,000X slower than DRAM
• importance of exploiting spatial locality:
– first byte is ~100,000X slower than successive bytes on disk
» vs. ~4X improvement for page-mode vs. regular accesses to DRAM
• “cache” size:
– main memory is ~100X larger than an SRAM cache
• addressing for disk is based on sector address, not memory address
SRAM
–4–
DRAM
Disk
CS 740 F’00
S’99
Impact of These Properties on Design
If DRAM was to be organized similar to an SRAM cache,
how would we set the following design parameters?
• Line size?
• Associativity?
• Replacement policy (if associative)?
• Write through or write back?
What would the impact of these choices be on:
•
•
•
•
miss rate
hit time
miss latency
tag overhead
–5–
CS 740 F’00
S’99
Locating an Object in a “Cache”
1. Search for matching tag
“Cache”
Tag
Data
0:
D
243
1:
X
•
•
•
J
17
•
•
•
105
• SRAM cache
Object Name
X
= X?
N-1:
2. Use indirection to look up actual object location
• virtual memory
Lookup Table
“Cache”
Location
Data
Object Name
D:
0
0:
243
X
J:
N-1
•
•
•
1
1:
17
•
•
•
105
X:
–6–
N-1:
CS 740 F’00
S’99
A System with Physical Memory Only
Examples:
• most Cray machines, early PCs, nearly all embedded systems, etc.
Memory
Store 0x10
0:
1:
CPU
Load 0xf0
N-1:
CPU’s load or store addresses used directly to access memory.
–7–
CS 740 F’00
S’99
A System with Virtual Memory
Examples:
• workstations, servers, modern PCs, etc.
Virtual
Addresses
Store 0x10
Page Table
0:
1:
Memory
0:
1:
Physical
Addresses
CPU
Load 0xf0
P-1:
N-1:
Disk
Address Translation: the hardware converts virtual addresses into
physical addresses via an OS-managed lookup table (page table)
–8–
CS 740 F’00
S’99
Page Faults (Similar to “Cache Misses”)
What if an object is on disk rather than in memory?
• Page table entry indicates that the virtual address is not in memory
• An OS trap handler is invoked, moving data from disk into memory
Memory
– current process suspends, others can resume
– OS has full control over placement, etc.
0:
1:
Page Table
Virtual
Physical
Addresses
0:
Addresses
1:
CPU
Load 0x05
Store 0xf8
P-1:
N-1:
Disk
–9–
CS 740 F’00
S’99
Servicing a Page Fault
(1) Initiate Block Read
Processor Signals
Controller
Processor
• Read block of length P
starting at disk address X
and store starting at memory
address Y
Reg
(3) Read
Done
Cache
Read Occurs
• Direct Memory Access
• Under control of I/O
controller
Memory-I/O bus
(2) DMA Transfer
I / O Controller Signals
Completion
• Interrupt processor
• Can resume suspended
process
– 10 –
Memory
I/O
controller
disk
Disk
disk
Dis
k
CS 740 F’00
S’99
Motivation #2: Memory Management
Multiple processes can reside in physical memory.
How do we resolve address conflicts?
(Virtual) Memory Image for Alpha Process
0000 03FF 8000 0000
Reserved
Not yet allocated
Dynamic Data
$gp
0000 0001 2000 0000
$sp
Static Data
Text (Code)
e.g., what if two different
Alpha processes access their
stacks at address
0x11fffff80 at the same
time?
Stack
Not yet allocated
0000 0000 0001 0000
Reserved
– 11 –
CS 740 F’00
S’99
Soln: Separate Virtual Addr. Spaces
• Virtual and physical address spaces divided into equal-sized blocks
– “Pages” (both virtual and physical)
• Each process has its own virtual address space
– operating system controls how virtual pages as assigned to physical
memory
Virtual Addresses
0
Process 1:
VP 1
VP 2
Address
Translation
Physical Addresses
0
PP 2
N-1
PP 7
Process 2:
0
N-1
– 12 –
VP 1
VP 2
(Read-only
library code)
PP 10
M-1
CS 740 F’00
S’99
Contrast: Macintosh Memory Model
Does not use traditional virtual memory
P1 Pointer Table
Process P1
Shared Address Space
A
B
“Handles”
Process P2
P2 Pointer Table
C
D
E
All program objects accessed through “handles”
• indirect reference through pointer table
• objects stored in shared global address space
– 13 –
CS 740 F’00
S’99
Macintosh Memory Management
Allocation / Deallocation
• Similar to free-list management of malloc/free
Compaction
• Can move any object and just update the (unique) pointer in
pointer table
Shared Address Space
P1 Pointer Table
B
Process P1
A
“Handles”
P2 Pointer Table
Process P2
C
D
E
– 14 –
CS 740 F’00
S’99
Mac vs. VM-Based Memory Mgmt
Allocating, deallocating, and moving memory:
• can be accomplished by both techniques
Block sizes:
• Mac: variable-sized
– may be very small or very large
• VM: fixed-size
– size is equal to one page (8KB in Alpha)
Allocating contiguous chunks of memory:
• Mac: contiguous allocation is required
• VM: can map contiguous range of virtual addresses to disjoint
ranges of physical addresses
Protection?
• Mac: “wild write” by one process can corrupt another’s data
– 15 –
CS 740 F’00
S’99
Motivation #3: Protection
Page table entry contains access rights information
• hardware enforces this protection (trap into OS if violation occurs)
Page Tables
Memory
Read? Write? Physical Addr
Process i:
VP 0:
Yes
No
PP 9
VP 1:
Yes
Yes
PP 4
VP 2:
No
No
XXXXXXX
•
•
•
•
•
•
0:
1:
•
•
•
Read? Write? Physical Addr
Process j:
– 16 –
VP 0:
Yes
Yes
PP 6
VP 1:
Yes
No
PP 9
VP 2:
No
No
XXXXXXX
•
•
•
•
•
•
N-1:
•
•
•
CS 740 F’00
S’99
VM Address Translation
V = {0, 1, . . . , N–1} virtual address space
P = {0, 1, . . . , M–1} physical address space
N>M
MAP: V  P U {} address mapping function
MAP(a)
= a' if data at virtual address a is present at physical
address a' in P
=  if data at virtual address a is not present in P
missing item fault
fault
handler
Processor
a
Addr Trans
Mechanism

a'
physical address
– 17 –
Main
Memory
Secondary
memory
OS performs
this transfer
(only if miss)
CS 740 F’00
S’99
VM Address Translation
Parameters
• P = 2p = page size (bytes). Typically 1KB–16KB
• N = 2n = Virtual address limit
• M = 2m = Physical address limit
n–1
p p–1
virtual page number
0
virtual address
page offset
address translation
m–1
p p–1
physical page number
page offset
0
physical address
Notice that the page offset bits don't change as a result of translation
– 18 –
CS 740 F’00
S’99
Page Tables
Virtual Page
Number
Page Table
(physical page
Valid or disk address)
1
1
0
1
1
1
0
1
0
1
– 19 –
Physical Memory
Disk Storage
CS 740 F’00
S’99
Address Translation via Page Table
page table base register
VPN acts
as
table index
virtual address
n–1
p p–1
virtual page number
valid access
0
page offset
physical page number
Address
if valid=0
then page
not in memory
m–1
p p–1
physical page number
page offset
physical address
– 20 –
CS 740 F’00
S’99
0
Page Table Operation
Translation
• Separate (set of) page table(s) per process
• VPN forms index into page table
Computing Physical Address
• Page Table Entry (PTE) provides information about page
– if (Valid bit = 1) then page in memory.
» Use physical page number (PPN) to construct address
– if (Valid bit = 0) then page in secondary memory
» Page fault
» Must load into main memory before continuing
Checking Protection
• Access rights field indicate allowable access
– e.g., read-only, read-write, execute-only
– typically support multiple protection modes (e.g., kernel vs. user)
• Protection violation fault if don’t have necessary permission
– 21 –
CS 740 F’00
S’99
Integrating VM and Cache
VA
CPU
miss
PA
Translation
data
Cache
Main
Memory
hit
Most Caches “Physically Addressed”
•
•
•
•
Accessed by physical addresses
Allows multiple processes to have blocks in cache at same time
Allows multiple processes to share pages
Cache doesn’t need to be concerned with protection issues
– Access rights checked as part of address translation
Perform Address Translation Before Cache Lookup
• But this could involve a memory access itself
• Of course, page table entries can also become cached
– 22 –
CS 740 F’00
S’99
Speeding up Translation with a TLB
“Translation Lookaside Buffer” (TLB)
• Small, usually fully associative cache
• Maps virtual page numbers to physical page numbers
• Contains complete page table entries for small number of pages
hit
PA
VA
CPU
TLB
Lookup
miss
miss
Cache
Main
Memory
hit
Translation
data
– 23 –
CS 740 F’00
S’99
Address Translation with a TLB
N–1
p p–1
0
process ID virtual page number page offset
valid dirty tag
valid
valid
valid
valid
virtual address
physical page number
TLB
=
TLB hit
physical address
tag
index
valid tag
=
cache hit
– 24 –
byte offset
data
Cache
data
CS 740 F’00
S’99
Alpha AXP 21064 TLB
•
•
•
•
•
– 25 –
page size:
hit time:
miss penalty:
TLB size:
placement:
8KB
1 clock
20 clocks
ITLB 8 PTEs, DTLB 32 PTEs
Fully associative
CS 740 F’00
S’99
TLB-Process Interactions
TLB Translates Virtual Addresses
• But virtual address space changes each time have context switch
Could Flush TLB
• Every time perform context switch
• Refill for new process by series of TLB misses
• ~100 clock cycles each
Could Include Process ID Tag with TLB Entry
• Identifies which address space being accessed
• OK even when sharing physical pages
– 26 –
CS 740 F’00
S’99
Virtually-Indexed Cache
VA
TLB
Lookup
Index
Tag
CPU
Data
PA
=
Hit
Cache
Cache Index Determined from Virtual Address
• Can begin cache and TLB index at same time
Cache Physically Addressed
• Cache tag indicates physical address
• Compare with TLB result to see if match
– Only then is it considered a hit
– 27 –
CS 740 F’00
S’99
Generating Index from Virtual Address
31
12 11
virtual page number
29
0
page offset
12 11
physical page number
0
page offset
Index
Size cache so that index is determined by page offset
• Can increase associativity to allow larger cache
• E.g., early PowerPC’s had 32KB cache
– 8-way associative, 4KB page size
Page Coloring
Index
• Make sure lower k bits of VPN match those of PPN
• Page replacement becomes set associative
• Number of sets = 2k
– 28 –
CS 740 F’00
S’99
Alpha Physical Addresses
Model
• 21064
• 21164
• 21264
Bits
Max. Size
34
40
44
16GB
1TB
16TB
Why a 1TB (or More) Address Space?
• At $1.00 / MB, would cost $1 million for 1 TB
• Would require 131,072 memory chips, each with 256 Megabits
• Current uniprocessor models limited to 2 GB
– 29 –
CS 740 F’00
S’99
Massively-Parallel Machines
Example: Cray T3E
• Up to 2048 Alpha 21164 processors
• Up to 2 GB memory / processor
M
• 8 TB physical address space!
Logical Structure
P
Interconnection
Network
M
M
P
P
M
•••
P
• Many processors sharing large global address space
• Any processor can reference any physical address
• VM system manages allocation, sharing, and protection among
processors
Physical Structure
• Memory distributed over many processor modules
• Messages routed over interconnection network to perform remote
reads & writes
– 30 –
CS 740 F’00
S’99
Alpha Virtual Addresses
Page Size
• Currently 8KB
Page Tables
• Each table fits in single page
• Page Table Entry 8 bytes
– 4 bytes: physical page number
– Other bytes: for valid bit, access information, etc.
• 8K page can have 1024 PTEs
Alpha Virtual Address
• Based on 3-level paging structure
level 1
level 2
level 3
page offset
10
10
10
13
• Each level indexes into page table
• Allows 43-bit virtual address when have 8KB page size
– 31 –
CS 740 F’00
S’99
Alpha Page Table Structure
Level 2
Page Tables
Level 1
Page Table
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Physical
Pages
Level 3
Page Tables
Tree Structure
• Node degree  1024
• Depth = 3
Nice Features
• No need to enforce contiguous
page layout
• Dynamically grow tree as
memory needs increase
– 32 –
•
•
•
•
•
•
CS 740 F’00
S’99
Mapping an Alpha 21064 Virtual Address
10 bits
13 bits
PTE size:
8 Bytes
PT size:
1024 PTEs
13 bits
21 bits
– 33 –
CS 740 F’00
S’99
Virtual Address Ranges
Binary Address
Segment
Purpose
1…1 11 xxxx…xxx seg1
Kernel accessible virtual addresses
– Information maintained by OS but not to be accessed by user
1…1 10 xxxx…xxx kseg
Kernel accessible physical addresses
– No address translation performed
– Used by OS to indicate physical addresses
0…0 0x xxxx…xxx seg0
User accessible virtual addresses
– Only part accessible by user program
Address Patterns
• Must have high order bits all 0’s or all 1’s
– Currently 64–43 = 21 wasted bits in each virtual address
• Prevents programmers from sticking in extra information
– Could lead to problems when want to expand virtual address space
in future
– 34 –
CS 740 F’00
S’99
Alpha Seg0 Memory Layout
3FF FFFF FFFF
3FF 8000 0000
Reserved
(shared libraries)
Not yet allocated
Dynamic Data
001 4000 0000
Static Data
Not used
001 2000 0000
$sp
Text (Code)
Stack
Not yet allocated
000 0001 0000
Reserved
– 35 –
Regions
• Data
– Static space for global variables
» Allocation determined at compile
time
» Access via $gp
– Dynamic space for runtime
allocation
» E.g., using malloc
• Text
– Stores machine code for program
• Stack
– Implements runtime stack
– Access via $sp
• Reserved
– Used by operating system
» shared libraries, process info,
CS 740 F’00
S’99
etc.
Alpha Seg0 Memory Allocation
Address Range
• User code can access memory
locations in range
0x0000000000010000 to
0x000003FFFFFFFFFF
• Nearly 242  4.3980465 X1012 byte
range
• In practice, programs access far
fewer
Shared
Libraries
(Read Only)
Gap
break
Dynamic Memory Allocation
• Virtual memory system only allocates
blocks of memory as needed
• As stack reaches lower addresses,
add to lower allocation
• As break moves toward higher
Current $sp
addresses, add to upper allocation
Minimum $sp
– Due to calls to malloc, calloc, etc.
– 36 –
Dynamic Data
Static Data
Gap
Text (Code)
Stack
Region
CS 740 F’00
S’99
Minimal Page Table Configuration
User-Accessible Pages
• VP4: Shared Library
– Read only to prevent undesirable
interprocess interactions
– Near top of Seg0 address space
• VP3: Data
– Both static & dynamic
– Grows upward from virtual
address 0x140000000
• VP2: Text
– Read only to prevent corrupting
code
• VP1: Stack
– Grows downward from virtual
address 0x120000000
0000 03FF 8000 1FFF
VP4
0000 03FF 8000 0000
0000 0001 4000 1FFF
VP3
0000 0001 4000 0000
0000 0001 2000 1FFF
VP2
0000 0001 2000 0000
0000 0001 1FFF FFFF
VP1
0000 0001 1FFF E000
– 37 –
CS 740 F’00
S’99
Partitioning Addresses
Address 0x001 2000 0000
0000 0000 0001 0010 0000 0000 0000 0000 0000 0000 0000
0000000000 100100000 0000000000 0000000000000
• Level 1: 0
Level 2: 576
Level 3: 0
Address 0x001 4000 0000
0000 0000 0001 0100 0000 0000 0000 0000 0000 0000 0000
0000000000 101000000 0000000000 0000000000000
• Level 1: 0
Level 2: 640
Level 3: 0
Address 0x3FF 8000 0000
0011 1111 1111 1000 0000 0000 0000 0000 0000 0000 0000
0111111111 110000000 0000000000 0000000000000
• Level 1: 511
– 38 –
Level 2: 768
Level 3: 0
CS 740 F’00
S’99
Mapping Minimal Configuration
0000 03FF 8000 1FFF
VP4
768
0000 03FF 8000 0000
0
0000 0001 4000 1FFF
VP3
0
511
0
640
576
575
0000 0001 4000 0000
0000 0001 2000 1FFF
0
VP2
1023
0000 0001 2000 0000
0000 0001 1FFF FFFF
VP1
0000 0001 1FFF E000
– 39 –
CS 740 F’00
S’99
Increasing Heap Allocation
Without More Page Tables
0000 0001 407F FFFF
• Could allocate 1023 additional
pages
• Would give ~8MB heap space
Adding Page Tables
•
•
•
• Must add new page table with
each additional 8MB increment
Maxiumum Allocation
• Our Alphas limit user to 1GB
data segment
• Limit stack to 32MB 1023
1
0
•
•
•
0000 0001 4000 2000
0000 0001 4000 1FFF
VP3
0000 0001 4000 0000
– 40 –
CS 740 F’00
S’99
Expanding Alpha Address Space
Increase Page Size
• Increasing page size 2X increases virtual address space 16X
– 1 bit page offset, 1 bit for each level index
level 1
level 2
10+k
10+k
level 3
10+k
page offset
13+k
Physical Memory Limits
• Cannot be larger than kseg
VA bits –2 ≥ PA bits
• Cannot be larger than 32 + page offset bits
– Since PTE only has 32 bits for PPN
Configurations
• Page Size
• VA Size
• PA Size
– 41 –
8K
43
41
16K
47
45
32K
51
47
64K
55
48
CS 740 F’00
S’99
Main Theme
Programmer’s View
• Large “flat” address space
– Can allocate large blocks of contiguous addresses
• Process “owns” machine
– Has private address space
– Unaffected by behavior of other processes
System View
• User virtual address space created by mapping to set of pages
– Need not be contiguous
– Allocated dynamically
– Enforce protection during address translation
• OS manages many processes simultaneously
– Continually switching among processes
– Especially when one must wait for resource
» E.g., disk I/O to handle page fault
– 42 –
CS 740 F’00
S’99