operating systems - virtual memory

UNIVERSITY OF MASSACHUSETTS AMHERST • Department of Computer Science

Emery Berger

University of Massachusetts Amherst

Operating SystemsCMPSCI 377

Virtual Memory


Virtual Memory

Virtual, not physical memory

Divided into pages

Page tables, TLB

Provides isolation, protection, optimization

Managed using eviction policies

2

UNIVERSITY OF MASSACHUSETTS AMHERST • Department of Computer Science 3

Demand-Paged Virtual Memory

Key idea: use RAM as cache for disk

OS transparently moves pages

Requires locality:

Working set (memory referenced recently)must fit in RAM

If not: thrashing (nothing but disk traffic)


Virtual Memory Pages

Memory divided into fixed-sized pages (e.g., 4K, 8K)

Allocates pages to framesin memory

OS manages pages

Moves, removes, reallocates

Copied to and from disk

A


Demand-Paging Diagram


Paging + Locality

Most programs obey 90/10 “rule”

90% of time spent accessing 10% of memory

Exploit this rule:

Only keep “live” parts of process in memory

A

B

AB


Virtual Memory

Processes use virtual addresses

Addresses start at 0

OS lays process down on pages

MMU (memory-management unit):

Hardware support for paging

Translates virtual to physical addresses

Uses page table to keep track of frame assigned to memory page


Mapping Virtual to Physical

8


Address Translation

Powers of 2:

Virtual address space: size 2m

Page size 2n

High-order m-n bits of virtual address select page

Low order n bits select offset in page


Paging Hardware: Diagram


Translation Lookaside Buffer (TLB)

TLB: fast, fully associative memory

Caches page table entries

Stores page numbers (key) and frame (value) in which they are stored

Assumption: locality of reference

Locality in memory accesses =locality in address translation

TLB sizes: 8 to 2048 entries

Powers of 2 simplifies translationof virtual to physical addresses


TLB Action

12


TLB: Diagram

v = valid bit: entry is up-to-date


Cost of Using TLB

Measure in terms of memory access cost

What is cost if: Page table is in memory?

Page table managed with TLB?

Large TLB: Improves hit ratio

Decreases average memory cost


Sharing

Paging allows sharing of memory across processes Different virtual addresses,

point to same physical address

Shared stuff includes code, data Compiler marks “text” segment (i.e., code) of

applications (e.g., emacs) - read-only

OS: keeps track of such segments Reuses if another instance of app arrives

Copy-on-write

Can greatly reduce memory requirements


Key Policy Decisions

Two key questions: (for any cache):

When do we read page from disk?

When do we write page to disk?


Reading Pages

Read on-demand: OS loads page on its first reference

May force an eviction of page in RAM

Pause while loading page = page fault

Can also perform pre-paging: OS guesses which page will next be needed,

and begins loading it

Most systems just do demand paging


Demand Paging

On every reference, check if page is in memory (valid bit in page table)

If not: trap to OS

OS checks address validity, and

Selects victim page to be replaced

Invalidates old page

Begins loading new page from disk

Switches to other process(paging = implicit I/O)

Note: must restart instruction later


Swap Space

Swap space = where victim pages go

Partition or special file reserved on disk

Sometimes: special filesystem (“tmpfs”)

What kind of victim pages can be evicted without going to swap?

Size of reserved swap space limits what?


Swap Space




What kind of victim pages can be evicted without going to swap?

Read-only (“text”), untouched anonymous pages

Size of reserved swap space limits what?


Swap Space




Only read-only or undirtied victim pages can be evicted without going to swap

“text” (code), untouched anonymous pages

Size of reserved swap space limitstotal virtual memory


Cost of Paging

Worst-case analysis – useless

Easy to construct adversary example:every page requires page fault

A, B, C, D, E, F, G, H, I, J, A...

size of available memory


Page Replacement Algorithms

MIN, OPT (optimal)

RANDOM

evict random page

FIFO (first-in, first-out)

give every page equal residency

LRU (least-recently used)

MRU (most-recently used)


MIN/OPT

Invented by Belady (“MIN”)

Now known as “OPT”: optimal page replacement

Evict page to be accessed furthest in the future

Provably optimal policy

Just one small problem...requires predicting the future

Still useful point of comparison


MIN/OPT example

Page faults: 5


RANDOM

Evict any page

Works surprisingly well – why?

Theoretically: very good,but not used in practice:takes no advantage of locality


LRU

Evict page that has not been used in longest time (least-recently used)

Approximation of MIN if recent past is good predictor of future

Variant of LRU used in all real operating systems


LRU example

Page faults: ?


LRU example

Page faults: 5


LRU, example II

Page faults: ?


LRU, example II

Page faults: 12!


FIFO

First-in, first-out: evict oldest page Also has competitive ratio k

But: performs miserably in practice! LRU takes advantage of locality

FIFO does not

Suffers from Belady’s anomaly: More memory can mean more paging!

LRU & other “stack” algs. do not


FIFO & Belady’s Anomaly


MRU

Evict most-recently used page

Shines for LRU’s worst-case: loop that exceeds RAM size

What we really want: adaptive algorithms(e.g., EELRU – Kaplan & Smaragdakis)

A, B, C, D, A, B, C, D, ...

size of available memory


The End

35


LRU: No Belady’s Anomaly

Why no anomaly for LRU?

operating systems - virtual memory

Technology