Lab4: Virtual Memory
CS 3410 : Computer System
Organization & Programming
Spring 2015
Why do we need Virtual Memory?
• We want to run multiple processes at the
same time!
• Even if we have multiple CPUs, addresses used
by multiple processes will conflict!
• Even if they do not conflict, they may not fit in
memory together!
Solution: Use a Mapping!
Map a Virtual Address (generated by CPU)
to a Physical Address (in memory)!
How does Virtual Memory work?
• How do we create the “map” that maps a
virtual address generated by the CPU to a
physical address used by main memory?
How does Virtual Memory work?
• Each process has its own virtual address space
– A process is a program being executed
– Programmer can code as if they own all of memory
• On-the-fly at runtime, for each memory access
– all accesses are indirect through a virtual address
– translate fake virtual address to a real physical address
– redirect load/store to the physical address
• Addresses are mapped in chunks called Pages!
– 4KB – 16KB pages are typical.
MMU (Memory Management Unit)
• Responsible for translating on the fly
• Keeps a Page Table
• Essentially, just a big array of integers:
– paddr = PageTable[vaddr];
– Page tables are indexed by virtual page number!
Address Translation
• Page size: 4 kB = 212
CPU
generated
Main
Memory
Virtual page number
31
Lookup
in
page table
Physical page number
Page Offset
vaddr
12 11
0
Page offset
paddr
12 11
0
Page Table Size
• Where is the page table stored?
– In Memory!
– PTBR (Page Table Base Register) holds the base
address for the page table of the current process.
• How large is the page table?
page table size =
logical address space size
page size
× page table entry size
Page Table Size
• Page table size:
– Many processors have 32-bit logical addresses,
which results in a 4GB logical address space size.
The page table entries size is usually 4B. If the
page size is 4KB then the page table size is:
Page table size =
4 GB
4 kB
× 4B
= 4 MB
– 4 MB in memory just for the page table is a too
much!
Multi-level Page Tables
• Used to reduce page table size!
10 bits
31
10 bits
22 21
10 bits
12 11
2 vaddr
210
Word
PTEntry
PDEntry
PTBR
Page Directory
Page Table
Page
Virtual Memory with 3 Processes
Each process
has its own
page tables!
Page
Directory
1
Page
Table
1
Page
…
Page
…
Process 1
Page
Page
Directory
2
PTBR
Page
Table
1
Page
Page
…
Page
Table
2
Process 2
Page
Page
…
Page
CPU
Memory
Page
Directory
3
Page
Table
1
…
Page
Page
…
Process 3
…
Paging!
• How can we run processes larger than the
physical memory?
– The OS copies pages from disk to main memory as
they are needed!
– Memory is the cache of disk!
Page Table Performance
• Every load/store translated to physical
addresses.
• To write to virtual memory:
– Look up vaddr to paddr translation in page table.
– Then write to physical memory.
• Page Table Miss: Page fault
– load the page on disk and retry instruction
– kill program if the page really doesn’t exist
– tell the program it made a mistake
Paging is too slow!!
• Solution: Instead of looking up translations on
Page Tables, cache them:
• TLB (Translation Lookaside Buffer)
– A small, very fast cache of recent address
mappings
• TLB hit: avoids PageTable lookup
• TLB miss: do PageTable lookup, cache result for
later
Address Lookup Procedure
Lab4
• Modify the MIPS simulator to simulate virtual
memory!
– Including a shared memory system call with copyon-write semantics.
A quick reminder: C Operators
• Leftshift a variable A to the left by 5 bits and store it in A.
A = A << 5;
• Rightshift a variable A to the left by 5 bits and store it in A.
A = A >> 5;
• AND, OR, and XOR two variables and store them into a third
variable.
z = x & y;
z = x | y;
z = x ^ y;
• Change a variable into its negation.
z = ~z;
Two-level Page Table Structure
• The Context Register (c0r4) contains a pointer
to a 4096-byte page directory
– 4096 Bytes = 212 Bytes  We need 20 bits!
• Each of the 4-byte page directory entries
(PDEs) points to a 4096-byte page table.
– 4096/4 = 1024 entries  We need 10 bits!
• Each of the 4-byte page table entries (PTEs)
points to a 4096-byte page of data.
• 4096/4 = 1024 entries  We need 10 bits!
Two-level Page Table
10 bits
31
vaddr
10 bits
22 21
12 11
0
Word
PTEntry
PDEntry
c0r4
Page Directory
Page Table
Page
Create address space per process!
unsigned int create_address_space() {
return allocate_physical_page()<<12;
}
• allocate_physical_page() returns a 32-bit
physical page number for a free physical page
• We only need 20 bits to map into a page.
• Discard the left 12-bits and use the remaining 20 bits!
• Ex. If we had 1,000 things to refer to and ids from 0 to
10,000, we would only use the last 3 digits! Same logic.
Map page!
• Returns the physical page number for a given virtual address.
unsigned int map_page(
unsigned int context, /*page number for the PageDir*/
unsigned int vaddr, /* virtual address*/
int writable, /* zero for read-only, non-zero for writable */
int executable /* zero for no-execute, non-zero for executable */
);
•
Check where map_page is called:
– Context is CPR[0][4]: Context Register
– Upper 20 bits of CPR[0][4] is the page number for the PageDir
Get the indexes first!
• We have a 32-bit Virtual Address vaddr
• Get the index of the page directory entry and the
index of the page table entry
unsigned int pd_index = vaddr >> 22;
// We only need the left 10 bits!
unsigned int pt_index =(vaddr<<10)>> 22;
// We only need the second left 10 bits!
Two-level Page Table
10 bits
31
vaddr
10 bits
22 21
12 11
0
Word
PTEntry
PDEntry
c0r4
Page Directory
Page Table
Page
Get the PDE!
• Get the page directory entry!
unsigned int *directory = (unsigned
int*)dereference_physical_page(context >> 12);
// Page number for page dir is in c0r4 (context)
// We only need the left 20 bits: rest is reserved!
unsigned int pde = directory[pd_index];
// Get the page directory entry!
Is the PDE valid?
• NO? 
• Allocate a fresh page for the Page Table!
• Update the Page Directory!
if(!(pde & 1)){
unsigned int newptbl = allocate_physical_page();
pde = (newptbl << 12) | 1;
// We only care about the right 20 bits!
directory[pd_index] = pde;
}
Now we know that PDE valid!
• Get the page table entry!
unsigned int *page_table = (unsigned
int*)dereference_physical_page(pde >> 12);
// We need only the next 10 bits in pde!
unsigned int pte = page_table[pt_index];
// We have the Page Table Entry now!
Is the PTE valid?
• NO? 
• Allocate a fresh page!
if(!(pte & 1)){
unsigned int page = allocate_physical_page();
pte = (page << 12);
// We only care about the right 20 bits!
}
We are so close!
• Set the permissions, update the page table
entry!
page_table[pt_index]= pte | (executable << 2)|
(writable << 1) | 1;
// Should be executable for instruction fetch!
// Should be writable for writes!
// Bits can be found in mem.c 
And done!
• Return the Physical Address for this Page!
// Shift it back before returning!
return pte >> 12;
More?
• map_shared_page
– To support shared, copy-on-write virtual memory.
• pfault
– To support killing processes and shared, copy-onwrite virtual memory.