Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 29 Annotated
29 -
Outline
Recap
Page Table
Page Faults
Fragmentation
Memory Sharing
Improving Paging
Translation Lookaside Buffer (TLB)
Announcements
Reading:
Memory Sharing
Fragmentation
Paging Improvements
Divide virtual memory into fixed-size pages that
are loaded into same-sized frames in physical RAM.
Page table is kept in physical memory, maintained
by kernel:
Paging solves external fragmentation.
Paging allows process memory to be split up non-
contiguously and used on an as-needed basis.
Internal fragmentation can still occur within pages
if process does not use the allocated pages
efficiently.
Kernel can enable memory sharing between
processes by mapping pages to the same frame.
Shared libraries don't need to be duplicated in
RAM for each process.
What happens on fork() ?
32-bit virtual address space.
4kB page.
4B page table entry.
How large is the page table for a process?
How much memory needed for 100 processes?
space wasted between processes
space wasted within a page
Each page table entry typically contain:
MMU keeps a pointer to the page table in memory
so it can look up the entry during translation
Exact fields and layout depend on OS and MMU
A page may not be loaded if not needed.
A page fault occurs when the process attempts to
access a page that is invalid.
On page fault, the requested page needs to be
loaded into RAM.
Process attempts to access memory location
MMU raises a page fault and traps to OS if
page table entry is invalid (valid bit == 0)
OS checks if the page exists in disk
Kernel copies page from disk to a free frame
in memory (page replacement)
Kernel updates page table entry with new
frame number and sets valid bit
Kernel sets process PC to same read/write
instruction to re-execute it next time it is
scheduled.
page doesn't exist => segfault, kill process
Page Table
Page Faults
1)
3)
4)
5)
2)
MOS 3.3 - 3.7
PA 5 released
Quiz Friday
Virtual Memory
0xdeadb
...
...
frame number
0xb
frame 0xb
frame #
...
...
0xeef
offset
page table
physical
memory
virtual address
physical address
0xbeef
-
-
-
one entry per page
frame number
(obviously)
whether page has been written to
whether page has been accessed
read/write/execute protections
whether page is currently loaded
dirty bit
referenced bit
protection bits
valid bit
one page table per process
kernel updates pointer on context switch
valid (present/absent)
protection bits
referenced (modified)
dirty
Example entry layout:
process
OS
disk
...
...
free frame
...
...
page table
main memory
i
(1)
(6)
(2)
(3)
(4)
(5)
(1)
(2)
(3)
(4)
(5)
(6)
process 5
process 5
process 5
process 5
process 4
process 6
process 4
process 6
OS
OS
External =
Internal =
instead of
-
e.g.
fragmentation of heap by malloc
malloc needs 1 word, but gets a whole page
splits always occur on page boundaries, so
there are no gaps that cannot be used
Exercise
PollEv
-
-
>
>
>
>
>
>
-
recall
kernel copies page table to child as well
faster than full copy + memory efficient
if parent or child writes to a page, copy the
page to a new frame and update that
every page needs an entry in the page table
page table lookup adds additional memory
access
grows exponentially with address bits
preserves parent/child isolation
kernel configures MMU to trigger copy-on-write
and
for IPC
shm_open
mmap
stack
...
...
...
0x1c
0x1c
...
stack
heap
heap
data
data
text
text
libc
libc
...
libc
...
main memory
frame
0x1c
P1
P2
P1
page table
P2
page table
2 performance concerns with naive implementation:
Solution: dedicated cache for the page table
TLB is a dedicated hardware cache for page table
entries.
We will discuss access performance more next time.
Like caches, "hit" is fast, but "miss" is slow.
-
-
-
-
-
-
page table size
address translation
only accessible to MMU
works because of temporal and spatial locality
TLB is associative memory, so lookup occurs in
parallel and is quite fast
on miss, MMU must load entry from page table
0xdeadb
...
...
0xb
frame 0xb
f
...
...
0xeef
o
page table
TLB
physical
memory
virtual address
physical address
0xbeef