Operating Systems Principles Memory Management Lecture 8: Virtual Memory

1
Operating Systems PrinciplesMemory
ManagementLecture 8 Virtual Memory

• ??????

2
Content

• Principles of Virtual Memory
• Implementations of Virtual Memory
• Paging
• Segmentation
• Paging With Segmentation
• Paging of System Tables
• Translation Look-Aside Buffers
• Memory Allocation in Paged Systems
• Global Page Replacement Algorithms
• Local Page Replacement Algorithms
• Load Control and Thrashing
• Evaluation of Paging

3
Operating Systems PrinciplesMemory
ManagementLecture 8 Virtual Memory

• Principles of Virtual Memory

4
The Virtual Memory

• Virtual memory is a technique that allows
  processes that may not be entirely in the memory
  to execute by means of automatic storage
  allocation upon request.
• The term virtual memory refers to the abstraction
  of separating LOGICAL memory ? memory as seen by
  the process ? from PHYSICAL memory ? memory as
  seen by the processor.
• The programmer needs to be aware of only the
  logical memory space while the operating system
  maintains two or more levels of physical memory
  space.

5
Principles of Virtual Memory
00000000
00000000
00000000
3FFFFFF
Physical Memory
64M
FFFFFFFF
FFFFFFFF
Virtual Memory
Virtual Memory
4G
4G
6
Principles of Virtual Memory
00000000
00000000
00000000
Address Map
Address Map
3FFFFFF
Physical Memory
64M
FFFFFFFF
FFFFFFFF
Virtual Memory
Virtual Memory
4G
4G
7
Principles of Virtual Memory
00000000
00000000

• For each process, the system creates the illusion
  of large contiguousmemory space(s)
• Relevant portions ofVirtual Memory (VM)are
  loaded automatically and transparently
• Address Map translates Virtual Addresses to
  Physical Addresses

00000000
Address Map
Address Map
3FFFFFF
Physical Memory
64M
FFFFFFFF
FFFFFFFF
Virtual Memory
Virtual Memory
4G
4G
8
Approaches

• Single-segment Virtual Memory
• One area of 0n?1 words
• Divided into fix-size pages
• Multiple-Segment Virtual Memory
• Multiple areas of up to 0n?1 (words)
• Each holds a logical segment(e.g., function,
  data structure)
• Each is contiguous or divided into pages

. . .
. . .
. . .
. . .
9
Main Issues in VM Design

• Address mapping
• How to translate virtual addresses to physical
  addresses?
• Placement
• Where to place a portion of VM needed by process?
• Replacement
• Which portion of VM to remove when space is
  needed?
• Load control
• How many process could be activated at any one
  time?
• Sharing
• How can processes share portions of their VMs?

10
Operating Systems PrinciplesMemory
ManagementLecture 8 Virtual Memory

• Implementations of Virtual Memory

11
Implementations of VM

• Paging
• Segmentation
• Paging With Segmentation
• Paging of System Tables
• Translation Look-aside Buffers

12
Paged Virtual Memory
Page No.
Offset
0
0
Page size 2n
1
1
2
2
w
p
2n?1
(p, w)
Virtual Address
P?1
Virtual Memory
13
Physical Memory
The size of physical memory is usually much
smaller than the size of virtual memory.
Frame No.
Offset
0
0
Frame size 2n
1
1
2
2
w
f
2n?1
F?1
(f, w)
Physical Address
Physical Memory
14
Virtual Physical Addresses
The size of physical memory is usually much
smaller than the size of virtual memory.
Memory Size
Address
va
pa
15
Address Mapping
Given (p, w), how to determine f from p?
Address Map
16
Address Mapping
Each process (pid id) has its own virtual
memory.
Given (id, p, w), how to determine f from (id, p)?
Address Map
17
Frame Tables
Each process (pid id) has its own virtual
memory.
Given (id, p, w), how to determine f from (id, p)?
frame f ?1
frame f
f
ID
p
frame f 1
pid
page
Physical Memory
18
Address Translation via Frame Table
Each process (pid id) has its own virtual
memory.
Given (id, p, w), how to determine f from (id, p)?
address_map(id,p,w) pa UNDEFINED
for(f0 fltF f) if(FTf.pidid
FTf.pagep) pa fw return pa
19
Disadvantages

• Inefficient mapping must be performed for every
  memory reference.
• Costly Search must be done in parallel in
  hardware (i.e., associative memory).
• Sharing of pagesdifficult or not possible.

20
Associative Memories as Translation Look-Aside
Buffers

• When memory size is large, frame tables tend to
  be quite large and cannot be kept in associative
  memory entirely.
• To alleviate this, associative memories are used
  as translation look-aside buffers.
• To be detailed shortly.

21
Page Tables
frame f ?1
frame f
PTR
Page Table Register
f
frame f 1
Page Tables
22
Page Tables

• A page table keeps track of current locations of
  all pages belonging to a given process.
• PTR points at PT of the current process at run
  time by OS.
• Drawback
• An extra memory accesses needed for any
  read/write operations.
• Solution
• Translation Look-Aside Buffer

23
Demand Paging

• Pure Paging
• All pages of VM are loaded initially
• Simple, but maximum size of VM size of PM
• Demand Paging
• Pages are loaded as needed on demand
• Additional bit in PT indicates
• a pages presence/absence in memory
• Page fault occurs when page is absent

24
Demand Paging
True the mth page is in memory. False the mth
page is missing.
resident(m)

• Pure Paging
• All pages of VM can be loaded initially
• Simple, but maximum size of VM size of PM
• Demand Paging
• Pages a loaded as needed on demand
• Additional bit in PT indicates
• a pages presence/absence in memory
• Page fault occurs when page is absent

25
Segmentation

• Multiple contiguous spaces (segments)
• More natural match to program/data structure
• Easier sharing (Chapter 9)
• va (s, w) mapped to pa (but no frames)
• Where/how are segments placed in PM?
• Contiguous versus paged application

26
Contiguous Allocation Per Segment
Segment x
Segment s
STR
Segment Table Register
Segment y
Segment Tables
Physical Memory
27
Contiguous Allocation Per Segment

• Each segment is contiguous in PM
• Segment Table (ST) tracks starting locations
• STR points to ST
• Address translation
• Drawback
• External fragmentation

address_map(s, w) if (resident((STRs)))
pa (STRs)w return pa else
segment_fault
28
Contiguous Allocation Per Segment

• Each segment is contiguous in PM
• Segment Table (ST) tracks starting locations
• STR points to ST
• Address translation
• Drawback
• External fragmentation

29
Paging with segmentation
30
Paging with segmentation

• Each segment is divided into fix-size pages
• va (s, p, w)
• s determines of segments (size of ST)
• p determines of pages per segment (size of
  PT)
• w determines page size
• Address Translation
• Drawback
• 2 extra memory references

31
Paging of System Tables
32
Paging of System Tables
Drawback3 extra memory references.

• ST or PT may be too large to keep in PM
• Divide ST or PT into pages
• Keep track by additional page table
• Paging of ST
• ST divided into pages
• Segment directory keeps track of ST pages
• Address Translation

33
Translation Look-Aside Buffers (TLB)

• Advantage of VM
• Users view memory in logical sense.
• Disadvantage of VM
• Extra memory accesses needed.
• Solution
• Translation Look-aside Buffers (TLB)
• A special high-speed memory
• Basic idea of TLB
• Keep the most recent translation of virtual to
  physical addresses readily available for possible
  future use.
• An associative memory is employed as a buffer.

34
Translation Look-Aside Buffers (TLB)
35
Translation Look-Aside Buffers (TLB)
When the search of (s, p) fails, the complete
address translation is needed. Replacement
strategy LRU.
36
Translation Look-Aside Buffers (TLB)
The buffer is searched associatively (in parallel)
37
Operating Systems PrinciplesMemory
ManagementLecture 8 Virtual Memory

• Memory Allocation in Paged Systems

38
Memory Allocation with Paging

• Placement policy ?
• where to allocate the memory on request?
• Any free frame is OK (no external fragmentation)
• Keep track of available space is sufficient both
  for statically and dynamically allocated memory
  systems
• Replacement policy ?
• which page(s) to be replaced on page fault?
• Goal Minimize the number of page faults and/or
  the total number pages loaded.

39
Global/Local Replacement Policies

• Global replacement
• Consider all resident pages (regardless of
  owner).
• Local replacement
• Consider only pages of faulting process, i.e.,
  the working set of the process.

40
Criteria for Performance Comparison

• Tool Reference String (RS)
• r0 r1 ... rt ... rT
• rt the page number referenced at time t
• Criteria
• The number of page faults
• The total number of pages loaded

41
Criteria for Performance Comparison

• Tool Reference String (RS)
• r0 r1 ... rt ... rT
• rt the page number referenced at time t
• Criteria
• The number of page faults
• The total number of pages loaded

To be used in the following discussions.
Equivalent
42
Global Page Replacement Algorithms

• Optimal Replacement Algorithm (MIN)
• Accurate prediction needed
• Unrealizable
• Random Replacement Algorithm
• Playing roulette wheel
• FIFO Replacement Algorithm
• Simple and efficient
• Suffer from Beladys anormaly
• Least Recently Used Algorithm (LRU)
• Doesnt suffer from Beladys anormaly, but high
  overhead
• Second-Chance Replacement Algorithm
• Economical version of LRU
• Third-Chance Replacement Algorithm
• Economical version of LRU
• Considering dirty pages

43
Optimal Replacement Algorithm (MIN)

• Replace page that will not be referenced for the
  longest time in the future.
• Problem
• Reference String not known in advance.

44
ExampleOptimal Replacement Algorithm (MIN)
Replace page that will not be referenced for the
longest time in the future.
RS c a d b e b a b c d
2 page faults
c
a
d
b
e
b
a
b
c
d
Problem Reference String not known in advance.
45
Random Replacement

• Program reference string are never know in
  advance.
• Without any prior knowledge, random replacement
  strategy can be applied.
• Is there any prior knowledge available for common
  programs?
• Yes, the locality of reference.
• Random replacement is simple but without
  considering such a property.

46
The Principle of Locality

• Most instructions are sequential
• Except for branch instruction
• Most loops are short
• for-loop
• while-loop
• Many data structures are accessed sequentially
• Arrays
• files of records

47
FIFO Replacement Algorithm

• FIFO Replace oldest page
• Assume that pages residing the longest in memory
  are least likely to be referenced in the future.
• Easy but may exhibit Beladys anormaly, i.e.,
• Increasing the available memory can result in
  more page faults.

48
ExampleFIFO Replacement Algorithm
Replace oldest page.
RS c a d b e b a b c d
5 page faults
c
a
d
b
e
b
a
b
c
d
?
?
?
?
?
?
?
?
?
?
?
49
Example Beladys Anormaly
RS dcbadcedcbaecdcbae
17 page faults
14 page faults
50
Example Beladys Anormaly
15 page faults
14 page faults
51
Least Recently Used Replacement (LRU)

• Replace Least Recently Used page
• Remove the page which has not been referenced for
  the longest time.
• Comply with the principle of locality
• Doesnt suffer from Beladys anormaly

52
ExampleLeast Recently Used Replacement (LRU)
Replace Least Recently Used page.
RS c a d b e b a b c d
3 page faults
c
a
d
b
e
b
a
b
c
d
53
LRU Implementation

• Software queue too expensive
• Time-stamping
• Stamp each referenced page with current time
• Replace page with oldest stamp
• Hardware capacitor with each frame
• Charge at reference
• Replace page with smallest charge
• n-bit aging register with each frame
• Set left-most bit of referenced page to 1
• Shift all registers to right at every reference
  or periodically
• Replace page with smallest value

R Rn?1 Rn?2 R1 R0
54
Second-Chance Algorithm
Also called clock algorithm since search cycles
through page frames.

• Approximates LRU
• Implement use-bit u with each frame
• Set u1 when page referenced
• To select a page
• If u0, select page
• Else, set u0 and consider next frame
• Used page gets a second chance to stay in PM

55
ExampleSecond-Chance Algorithm

• To select a page
• If u0, select page
• Else, set u0 and consider next frame

cycle through page frames
RS c a d b e b a b c d
4 page faults
c
a
d
b
e
b
a
b
c
d
?
?
?
?
?
?
?
?
?
?
?
56
Third-Chance Algorithm

• Second chance algorithm does not distinguish
  between read and write access
• Write access more expensive
• Give modified pages a third chance
• u-bit set at every reference (read and write)
• w-bit set at write reference
• to select a page, cycle through frames,resetting
  bits, until uw00
• uw ? uw
• 1 1 0 1
• 1 0 0 0
• 0 1 0 0 (remember modification)
• 0 0 select

Can be implemented by an additional bit.
57
ExampleThird-Chance Algorithm
uw ? uw 1 1 0 1 1 0 0 0 0 1 0
0 0 0 select
RS c aw d bw e b aw b c d
3 page faults
c
aw
d
bw
e
b
aw
b
c
d
?
?
?
?
?
?
?
?
?
?
?
58
Local Page Replacement Algorithms

• Measurements indicate thatEvery program needs a
  minimum set of pages
• If too few, thrashing occurs
• If too many, page frames are wasted
• The minimum varies over time
• How to determine and implement this minimum?
• Depending only on the behavior of the process
  itself.

59
Local Page Replacement Algorithms

• Optimal Page Replacement Algorithm (VMIN)
• The Working Set Model (WS)
• Page Fault Frequency Replacement Algorithm (PFF)

60
Optimal Page Replacement Algorithm (VMIN)

• The method
• Define a sliding window (t, t ?) ? width ? 1
• ? is a parameter (a system constant)
• At any time t, maintain as resident all pages
  visible in window
• Guaranteed to generate smallest number of page
  faults corresponding to a given window width.

61
ExampleOptimal Page Replacement Algorithm
(VMIN)
? 3
RS c c d b c e c e a d
5 page faults
62
ExampleOptimal Page Replacement Algorithm
(VMIN)
? 3
RS c c d b c e c e a d
5 page faults
63
ExampleOptimal Page Replacement Algorithm
(VMIN)
? 3

• By increasing ?, the number of page faults can
  arbitrarily be reduced, of course at the expense
  of using more page frames.
• VMIN is unrealizable since the reference string
  is unavailable.

RS c c d b c e c e a d
5 page faults
64
Working Set Model

• Use trailing window (instead of future window)
• Working set W(t, ?) is all pages referenced
  during the interval (t ?, t) (instead of (t, t
  ?) )
• At time t
• Remove all pages not in W(t, ?)
• Process may run only if entire W(t, ?) is resident

65
ExampleWorking Set Model
? 3
RS e d a c c d b c e c e a d
5 page faults
66
ExampleWorking Set Model
? 3
RS e d a c c d b c e c e a d
5 page faults
67
Approximate Working Set Model

• Drawback costly to implement
• Approximations
• 1. Each page frame with an aging register
• Set left-most bit to 1 whenever referenced
• Periodically shift right all aging registers
• Remove pages which reach zero from working set.
• 2. Each page frame with a use bit and a time
  stamp
• Use bit is turned on by hardware whenever
  referenced
• Periodically do following for each page frame
• Turn off use-bit if it is on and set current time
  as its time stamp
• Compute turn-off time toff of the page frame
• Remove the page from the working set if toff gt
  tmax

68
Page Fault Frequency (PFF) Replacement

• Main objective Keep page fault rate low
• Basic principle
• If the time btw the current (tc) and the previous
  (tc?1) page faults exceeds a critical value ?,
  all pages not referenced during that time
  interval are removed from memory.
• The algorithm of PFF
• If time between page faults ? ?
• grow resident set by adding new page to resident
  set
• If time between page faults gt ?
• shrink resident set by adding new page and
  removing all pages not referenced since last page
  fault

69
ExamplePage Fault Frequency (PFF) Replacement
? 2
RS c c d b c e c e a d
5 page faults
70
ExamplePage Fault Frequency (PFF) Replacement
? 2
RS c c d b c e c e a d
5 page faults
71
Load Control and Thrashing

• Main issues
• How to choose the degree of multiprogramming?
• Decrease? Increase?
• When level decreased,which process should be
  deactivated?
• When a process created or a suspended one
  reactivated,which of its pages should be loaded?
• One or many?
• Load Control
• Policy to set the number type of concurrent
  processes
• Thrashing
• Most systems effort pays on moving pages between
  main and secondary memory, i.e., low CPU
  utilization.

72
Load control ?Choosing Degree of Multiprogramming

• Local replacement
• Each process has a well-defined resident set,
  e.g., Working set model PFF replacement
• This automatically imposes a limit, i.e., up to
  the point where total memory is allocated.
• Global replacement
• No working set concept
• Use CPU utilization as a criterion
• With too many processes, thrashing occurs

73
Load control ?Choosing Degree of Multiprogramming

• Local replacement
• Each process has a well-defined resident set,
  e.g., Working set model PFF replacement
• This automatically imposes a limit, i.e., up to
  the point where total memory is allocated.
• Global replacement
• No working set concept
• Use CPU utilization as a criterion
• With too many processes, thrashing occurs

L mean time between faultsS mean page fault
service time
74
Load control ?Choosing Degree of Multiprogramming
How to determine the optimum, i.e., Nmax

• Local replacement
• Each process has a well-defined resident set,
  e.g., Working set model PFF replacement
• This automatically imposes a limit, i.e., up to
  the point where total memory is allocated.
• Global replacement
• No working set concept
• Use CPU utilization as a criterion
• With too many processes, thrashing occurs

L mean time between faultsS mean page fault
service time
75
Load control ?Choosing Degree of Multiprogramming
How to determine Nmax ?

• LS criterion
• Page fault service S needs to keep up with mean
  time between faults L.
• 50 criterion
• CPU utilization is highest when paging disk 50
  busy (found experimentally).
• Clock load control
• Scan the list of page frames to find replaced
  page.
• If the pointer advance rate is too low, increase
  multiprogramming level.

76
Load control ?Choosing the Process to Deactivate

• Lowest priority process
• Consistent with scheduling policy
• Faulting process
• Eliminate the process that would be blocked
• Last process activated
• Most recently activated process is considered
  least important.
• Smallest process
• Least expensive to swap in and out
• Largest process
• Free up the largest number of frames

77
Load control ? Prepaging

• Which pages to load when process activated
• Prepage last resident set

78
Evaluation of Paging

• Advantages of paging
• Simple placement strategy
• No external fragmentation
• Parameters affecting the dynamic behavior of
  paged systems
• Page size
• Available memory

79
Evaluation of Paging
80
Evaluation of Paging
Prepaging is important.
A process requires a certain percentages of its
pages within the short time period after
activation.
81
Evaluation of Paging
However, small pages require lager page tables.
Smaller page size is beneficial.
Another advantage with a small page size Reduce
memory waste due to internal fragmentation.
82
Evaluation of Paging
W Minimum amount of memory to avoid thrashing.
Load control is important.