17: Lecture Memory Management
David Lie
ECE344
University of Toronto
1
Overview
The TLB Miss Handler:
Page Fault Handler
Swap Handler
Managing the Swap Area
Paging issues and Performance
Putting it all together. VM and OS events:
Process Creation, Copy-on-Write
Process Termination
Context Switching
Memory mapped files and shared memory
Modern Paging hardware: Superpages
ECE344: Operating Systems
2
Putting it all together
What does virtual memory system do during key OS events?
Process Creation (fork)
Process Execution (execv)
Process Termination (exit)
Context switch
ECE344: Operating Systems
3
Putting it all together (fork)
Fork creates a new address space:
1. Copy Parents address space structure
All regions will have the same location, sizes and
permissions
2. Create a new page table
Page table is a copy of the parents page table
This means virtual pages in child address space map to
the same physical frames as parent
Is there a problem with this?
ECE344: Operating Systems
4
Copy-on-write
Problem:
If child/parent modifies a page, then the other will see the
modification since both are mapping the same physical
page. No isolation between child and parent.
Solution: copy-on-write (COW)
When copying an address space, mark all virtual mappings
in both page tables as read-only (even if region is writeable)
Pages that should be writeable but have been made
read-only are called COW pages.
When one process modifies a COW page, this will cause a
TLB fault with a read-only type.
ECE344: Operating Systems
5
TLB Faults on COW pages
When the TLB fault handler detects a fault on a COW page:
1. Allocate a new physical page
2. Copy the contents of the original page to the new page
3. Make page table entry in current address space point to
the new page
4. Remove current address space from reference of original
page in coremap and add current address space as
reference to the new page.
5. Make page table entry in current address space writeable
and write to TLB
6. Optional: Check the number of references on the original
page, if it is the last reference (only one), then make the
corresponding page table entry writeable as well.
Saves an extra fault later on.
ECE344: Operating Systems
6
Putting it all together (execv)
Process start (i.e. execv)
1. Destroy old address space structure
Includes traversing page table and freeing all page
frames mapped by the page table
Free all swap regions used by the process
Free space used by address space structure
2. Create new address space structure
Set size text and code regions according to executable
Set size of heap and stack according to defaults
Initialize a new page table with all invalid entries
ECE344: Operating Systems
7
Putting it all together (exit, context switch)
Process Termination (exit, process crash):
Destroy old address space. The same as destroying old
address space in execv.
Context switch:
Have to change the currently active page table
Hardware managed TLB(x86): Change the hardware register
that points to current page table. This automatically causes
a TLB flush.
Software manage TLB(os161):
Change current address space and page table
Flush TLB
ECE344: Operating Systems
8
System Calls for Sharing Memory
mmap(), munmap() system calls allow process to control
memory mappings
Allows accessing a file using a memory interface
Threads read and write files using load/store rather than
read/write!
These files are called memory-mapped files
ECE344: Operating Systems
9
Memory-Mapped Files
OS maps file contiguously within address space
Say, virtual address file_base stores start of file
Then, file_base + N refers to offset N in file
loading Allows file data in memory on demand (demand paging)
OS reads a page frame from file when invalid (but mapped)
page is accessed
OS writes a page frame to file when dirty page is evicted
Essentially, file is used for backing store instead of swap
area
When threads map the same file, they can share file data via
memory
ECE344: Operating Systems
10
Example of Memory-Mapped File
Any part of the file can be mapped
Page 2^20 - 1
Stack
Mapped
file
Heap
Data
Page 1
Page 0
ECE344: Operating Systems
Text
Virtual address space
11
Page Sharing
Two (or more) processes can share memory by mapping a page
to the same frame in their page tables
Implemented using the mmap system call
Typical mmap arguments:
Address of mapped region
Size of mapped region
Protection flags (writeable, readable, executable)
File Descriptor
Two processes share memory by mapping the same file into
their address spaces:
The same physical frames are used to back the virtual pages
in both processes
ECE344: Operating Systems
12
Page Sharing
Physical memory
Stack (rw)
Thread 1
address
space
Thread 1
page table
Data (rw)
Text (rx)
Shared
text
pages
Thread 2
address
space
Thread 2
page table
ECE344: Operating Systems
13
Motivation for Page Sharing
Typically, programs run in their own address space because it
provides protection
However, sometimes programs need to share memory
Web server parent and children threads may wish to only a
few pages (i.e. communication buffer)
Sharing entire address space provides no protection
No sharing requires copying data through disk, i.e., slow
communication
If more than one instance of a program is running, then the
text (code) segments can be shared:
Code segments are read-only anyways so its safe to
map the same physical frame into multiple address
spaces.
ECE344: Operating Systems
14
Page Sharing
Page table entries can have different protection
E.g., one process has read, another write enabled, allows
certain types of broadcast communication
Shared memory can be mapped at same or different virtual
address in each address space
Must update all page table entries when frame is evicted
Use coremap to find all mappings
ECE344: Operating Systems
15
Shared Libraries
Shared libraries are another form of page sharing:
Libraries are loaded via a the mmap system call
Multiple processes all map the library into their address space:
Library is only loaded once into memory, but shared among
many unrelated processes -- saves physical memory.
Example: many programs use libc (common functions like
printf, system calls, etc)
Libc is only loaded at one physical location
Can be mapped into any location various processes
ECE344: Operating Systems
16
Modern OS and Hardware
Modern computer systems have much larger memories
available to them:
Not unreasonable to have 8-16GB in a desktop PC
Application use 64-bit address spaces to take advantage of
larger memory. Memory usage is higher.
Memory pressure puts more pressure on TLB use
Applications that use more memory use more TLB entries
TLB misses can become a performance bottleneck
Higher overhead due to page table size:
Program that allocates 1MB of memory needs 25 page table
entries
ECE344: Operating Systems
17
Superpages
Modern processors support several pages sizes to
accommodate programs that use more memory:
OS can configure processor to use larger pages, known as
superpages
Larger pages can waste memory due to internal
fragmentation so this the optimal choice is application
dependent.
Example:
x86 processors support standard 4KB pages as well as
2MB, 4MB and 1GB pages under various configurations
ECE344: Operating Systems
18