Chapter 9
Virtual-Memory Management
Virtual Memory
Virtual Memory
A technique that allows the execution of a process that may not be
completely in memory.
Motivation:
An entire program in execution may not all be needed at the same time!
e.g. error handling routines, a large array, certain program features, etc
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Virtual Memory
Potential Benefits
Programs can be much larger than the amount of physical memory. Users can concentrate on their problem programming.
The level of multiprogramming increases because processes occupy less physical memory.
Each user program may run faster because less I/O is needed for loading or swapping user programs.
Implementation: demand paging,
demand segmentation (more difficult),etc.
Demand Paging – Lazy Swapping
Process image may reside on the backing store. Rather than swap in the entire
process image into memory, Lazy
Swapper only swap in a page when it is needed!
Pure Demand Paging – Pager vs Swapper
A Mechanism required to recover from the missing of non-resident referenced pages.
A page fault occurs when a process references a non-memory-resident page.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Demand Paging – Lazy Swapping
CPU p d f d
4 v
i
6 v
i
9 vi
i i
Page Table
. . . 9 -F
8 7 6 - C
5 4 - A
3 2 1 0
valid-invalid bit invalid page?
non-memory- resident page?
A B C D E F
Logical Memory
Physical Memory
A Procedure to Handle a Page Fault
OS
CPU i Free
Frame 1. Reference
6. Return to execute the instruction
5. Reset the Page Table 2. Trap
(valid disk-resident page) 3. Issue a ‘read”
instruction & find a free frame
4. Bring in the missing page
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
A Procedure to Handle A Page Fault
Pure Demand Paging:
Never bring in a page into the memory until it is required!
Pre-Paging
Bring into the memory all of the pages that “will” be needed at one time!
Locality of reference
Hardware Support for Demand Paging
New Bits in the Page Table
To indicate that a page is now in memory or not.
Secondary Storage
Swap space in the backing store
A continuous section of space in the secondary storage for better
performance.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Crucial issues
Example 1 – Cost in restarting an instruction
Assembly Instruction: Add a, b, c
Only a short job!
Re-fetch the instruction, decode, fetch operands, execute, save, etc
Strategy:
Get all pages and restart the instruction from the beginning!
Crucial Issues
Example 2 – Block-Moving Assembly Instruction
MVC x, y, 256
IBM System 360/ 370
Characteristics
More expensive
“self-modifying” “operands”
Solutions:
Pre-load pages
Pre-save & recover before page-fault services
x:
y:
A B C D A B C D
Page fault!
Return??
X is destroyed MVC x, y, 4
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Crucial Issues
(R2) +
- (R3)
Page Fault
When the page fault is serviced, R2, R3 are modified!
- Undo Effects!
Example 3 – Addressing Mode
MOV (R2)+, -(R3)
Performance of Demand Paging
Effective Access Time:
ma: memory access time for paging
p: probability of a page fault
pft: page fault time (1 - p) * ma + p * pft
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Performance of Demand Paging
Page fault time - major components
Components 1&3 (about 103 ns ~ 105 ns)
Service the page-fault interrupt
Restart the process
Component 2 (about 25ms)
Read in the page (multiprogramming!
However, let’s get the taste!)
pft ≈ 25ms = 25,000,000 ns
Effect Access Time (when ma = 100ns)
(1-p) * 100ns + p * 25,000,000 ns
100ns + 24,999,900ns * p
Performance of Demand Paging
Example (when ma = 100ns)
p = 1/1000
Effect Access Time ≈ 25,000 ns
→ Slowed down by 250 times
How to only 10% slow-down?
110 > 100 * (1-p) + 25,000,000 * p p < 0.0000004
p < 1 / 2,500,000
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Performance of Demand Paging
How to keep the page fault rate low?
Effective Access Time ≈ 100ns + 24,999,900ns * p
Handling of Swap Space – A Way to Reduce Page Fault Time (pft)
Disk I/O to swap space is generally faster than that to the file system.
Preload processes into the swap space before they start up.
Demand paging from file system but do page replacement to the swap space. (BSD UNIX)
Copy-on-Write
Rapid Process Creation and Reducing of New Pages for the New Process
fork(); execve()
Shared pages Æ copy-on-write pages
Only the pages that are modified are copied!
3 4 6 1
3 4 6 1
* data1
*
* ed1
*
* ed2
*
* ed3
?? ::
Page Table 1
Page Table 2
P1
P2
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Copy-on-Write
zero-fill-on-demand
Zero-filled pages, e.g., those for the stack or bss.
vfork() vs fork() with copy-on-write
vfork() lets the sharing of the page table and pages between the parent and child processes.
Where to keep the needs of copy-on- write information for pages?
Page Replacement
Demand paging increases the
multiprogramming level of a system by
“potentially” over-allocating memory.
Total physical memory = 40 frames
Run six processes of size equal to 10 frames but with only five frames. => 10 spare frames
Most of the time, the average memory usage is close to the physical memory size if we increase a system’s
multiprogramming level!
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Page Replacement
Q: Should we run the 7th processes?
How if the six processes start to ask their shares?
What to do if all memory is in use, and more memory is needed?
Answers
Kill a user process!
But, paging should be transparent to users?
Swap out a process!
Do page replacement!
Page Replacement
A Page-Fault Service
Find the desired page on the disk!
Find a free frame
Select a victim and write the victim page out when there is no free frame!
Read the desired page into the selected frame.
Update the page and frame tables, and restart the user process.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
B M 0
E 7
A 6
J 5
M/B 4
H 3
D 2
1
OS v
5 i v 4
v 3
v 2
v 7
i v 6
3 2 1 0
J Load
M H
3 2 1 0
E D B A
P1
P2 PC
Page Replacement
Page Table Logical Memory
OS
Two page transfers per page fault if no frame is available!
Y V
7
Y V
3
N V
4
N V
6
Modify (/Dirty) Bit! To
“eliminate” ‘swap out” =>
Reduce I/O time by one-half
Page Replacement
Page Table
Valid-Invalid Bit
Modify Bit is set by the hardware automatically!
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Page Replacement
Two Major Pieces for Demand Paging
Frame Allocation Algorithms
How many frames are allocated to a process?
Page Replacement Algorithms
When page replacement is required, select the frame that is to be
replaced!
Goal: A low page fault rate!
Note that a bad replacement choice does not cause any incorrect execution!
Page Replacement Algorithms
Evaluation of Algorithms
Calculate the number of page faults on strings of memory references, called reference strings, for a set of algorithms
Sources of Reference Strings
Reference strings are generated artificially.
Reference strings are recorded as system traces:
How to reduce the number of data?
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Page Replacement Algorithms
Two Observations to Reduce the Number of Data:
Consider only the page numbers if the page size is fixed.
Reduce memory references into page references
If a page p is referenced, any immediately following references to page p will never cause a page fault.
Reduce consecutive page references of page p into one page reference.
Page Replacement Algorithms
Does the number of page faults decrease when the number of page frames available increases?
XX XX page# offset
0100, 0432, 0101, 0612, 0103, 0104, 0101, 0611 01, 04, 01, 06, 01, 01, 01, 06
01, 04, 01, 06, 01, 06
Example
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
FIFO Algorithm
A FIFO Implementation
1. Each page is given a time stamp when it is brought into memory.
2. Select the oldest page for replacement!
reference string page frames
FIFO queue
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7
0 7 0 1
2 0 1
2 3 1
4 3 0 2 3 0
4 2 0
4 2 3
0 2 3
7 7
0 7 0 1
0 1 2
1 2 3
2 3 0
3 0 4
0 4 2
4 2 3
2 3 0
0 1 3
0 1 2
7 1 2
7 0 2
7 0 1 3
0 1
0 1 2
1 2 7
2 7 0
7 0 1
FIFO Algorithm
The Idea behind FIFO
The oldest page is unlikely to be used again.
??Should we save the page which will be used in the near future??
Belady’s anomaly
For some page-replacement algorithms, the page fault rate may increase as the number of allocated frames increases.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
FIFO Algorithm
Run the FIFO algorithm on the following reference:
1 2 3 4 1 2 5 1 2 3 4 5 1 1 1 2 3 4 1 1 1 2 5 5 2 2 3 4 1 2 2 2 5 3 3 3 4 1 2 5 5 5 3 4 4 1 1 1 1 1 1 2 3 4 5 1 2 2 2 2 2 2 3 4 5 1 2 3 3 3 3 3 4 5 1 2 3 4 4 4 4 5 1 2 3 4 5
Push out pages
that will be used later!
string:
3 frames
4 frames
Optimal Algorithm (OPT)
Optimality
One with the lowest page fault rate.
Replace the page that will not be used for the longest period of time. ÅÆ Future Prediction
reference string page frames
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7
0 7 0 1
2 0 1
2 0 3
2 4 3
2 0 3
2 0 1
7 0 1 next 7
next 0
next 1
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Least-Recently-Used Algorithm (LRU)
The Idea:
OPT concerns when a page is to be used!
“Don’t have knowledge about the future”?!
Use the history of page referencing in the past to predict the future!
S ? SR ( SR is the reverse of S !)
LRU Algorithm
reference string page frames
LRU queue
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7
0 7 0 1
2 0 1
2 0 3
4 0 3
4 0 2
4 3 2
0 3 2
0 0
7 1 0 7
2 1 0
3 0 2
0 3 2
4 0 3
2 4 0
3 2 4
0 3 2
1 3 2
1 0 2
7 0 7 1
2 3
2 1 3
1 0 2
7 1 0
0 7 1 0
2 1
3 0 2
2 3 0
0 2 1
1 0 7 a wrong prediction!
Example
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
LRU Implementation – Counters
CPU p d f d
frame # v/i timetag p
f
cnt++
Time of Last Use!
………
Page Table for Pi Logical
Address
Physical Memory
Disk Update the
“time-of-use”
field A Logical Clock
LRU Implementation – Counters
Overheads
The logical clock is incremented for every memory reference.
Update the “time-of-use” field for each page reference.
Search the LRU page for replacement.
Overflow prevention of the clock & the maintenance of the “time-of-use” field of each page table.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
LRU Implementation – Stack
CPU p d f d
frame # v/i p
f
………
Page Table Logical
Address
Physical Memory
Disk
…
Head
Tail
(The LRU page!) A LRU
Stack
move
Overheads: Stack maintenance per memory reference ~ no search for page replacement!
A Stack Algorithm
Need hardware support for efficient implementations.
Note that LRU maintenance needs to be done for every memory reference.
memory- resident pages
memory- resident pages
n frames
⊆
available
(n +1) frames available
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
LRU Approximation Algorithms
Motivation
No sufficient hardware support
Most systems provide only “reference bit”
which only indicates whether a page is used or not, instead of their order.
Additional-Reference-Bit Algorithm
Second-Chance Algorithm
Enhanced Second Chance Algorithm
Counting-Based Page Replacement
Additional-Reference-Bits Algorithm
Motivation
Keep a history of reference bits
1 01101101
0 10100011
0 11101010
1 00000001
… … OS shifts all
history registers right by one bit at each regular interval!!
reference
bit one byte per page in memory
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
History Registers
But, how many bits per history register should be used?
Fast and cost-effective!
The more bits, the better the approximation is.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 LRU
(smaller value!)
MRU
Not used for 8 times
Used at least once every time
Additional-Reference-Bits Algorithm
Second-Chance (Clock) Algorithm
Motivation
Use the reference bit only
Basic Data Structure:
Circular FIFO Queue
Basic Mechanism
When a page is selected
Take it as a victim if its reference bit = 0
Otherwise, clear the bit and advance to the 0
0 1 1
1 0…
Reference Bit
Page
…
0 0 0 0
1 0…
Reference Bit
Page
…
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Enhanced Second-Chance Algorithm
Motivation:
Consider the cost in swapping out pages.
4 Classes (reference bit, modify bit)
(0,0) – not recently used and not “dirty”
(0,1) – not recently used but “dirty”
(1,0) – recently used but not “dirty”
(1,1) – recently used and “dirty”
low priority
high priority
Enhanced Second-Chance Algorithm
Use the second-chance algorithm to replace the first page encountered in the lowest nonempty class.
=> May have to scan the circular queue several times before find the right page.
Macintosh Virtual Memory
Management
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Counting-Based Algorithms
Motivation:
Count
the # of references made to each page, instead of their referencing times. Least Frequently Used Algorithm (LFU)
LFU pages are less actively used pages!
Potential Hazard: Some heavily used pages may no longer be used !
A Solution – Aging
Shift counters right by one bit at each regular interval.
Counting-Based Algorithms
Most Frequently Used Algorithm (MFU)
Pages with the smallest number of references are probably just brought in and has yet to be used!
LFU & MFU replacement schemes can be fairly expensive!
They do not approximate OPT very well!
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Page Buffering
Basic Idea
a. Systems keep a pool of free frames
b. Desired pages are first “swapped in” some frames in the pool.
c. When the selected page (victim) is later written out, its frame is returned to the pool.
Variation 1
a. Maintain a list of modified pages.
b. Whenever the paging device is idle, a modified page is written out and reset its
“modify bit”.
Page Buffering
Variation 2
a. Remember which page was in each frame of the pool.
b. When a page fault occurs, first check
whether the desired page is there already.
Pages which were in frames of the pool must be “clean”.
“Swapping-in” time is saved!
VAX/VMS with the FIFO replacement algorithm adopt it to improve the
performance of the FIFO algorithm.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Frame Allocation – Single User
Basic Strategy:
User process is allocated any free frame.
User process requests free frames from the free-frame list.
When the free-frame list is exhausted, page replacement takes place.
All allocated frames are released by the ending process.
Variations
O.S. can share with users some free frames for special purposes.
Page Buffering - Frames to save “swapping”
time
Frame Allocation – Multiple Users
Fixed Allocation
a. Equal Allocationm frames, n processes Æ m/n frames per process
b. Proportional Allocation 1. Ratios of Frames ∝ Size
S = Σ Si, Ai ∝ (Si/ S) x m, where (sum <= m) &
(Ai>= minimum # of frames required)
2. Ratios of Frames ∝ Priority
Si : relative importance
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Frame Allocation – Multiple Users
Dynamic Allocation
a. Allocated frames ∝ the multiprogramming level
b. Allocated frames ∝ Others
The minimum number of frames
required for a process is determined by the instruction-set architecture.
ADD A,B,C Æ 4 frames needed
ADD (A), (B), (C) Æ 1+2+2+2 = 7 frames, where (A) is an indirect addressing.
Frame Allocation – Multiple Users
Minimum Number of Frames (Continued)
How many levels of indirect
addressing should be supported?
It may touch every page in the logical address space of a process
=> Virtual memory is collapsing!
A long instruction may cross a page boundary.
MVC X, Y, 256 Æ 2 + 2 + 2 = 6 frames
The spanning of the instruction and the operands.
address
16 bits
1 indirect 0 direct
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Frame Allocation – Multiple Users
Global Allocation
Processes can take frames from others. For example, high-priority processes can
increase its frame allocation at the expense of the low-priority processes!
Local Allocation
Processes can only select frames from their own allocated frames Æ Fixed Allocation
The set of pages in memory for a process is affected by the paging behavior of only that process.
Frame Allocation – Multiple Users
Remarks
a.Global replacement generally results in a better system throughput
b.Processes can not control their own page fault rates such that a process can affect each another easily.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Thrashing
Thrashing – A High Paging Activity:
A process is thrashing if it is spending more time paging than executing.
Why thrashing?
Too few frames allocated to a process!
Thrashing
low CPU utilization Dispatch a new process
under a global page- replacement algorithm
degree of multiprogramming
CPU utilization
thrashing
Thrashing
Solutions:
Decrease the multiprogramming level Æ Swap out processes!
Use local page-replacement algorithms
Only limit thrashing effects “locally”
Page faults of other processes also slow down.
Give processes as many frames as they need!
But, how do you know the right number of frames for a process?
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Locality Model
A program is composed of several different (overlapped) localities.
Localities are defined by the program
structures and data structures (e.g., an array, hash tables)
How do we know that we allocate enough frames to a process to accommodate its current locality?
localityi= {Pi,1,Pi,2,…,Pi,ni}
control flow
localityj= {Pj,1,Pj,2,…,Pj,nj}
Working-Set Model
The working set is an approximation of a program’s locality.
Page references
…2 6 1 5 7 7 7 7 5 1 6 2 3 4 1 2 3 4 4 4 3 4 3 4 4 4
working-set windowΔ t1
working-set(t1) = {1,2,5,6,7}
working-set windowΔ t2
working-set(t2) = {3,4}
The minimum allocation
Δ ∞
All touched pages may cover several
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Working-Set Model
where M is the total number of available frames.
∑ − − ≤
= working set size M
D
iSuspend some processes and
swap out their pages.
“Safe”
D>M
Extra frames are available, and initiate new processes.
D>M
D≦M
Working-Set Model
The maintenance of working sets is expensive!
Approximation by a timer and the reference bit
Accuracy v.s. Timeout Interval!
0 1
1 0
…… …… …… ……
shift or copy
timer!
reference bit in-memory history
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Page-Fault Frequency
Motivation
Control thrashing directly through the observation on the page-fault rate!
increase # of frames!
decrease # of frames!
upper bound lower bound
number of frames
*Processes are suspended and swapped out if the number of available frames is reduced to that under the minimum needs.
page-fault rate
Memory-Mapped Files
File writes might not cause any disk write!
Solaris 2 uses memory-mapped files for open(), read(), write(), etc.
24 51 6 3
2 45 1
6 3
2 45 1
6 3
P1 VM P2 VM
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Shared Memory – Win32 API
Producer
1. hfile=CreateFile(“temp,txt”, …);
2. hmapfile=CreateFileMapping(hfi le, …, TEXT(“Shared Object”));
3. lpmapaddr=MapViewOfFile(hm apfile, …);
4. sprintf(lpmapaddr,”for consumer”);
5. UnmapViewOfFile(lpmapaddr);
6. CloseHandle(hfile);
7. CloseHandle(hmapfile);
Consumer
1. hmapfile=OpenFileMapping(
hfile, …, TEXT(“Shared Object”));
2. lpmapaddr=MapViewOfFile(
hmapfile, …);
3. printf(lpmapaddr,”for consumer”);
4. UnmapViewOfFile(“Get
%s\n”, lpmapaddr);
5. CloseHandle(hfile);
6. CloseHandle(hmapfile);
* Named shared-memory objects
Memory-Mapped I/O
Processor can have direct access!
Intermediate storage for data in the registers of device controllers
Memory-Mapped I/O (PC & Mac)
(1) Frequently used devices(2) Devices must be fast, such as video controller, or special I/O instructions is used to move data between
memory & device controller registers
Programmed I/O – polling
or interrupt-driven handling
R1 R2
R3 . . .
Memory
Device Controller
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Kernel Memory Allocation
Separation from user-mode memory allocation
The kernel might request memory of various sizes, that are often less than a page in size.
Certain hardware devices interact directly with physical memory, and the accesses memory must be in physically contiguous pages!
Kernel Memory Allocation
The Buddy System
A fixed-size segment of physically contiguous pages
A power-of-2 allocator
Advantage: quick
coalescing algorithms
Disadvantage: internal
256KB
128KB 128KB
64KB 64KB
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Kernel Memory Allocation
Slab Allocation
Slab: one or more physically contiguous pages
Cache: one or more slabs
Kernel Objects Caches Slabs
• Slab States
• Full
• Empty
• Partial
•
Kernel Memory Allocation
Slab Allocator
Look for a free object in a partial slab.
Otherwise, allocate a new slab and assign it to a cache.
Benefits
No space wasted in fragmentation.
Memory requests are satisfied quickly.
Implementations
Solaris 2.4 kernel, Linux version 2.2+
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Other Considerations
Pre-Paging
Bring into memory at one time all the pages that will be needed!
Issue
Pre-Paging Cost Cost of Page Fault Services ready
processes
suspended processes resumed
swapped out
Do pre-paging if the working set is known!
Not every page in the working set will be used!
Other Considerations
Page Size
Trends - Large Page Size
∵ The CPU speed and the memory capacity grow much faster than the disk speed!
small p d large
Smaller Page Table Size &
Better I/O Efficiency Better
Resolution for Locality &
Internal
Fragmentation 512B(29)~16,384B(212) Page Size
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Other Considerations
TLB Reach
TLB-Entry-Number * Page-Size
Wish
The working set is stored in the TLB!
Solutions
Increase the page size
Have multiple page sizes –
UltraSparc II (8KB - 4MB) + Solaris 2 (8KB or 4MB)
Other Considerations
Inverted Page Table
The objective is to reduce the
amount of physical memory for page tables, but they are needed when a page fault occurs!
More page faults for page tables will occur!!!
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Other Considerations
Program Structure
Motivation – Improve the system performance by an awareness of the underlying demand paging.
var A: array [1..128,1..128] of integer;
for j:=1 to 128
for i:=1 to 128 A(i,j):=0 A(1,1)
A(1,2) . . A(1,128)
A(2,1) A(2,2)
. . A(2,128)
A(128,1) A(128,2)
. . A(128,128)
……
128 words
128 pages
128x128 page faults if the process has less than 128 frames!!
Other Considerations
Program Structures:
Data Structures
Locality: stack, hash table, etc.
Search speed, # of memory references, # of pages touched, etc.
Programming Language
Lisp, PASCAL, etc.
Compiler & Loader
Separate code and data
Pack inter-related routines into the same page
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
I/O Interlock
buffer Drive
• DMA gets the following information of the buffer:
• Base Address in Memory
• Chunk Size
• Could the buffer-residing pages be swapped out?
Physical Memory
I/O Interlock
Solutions
I/O Device ÅÆ System Memory ÅÆ User Memory
Extra Data Copying!!
Lock pages into memory
The lock bit of a page-faulting page is set until the faulting process is dispatched!
Lock bits might never be turned off!
Multi-user systems usually take locks as
“hints” only!
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
Real-Time Processing
Solution:
Go beyond locking hints Î Allow
privileged users to require pages being locked into memory!
Predictable Behavior
Virtual memory
introduces unexpected, long-term delays in the execution of a program.
OS Examples – XP
Virtual Memory – Demand Paging with Clustering
Clustering brings in more pages surrounding the faulting page!
Working Set
A Min and Max bounds for a process
Local page replacement when the max number of frames are allocated.
Automatic working-set trimming reduces allocated frames of a process to its min when the system threshold on the
available frames is reached.
* All rights reserved, Tei-Wei Kuo, National Taiwan University, 2005.
OS Examples – Solaris
Process pageout first clears the reference bit of all pages to 0 and then later returns all pages with the reference bit = 0 to the system (handspread).
4HZ Æ 100HZ when desfree is reached!
Swapping starts when desfree fails for 30s.
pageout runs for every
request to a new page when minfree is reached.
lotsfree 100
slowscan 8192 fastscan
desfree minfree
Demand Segmentation
Motivation
Segmentation captures better the logical structure of a process!
Demand paging needs a significant amount of hardware!
Mechanism
Like demand paging!
However, compaction may be needed!
Considerable overheads!
