Scribd
Upload
24 views

Dining Philosopher Problem

The Dining Philosopher Problem involves philosophers who must acquire two forks to eat. Each philosopher thinks, takes the forks on either side, eats, then puts the forks down and thinks again. Semaphores (mutex and s[]) are used to synchronize access to shared resources and prevent deadlock. The Working Set model recognizes that processes access pages in localities over time and thrashing occurs when active working sets exceed available memory frames. Frame allocation algorithms like FIFO, LRU, and priority-based schemes aim to minimize page faults while avoiding thrashing.

Uploaded by

nasa stick
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
24 views

Dining Philosopher Problem

The Dining Philosopher Problem involves philosophers who must acquire two forks to eat. Each philosopher thinks, takes the forks on either side, eats, then puts the forks down and thinks again. Semaphores (mutex and s[]) are used to synchronize access to shared resources and prevent deadlock. The Working Set model recognizes that processes access pages in localities over time and thrashing occurs when active working sets exceed available memory frames. Frame allocation algorithms like FIFO, LRU, and priority-based schemes aim to minimize page faults while avoiding thrashing.

Uploaded by

nasa stick
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 13

Dining Philosopher Problem

Dining Philosopher Problem


Shared: int state[5], semaphore s[5], semaphore mutex;
Init: mutex = 1; s[i] = 0 for all i=0 .. 4

take_fork(i) {
Philosopher i P(mutex);
state[i] = hungry;
test(i) {
do { test(i);
if(state[i] == hungry
/* think */ V(mutex);
&& state[(i+1)%N] != eating
take_fork(i); P(s[i]);
&& state[(i-1+N)%N != eating)
/* eat */ }
{
put_fork(i); state[i] = eating;
/* think */ put_fork(i) {
V(s[i]);
} while(true); P(mutex);
}
state[i] = thinking;
test(LEFT);
test(RIGHT)%N);
V(mutex);
}
Memory Management
Page and Frame Replacement Algorithms

 Page Replacement algorithm


 FIFO, Optimal and LRU
 Want lowest page-fault rate on both first access and re-access
 Frame Allocation algorithm determines
 How many frames to give each process
Allocation of Frames
 How to calculate number of frames allocated to each process ?
 Same fraction of memory?
 Different fractions of memory?
 Each process needs minimum number of pages
 Want to make sure that all processes that are loaded into memory can
make forward progress
 Example: IBM 370 – 6 pages to handle SS MOVE instruction:
 instruction is 6 bytes, might span 2 pages
 2 pages to handle from
 2 pages to handle to
Fixed Allocation
 Equal allocation
 Every process gets same amount of memory
 Example:
 100 frames
 5 processes  each process gets 20 frames

 Proportional allocation
 Allocate according to the size of process
 Computation proceeds as follows:
si = size of process pi and
S = si
m = total number of frames
s si
ai = allocation for pi = m
S
Priority Allocation

 Proportional scheme using process priorities rather than size


 If process Pi generates a page fault,
 select for replacement one of its frames
 select for replacement a frame from a process with lower priority
number
Thrashing
Thrashing
 If a process does not have “enough” pages, the page-fault rate is very high
 Page fault to get page
 Replace existing frame
 But quickly need replaced frame back
 This leads to:
 Low CPU utilization
 Operating system thinking that it needs to increase the degree of
multiprogramming
 Another process added to the system

 Thrashing  a process is busy swapping pages in and out


Thrashing
 Swapping out pages of a process just before that pages are needed
 The processor spends most of its time swapping pages rather than
executing user instructions
 Why does thrashing occur?
Σ size of locality > total memory size
Working Set Model
 As a program executes it transitions through a sequence of “working sets”
consisting of varying sized subsets of the address space
Page Number

Time
Working-Set Model

   working-set window  fixed number of page references


 Example: 10,000 instructions
 WSi (working set of Process Pi) = total set 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 = |WSi|  total demand frames
 if D > m  Thrashing
 Policy: if D > m, then suspend/swap out processes
 This can improve overall system behavior by a lot!
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
 But then process execution time can vary greatly
 But greater throughput so more common

 Local replacement – each process selects from only its own set of
allocated frames
 More consistent per-process performance
 But possibly underutilized memory

You might also like