Chapter Two

Process and Process Management

2.1 The Process Concept
The most fundamental task of modern operating systems is process management. It includes
o Creating processes
o Allocating resources to processes
o Managing conflicting demands
o Protecting resources of each process from other processes
o Enabling processes to share and exchange information
o Enabling synchronization among processes for proper sequencing and coordination when dependencies exist
o Termination processes
The most central concept in operating system is a process
o A process may have inputs and outputs
o A process resides in memory
o A process may access files
Process vs. Program
o Program
It is sequence of instructions defined to perform some task
It is a passive entity
o Process
It is a program in execution
It is an instance of a program running on a computer
It is an active entity
A processor performs the actions defined by a process
Types of Processes
o There are two types of processes
Sequential Processes
• Execution progresses in a sequential fashion, i.e. one after the other
• At any point in time, at most one process is being executed
Concurrent Processes
• There are two types of concurrent processes
• True Concurrency (Multiprocessing)
- Two or more processes are executed simultaneously in a multiprocessor environment
- Supports real parallelism
• Apparent Concurrency (Multiprogramming)
- Two or more processes are executed in parallel in a uniprocessor environment by
switching from one process to another
- Supports pseudo parallelism, i.e. the fast switching among processes gives illusion of
parallelism
• In both cases if a snapshot of the system is taken, several processes will be found in a state
of partial execution

1
 o Real life example: Consider a computer scientist who is baking a birthday cake for her daughter and who is
interrupted by her daughter’s bleeding accident
Analysis
Processes Baking Cake First Aid
Processor Computer Scientist Computer Scientist
Program Recipe First Aid Book
Input Ingredients First Aid Kit
Output Cake First Aid Service
Priority Higher Lower
States Running, Idle Running, Idle
Sequence of actions
• Bringing ingredients i.e. flour, sugar, eggs, etc
• Placing the mixture into the oven
• Following the baking processes
• Hearing a cry and analyzing it to be because of bleeding
• Recording baking processes state and switching to provide first aid service
• Providing first aid service
• Coming back and resuming the baking process
Process States
a. Process States
o During its lifetime, a process passes through a number of states. The most important states are: Ready,
Running, Blocked (waiting)
New
• A process that has just been created but has not yet been admitted to the pool of executable
processes by the operating system
• Information concerning the process is already maintained in memory but the code is not
loaded and no space has been allocated for the process
Ready
• A process that is not currently executing but that is ready to be executed as soon as the
operating system dispatches it
Running
• A process that is currently being executed
Blocked (Waiting)
• A process that is waiting for the completion of some event, such as and I/O operation
Exit (Terminated)
• A process that has been released from the pool of executable processes by the operating
system, either because it halted or because it aborted for some reason
• Information associated with the process are temporarily preserved by the operating system
until auxiliary or support programs extract any needed information, for instance for
performance monitoring or billing purpose

dispatch release
New admit Ready Running Exit

Event occurs Event wait

Blocked

2
b. Process State Transitions
o The main process state transitions are
Null New
• It occurs when a new process is created to execute a program

New Ready
• It occurs when the operating system is prepared to take on additional process and a new
process is admitted
Ready Running
• It occurs when the operating system chooses one of the processes in the ready state for
running
• The process is called dispatching and it is caused by the dispatcher (scheduler)
• Dispatch (process name)
Running Blocked
• It occurs when a process requests something for which it must wait
• Examples
- Request for an I/O operation
- Request for a file
- Request for another process to produce input
- Request for another process to produce a message
- Request for a shared section of a virtual memory
- Wait (process name)
Blocked Ready
• It occurs when the event for which a process has been waiting occurs
• Wakeup (process name)
Running Ready
• It occurs when a process is preempted by the operating system
• Examples
- When time is expired
- When a blocked process with higher priority is moved to ready state
- Timeout (process name)
Running Exit
• It occurs when a currently running process is terminated
• Halt (process name) or Abort (process name)
o The operating system manages ready and blocked processes using queue data structures

Ready Queue
Processor release
admit ... Dispatch
Time-out
Event
Blocked Queue Event wait
Occurs
...
o To improve performance multiple ready and blocked queues can be used
Multiple blocked queues are used to categorize blocked processes based on events
Multiple ready queues are used to categorize ready processes based on priorities

3
Process Description
a. Control Tables
o If the operating system is to manage processes and resources, it must have information about the current
status of each process and resources
o The operating system constructs and maintains tables of information, called control tables
o There are four major control tables
Memory tables
• Used to keep track of both main and virtual memory
• Include information about
- Allocation of main memory to processes
- Allocation of secondary memory to processes
- Any protection attributes of blocks of memory
- Any information needed to manage virtual memory
I/O tables
• Used to manage the I/O devices and channels of computer system
• Include information about
- Status of I/O devices: available/assigned
- Status of I/O operation
- Main memory being used as a source or destination of the I/O transfer
File tables
• Used to manage files
• Include information about
- Existence of files
- Location of files on secondary memory
- Current status of files
- Other attributes of files
Process tables
• Used to manage processes
• Include information about
- Location of each process
- Attributes of each process
o The tables must be linked or cross-referenced in some fashion
o The operating system must have some knowledge of the basic environment of the computer system
Amount of main and virtual memories
I/O devices available
b. Process Image
o It is the physical manifestation of each process. It consists of two parts
Address space
• Memory space within which the process executes. It consists of
- Program: code of the program to be executed
- Data: data locations for local and global variables and any defined constants
- System stack: used to keep track of procedure calls and parameter passing between
procedures
PCB (Process Control Block)
• Contains all information that is required by the operating system to manage a process
• It consists of the following categories of information
- Process Identification
Process identifier
4
 Parent identifier
User identifier
- Processor State Information
User visible registers (AX, BX, CX, DX, SI, DI etc)
Control status register (PSW, PC)
Stack pointer (SP, BP)
- Process Control Information
Scheduling and state information: process state, priority, event
Data structuring: pointers to other processes
Interprocess communication: flags, signals, messages
Process privileges: memory access, instructions, utilities and services
Memory management: pointers to segments and / or page tables
Resource ownership and utilization: resources controlled, resource utilization
history
• It is the most important data structure in an operating system
• It is accessed virtually by every module in the operating system
• All PCBs are linked to form a list. Which is accessed by a pointer in a central table
Process Image1
Memory Memory tables Address
Space 1
Devices I/O tables PCB 1

Files File tables Process Image2

Address
Processes Primary process table Space 2

Process 1 PCB 2

Process 2 .
. .
. .
.
Process Imagen
.
Process n Address
General structure of operating system control tables Space n
PCB n
Process Switching
o Process switch occurs when a running process is interrupted and the operating system assigns another
process to the running state and turns control over to that process
o Process switch is sometimes called context switch
o A running process may be interrupted by
Interrupt: An event that occurs outside the process and that is recognized by the processor
(clock interrupt, I/O interrupt)
Supervisor Call: A procedure call used by user programs to call an operating system function
Trap: An error or exception condition generated within the currently running process (illegal file
access attempt)
o If an interrupt is pending, the processor does the following
It saves the context of the current process
It sets the program counter to the starting address of an interrupt handler program
It switches the processor mode from user mode to kernel mode so that the interrupt processing
code may include privileged instructions
o The occurrence of an interrupt results in mode switch but does not necessarily mean a process switch
i.e. a mode switch may occur without changing the state of the process that is currently running

5
 o If the interrupt is handled and the operating system has decided to move the currently running process
to another state, process switch occurs
o Steps involved in each process switch are
Save the context of the processor
Update the PCB of the process that is currently in running state
Move the PCB of this process to the appropriate queue
Update the PCB of the process selected
Update the memory management data structures
Restore the context of the processor to that which existed at the time the selected process was
last switched out of running state
o Process switch (dispatch latency) is an overhead and its speed depends on the hardware: 1 to 100 ms
o Process switch is sometimes a performance bottleneck
2.2 The Thread Concept
o Thread vs. Process
A thread is a dispatchable unit of work (lightweight process) that has independent context, state
and stack
A process is a collection of one or more threads and associated system resources
Traditional operating systems are single-threaded systems
Modern operating systems are multithreaded systems
2.2.1. Multithreading and Thread Usage (Why do we need threads)
Multithreading is a technique in which a process, executing an application, is divided into
threads that can run concurrently
• Handling several independent tasks of an application that do not need to be serialized
(e.g. database servers, web servers)
• Having great control over the modularity of the application and the timing of application
related events
Each thread has independent context, state and stack
All threads share the same address space and a separate thread table is needed to manage the
threads
Threads can be managed in the kernel or user space
• Kernel Space
- The operating system is aware of the existence of multiple threads
- When a thread blocks, the operating system chooses the next one to run, either
from the same process or a different one
- The kernel has a thread table
- Thread management is slow
• User Space
- The operating system is not aware of the existence of multiple threads
- When a thread is about to block, it chooses and starts its successor before
stopping
- The user space has a thread table
- Thread management is much faster (specially switching)
- When one thread blocks, the kernel blocks the entire process
Both systems are in use and various hybrid schemes have been proposed as well
Introducing threads into an existing system needs a substantial system redesign

6
2.3 Inter-Process Communication
2.3.1 IPC and the race condition
A. Basic Concept
o The most fundamental task of modern operating systems is management of multiple processes within
uniprocessor, multiprocessor or distributed computer systems
o The fundamental design issue in the management of multiple processes is concurrency: simultaneous
execution of multiple processes
o Concurrency arises in three different contexts
Multiple applications: concurrently running applications
Structured applications: an application structured as a set of concurrent processes (threads)
OS structure: OS implemented as a set of processes
o Concurrency provides major benefits in processing efficiency and in program structuring
B. Inter-process Communication
There is frequent interaction among concurrently running processes. There are three ways in which concurrent
processes interact with each other:
Competition for Resources
It occurs when independent processes that are not intended to work together compete for the use of
the same or shared resource, e.g. printer, memory, or file
There is no exchange of information between competing processes
Processes are unaware of each other
Cooperation by Sharing Resources
It occurs when processes that are not necessarily aware of each other use and update shared data
without reference to other processes but know that other processes may have access to the same
data
Processes must cooperate to ensure that the data they share are properly managed
Processes are aware of each other indirectly
Cooperation by Communication
It occurs when various processes communicate with each other, for instance with message passing in
order to provide a way to synchronize or coordinate their various activities.
There is nothing shared between processes
Processes are aware of each other directly
C. Concurrency Problems
There are some serious problems associated with the interaction of concurrently running processes:
i. Race Condition
A situation that occurs when two or more processes are reading or writing into some shared data and
the final result depends on who runs precisely when
E.g. 1 Printer Spooler: when a process wants to print a file, it enters the file name in a special spooler
directory. Assume that the spooler directory has a large number of slots, numbered 0,1,2,…
There are two globally shared variables
Outfile: points to the next file to be printed
Infile: points to the next free slot in the directory
There were some files in the spooler directory and assume the current value of infile is 7 and that
of outfile is 3
Assume that simultaneously process A and process B decide they want to queue a file for printing
- Process A reads infile and stores the value 7 in its local variable (x=infile)
- An interrupt occurs and the CPU decides that process A has run long enough so it switches
to process B
- Process B reads infile and stores the value 7 in its local variable (y=infile)
- Process B stores the name of its file in slot 7 and adjusts infile to be 8
7
 - Eventually process A runs again, it checks x and finds 7 there, and writes its file name in
slot 7, erasing the name process B just put there, it updates infile to be 8
- The printer daemon will now print the file of process A, process B file will never get any
output
E.g. 2 Character echo procedure: consider the following globally shared procedure
Void echo
{
chin=getchar(); //read a character from keyboard
chout=chin;
putchar (chout); //display the character on the screen
}
Consider two processes (P1 & P2) trying to access the procedure
- Process P1 invokes the echo procedure and is interrupted immediately after the conclusion
of getchar function (chin =x)
- Process P2 is activated and invokes the echo procedure, which runs to conclusion,
inputting an displaying a single character, y
- Process P1 is resumed. By this time the value x ihas been overwritten in chin and therefore
lost. Instead chin contains y, and is displayed twice
ii. Deadlock
It is the permanent blocking of a set of processes that either compete for system resources or
communicate with each other. It involves conflicting needs for resources by two or more processes.
It refers to a situation in which a set of two or more processes are waiting for other members of the set
to complete an operation in order to proceed, but none of the members is able to proceed.
E.g. Traffic deadlock: consider a situation in which four cars have arrived at a four-way stop
intersection at the same time. The four quadrants of the intersection are the resources over which
control is needed. If all four cars proceed into the intersection, then each car controls one resource
(one quadrant) but cannot proceed because the required second resource has already been
controlled by another car. Hence deadlock will occur. The main reason for this deadlock is because
each car needs exclusive use of both resources for certain period of time
It is a difficult phenomenon to anticipate and there are no easy general solutions to this problem
iii. Starvation
It referees to the situation in which a process is ready to execute but is continuously denied access to
a processor in deference to other processes.
E.g. suppose that there are three processes P1, P2, and P3 and each require periodic access to
resource R. If the operating system grants the resource to P1 and P2 alternately, P3 may indefinitely
be denied access to the resource, thus starvation may occur.
In large part, it is a scheduling issue
2.3.2. Critical Sections (Regions) and Mutual Exclusion
The key to preventing race condition is to enforce mutual exclusion: It is the ability to exclude
(prohibit) all other processes from using a shared variable or file while one process is using it.
Part of a program where shared resource (critical resource) is accessed is called critical region or
critical section

8
 Process A Process B
- -
- - Non-Critical Section
- -
Read infile Read infile
Put file Put file Critical Section
Increment infile Increment infile
- -
- - Non-Critical Section
- -
The fundamental strategy for implementing mutual exclusion is avoiding the situation where no two
processes could ever be in their critical regions at the same time.
There are some basic requirements that should be met while implementing mutual exclusion
i. No two processes may be simultaneously in their critical regions
ii. No assumptions may be made about speed or the number of processors
iii. No process running outside its critical region may block other processes
iv. No process should have to wait forever to enter its critical region

Implementing Mutual Exclusion with Busy Waiting

In this section, various proposals for achieving mutual exclusion with the help of busy waiting are examined:
A. Disabling Interrupts
o An interrupt is an event that alters the sequence in which a process executes instruction
o In this technique, each process disables all interrupts just after entering its critical section and re-enables them
just before leaving it. With interrupts turned off the processor will not be switched to another process
o Disadvantages
It is unwise to give processes the power to turn off interrupts. For instance, a process can turn off
interrupts but never turn them on again in which the whole system freezes
If the system is multiprocessor, disabling interrupts affects only the processor that executed the
disable instruction. The other ones will continue running and can access the shared memory.
o Disabling interrupts is often a useful technique within the operating system itself but is not appropriate as a
general mutual exclusion mechanism for user processes.

B. Lock Variables
o Assume we have a single shared (lock) variable initially set to 0
o A process enters its critical section if this variable is 0, when it enters it sets it to 1
o If the lock is already 1, the process waits until it becomes 0
o Thus a 0 means that no process is in its critical region, and a 1 means that some process is in its critical
region
o Disadvantages
Suppose that one process reads the lock and sees that it is 0. Before it can set the lock to 1, another
process is scheduled, runs and sets the lock to 1. when the first process runs again, it will also set the
lock to 1 and the two processes will be in their critical region at the same time causing race condition
Continuously testing a variable waiting for some value to appear is called busy waiting. This technique
wastes processor time
C. Strict Alternation
o Strict alternation is shown in the program fragment below for two processes, process 0 and process 1. This
solution requires that the two processes strictly alternate in entering their critical regions.

9
 While (TRUE) {
While (TRUE) { While(turn!=1) /*wait*/;
While(turn!=0) /*wait*/; Critical_region();
Critical_region(); turn=0;
turn=1; Noncritical_region();
Noncritical_region(); }
}
o The integer turn, initially 0, keeps track of whose turn it is to enter the critical region and examines or
updates the shared memory
o Initially, process 0 inspects turn, finds it to be 0, and enters its critical region. Process 1 also finds to be
0 and therefore sits in a tight loop continually testing turn to see when it becomes 1. When process 0
leaves the critical region, it sets turn to 1, to allow process 1 to enter its critical region.
o Disadvantages
Taking turns is not a good idea when one of the processes is much slower than the other. This
situation violates condition 3 of implementing mutual exclusions: process 0 is being blocked by
a process not in its critical region.
D. Peterson’s Solution
o It is a software solution. It combines the idea of taking turns with the idea of lock variables and warning
variables. It does not require strict alternation.
o Before using the shared variable, i.e. before entering its critical region, each process calls enter_region
procedure with its own process number, 0 or 1 as a parameter. This call will cause it to wait, if need be,
until it is safe to enter. After it has finished with the shared variables, the process calls leave_region
procedure to indicate that it is done and to allow the other process to enter, if it so desires. The code is
shown below:

#define FALSE 0
#define TRUE 1
#define N 2 /* number of processes*/
int turn; /*whose turn is it?*/
int interested[N]; /*all values initially 0 (FALSE)*/
void enter_region (int process) /*process is 0 or 1*/
{
int other; /*number of the othe process*/
other = 1-process; /*the opposite of the process*/
interested[process] = TRUE; /*show that you are interested*/
turn = process; /* set flag*/
while (turn ==process && interested[other]=TRUE); /*null statement*/
}
void leave_region (int process) /*process who is leaving*/
{
interested[process] = FALSE;
}
10
 o Initially, neither process is in its critical section. Now process 0 calls enter_region. It indicates its interest
by setting its array element & sets turn to to 0. Since process 1 is not interested, enter_region returns
immediately. If process 1 now calls enter_region, it will hang there until interested[0] goes to false, an
event that only happens when process 0 calls leave_region to exit the critical region.
o Now consider the case that both processes call enter_region almost simultaneously. Both will store
their process number in turn. Whichever store is done last is the one that counts; the first one is lost.
Suppose that process 1 stores last, so turn is 1. When both processes come to the while statement,
process 0 executes it zero times and enters its critical section. Process 1 loops and does not enter its
critical section.
E. TSL Instruction
o This technique requires a little help from the hardware. It uses the hardware instruction TSL.
o TSL (Test and Set Lock) is an indivisible atomic instruction that copies the content of a memory location
into a register and stores a non-zero value at the memory location. The operation of reading the word
and storing into it are guaranteed to be indivisible, i.e. no other processor can access the memory word
until the instruction is finished. The processor executing the TSL instruction locks the memory bus to
prohibit other processors from accessing the memory until it is done.
o To implement mutual exclusion with TSL instruction, we use a shared variable, lock, to coordinate
access to shared memory. When lock is 0 the process may set it to 1 using TSL instruction and
executes its critical section. When it is done, the process sets lock into 0.

enter_region:
TSL register, lock ;copy lock to register and set lock to 1
CMP register, #0 ;was lock 0?
JNE enter region ;if it was non zero, lock was set, so loop
RET ;return to caller, critical region entered
leave_region:
MOV lock, #0 ;store 0 in lock
RET ;return to caller

o Before entering its critical region, a process calls enter_region, which does busy waiting until the lock is
free; then it acquires the lock and returns. After the critical region the process calls leave_region, which
stores a 0 in lock.

Implementing Mutual Exclusion without Busy Waiting

o Both Peterson’s solution and the solution using TSL are correct, but both have the defect of requiring
busy waiting which wastes CPU time and which can also have unexpected effects, like the priority
inversion problem.
o Priority inversion problem: consider a computer with two processes, H with high priority and L with low
priority. The scheduling rules are such that H runs whenever it is in the ready state. At a certain
moment, with L in its critical region, H becomes ready to run. H now begins busy waiting, but since L is
never scheduled while H is running, L never gets the chance to leave its critical region, so H loops
forever.
o Now let us look at some inter-process communication primitives that block instead of wasting CPU time
when they are not allowed to enter their critical regions.
Sleep: It is a system call that causes the caller to block, i.e. be suspended until another process
wakes it up.
Wakeup: It is a system call that causes the process specified by the parameter to wake up.
o As an example of how these primitives can be used let us consider the producer-consumer problem
(also known as the bounded buffer problem)

11
o Producer-consumer problem
Two processes share a common fixed-size buffer. One of, the producers, puts information in
the buffer, and the other one, the consumer, takes it out.
When the producer wants to put a new item in the buffer, it checks the buffer, if it is full, it goes
to sleep, to be awakened when the consumer has removed one or more items.
When the consumer wants to remove an item from the buffer and sees that the buffer is empty,
it goes to sleep until the producer puts something in the buffer and wakes it up.
Let us see the producer-consumer problem using c programming

#define N 100 /* number of slots in the buffer*/

int count =0; /*number of items in the buffer*/
void producer ()
{
while (TRUE)
{ /*repeat forever*/
item=producer_item(); /*generate next item*/
if(count==N) sleep(); /*if buffer is full, go to sleep*/
insert_item(item); /*put item in buffer*/
count=count+1; /*increment count of items in buffer*/
if(count==1) wakeup(consumer); /*was buffer empty?*/
}
}

void consumer ()
{
while (TRUE)
{
if(count==0) sleep(); /*if buffer is empty, go to sleep*/
item=remove_item(); /*take item out of buffer*/
count=count-1; /*decrement count of items in buffer*/
if(count==N-1) wakeup(producer); /*was buffer full?*/
consume_item(item); /*print item*/
}
}
Problem:
• Race condition can occur because access to count is unconstrained. Consider the
following situation. The buffer is empty and the consumer has just read count to see if it
is 0. At that instant, the scheduler decides to stop running the consumer temporarily
and start running the producer. The producer enters an item in the buffer, increments
count, and notices that it is now 1. Reasoning the count was just 0, and thus the
consumer must be sleeping, and the producer calls wakeup to wake the consumer up.
Unfortunately, the consumer is not yet logically asleep, so the wakeup signal is lost.
When the consumer next runs, it will test the value of count it previously read, find it to
be 0, and go to sleep. Sooner or later the producer will fill up the buffer and also go to
sleep. Both will sleep forever.
• The problem arises because the wakeup signal is lost. A quick fix is to add to the rules
by adding wakeup-waiting bit. It is a piggy bank for wakeup signals

12
 - When a wakeup is sent to a process that is still awake, this bit is set. Later,
when the process tries to go to sleep, if the wakeup-waiting bit is on, it will be
turned off, but the process will stay awake.
- The wakeup waiting bit cannot be a general solution, especially for any random
number of processes.
A. Semaphores
o Semaphores solve the lost-wakeup problem
o A semaphore is a new integer variable type that counts the number of wakeups saved for future use. A
semaphore could have the value 0, indicating that no wakeups were saved or some positive value if
one or more wakeups were pending.
o Two operations were proposed to implement semaphores: up and down
DOWN operation
• It checks the value of the semaphore to see if the value is greater than 0. If so it
decrements the value and just continues. If the value is 0, the process is put to sleep
without completing the DOWN operation for the moment
• Checking the value, changing it and going to sleep is all done as a single, indivisible
atomic operation. Once a semaphore operation has started, no other process can
access the semaphore until the operation has completed or blocked
UP operation
• It increments the value of the semaphore. If one or more processes were sleeping on
that semaphore, unable to complete an earlier DOWN operation, one of them is chosen
by the system and is allowed to complete its DOWN operation
• The process of incrementing the semaphore and waking up one process is also
indivisible.
Semantics of DOWN and UP operations
Void DOWN(s:semaphore)
{
if(s==0) sleep();
s=s-1;
}
Void UP(s:semaphore)
{
s=s+1;
wakeup a sleeping process if any;
}
o Semaphores can be implemented in either of the two ways:
As system calls, with the operating system disabling all interrupts while it is testing the
semaphore, updating it, and putting the process to sleep, if necessary
If multiple CPUs are being used, each semaphore should be protected by a lock variable, with
the TSL instruction used to make sure that only one CPU at a time examines the semaphore
o Solving the Producer – Consumer problem using semaphores

#define N 100 /*number of slots in the buffer*/

typedef int semaphore; /*semaphores are a special kind of int*/
semaphore mutex =1; /*controls access to critical section*/
semaphore empty =N; /*counts empty buffer slots*/
semaphore full =0; /*counts full buffer slots*/
void producer ()
{
int item;
13
 while (TRUE) {
item=produce_item(&item); /*generates something to put in buffer*/
down(&empty); /*decrements empty counts*/
down(&mutex); /*enter critical section*/
insert_item(item); /*enter new item in buffer*/
up(&mutex); /*leave critical section*/
up(&full); /*increment count of full slots*/ }
}

void consumer ()
{
int item;
while (TRUE) {
down(&full); /*decrement full count*/
down(&mutex); /*enter critical section*/
item=remove_item(&item); /*take item from buffer*/
up(&mutex); /*leave critical section*/
up(&empty); /*increment count of empty slots*/
consumer_item(item); /*do something with the item*/ }
}
The solution uses three semaphores: full, to count the number of full slots, empty, to count the
number of empty slots and mutex, to make sure the producer and the consumer do not access
the buffer at the same time
Mutex is used for mutual exclusion, i.e. it is designed to guarantee that only one process at a
time will be reading or writing the buffer and the associated variables
Full/empty are used for synchronization, i.e. they are designed to guarantee that certain event
sequences do or do not occur
The producer stops running when the buffer is full, and the consumer stops running when it is
empty.
Semaphores that are initialized to 1 and are used by two or more processes to ensure that only
one of them can enter its critical region at the same time are called binary semaphores
o Problems
Semaphores are too low-level and error prone. If you are not careful when using them, errors
like race condition, deadlocks and other forms of unpredictable and irreproducible behavior can
occur
Suppose that the two downs in the producer’s code were interchanged or reversed in order and
suppose also the buffer was full and mutex is 1
down (&mutex);
down (&empty);
The producer does a down on mutex and mutex becomes 0 and then the producer does a
down on empty. The producer would block since the buffer is full. Next time the consumer does
a down on mutex and it blocks since mutex is 0. Therefore both processes would block forever
and hence deadlock would occur.
B. Monitors
o A monitor is a higher level of synchronization primitive proposed by Hoare and Branch Hansen to make
writing a correct program easier.
o A monitor is a collection of procedures, variables and data structures that are all grouped together in a
special kind of module or package.
o Rules associated with monitors
Processes may call the procedures in a monitor whenever they want to, but they can not
directly access the monitor’s internal data structures

14
 Only one procedure can be active in a monitor at any instant. Monitors are programming
language construct, so the compiler knows that they are special and can handle calls to a
monitor procedures differently from other procedure calls
It is the compiler that implements mutual exclusion. The person writing the monitor does not
have to be aware of how the compiler arranges for mutual exclusion. It is sufficient to know that
by turning all critical regions into monitor procedure, no two processes will ever execute their
critical regions at the same time.
o Monitors use condition variables, along with two operations on them, WAIT and SIGNAL to block and
wake up a process.
WAIT
• When a monitor procedure discovers that it can not continue, it does a WAIT on some
condition variable that causes the calling procedure to block.
• It allows another process that had been previously prohibited from entering the monitor
to enter now.
SIGNAL
• A process can wake up its sleeping partner by doing a SIGNAL on the condition
variable that its partner is waiting on
• A process doing a SIGNAL statement must exit the monitor immediately, i.e. SIGNAL
will be the final statement in a monitor procedure. This avoids having two active
processes in a monitor at the same time.
• If a SIGNAL is done on a condition variable on which several processes are waiting,
only one of them, determined by the system scheduler is revived.
Condition variables are not counters. They do not accumulate signals for later use, unlike
semaphores. If a condition variable is signaled with no one waiting on it, the signal is lost.
The WAIT must always come before the SIGNAL
o An outline of the producer-consumer problem with monitors is shown below
Monitor ProducerConsumer
Condition full, empty; Begin
Integer count;

Procedure enter;
Begin
Produce_item;
If count=N then wait(full);
ProducerConsumer.enter;
Enter_item;
End;
Count=count+1;
End;
If count =1 then Signal(empty);
End;
Procedure consumer;
Procedure remove; Begin;
Begin While true do
If count=0 then wait(empty); Begin
remove_item; ProducerConsumer.remove;
Count=count-1; Produce_item;
If count =N-1 then Signal(full); End;
End; End;
Count=0;
End monitor;
Procedure producer;
Begin;
While true do
15
o WAIT and SIGNAL are similar to SLEEP and WAKEUP but with one critical difference. SLEEP and WAKEUP
failed because while one process was trying to go to sleep, the other one was trying to wake it up. With
monitors, this cannot happen. The automatic mutual exclusion on monitor procedures guarantees that if, say,
the procedure inside a monitor discovers that the buffer is full, it will be able to complete the WAIT operation
without having to worry about the possibility that the scheduler may switch to the consumer just before the
WAIT completes.
o Advantage of monitors
By making mutual exclusion of critical regions automatic, monitors make parallel programming much
less error prone than with semaphores
o Drawback of monitors
You need a language that has built-in monitors, but languages that have built-in monitors are rare. But
adding semaphores in C, C++ and other languages is easy.
o Drawback of monitors and semaphores
They were designed for solving the mutual exclusion problem on one or more CPUs that all have
access to a common memory
In a distributed system consisting of multiple CPUs, each with its own private memory, connected by a
local area network, these primitives become inapplicable
Semaphores are too low level and monitors are not usable except in a few programming languages.
And none of them provide information exchange between machines

B. Message Passing
o This technique uses two primitives: SEND and RECEIVE
o SEND and RECEIVE are system calls and they can be put as library procedures: SEND(dest, &msg),
RECEIVE(source, &msg)
o If no message is available, the receiver could block until one arrives or could return with an error code
o The producer-consumer problem with message passing
An outline for the solution of producer-consumer problem with message passing is shown below
#define N 100
void producer()
{
int item;
message m;
while (TRUE) {
produce_item(&item);
receive(consumer, &m);
build_message(&m, item);
send(consumer, &m); }
}
void consumer()
{
int item, i;
message m;
for(I=0;I<N;I++) send (producer, &m);
while(TRUE) {
receive(producer, &m);
extract_item(&m, &item);
send(producer, &m);
consume_item(item);
}
}
16
 All messages are of the same size
Messages sent are buffered automatically by the operating system
The consumer starts out by sending N empty messages
Whenever the producer has an item to give to the consumer, it takes an empty message and sends
back a full one
If the producer works faster
• All messages will end up full, waiting for the consumer
• The producer will be blocked, waiting for an empty messages to comeback
If the consumer works faster
• All the messages will be empties waiting for the producer to fill them up
• The consumer will be blocked, waiting for a full message
o Message passing variants (How messages are addressed?)
Using process address
• Assigning each process a unique address and have messages be addressed to processes
Using mailbox
• A mailbox is a place to buffer certain number of messages, typically specified when the
mailbox is created
• The address parameters in SEND and RECEIVE calls are mailboxes not processes
• The producer sends messages containing data to the consumer’s mailbox and the consumer
sends empty messages to the producer’s mailbox
Rendezvous (Eliminate buffering)
• SEND is done before RECEIVE
• The sending process is blocked until the receive happens at which time the message can be
copied directly from the sender to the receiver, with no intermediate buffering
• If the receive is done first, the receiver is blocked until a send happens
• It is easier to implement
• It is less flexible since the sender and receiver are forced to run in lock stop
o Design issues for message passing
Messages can be lost. The solution for this problem is using acknowledgement message
Acknowledgement message can be lost. The solution for this problem is to put consecutive sequence
numbers in each original message
Ambiguous process names. The solution for this problem to use naming conventions
Authentication
Performance, especially if sender and receiver processes are on the same machine
2.4 Process Scheduling
2.4.1 Preemptive and non-preemptive scheduling
o Scheduling refers to a set of policies and mechanisms to control the order of work to be performed by a
computer system. Of all the resources of a computer system that are scheduled before use, the
CPU/processor is the far most important.
o Processor Scheduling is the means by which operating systems allocate processor time for processes.
o The operating system makes three types of scheduling decisions with respect to execution of processes:
Long-term Scheduling
• The decision to add to the pool of processes to be executed
• It determines when new processes are admitted to the system
• It is performed when a new process is created and admitted
Medium-term Scheduling
• The decision to add to the number of processes that are partially/fully in main memory

17
 • It determines when a program is brought partially or fully into main memory so that it may be
executed
• It is performed when swapping is done
Short-term Scheduling
• The decision of which ready process to execute next
• It determines which ready process will get processor time next
• It is performed when a ready process is allocated the processor (when it is dispatched)
o Part of the operating system that makes scheduling decision is called scheduler and the algorithm it uses is
called scheduling algorithm
o In the case of short term scheduling, the module that gives control of CPU to the process selected by the
scheduler is called dispatcher. Its functions are
Process switch (Context Switch)
Mode Switch: Kernel User
Control branching: to the proper location in the user program
o There are some requirements that should be met by short-term schedulers/scheduling algorithms. Some of
these requirements are user-oriented, which relate to the behavior of the system as perceived by the
individual user or process and the rest are system-oriented, which focus on effective and efficient utilization
of the processor
Response Time: For interactive users, the time from submission of request until the response begins
to be received should be minimized
Turn Around Time: For batch users, the interval of time between the submission of a process and its
completion should be minimized
Throughput: The number of processes completed per unit time should be maximized
Fairness: Each process should get its fair share of the CPU. No process should suffer starvation
Predictability: A given process should run in about the same amount of time and at about the same
cost regardless of the load of the system
Efficiency/CPU Utilization: The percentage of time that the CPU is busy should be maximized
o Scheduling requirements are interdependent and some of them are contradictory and hence it is impossible to
optimize all of them simultaneously. For instance minimizing response time requires frequent switching which
increases the overhead of the system and so reduces throughput
o The design of scheduling policy involves compromising among competing requirements
o There are two main characteristics of short-term scheduling algorithms
Selection function
• It determines which process, among ready processes, is selected for execution
• It may be based on
- Priority
- Resource requirement
- Execution behavior: time spent in system so far (waiting and executing), time spent in
execution so far, total service time required by the process
Decision mode
• It specifies the instants in time at which the selection function is exercised
• There are two types of decision modes
- Preemptive
The strategy of allowing processes that are logically runnable to be temporarily
suspended and be moved to the ready state. Events that may result pre-emption
are arrival of new processes, occurrence of an interrupt that moves blocked
process to ready state and clock interrupt
Suitable for general purpose systems with multiple users
Guarantees acceptable response time and fairness
18
 Context switching is an overhead
- Non-Preemptive
Run to completion method: once a process is in running state, it continues to
execute until it terminates or blocks itself to wait for some event
Simple and easy to implement
Used in early batch systems
It may be well reasonable for some dedicated systems
Efficiency can be attained but response time is very high
2.4.2 Scheduling policies
a. First-Come-First-Served Scheduling (FCFSS)
Basic Concept
o The process that requested the CPU first is allocated the CPU and keeps it until it released it,
either due to completion or request of an I/O operation. The process that has been in the ready
queue the longest is selected for running.
o Its selection function is waiting time and it uses non preemptive scheduling/decision mode
o Process execution begins with CPU burst, followed by an I/O burst, followed by another CPU
burst, then by another I/O burst and so on.
Illustration
o Consider the following processes arrive at time 0
Process P1 P2 P3
CPU Burst/Service Time (in ms) 24 3 3
Case i. If they arrive in the order of P1, P2, P3
Process P1 P2 P3
Service Time (Ts) 24 3 3
Turn around time (Tr) 24 27 30
Response time 0 24 27
Tr/Ts 1 9 10
Average response time = (0+24+27)/3 = 17
Average turn around time = (24+27+30)/3=27
Throughput = 3/30= 1/10
Case ii. If they arrive in the order of P3, P2, P1
Process P3 P2 P1
Service Time (Ts) 3 3 24
Turn around time (Tr) 3 6 30
Response time 0 3 6
Tr/Ts 1 2 1.25
Average response time = (0+3+6)/3 = 3
Average turn around time = (3+6+30)/3=13
Throughput = 3/30= 1/10
o Consider the following processes arrive at time 0, 1, 2, 3 respectively
Process P1 P2 P3 P4
Arrival Time (Ta) 0 1 2 3
Service Time (Ts) 1 100 1 100
Turn around time (Tr) 1 100 100 199
Response time 0 0 99 99
Tr/Ts 1 1 100 1.99
Average response time = (0+0+99+99)/4 = 49.5
Average turn around time = (1+100+100+199)/4=100
Throughput = 4/202
19
 Advantages
o It is the simplest of all non-preemptive scheduling algorithms: process selection & maintenance of
the queue is simple
o There is a minimum overhead and no starvation
o It is often combined with priority scheduling to provide efficiency
Drawbacks
o Poor CPU and I/O utilization: CPU will be idle when a process is blocked for some I/O operation
o Poor and unpredictable performance: it depends on the arrival of processes
o Unfair CPU allocation: If a big process is executing, all other processes will be forced to wait for a
long time until the process releases the CPU. It performs much better for long processes than short
ones

b. Shortest Job First Scheduling (SJFS)

Basic Concept

o Process with the shortest expected processing time (CPU burst) is selected next
o Its selection function is execution time and it uses non preemptive scheduling/decision mode
Illustration
o Consider the following processes arrive at time 0
Process P1 P2 P3
CPU Burst (in ms) 24 3 3

Case i. FCFSS
Process P1 P2 P3
Turn around time 24 27 30
Response time 0 24 27
Average response time = (0+24+27)/3 = 17
Average turn around time = (24+27+30)/3=27
Throughput = 3/30

Case ii. SJFS

Process P3 P2 P1
Turn around time 3 6 30
Response time 0 3 6
Average response time = (0+3+6)/3 = 3
Average turn around time = (3+6+30)/3=13
Throughput = 3/30

o Consider the following processes arrive at time 0, 2, 4, 6, 8 respectively

Process P1 P2 P3 P4 P5
Arrival Time (Ta) 0 2 4 6 8
Service Time (Ts) 3 6 4 5 2
Turn around time (Tr) 3 7 11 14 3
Response time 0 1 7 9 1
Tr/Ts 1 1.17 2.75 2.8 1.5
Average response time = (0+1+7+9+1)/5 = 3.6
Average turn around time = (3+7+11+14+3)/5=7.6
Throughput = 5/20

20
Advantages
o It produces optimal average turn around time and average response time
o There is a minimum overhead
Drawbacks
o Starvation: some processes may not get the CPU at all as long as there is a steady supply of
shorter processes. It can be modified by reducing the calculated average time of the process by a
constant for each allocation so that it will be eventually move up to the next queue
o It is not desirable for a time-sharing or transaction processing environment because of its lack of
processing
o Variability of response time is increased, especially for longer processes
Difficulty with SJFS
o Figuring out the shortest process or the required processing time of each process: one
approach to is to
• Use aging: a technique of estimating the next value in a series by taking the weighed
average of the current measured value and the previous estimate
• Estimate the next CPU burst based on the average of the measured length of previous CPU
burst
• Sn+1 = 1/n (T1 + T2 + T3 … Tn) where Ti is processor execution time for the Ith instance
and Si is predicted value for the Ith instance
o Arrival of processes may not be simultaneous

c. Shortest Remaining Time Scheduling (SRTS)

Basic Concept
o The process that has the shortest expected remaining process time
o If a new process arrives with a shorter next CPU burst than what is left of the currently
executing process, the new process gets the CPU
o Its selection function is remaining execution time and uses preemptive decision mode

Illustration
o Consider the following processes arrive at time 0, 2, 4, 6, 8 respectively
Process P1 P2 P3 P4 P5
Arrival Time (Ta) 0 2 4 6 8
Service Time (Ts) 3 6 4 5 2
Turn around time (Tr) 3 13 4 14 2
Response time 0 1 0 9 0
Tr/Ts 1 2.17 1 2.8 1
Average response time = (0+1+0+9+0)/5 = 2
Average turn around time = (3+13+4+14+2)/5=7.2
Throughput = 5/20
Advantages
o It gives superior turnaround time performance to SJFS, because a short job is given immediate
preference to a running longer process
Drawbacks
o There is a risk of starvation of longer processes
o High overhead due to frequent process switch
Difficulty with SJFS
o Figuring out required processing time of each process

21
d. Round Robin Scheduling (RRS)
Basic Concept
o A small amount of time called a quantum or time slice is defined. According to the quantum, a
clock interrupt is generated at periodic intervals. When the interrupt occurs, the currently
running process is placed in the ready queue, and the next ready process is selected on a
FCFS basis.
o The CPU is allocated to each process for a time interval of upto one quantum. When a process
finishes its quantum it is added to the ready queue, when it is requesting I/O it is added to the
waiting queue
o The ready queue is treated as a circular queue
o Its selection function is based on quantum and it uses preemptive decision mode
Illustration
o Consider the following processes arrive at time 0, 2, 4 respectively
Process P1 P2 P3
Arrival Time (Ta) 0 2 4
Service Time (Ts) 3 7 4
Turn around time (Tr)
Response time
Tr/Ts
Average response time =
Average turn around time =)
Throughput = 3/14
Features
o The oldest, simplest, fairest and most widely used preemptive scheduling
o Reduces the penalty that short processes suffer with FCFS
Drawbacks
o CPU-bound processes tend to receive unfair portion of CPU time, which results in poor
performance for I/O bound processes
o It makes implicit assumption that all processes are equally important. It does not take external
factors into account
o Maximum overhead due to frequent process switch
Difficulty with RRS
o The length of the quantum should be decided carefully
• E.g.1 quantum =20ms, context switch =5ms, % of context switch = 5/25 *100=20%
Poor CPU utilization
Good interactivity
• E.g.1 quantum =500ms, context switch =5ms, % of context switch = 5/505 *100<1%
Improved CPU utilization
Poor interactivity
• Setting the quantum too short causes
Poor CPU utilization
Good interactivity
• Setting the quantum too long causes
Improved CPU utilization
Poor interactivity
• A quantum around 100ms is often reasonable compromise
o To enable interactivity, a maximum response time (MR) can be specified, and the quantum (m)
can be computed dynamically as follows
• m = MR/n , where n is number of processes
A new m is calculated when the number of processes changes
22
 • Not to allow m to be very small
Fix a minimum quantum (min_time_slice) and choose the maximum of MR/n and
min_time_slice: m = max (MR/n, min_time_slice)
Use biased round robin that gives extra service to high priority processes: e.g. process k is
given a time slice of mk
mk = max (pkMR/∑pi , min_time_slice) , where pi is the priority of process I
and bigger pi means higher priority
e. Priority Scheduling (PS)
Basic Concept
o Each process is assigned a priority and the runnable process with the highest priority is allowed
to run i.e. a ready process with highest priority is given the CPU.
o It is often convenient to group processes into priority classes and use priority scheduling among
the classes but round robin scheduling within each class
Illustration
o Consider the following processes arrive at time 0
Process P1 P2 P3 P4 P5
Priority 2 4 5 3 1
Service Time (Ts) 3 6 4 5 2
Turn around time (Tr) 18 10 4 15 20
Response time 15 4 0 10 18
Tr/Ts 6 1.67 1 3 10
Average response time = (0+15+4+10+18)/5 = 9.4
Average turn around time = (18+10+4+15+20)/5=13.4
Throughput = 5/20= 0.25
o Consider the following priority classes
Processes type: Deans Heads Instructors Secretaries Students
Priority: 5 4 3 2 1
• As long as there are runnable processes in priority level 5, just run each
one for one quantum, round robin fashion, and never bother with lower
priority classes
• If priorities are not adjusted occasionally, lower priority classes may all
starve to death
Advantages
o It considers the fact that some processes are more important than others, i.e. it takes external
factors into account
Drawbacks
o A high priority process may run indefinitely and it can prevent all other processes from running.
This creates starvation on other processes. There are two possible solutions for this problem:
• Assigning a maximum quantum to each process
• Assigning priorities dynamically, i.e. avoid using static priorities
Assigning a process a priority of 1/q where q is the fraction of the last quantum that is
used
- A process that used only 2ms of its 100ms quantum would get a priority of
50=1/2/100
- A process that used 50ms of its 100ms quantum would get a priority of
2=1/50/100
Decreasing the priority of the currently running process at each clock tick

23
2.5 Deadlock
Computer systems are full of resources that can only be used by one process at a time.
E.g. plotter, CD-ROM readers/recorders, tape drive backup systems
Definition: A set of processes is deadlocked if each process in the set is waiting for an event that only another process
in the set can cause.
♦ Deadlock happens when processes have been granted exclusive access to resources such as devices, files, and so
forth.
♦ A resource is anything that can only be used by a single process at any instance.
♦ There are two types of resources
o Preemptable (can be taken away from a process) and
o Non-preemptable (cannot be taken away from its current owner without causing the computation to
fail). If a process has began to burn a CD-ROM, suddenly taking the CD recorder away from it and
giving it to another process will result in a garbled CD.
♦ In general deadlock involves non-preemptable resources
♦ The sequence of events while using resources are:
o Request the resource
o Use the resource
o Release the resource
Examples:
1. Suppose that process A asks for CD-ROM drive and gets it. A moment later, process B asks for the flatbed
plotter and gets it, too. Now process A asks for the plotter and blocks waiting for it. Finally process B asks for
CD-ROM drive and also blocks. This situation is called a deadlock.
2. Suppose process A locks record R1 and process B locks record R2, and then each process tries to lock the other
one’s record, this time a deadlock will happen.
Conditions for deadlock
1. Mutual Exclusion: Each resource is either currently assigned to exactly one process or is available
2. Hold and Wait Condition: Processes currently holding resources granted earlier can request new resources
3. No Preemptive Condition: Resources previously granted cannot be forcibly taken away from a process
4. Circular Wait Condition: There must be a circular chain of two or more processes, each of which is waiting
for a resource held by the next member of the chain.
Note: If one of the four is absent, no deadlock is possible
Deadlock Modeling

♦ Directed graph can be used

♦ We have two kinds of nodes: Process (circles) and Resources (square)
♦ An arc from a resource to a process means the resource is currently held by that process
♦ An arc from process to a resource means the process is currently blocked waiting for that resource
♦ The following resource allocation graph shows a deadlock

24
 The Cycle is:
B-R1-A-R2-B

Example: Let we have three processes A, B, C and three resources R1, R2 and R3. The request and the release of the
three processes are as follows:
A B C
A1: requests R1 B1: Requests R2 C1: Requests R3
A2: requests R2 B2: Requests R3 C2: Requests R1
A3: releases R1 B3: Releases R2 C3: Releases R3
A4: releases R2 B4: Releases R3 C4: Releases R1

♦ Let round robin scheduling algorithm is used and instructions are executed in the following order:
A1 B1 C1 A2 B2 C2

♦ Resource graphs are a tool that let us see if a given request/release sequence leads to deadlock
♦ If there is any cycle in the graph that means there is a deadlock
Solving Deadlock Problems

♦ In general, four strategies are used for dealing with deadlocks

o Ignore the problem
o Detect and recover
o Dynamically avoid deadlock by careful resource allocation
o Prevent, by structurally negating one of the four required conditions
The Ostrich Algorithm
It is the simplest approach
Stick your head in the sand and pretend there is no problem at all.
• Mathematicians do not accept it
• Engineers accept with constraints – frequency (chance of happening)
The problem is the price, mostly in terms of putting inconvenient restrictions on processes

2.5.1 Detection
Every time a resource is requested or released, the resource graph is updated, and a check is
made to see if any cycles exist
If cycle exists, one of the processes in the cycle is killed
If the method is to check the length of time a process is requesting a resource and if large kill it

25
2.5.2 Prevention
Impose some condition on processes
• Spooling – By spooling printer output, several processes can generate output at the
same time but the only process that actually requests the physical printer is the printer
daemon.
• Disadvantage: This solution cannot be used for every device
If we can prevent processes that hold resources from waiting for more resources, we can
eliminate deadlocks. (request before use)
• Disadvantage: Resources will not be used optimally and most processes do not know
that resources they need before running
Let a process temporarily release all the resources it currently holds when requesting another
resource.
Let every process is entitled only to a single resource at any moment
• Disadvantage: Consider a process that copies a huge file from a tape to a printer
Let resources be requested in predefined order
• Disadvantage: Ordering resources is almost impossible to meet the requirements of all
processes
Summary

Condition Approach
Mutual Exclusion Spool everything
Hold and wait Request all resources initially
No preemptive Take resources away
Circular wait Order resources numerically

2.5.3 Avoidance
We can avoid deadlocks, but only if certain information is available in advance
The Banker’s algorithm considers each request as it occurs and sees if granting it leads to a safe
state. If it does, the request is granted; otherwise, it is postponed until later.
To see if a state is safe, the banker checks to see if he has enough resources to satisfy the
customer closest to his or her maximum. If so, those loans are assumed to be repaid. If all loans
can eventually be repaid, the state is safe and the initial request can be granted.
Here there is no imposition of rules on processes like the case in prevention case.

26