Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 33 Annotated
33 -
Outline
Working Set Algorithm
Frame Allocation
Local Algorithms
Global Algorithms
Other Considerations
Summary of Algorithms
Working Set Clock Algorithm (WSClock)
Announcements
Reading:
Working Set Algorithm
Working Set Clock Algorithm
Frame Allocation
1)
2)
3)
MOS 3.3 - 3.7
PA 5 due Friday.
Please use the Makefile to create the zip
submission.
Create your project groups on Canvas.
Page Replacement
Recall:
Utilize page table entry fields:
Algorithm:
Pros:
We can fix those issues.
Keep a circular list of frame entries instead of
page table entries containing:
On a page fault, do approximately the following:
Some Pythonic pseudocode:
Cons:
On a page fault, do (approximately) the following:
Note how w(k, t2) = w(k, t3)
Working Set algorithm tries to take advantage of
the relative stability of a working set
Instead of a window size in # of references,
kernel defines a window size as time threshold T
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 1 3 2 3 4 4 4
k = 10
-
-
-
time of last use
cleared by kernel on clock interrupt
candidates = []
oldest = (none, 0)
for entry in page_table:
  if entry.R = 1:
    # page was used since last interrupt
    # update time, but do not remove
    entry.last_time = current_time()
  else: # R = 0
    # compute page age
    age = current_time() - entry.last_time
    if age > T:
      # not in working set
      # page is removal candidate
      candidates.append(entry)
    else: # age <= T
      if age > oldest[1]:
        # find the oldest unused page
        # in case all are in working set
        oldest = (entry, age)
     Â
      # page still in working set,
      # continue
      pass
if candidates:
  # remove a random unused page
  # that is not in working set
  page_table.remove(choice(candidates))
elif oldest[0]:
  # otherwise remove the oldest page
  # in the working set
  page_table.remove(oldest[0])
else:
  # otherwise pick a random page
  page_table.remove(choice(page_table))
# frames implemented as linked list
global frames
# clock hand is a pointer to a node in frames
global hand
victim = none
writebacks = []
count = 0
while count < len(frames) or writebacks:
  count += 1
  if hand.R == 1:
    # page has been used recently and part of working set
    hand.last_time = current_time()
    hand.R = 0
  else:
    # page has not been used recently
    age = current_time() - hand.last_time
    if age > T:
      # page is not in working set
      if hand.M == 0:
        # clean page, replace immediately
        victim = hand
        hand = hand.next
        break
      else:
        # dirty page, schedule writeback (nonblocking)
        # writeback will clear M bit on completion
        writebacks.append(hand.page_number)
    else:
      # page is still in working set, don't consider it
      pass
  hand = hand.next
if not victim:
  # all pages used and in working set
  # pick a page at random
  victim = choice(frames)
evict(victim)
R bit (M bit for writeback)
MOS Figure 3-19
-
-
-
-
-
-
-
-
-
-
-
-
-
-
set last time = current time
if page is clean (M==0), replace the page
if page is dirty (M==1), schedule writeback
set R = 0
advance clock hand
advance clock hand
-
-
current page number
if R = 1:
if R = 0 and age > T:
after first pass, if no page was evicted:
if a writeback was scheduled:
otherwise evict any clean page
continue advancing clock hand and evict the
first clean, unused page encountered.
last time used
R and M bits
-
-
successfully reduces page faults
inefficiency: scans entire page table
putting a time field in the page table entry
takes up a lot of space...
MOS Figure 3-20
Optimal
NRU
FIFO
2nd Chance
Clock
LRU
NFU
Aging
Working Set
WSClock
Impossible, but a useful benchmark
2 schemes result:
Local algorithms expect process to have a fixed
number of frames to use. Since they only examine
current process's pages.
Processes can be started up under fixed
allocation, but global algorithms can replace pages
used by other processes.
Need a way to put minimum and maximum on number
of frames a process uses to prevent thrashing
across processes.
Relatedly, may want to limit # of processes
swap out processes to relieve memory load (e.g.
long idle processes go to disk)
requires more complex scheduling
deduplicating pages (same page merging)
Other strategies
Out of Memory (OOM) Killer
Frames can be divided up among processes
periodically in a fixed manner:
LRU/Aging and WSClock or combinations/variants
thereof get used most often in practice
Each process needs a minimum number of frames,
but exactly how many should be allocated?
Replacement algorithms make different assumptions
Crude approximation of LRU
Might evict important pages
Big improvement on FIFO
Efficient 2nd Chance
Excellent, but exact impl. difficult
Crude approximation of LRU
Efficient, decent approx. of LRU
Good, but impl. expensive
Good, efficient
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Local algorithms -> Fixed Allocation
Equal allocation
Proportional allocation
e.g. 100 frames, 5 processes
Example:
64 frames
process 1 uses 100 kB
process 1 => (1/4) * 64 = 16 frames
=> 20 frames / process
process 2 => (3/4) * 64 = 48 frames
process 2 uses 300 kB
process gets frames proportional to its
relative size
a process may have many frames taken from it and end up
thrashing (fewer frames than its working set size).
it may take frames from another process causing the other
process to thrash as well...
doesn't influence which pages are replaced
based on the observation that page fault
rate decreases as more frames are assigned.
measures page fault rate and set upper and
lower bounds for acceptability
too many processes, may not have enough
RAM for each one, causing thrashing
special process that runs when available
memory is low
examines all processes, assigns a badness
score to each one, and kills high scoring ones
score can be calculated from how much RAM
process uses, its priority level, etc.
too high => allocate more frames
too low => allocate fewer frames
i.e. algorithms that only replace current process pages
i.e. algorithms that consider pages from any process
Global algorithms -> Dynamic Allocation
Page Fault Frequency (PFF) Algorithm
Pros:
Cons:
-
-
if a process thrashes, won't influence others
wasted memory if not all frames used
Pros:
Cons:
-
-
uses memory efficiently for varying working sets
domino-style thrashing can occur
page fault rate
# of frames
upper bound
lower bound
thrashing
# processes
CPU utilization
thrashing
Options?
Process Swapping