Module 7: Process Synchronization

1
Operating SystemsLecture 38 Frame
Allocation Read Ch. 10.5 - 10.6
2
Page Replacement Algorithms

• Page replacement algorithms select the page to be
  replaced.
• Want lowest page-fault rate.
• Evaluate algorithm by running it 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.
• Last time
• FIFO algorithm
• Optimal algorithm

3
Least Recently Used (LRU) Algorithm

• Replace the page that has not been used for the
  longest period of time.
• Reference string 1, 2, 3, 4, 1, 2, 5, 1, 2, 3,
  4, 5
• Considered a good replacement algorithm.
• Question How do we implement it?

4
LRU Counter implementation

• Add a logical clock or counter that is
  incremented with each memory reference.
• When a reference is made to a page, the clock
  register is copied into the time-of-use field in
  the page table entry.
• Replace the page with the smallest time value.
• This requires a search of the page table to find
  the page with the lowest clock value.
• It also requires an extra write to memory (of the
  clock value) for each memory access.

5
LRU Algorithm, Stack Implementation

• Keep a stack of page numbers.
• If a page is referenced, move it to the top of
  the stack.
• The LRU page ends up on the bottom of the stack.
• No search is required to find the LRU page.
• Because of the need to remove a page from the
  middle of the stack, implement the stack with a
  doubly linked list.
• Example 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

6
Use Of A Stack to Record The Most Recent Page
References
7
Allocation of Frames

• Each process has a maximum number of frames
  allocated--we cannot allocate more frames than
  there are in memory.
• Each process needs minimum number of pages.
• As the number of frames per process decreases,
  the fault rate increases.
• When a page fault occurs before an instruction is
  complete, we must restart the instruction.
• There must be enough frames to hold all the pages
  that a single instruction can reference.
• Example IBM 370 6 pages to handle Storage to
  Storage MOVE instruction (SS MOVE)
• instruction is 6 bytes, might span 2 pages.
• 2 pages to handle from.
• 2 pages to handle to.
• Two major allocation schemes.
• fixed allocation
• priority allocation

8
Fixed Allocation

• Equal allocation e.g., if 100 frames and 5
  processes, give each 20 pages.
• Proportional allocation Allocate according to
  the size of process.

9
Priority Allocation

• Use a proportional allocation scheme using
  priorities rather than size.
• If process Pi generates a page fault, either
• select for replacement one of its frames.
• OR select for replacement a frame from a process
  with lower priority number.

10
Global vs. Local Allocation

• Global replacement process selects a
  replacement frame from the set of all frames one
  process can take a frame from another.
• Local replacement each process selects from
  only its own set of allocated frames.
• In global replacement a process cannot control
  its own page fault rate. It's turnaround time
  may vary depending on the behavior of other
  processes.
• With local replacement, a process may be hindered
  because it does not have access to other, less
  used pages in memory.
• Global replacement generally has greater system
  throughput, so it is more commonly used.

11
Thrashing

• If a process does not have enough pages, the
  page-fault rate is very high.
• Thrashing ? a process is busy swapping pages in
  and out.
• Cause of thrashing
• If using a global replacement scheme, if one
  process starts needing more frames it will take
  them from other processes.
• These other processes may start faulting more.
• There could end up being many processes in queue
  waiting for pager to swap in needed pages.
• This leads to low CPU utilization.
• operating system thinks that it needs to increase
  the degree of multiprogramming to increase CPU
  utilization.
• another process added to the system, making the
  problem worse.

12
Thrashing

• Why does paging work?Locality model
• Process migrates from one locality to another.
• Localities may overlap.
• Why does thrashing occur?? size of locality gt
  total memory size

13
Locality In A Memory-Reference Pattern
14
Working-set model

• The working-set model is a way of estimating the
  size of the current locality for a process.
• ? ? working-set window ? a fixed number of page
  references
• The working set is the set of pages in the most
  recent D page references.

15
Working-Set Model

• WSSi (working set of Process Pi) total number
  of pages referenced in the most recent ? (varies
  in time)
• if ? too small will not encompass entire
  locality.
• if ? too large will encompass several localities.
• if ? ? ? will encompass entire program.
• D ? WSSi ? total demand frames
• if D gt m ? Thrashing
• Policy if D gt m, then suspend one of the
  processes.

16
Page-Fault Frequency Scheme

• The Page-Fault Frequency scheme is an alternative
  to the working-set model.
• Establish acceptable page-fault rate.
• If actual rate too low, process loses frame.
• If actual rate too high, process gains frame.