Operating Systems{week 15}

Rensselaer Polytechnic InstituteCSC 432 – Operating SystemsDavid Goldschmidt, Ph.D.

Noncontiguous allocation (i)

A noncontiguous memory allocation scheme avoids the external fragmentation problem Slice up physical memory into

fixed-sized blocks called frames ▪ Sizes typically range from 216 and up!

Slice up logical memory intofixed-sized blocks called pages

Allocate pages into frames▪ Note that frame size equals page size

Noncontiguous allocation (ii)

When a process of size n pages is ready to run, operating system finds n free frames

The OS keepstrack of pagesvia a page table

main memory

process Pi

== in use

== free

Paging via a page table

Page tables map logical memoryaddresses to physical memoryaddresses

Address translation

Covers a logical addressspace of size 2m withpage size 2n

page numberpage offset

p d(m – n)

(n)

Address translation

Translation look-aside buffer

Use page tablecaching at thehardware levelto speed addresstranslation

Hardware-leveltranslation look-aside buffer(TLB)

Segmentation (i)

Segmentation is a memory-management scheme that correspondsto logical segments of auser program A segment resides in a

contiguous block of memory Segments are numbered

and referred to by a<segment-number, offset> pair

Segmentation (ii)

Logical segments map to physical memory

0

3

4

21

0

1

2

3

4

Segment table (i)

A segment table maps a <segment-number, offset> pair to a physical address

Each table entry has: A segment base containing

the starting physical address where the segment resides

A segment limit specifyingthe length of the segment

Segment table (ii)

Segment table (iii)

Virtual memory (i)

Only part of a process needs to be loaded into memory for it to start its execution Virtual memory further separates logical

memory and physical memory Logical (or virtual) address space can be

larger than physical address space Allows physical address space to be shared

by several processes Enables quicker process creation

Virtual memory (ii)

Unused pages are stored on disk

Shared libraries

Multiple processes can share common libraries or data by mapping virtual pages to shared physicalpages More efficient

use of physicalmemory space

Demand paging

When a page of memory is requested, if it’s not in physical memory,load page from disk i.e. on demand Less I/O required Less physical memory Faster user response

times (usually) More user processes

Virtual memory policies

Virtual memory policies include: The fetch policy governs when a page

should be loaded into memory The placement policy specifies where a

page is loaded into physical memory The replacement policy determines

whichexisting page in memory should be replaced

Page-to-process allocation Page allocation:

In a static allocation scheme,the number of frames per process is fixed

In a dynamic allocation scheme,the number of frames per process varies

In an equal allocation scheme, all processeshave an equal number of frames

In a proportional allocation scheme, processesare allocated frames in proportion to size, priority, etc.

Virtual memory page table

Associate a valid/invalid bit witheach page table entry Initially set all entries to i During address translation,

if valid/invalid bit is v, pageis already in memory

Otherwise, if bit is i,a page fault occurs

vvvvi

ii

….

frame # valid/invalid bit

page table

Page faults (i)

Page faults are trapped by the OS: When an invalid reference occurs in the page

table When a page is not yet in the page table

Page fault recovery: Get free frame from physical memory Swap desired page into free frame Reset page table entry Set validation bit to v Restart instruction that caused the page fault

Page faults (ii)

Page faultsare costly!

Page faults (iii)

Demand paging performance (i) The page fault rate p is in the range [0.0,

1.0]: If p is 0.0, no page faults occur If p is 1.0, every page request is a page fault Typically p is very low....

The effective memory-access time is (1 – p) x physical-memory-access +

p x ( page-fault-overhead + swap-page-out + swap-page-in + restart-overhead )

Demand paging performance (ii)

Given: Memory access time is 200 nanoseconds Average page-fault service time is 8

milliseconds

The effective memory access time is (1 – p) x 200ns + p x 8ms = 200ns – 200ns p + p x 8,000,000ns

= 200ns + 7,999,800 p

Thrashing (i)

If a process does not have enough pages, the page-fault rate is high, leading to thrashing Process is busy swapping pages

in and out of memory Low CPU utilization Operating system might think

it needs to increase the degreeof multiprogramming!▪ More processes added, further degrading

performance

Thrashing (ii)

Remember the Principle of Locality

Principle of locality (i)

Future memory references in a given process will likely be local to previous memory references This phenomenon is called

the principle of locality A process executes in

a series of phases, spendinga finite amount of time performingmemory references in each phase

Principle of locality (ii)

Example graph of page faults versus total number of allocated frames

Principle of locality (iii)

Operating system should allocate enough frames for the current locality of a process: What happens when too few

frames are allocated?

What happens whentoo many frames are allocated?

Principle of locality (iv)

Example of asingle process:

Principle of locality (v)

Dynamic page fault frequency scheme

Page replacement

How do weidentify the victim?

Page replacement algorithms

Page replacement algorithms include: First-in-first-out (FIFO) Optimal (OPT) Least recently used (LRU) Least frequently used (LFU) Page fault frequency scheme

(introduced earlier) Working set

apply these algorithms to apage reference stream

First-in-first-out (FIFO) algorithm

The above is a 3-frame memory How many page faults occur if we use

a 4-frame memory instead?

Belady’s anomaly (i)

Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 How many page faults occur with a 3-

frame memory?

How many page faults occur with a 4-frame memory?

Belady’s anomaly (ii)

Belady’s Anomaly: More frames may lead to more page

faults!

Optimal (OPT) algorithm

Replace pages that will not be used forthe longest amount of timeFIFO:

OPT:

Least recently used (LRU) algorithm

Replace pages that have not been used forthe longest amount of time

Least frequently used (LFU) algorithm

Similar to LRU, but replaceleast frequently used pages Requires usage counts Initial page replacements are

swapped out quickly becausetheir usage counts are 1

Working set algorithm

For each process, maintain a working set of pages referenced by the process during the most recent w page references

How do we choose w?

Total demand of frames

Let d be the sum of the sizes of the working sets of all active processes

Let F be the total number of frames If d < F, then the operating system can

allow additional processes to enter the system

If d > F, then the operating system must suspend one or more active processes▪ Otherwise thrashing will occur!

Windows XP example (i)

Windows XP uses demand paging with clustering (which loads pages surrounding the page fault) Processes are assigned a working set

minimum and a working set maximum The working set minimum is the

minimum number of pages a process is guaranteed to have in physical memory

Likewise, a process may be assigned pages up to its working set maximum

Windows XP example (ii)

When the amount of free memory in the system falls below a threshold, automatic working set trimming is performed Increases the amount

of free memory Removes pages from

processes that have pagesin excess of their workingset minimum