CHAPTER FOUR

Process Management
 Introduction
• An important and fundamental feature in modern operating
systems is concurrent execution of processes/threads.
• This feature is essential for the realization of multiprogramming,
multiprocessing, distributed systems, and client-server model of
computation.
• Concurrency encompasses many design issues including
communication and synchronization among processes,
sharing of and contention for resources.
Principles of Concurrency
• Interleaving and overlapping the execution of
processes.
• Consider two processes P1 and P2 executing
the function echo:
{
input (in, keyboard);
out = in;
output (out, display);
}
 ...Concurrency (contd.)
• P1 invokes echo, after it inputs into in , gets interrupted (switched).
• P2 invokes echo, inputs into in and completes the execution and exits.
• When P1 returns in is overwritten and gone. Result: first ch is lost and
second ch is written twice.
• This type of situation is even more probable in multiprocessing systems
where real concurrency is realizable thru’ multiple processes executing
on multiple processors.
• Solution: Controlled access to shared resource
• Protect the shared resource : in buffer; “critical resource”
• one process/shared code. “critical region”
Interactions among processes
• In a multi-process application these are the various degrees of
interaction:
1. Competing processes: Processes themselves do not share
anything. But OS has to share the system resources among
these processes “competing” for system resources such as
disk, file or printer.
Co-operating processes : Results of one or more processes may
be needed for another process.
2. Co-operation by sharing : Example: Sharing of an IO buffer.
Concept of critical section. (indirect)
3. Co-operation by communication : Example: typically no data
sharing, but co-ordination thru’ synchronization becomes
essential in certain applications. (direct)
Interactions ...(contd.)

• Among the three kinds of interactions

indicated by 1, 2 and 3 above:
• 1 is at the system level: potential problems :
deadlock and starvation.
• 2 is at the process level : significant problem is
in realizing mutual exclusion.
• 3 is more a synchronization problem.
Race Condition
• Race condition: The situation where several
processes access – and manipulate shared data
concurrently.
• The final value of the shared data depends upon which
process finishes last.
• To prevent race conditions, concurrent processes must
be synchronized.
Mutual exclusion problem
• Successful use of concurrency among processes
requires the ability to define critical sections and
enforce mutual exclusion.

• Critical section : is that part of the process code

that affects the shared resource.

• Mutual exclusion: in the use of a shared resource is

provided by making its access mutually exclusive
among the processes that share the resource.
• This is also known as the Critical Section (CS)
problem.
 Mutual exclusion
• Any facility that provides mutual exclusion should
meet these requirements:
1. No assumption regarding the relative speeds of
the processes.
2. A process is in its CS for a finite time only.
3. Only one process allowed in the CS.
4. Process requesting access to CS should not wait
indefinitely.
5. A process waiting to enter CS cannot be blocking
a process in CS or any other processes.
Software Solutions: Algorithm 1
• Process 0 • Process 1
• ... • ...
• while turn != 0 do • while turn != 1 do
• nothing; • nothing;
• // busy waiting
• // busy waiting
• < Critical Section>
• turn = 1;
• < Critical Section>
• ...
• turn = 0;
Problems : Strict • ...
alternation, Busy Waiting
Algorithm 2
• PROCESS 0 • PROCESS 1
• ... • ...
• flag[0] = TRUE; • flag[1] = TRUE;
• while flag[1] do nothing;
• while flag[0] do nothing;
• <CRITICAL SECTION>
• <CRITICAL SECTION>
• flag[0] = FALSE;
• flag[1] = FALSE;

PROBLEM : Potential for

deadlock, if one of the
processes fail within CS.
Algorithm 3
• Combined shared variables of algorithms 1 and 2.
• Shared variables
• boolean flag[2];
initially flag [0] = flag [1] = false.
• flag [i] = true  Pi ready to enter its critical section
• Process Pi
do {
flag [i]:= true;

turn = j;

while (flag [j] and turn = j) ;

critical section
flag [i] = false;
remainder section
} while (1);
• Solves the critical-section problem for two processes.
• This is called Peterson’s Solution
Semaphores
• Think about a semaphore as a class
• Attributes: semaphore value, Functions: init, wait,
signal
• Support provided by OS
• Considered an OS resource, a limited number
available: a limited number of instances (objects)
of semaphore class is allowed.
• Can easily implement mutual exclusion among
any number of processes.
Critical Section of n Processes

• Shared data:
Semaphore mutex; //initially mutex = 1

• Process Pi:

do {
mutex.wait();
critical section
mutex.signal();
remainder section
} while (1);
Semaphore Implementation
• Define a semaphore as a class:
class Semaphore
{ int value; // semaphore value
ProcessQueue L; // process queue
//operations
wait()
signal()
}
• In addition, two simple utility operations:
• block() suspends the process that invokes it.
• Wakeup() resumes the execution of a blocked process P.
Semantics of wait and signal
• Semaphore operations now defined as
S.wait():
S.value--;
if (S.value < 0) {
add this process to S.L;
block(); // block a
process
}

S.signal():
S.value++;
if (S.value <= 0) {
remove a process P from S.L;
wakeup(); // wake a process
}
 Semaphores for CS

• Semaphore is initialized to 1. The first process that executes

a wait() will be able to immediately enter the critical section
(CS). (S.wait() makes S value zero.)
• Now other processes wanting to enter the CS will each
execute the wait() thus decrementing the value of S, and will
get blocked on S. (If at any time value of S is negative, its
absolute value gives the number of processes waiting
blocked. )
• When a process in CS departs, it executes S.signal() which
increments the value of S, and will wake up any one of the
processes blocked. The queue could be FIFO or priority
queue.
Two Types of Semaphores
• Counting semaphore – integer value can range
over an unrestricted domain.
• Binary semaphore – integer value can range only
between 0 and 1; can be simpler to implement. ex:
nachos
• Can implement a counting semaphore using a
binary semaphore.
 Semaphore for Synchronization

• Execute B in Pj only after A executed in Pi

• Use semaphore flag initialized to 0
• Code:
Pi Pj
 
A flag.wait()
flag.signal() B
 Classical Problems of Synchronization

• Bounded-Buffer Problem (Producer/Consumer Problem)

• Readers and Writers Problem

• Dining-Philosophers Problem
Producer/Consumer problem
• Producer • Consumer
repeat repeat
produce item v; while (in <= out) nop;
b[in] = v; w = b[out];
in = in + 1; out = out + 1;
forever; consume w;
forever;
Solution for P/C using Semaphores
• Producer • Consumer
• repeat • repeat
• produce item v; • while (in <= out) nop;
• MUTEX.wait(); • MUTEX.wait();
• b[in] = v; • w = b[out];
• out = out + 1;
• in = in + 1;
• MUTEX.signal();
• MUTEX.signal();
• consume w;
• forever;
• forever;
• Ans: Consumer will busy-
• What if Producer is wait at the while
slow or late? statement.
P/C: improved solution
• Producer • Consumer
repeat repeat
produce item v; AVAIL.wait();
MUTEX.wait(); MUTEX.wait();
b[in] = v; w = b[out];
in = in + 1; out = out + 1;
MUTEX.signal(); MUTEX.signal();
AVAIL.signal(); consume w;
forever; forever;

• What will be the initial • ANS: Initially MUTEX = 1,

values of MUTEX and AVAIL = 0.
AVAIL?
P/C problem: Bounded buffer
• Producer • Consumer
repeat repeat
produce item v; while (in == out) NOP;
while((in+1)%n == out) w = b[out];
NOP;
b[in] = v; out = (out + 1)%n;
in = ( in + 1)% n; consume w;
forever; forever;
• How to enforce bufsize? • ANS: Using another
counting semaphore.
P/C: Bounded Buffer solution
• Producer
repeat • Consumer
produce item v; repeat
BUFSIZE.wait(); AVAIL.wait();
MUTEX.wait(); MUTEX.wait();
b[in] = v; w = b[out];
in = (in + 1)%n; out = (out + 1)%n;
MUTEX.signal(); MUTEX.signal();
AVAIL.signal(); BUFSIZE.signal();
forever; consume w;
• What is the initial value of forever;
BUFSIZE? • ANS: size of the bounded
buffer.
Semaphores - comments
• Intuitively easy to use.
• wait() and signal() are to be implemented as atomic
operations.
• Difficulties:
• signal() and wait() may be exchanged inadvertently by
the programmer. This may result in deadlock or violation
of mutual exclusion.
• signal() and wait() may be left out.
• Related wait() and signal() may be scattered all over the
code among the processes.
Monitors

• Monitor is a predecessor of the “class” concept.

• Initially it was implemented as a programming language
construct and more recently as library. The latter made
the monitor facility available for general use with any
PL.
• Monitor consists of procedures, initialization sequences,
and local data. Local data is accessible only thru’
monitor’s procedures. Only one process can be
executing in a monitor at a time. Other process that
need the monitor wait suspended.
Monitors
monitor monitor-name
{
shared variable declarations
procedure body P1 (…) {
. . .}
procedure body P2 (…) {
. . .}
procedure body Pn (…) {
. . .}
{
initialization code
}
}
Monitors
• To allow a process to wait within the monitor, a condition
variable must be declared, as
condition x, y;
• Condition variable can only be used with the operations
wait and signal.
• The operation
x.wait();
means that the process invoking this operation is
suspended until another process invokes
x.signal();
• The x.signal operation resumes exactly one suspended
process. If no process is suspended, then the signal
operation has no effect.
Schematic View of a Monitor
Monitor With Condition Variables
Message passing

• Both synchronization and communication

requirements are taken care of by this
mechanism.
• More over, this mechanism yields to
synchronization methods among distributed
processes.
• Basic primitives are:
send (destination, message);
receive ( source, message);
 Issues in message passing
• Send and receive: could be blocking or non-blocking:
• Blocking send: when a process sends a message it blocks until the
message is received at the destination.
• Non-blocking send: After sending a message the sender proceeds
with its processing without waiting for it to reach the destination.
• Blocking receive: When a process executes a receive it waits
blocked until the receive is completed and the required message is
received.
• Non-blocking receive: The process executing the receive proceeds
without waiting for the message(!).
• Blocking Receive/non-blocking send is a common combination.
 Reader/Writer problem
• Data is shared among a number of processes.
• Any number of reader processes could be accessing the
shared data concurrently.
• But when a writer process wants to access, only that process
must be accessing the shared data. No reader should be
present.
• Solution 1 : Readers have priority; If a reader is in CS any
number of readers could enter irrespective of any writer waiting
to enter CS.
• Solution 2: If a writer wants CS as soon as the CS is available
writer enters it.
Reader/writer: Priority Readers
• Reader:
• Writer: ES.wait();
ForCS.wait(); NumRdr = NumRdr + 1;
CS; if NumRdr = 1 ForCS.wait();
ForCS.signal(); ES.signal();
CS;
ES.wait();
NumRdr = NumRdr -1;
If NumRdr = 0 ForCS.signal();
ES.signal();
THE DINING PHILOSOPHERS PROBLEM
5 philosophers with 5 chopsticks sit around a circular table. They each want to eat at
random times and must pick up the chopsticks on their right and on their left.

Clearly deadlock is rampant ( and starvation possible.)

Several solutions are possible:

• Allow only 4 philosophers to be hungry at a

time.

• Allow pickup only if both chopsticks are

available. ( Done in critical section )
Dining Philosophers Example
monitor dp
{
enum {thinking, hungry, eating} state[5];
condition self[5];
void pickup(int i) // following slides
void putdown(int i) // following slides
void test(int i) // following slides
void init() {
for (int i = 0; i < 5; i++)
state[i] = thinking;}
}
Dining Philosophers
void pickup(int i) {
state[i] = hungry;
test[i];
if (state[i] != eating)
self[i].wait();
}

void putdown(int i) {
state[i] = thinking;
// test left and right neighbors
test((i+4) % 5);
test((i+1) % 5);
}
Dining Philosophers

void test(int i) {
if ( (state[(I + 4) % 5] != eating) &&
(state[i] == hungry) &&
(state[(i + 1) % 5] != eating)) {
state[i] = eating;
self[i].signal();
}
}
 Assignment
• Read the following practical problem and write
explanations
• Submission: During next class or lab
 A Practical Problem
High in the Andes mountains, there are two circular railway lines. One line is in
Peru, the other in Bolivia. They share a common section of track where the lines
cross a mountain pass that lies on the international border (near Lake Titicaca?).

Unfortunately, the Peruvian and Bolivian trains occasionally collide when simultaneously
entering the common section of track (the mountain pass). The trouble is, alas, that the
drivers of the two trains are both blind and deaf, so they can neither see nor hear each other.
The two drivers agreed on the following method of preventing collisions. They
set up a large bowl at the entrance to the pass. Before entering the pass, a
driver must stop his train, walk over to the bowl, and reach into it to see it it
contains a rock. If the bowl is empty, the driver finds a rock and drops it in the
bowl, indicating that his train is entering the pass; once his train has cleared the
pass, he must walk back to the bowl and remove his rock, indicating that the
pass in no longer being used. Finally, he walks back to the train and continues
down the line.
If a driver arriving at the pass finds a rock in the bowl, he leaves the rock there;
he repeatedly takes a siesta and rechecks the bowl until he finds it empty. Then
he drops a rock in the bowl and drives his train into the pass. A smart graduate
from the University of La Paz (Bolivia) claimed that subversive train schedules
made up by Peruvian officials could block the train forever.
Explain 1
The Bolivian driver just laughed and said that could not be true because it never
happened.
Explain 2

Unfortunately, one day the two trains crashed.

Explain 3
 Page 43
Following the crash, the graduate was called in as a consultant to ensure that no
more crashes would occur. He explained that the bowl was being used in the
wrong way. The Bolivian driver must wait at the entry to the pass until the bowl is
empty, drive through the pass and walk back to put a rock in the bowl. The
Peruvian driver must wait at the entry until the bowl contains a rock, drive through
the pass and walk back to remove the rock from the bowl. Sure enough, his
method prevented crashes.
Prior to this arrangement, the Peruvian train ran twice a day and the Bolivian train
ran once a day. The Peruvians were very unhappy with the new arrangement.
Explain 4

The graduate was called in again and was told to prevent crashes while avoiding
the problem of his previous method. He suggested that two bowls be used, one
for each driver. When a driver reaches the entry, he first drops a rock in his bowl,
then checks the other bowl to see if it is empty. If so, he drives his train through
the pass. Stops and walks back to remove his rock. But if he finds a rock in the
other bowl, he goes back to his bowl and removes his rock. Then he takes a
siesta, again drops a rock in his bowl and re-checks the other bowl, and so on,
until he finds the other bowl empty. This method worked fine until late in May,
when the two trains were simultaneously blocked at the entry for many siestas.

Explain 5