W4118 Operating Systems

Instructor: Junfeng Yang

 Background: memory hierarchy

Levels of memory in computer system

size
speed
< 1 cycle
registers cost
a few cycles
cache

memory <100 ns

disk a few ms

1
 Virtual memory motivation

Previous approach to memory management

Must completely load user process in memory

One large AS or too many AS
out of memory

Observation: locality of reference

Temporal: access memory location accessed just now

Spatial: access memory location adjacent to locations
accessed just now

Implication: process only needs a small part of address

space at any moment!

2
 Virtual memory idea

OS and hardware produce illusion of a disk as

fast as main memory

Process runs when not all pages are loaded in

memory
 Only keep referenced pages in main memory
 Keep unreferenced pages on slower, cheaper backing
store (disk)
 Bring pages from disk to memory when necessary

3
Virtual memory illustration

4
 Virtual memory operations

Detect reference to page on disk

Recognize disk location of page

Choose free physical page

 OS decision: if no free page is available, must
replace a physical page

Bring page from disk into memory

 OS decision: when to bring page into memory?

Above steps need hardware and software

cooperation

5
 Detect reference to page on disk and
recognize disk location of page

Overload the valid bit of page table entries

If a page is on disk, clear valid bit in

corresponding page table entry and store disk
location using remaining bits

Page fault: if bit is cleared then referencing

resulting in a trap into OS

In OS page fault handler, check page table

entry to detect if page fault is caused by
reference to true invalid page or page on disk

6
Steps in handling a page fault

7
 OS decisions

Page selection
 When to bring pages from disk to memory?

Page replacement
 When no free pages available, must select victim
page in memory and throw it out to disk

8
 Page selection algorithms

Demand paging: load page on page fault

Start up process with no pages loaded

Wait until a page absolutely must be in memory

Request paging: user specifies which pages are

needed

Requires users to manage memory by hand

Users do not always know best

OS trusts users (e.g., one user can use up all memory)

Prepaging: load page before it is referenced

When one page is referenced, bring in next one

Do not work well for all workloads
• Difficult to predict future

9
 Page replacement algorithms

Optimal: throw out page that won’t be used for
longest time in future

Random: throw out a random page

FIFO: throw out page that was loaded in first

LRU: throw out page that hasn’t been used in

longest time

10
Evaluating page replacement algorithms

Goal: fewest number of page faults

A method: run algorithm on a particular string

of memory references (reference string) and
computing the number of page faults on that
string

In all our examples, the reference string is

1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

11
 Optimal algorithm

Throw out page that won’t be used for longest
time in future

1 2 3 4 1 2 5 1 2 3 4 5
1 1 1 1 1 1 1 1 1 1 4 4
2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 5 5 5 5 5 5

6 page faults

Problem: difficult to predict future!

12
Fist-In-First-Out (FIFO) algorithm

Throw out page that was loaded in first

1 2 3 4 1 2 5 1 2 3 4 5
1 1 1 1 1 1 5 5 5 5 4 4
2 2 2 2 2 2 1 1 1 1 5
3 3 3 3 3 3 2 2 2 2
4 4 4 4 4 4 3 3 3

10 page faults

Problem: ignores access patterns

13
Fist-In-First-Out (FIFO) algorithm
(cont.)

Results with 3 physical pages

1 2 3 4 1 2 5 1 2 3 4 5
1 1 1 4 4 4 5 5 5 5 5 5
2 2 2 1 1 1 1 1 3 3 3
3 3 3 2 2 2 2 2 4 4

9 page faults

Problem: fewer physical pages
fewer faults!

belady anomaly
14
Ideal curve of # of page faults v.s. # of
physical pages

15
FIFO illustrating belady’s anomaly

16
Least-Recently-Used (LRU) algorithm

Throw out page that hasn’t been used in

longest time. Can use FIFO to break ties
1 2 3 4 1 2 5 1 2 3 4 5
1 1 1 1 1 1 1 1 1 1 1 5
2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 5 5 5 5 4 4
4 4 4 4 4 4 3 3 3

8 page faults

Advantage: with locality, LRU approximates Optimal

17
 Implementing LRU: hardware

A counter for each page

Every time page is referenced, save system

clock into the counter of the page

Page replacement: scan through pages to find

the one with the oldest clock

Problem: have to search all pages/counters!

18
 Implementing LRU: software

A doubly linked list of pages

Every time page is referenced, move it to the

front of the list

Page replacement: remove the page from back

of list
 Avoid scanning of all pages

Problem: too expensive

 Requires 6 pointer updates for each page reference
 High contention on multiprocessor

19
 LRU: concept vs. reality

LRU is considered to be a reasonably good
algorithm

Problem is in implementing it efficiently

Hardware implementation: counter per page, copied per
memory reference, have to search pages on page
replacement to find oldest

Software implementation: no search, but pointer swap on
each memory reference, high contention

In practice, settle for efficient approximate LRU

Find an old page, but not necessarily the oldest

LRU is approximation anyway, so approximate more

20
 Clock (second-chance) algorithm

Goal: remove a page that has not been

referenced recently
 good LRU-approximate algorithm

Idea
 A reference bit per page
 Memory reference: hardware sets bit to 1
 Page replacement: OS finds a page with reference
bit cleared
 OS traverses all pages, clearing bits over time

 Combining FIFO with LRU: give the page FIFO

selects to replace a second chance
21
 Clock algorithm implementation

OS circulates through pages, clearing
reference bits and finding a page with
reference bit set to 0

Keep pages in a circular list = clock

Pointer to next victim = clock hand

22
A single step in Clock algorithm

23
 Clock algorithm example

1 2 3 4 1 2 5 1 2 3 4 5
1 1 1 1 1 1 1 1 1 1 1 1 5 1 5 1 5 1 5 1 4 1 4 1
2 1 2 1 2 1 2 1 2 1 2 0 1 1 1 1 1 1 1 0 5 1
3 1 3 1 3 1 3 1 3 0 3 0 2 1 2 1 2 0 2 0
4 1 4 1 4 1 4 0 4 0 4 0 3 1 3 0 3 0

10 page faults

Advantage: simple to implemet!

24
 Clock algorithm extension

Problem of clock algorithm: does not

differentiate dirty v.s. clean pages

Dirty page: pages that have been modified and

need to be written back to disk
 More expensive to replace dirty pages than clean
pages
 One extra disk write (5 ms)

25
 Clock algorithm extension (cont.)

Use dirty bit to give preference to dirty pages

On page reference

Read: hardware sets reference bit

Write: hardware sets dirty bit

Page replacement

reference = 0, dirty = 0  victim page

reference = 0, dirty = 1  skip (don’t change)

reference = 1, dirty = 0  reference = 0, dirty = 0

reference = 1, dirty = 1  reference = 0, dirty = 1

advance hand, repeat

If no victim page found, run swap daemon to flush
unreferenced dirty pages to the disk, repeat

26
Summary of page replacement algorithms

 Optimal: throw out page that won’t be used for longest time
in future

Best algorithm if we can predict future

Good for comparison, but not practical
 Random: throw out a random page

Easy to implement

Works surprisingly well. Why? Avoid worst case

Random
 FIFO: throw out page that was loaded in first

Easy to implement

Fair: all pages receive equal residency

Ignore access pattern
 LRU: throw out page that hasn’t been used in longest time

Past predicts future

With locality: approximates Optimal

Simple approximate LRU algorithms exist (Clock)

27
Current trends in memory management

Less critical now

Personal computer v.s. time-sharing machines

Memory is cheap
Larger physical memory

Virtual to physical translation is still useful

“All problems in computer science can be solved using
another level of indirection” David Wheeler

Larger page sizes (even multiple page sizes)

Better TLB coverage

Smaller page tables, less page to manage

Internal fragmentation

Larger virtual address space

64-bit address space

Sparse address spaces

File I/O using the virtual memory system

Memory mapped I/O: mmap()

28