lOMoARcPSD|28935410

CS3451 OS Unitii Notes - DSSDSD

Computer Science and Engineering (Anna University)

Scan to open on Studocu

Studocu is not sponsored or endorsed by any college or university

Downloaded by surya prakash (psurya0303@[Link])
 lOMoARcPSD|28935410

GRT INSTITUTE OF
ENGINEERING AND
TECHNOLOGY, TIRUTTANI - 631209
Approved by AICTE, New Delhi Affiliated to Anna University,
Chennai

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

II CSE
IV SEMESTER
ACADEMIC YEAR 2023-2024

CS3451
INTRODUCTION TO OPERATING SYSTEM

UNIT II
(NOTES)

Prepared by
[Link] [Link].,
ASST. PROF , DEPT. OF /CSE
GRTIET

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

UNIT-II
PROCESS MANAGEMENT

Processes-Process Concept:

An operating system executes a variety of programs:

O Batch system – ―jobs”
o Time-shared systems – ―user programs” or ―tasks” 
We will use the terms job and process almost interchangeably 
Process – is a program in execution (informal definition)
 Program is passive entity stored on disk (executable file), process is active
o Program becomes process when executable file loaded into
memory  Execution of program started via GUI, command line entry of its
name, etc  One program can be several processes
o Consider multiple users executing the same program
x In memory, a process consists of multiple parts:
o Program code, also called text section
o Current activity including
ƒ program counter
ƒ processor registers
o Stack containing temporary data
ƒ Function parameters return addresses, local variables
o Data section containing global variables
o Heap containing memory dynamically allocated during run time

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

As a process executes, it changes state

o new: The process is being created
o ready: The process is waiting to be assigned to a processor
o running: Instructions are being executed
o waiting: The process is waiting for some event to occur
o terminated: The process has finished execution
PROCESS CONTROL BLOCK (PCB)
Each process is represented in the operating system by a process control block (PCB)—also called a
task control block. A PCBis shown in 3.3. It contains many pieces of information associated with a
specific process, including these:

Figure 3.3 Process control block (PCB)

• Process state. The state may be new, ready, running, waiting, halted, and so on.
• Program counter: The counter indicates the address of the next instruction to be executed for this process.
• CPU registers: The registers vary in number and type, depending on the computer architecture. They
include accumulators, index registers, stack pointers, and general-purpose registers, plus any condition-code
information. Along with the program counter, this state information must be saved when an interrupt occurs,
to allow the process to be continued correctly afterward (Figure 3.4).
• CPU-scheduling information:This information includes a process priority, pointers to scheduling queues,
and any other scheduling parameters.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

• Memory-management information: This information may include such items as the value of the base and
limit registers and the page tables, or the segment tables, depending on the memory system used by the
operating system
• Accounting information. This information includes the amount of CPU and real time used, time
limits, account numbers, job or process numbers, and so on.
• I/O status information. This information includes the list of I/O devices allocated to the process, a list of
open files, and so on.

Process Scheduling:
The objective of multiprogramming is to have some process running at all times, to maximize CPU
utilization. the process scheduler selects an available process (possibly from a set of several available
processes) for program execution on the CPU. For a single-processor system, there will never be more than
one running process. If there are more processes, the rest will have to wait until the CPU is free and can be
rescheduled.
Scheduling Queues
x Job queue – set of all processes in the system
x Ready queue – set of all processes residing in main memory, ready and waiting to
execute
x Device queues – set of processes waiting for an I/O device Processes migrate among
the various queues.

A common representation of process scheduling is a queueing diagram. Two types of queues are
present: the ready queue and a set of device queues. The circles represent the resources that serve the
queues, and the arrows indicate the flow of processes in the system. A new process is initially put in the
ready queue. It waits there until it is selected for execution, or dispatched. Once the process is allocated the
CPU and is executing, one of several events could occur:

• The process could issue an I/O request and then be placed in an I/O queue.
• The process could create a new child process and wait for the child’s termination.
• The process could be removed forcibly from the CPU, as a result of an interrupt, and be put back in the
ready queue.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Schedulers
x Long-term scheduler (or job scheduler) – selects which processes should be brought into the
ready queue
x Short-term scheduler (or CPU scheduler) – selects which process should be executed next and
allocates CPU

x Short-term scheduler is invoked very frequently (milliseconds)(must be fast)

x Long-term scheduler is invoked very infrequently (seconds, minutes)(may be slow)
x The long-term scheduler controls the degree of multiprogramming
x Processes can be described as either:
o I/O-bound process – spends more time doing I/O than computations, many short CPU bursts
o CPU-bound process – spends more time doing computations; few very long CPU bursts
Some operating systems, such as time-sharing systems, may introduce an additional, intermediate level of
scheduling. The key idea behind a medium-term scheduler is that sometimes it can be advantageous to remove a
process from memory (and from active contention for the CPU) and thus reduce the degree of multiprogramming.
Context Switch

x When CPU switches to another process, the system must save the state of the old process and
load the saved state for the new process
x Context-switch time is overhead; the system does no useful work while switching
x Time dependent on hardware support
Operations on Processes

Process Creation

x Parent process create children processes, which, in turn create other processes, forming
a tree of processes
x Resource sharing
o Parent and children share all resources
o Children share subset of parent’s resources
o Parent and child share no resources
 Execution
o Parent and children execute concurrently
o Parent waits until children terminate
 Address space

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

o Child duplicate of parent

o Child has a program loaded into
it  UNIX examples
o fork system call creates new process
o exec system call used after a fork to replace the process’ memory space with a new program

C Program Forking Separate Process

int main()
{
pid_t pid;
/* fork another process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
exit(-1);
}
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL);
}
else { /* parent process */
/* parent will wait for the child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);
}
}
A tree of processes on a typical Solaris

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Process Termination

x Process executes last statement and asks the operating system to delete it (exit)
o Output data from child to parent (via wait)
o Process’ resources are deallocated by operating system
x Parent may terminate execution of children processes (abort)
o Child has exceeded allocated resources
o Task assigned to child is no longer required
o If parent is exiting
ƒ Some operating system do not allow child to continue if its parent terminates
x All children terminated - cascading termination
Cooperating Processes
x Independent process cannot affect or be affected by the execution of another process
x Cooperating process can affect or be affected by the execution of another process
x Advantages of process cooperation
o Information sharing
o Computation speed-up
o Modularity
o Convenience
Interprocess Communication (IPC)

x Mechanism for processes to communicate and to synchronize their actions

x Message system – processes communicate with each other without resorting to shared variables
x IPC facility provides two operations:
o send(message) – message size fixed or variable
o receive(message)
 If P and Q wish to communicate, they need to:
o establish a communication link between them
o exchange messages via send/receive
x Implementation of communication link
o physical (e.g., shared memory, hardware bus)
o logical (e.g., logical properties)

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Direct Communication

x Processes must name each other explicitly:

o send (P, message) – send a message to process P
o receive(Q, message) – receive a message from process Q
 Properties of communication link
o Links are established automatically
o A link is associated with exactly one pair of communicating processes
o Between each pair there exists exactly one link
o The link may be unidirectional, but is usually bi-directional
Indirect Communication

x Messages are directed and received from mailboxes (also referred to as

ports) o Each mailbox has a unique id
o Processes can communicate only if they share a mailbox
x Properties of communication link
o Link established only if processes share a common mailbox
o A link may be associated with many processes
o Each pair of processes may share several communication links
o Link may be unidirectional or bi-directional
Threads- Overview

A thread is a basic unit of CPU utilization; it comprises a thread ID, a program counter, a
register set, and a stack. It shares with other threads belonging to the same process its code section, data
section, and other operating-system resources, such as open files and signals. A traditional (or heavyweight)
process has a single thread of control. If a process has multiple threads of control, it can perform more than
one task at a time.

Benefits

The benefits of multithreaded programming can be broken down into four major categories:
1. Responsiveness. Multithreading an interactive application may allow a program to
continue running even if part of it is blocked or is performing a lengthy operation, thereby
increasing responsiveness to the user.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

2. Resource sharing. Processes can only share resources through techniques such as
shared memory and message passing.
3. Economy. Allocating memory and resources for process creation is costly. Because threads share
the resources of the process to which they belong, it is more economical to create and context-
switch threads.
4. Scalability. The benefits of multithreading can be even greater in a multiprocessor
architecture, where threads may be running in parallel on different processing cores.
Multicore Programming
Earlier in the history of computer design, in response to the need for more computing
performance, single-CPU systems evolved into multi-CPU systems. A more recent, similar trend in
system design is to place multiple computing cores on a single chip. Each core appears as a separate
processor to the operating Whether the cores appear across CPU chips or within CPU chips, we call
these systems multicore or multiprocessor systems.
Multithreaded programming provides a mechanism for more efficient use of these multiple
computing cores and improved concurrency. Consider an application with four threads. On a system
with a single computing core, concurrency merely means that the execution of the threads will be
interleaved over time because the processing core is capable of executing only one thread at a time.
On a system with multiple cores, however,
Concurrency means that the threads can run in parallel, because the system can assign a
separate thread to each core .Notice the distinction between parallelism and concurrency in this
discussion. A system is parallel if it can perform more than one task simultaneously. In contrast, a
concurrent system supports more than one task by allowing all the tasks to make progress.
Multithreading Models

x Many-to-One
x One-to-One
x Many-to-Many
1. Many-to-One
 Many user-level threads mapped to single kernel
thread  Examples:
o Solaris Green Threads
o GNU Portable Threads

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

2. One-to-One
 Each user-level thread maps to kernel thread 
Examples
o Windows NT/XP/2000
o Linux
o Solaris 9 and later

3. Many-to-Many Model
 Allows many user level threads to be mapped to many kernel threads
x Allows the operating system to create a sufficient number of kernel threads
x Solaris prior to version 9
x Windows NT/2000 with the ThreadFiber package

Windows 7

Windows implements the Windows API, which is the primary API for the family of Microsoft
operating systems (Windows 98, NT, 2000, and XP, as well as Windows 7). Indeed, much of what is
mentioned in this section applies to this entire family of operating systems. A Windows application runs as a
separate process, and each process may contain one or more threads.

The general components of a thread include:

• A thread ID uniquely identifying the thread
• A register set representing the status of the processor
• A user stack, employed when the thread is running in user mode, and a kernel stack, employed when
the thread is running in kernel mode

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

• A private storage area used by various run-time libraries and dynamic link libraries (DLLs).
The register set, stacks, and private storage area are known as the context of the thread. The primary
data structures of a thread include:
• ETHREAD—executive thread block
• KTHREAD—kernel thread block
• TEB—thread environment block

Process Synchronization

x Concurrent access to shared data may result in data inconsistency.

x Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating
processes.
x Shared-memory solution to bounded-butter problem allows at most n – 1 items in buffer at the same
time. A solution, where all N buffers are used is not simple.
x Suppose that we modify the producer-consumer code by adding a variable counter, initialized to 0
and increment it each time a new item is added to the buffer
x 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.
x To prevent race conditions, concurrent processes must be synchronized.
The Critical-Section Problem:

x There are n processes that are competing to use some shared data
x Each process has a code segment, called critical section, in which the shared data is accessed.
x Problem – ensure that when one process is executing in its critical section, no other process is allowed
to execute in its critical section.
Requirements to be satisfied for a Solution to the Critical-Section Problem:
1. Mutual Exclusion - If process Pi is executing in its critical section, then no other processes can be
executing in their critical sections.
2. Progress - If no process is executing in its critical section and there exist some processes that wish to enter
their critical section, then the selection of the processes that will enter the critical section next cannot be
postponed indefinitely.
3. Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter
their critical sections after a process has made a request to enter its critical section and before that request is
granted.
do {
entry section
critical section
exit section
remainder section
} while (true);
 Two general approaches are used to handle critical sections in operating systems: preemptive
kernels and nonpreemptive kernels.
x A preemptive kernel allows a process to be preempted while it is running in kernel mode.
x A non-preemptive kernel does not allow a process running in kernel mode to be preempted; a kernel-
mode process will run until it exits kernel mode, blocks, or voluntarily yields control of the CPU.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Mutex Locks

x A high-level abstraction that provides a convenient and effective mechanism for process
synchronization
x Only one process may be active within the monitor at a time monitor monitor-name

/ shared variable declarations

procedure body P1 (…) { …. }

procedure body Pn (…) {……}

initialization code

x To allow a process to wait within the monitor, a condition variable must be declared as o condition x,
y;
x Two operations on a condition variable:
x [Link] () –a process that invokes the operation is suspended.
x [Link] () –resumes one of the suspended processes(if any)

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Solution to Dining Philosophers Problem

Monitor DP
{
enum { THINKING; HUNGRY, EATING) state [5] ;
condition self [5];
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);
}
void test (int i) {
if ( (state[(i + 4) % 5] != EATING)
&& (state[i] == HUNGRY) &&
(state[(i + 1) % 5] != EATING) )
{ state[i] = EATING ;
self[i].signal () ;
}
}
initialization_code()
{ for (int i = 0; i < 5; i+
+) state[i] =
THINKING;
}
}

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Semophores

x It is a synchronization tool that is used to generalize the solution to the critical section problem in
complex situations.
x A Semaphore s is an integer variable that can only be accessed via two indivisible (atomic)
operations namely
wait (s)
{
1. wait or P operation ( to test )
2. signal or V operation ( to increment )
while(s 0);
s--;
}
signal (s)
{
s++;
}
Mutual Exclusion Implementation using semaphore

do
{
wait(mutex);
critical section

remainder section
} while (1);
signal(mutex);
Semaphore Implementation

x The semaphore discussed so far requires a busy waiting. That is if a process is in critical-section,
the other process that tries to enter its critical-section must loop continuously in the entry code.
x To overcome the busy waiting problem, the definition of the semaphore operations wait and
signal should be modified.
 When a process executes the wait operation and finds that the semaphore value is not
positive, the process can block itself. The block operation places the process into a
waiting queue associated with the semaphore.
x A process that is blocked waiting on a semaphore should be restarted when some other
process executes a signal operation. The blocked process should be restarted by a wakeup
operation which put that process into ready queue.
 To implemented the semaphore, we define a semaphore as a record as:

typedef struct {

int value;

struct process *L;

} semaphore;

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Deadlock & starvation:

Example: Consider a system of two processes , P0 & P1 each accessing two semaphores ,S & Q,
set to the value 1.

P0 P1
Wait (S) Wait (Q)
Wait (Q) Wait (S)
. .
. .
. .
Signal(S) Signal(Q)
Signal(Q) Signal(S)
x Suppose that P0 executes wait(S), then P1 executes wait(Q). When P0 executes wait(Q), it
must wait until P1 executes signal(Q).Similarly when P1 executes wait(S), it must wait
until P0 executes signal(S). Since these signal operations cannot be executed, P0 & P1 are
deadlocked.
x Another problem related to deadlock is indefinite blocking or starvation, a situation where
a process wait indefinitely within the semaphore. Indefinite blocking may occur if we add
or remove processes from the list associated with a semaphore in LIFO order.
Types of Semaphores
x Counting semaphore – any positive integer value
x Binary semaphore – integer value can range only between 0 and 1

CPU Scheduling

x CPU scheduling is the basis of multi programmed operating systems.

x The objective of multiprogramming is to have some process running at all times, in order to
maximize CPU utilization.
x Scheduling is a fundamental operating-system function.
x Almost all computer resources are scheduled before use.
CPU-I/O Burst Cycle

x Process execution consists of a cycle of CPU execution and I/O wait.

x Processes alternate between these two states.
x Process execution begins with a CPU burst.
x That is followed by an I/O burst, then another CPU burst, then another I/O burst, and so on.
x Eventually, the last CPU burst will end with a system request to terminate execution,
rather than with another I/O burst.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

CPU Scheduler
Whenever the CPU becomes idle, the operating system must select one of the processes in the ready queue to
be executed.
The selection process is carried out by the short-term scheduler (or CPU scheduler).
The ready queue is not necessarily a first-in, first-out (FIFO) queue. It may be a FIFO queue, a priority
queue, a tree, or simply an unordered linked list.
Preemptive Scheduling
x CPU scheduling decisions may take place under the following four circumstances:
1. When a process switches from the running state to the waiting state
2. When a process switches from the running state to the ready state
3. When a process switches from the waiting state to the ready state
4. When a process terminates
x Under 1 & 4 scheduling scheme is non preemptive.
x Otherwise the scheduling scheme is preemptive.
Non-preemptive Scheduling
In non preemptive scheduling, once the CPU has been allocated a process, the process keeps the
CPU until it releases the CPU either by termination or by switching to the waiting state.
This scheduling method is used by the Microsoft windows environment.
Dispatcher
The dispatcher is the module that gives control of the CPU to the process selected by the short-term
scheduler.
This function involves:
1. Switching context
2. Switching to user mode
3. Jumping to the proper location in the user program to restart that program
Scheduling Criteria

1. CPU utilization: The CPU should be kept as busy as possible. CPU utilization may range from 0 to 100
percent. In a real system, it should range from 40 percent (for a lightly loaded system) to 90 percent (for a
heavily used system).
2. Throughput: Itis the number of processes completed per time unit. For long processes, this rate may be 1
process per hour; for short transactions, throughput might be 10 processes per second.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

3. Turnaround time: The interval from the time of submission of a process to the time of completion is
the turnaround time. Turnaround time is the sum of the periods spent waiting to get into memory, waiting
in the ready queue, executing on the CPU, and doing I/O.
4. Waiting time: Waiting time is the sum of the periods spent waiting in the ready queue.
5. Response time: It is the amount of time it takes to start responding, but not the time that it takes to output
that response.
CPU Scheduling Algorithms
1. First-Come, First-Served Scheduling
2. Shortest Job First Scheduling
3. Priority Scheduling
4. Round Robin Scheduling
First-Come, First-Served (FCFS) Scheduling

Process Burst Time

P1 24

P2 3

P3 3

• Suppose that the processes arrive in the order: P1 , P2 ,

P3 The Gantt Chart for the schedule is:

• Waiting time for P1 = 0; P2 = 24; P3 = 27

• Average waiting time: (0 + 24 + 27)/3 = 17

Suppose that the processes arrive in the order

The Gantt chart for the schedule is:

• Waiting time for P1 = 6; P2 = 0; P3 = 3

• Average waiting time: (6 + 0 + 3)/3 = 3

• Much better than previous case

• Convoy effect short process behind long process

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its next CPU burst. Use these lengths to schedule the
process with the shortest time

• SJF is optimal – gives minimum average waiting time for a given set of processes

– The difficulty is knowing the length of the next CPU request

Process Arrival Time Burst Time

P1 0.0 6

P2 2.0 8

P3 4.0 7

P4 5.0 3
• SJF scheduling chart

• Average waiting time = (3 + 16 + 9 + 0) / 4 = 7

Determining Length of Next CPU Burst

• Can only estimate the length

• Can be done by using the length of previous CPU bursts, using exponential averaging

1. tn actual length of nth CPU burst


2. n1 predicted value for the next CPU burst
3. , 0    1

n 1  tn 1 n .
4. Define :

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Examples of Exponential Averaging

•  =0

– n+1 = n

– Recent history does not count

•  =1

– n+1 =  tn

– Only the actual last CPU burst counts

• If we expand the formula, we get:

n+1 =  tn+(1 - ) tn -1 + …

+(1 -  )j  tn -j + …

+(1 -  )n +1 0

• Since both  and (1 - ) are less than or equal to 1, each successive term has less weight than its
predecessor
Priority Scheduling

• A priority number (integer) is associated with each process

• The CPU is allocated to the process with the highest priority (smallest integer  highest priority)

– Preemptive

– nonpreemptive

• SJF is a priority scheduling where priority is the predicted next CPU burst time

• Problem  Starvation – low priority processes may never execute

• Solution  Aging – as time progresses increase the priority of the process

Round Robin (RR)

• Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this
time has elapsed, the process is preempted and added to the end of the ready queue.
• If there are n processes in the ready queue and the time quantum is q, then each process gets 1/n
of the CPU time in chunks of at most q time units at once. No process waits more than (n-1)q time
units.

• Performance

– q large FIFO

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

– q small q must be large with respect to context switch, otherwise overhead is too high

Example of RR with Time Quantum = 4

Process Burst Time

P1 24

P2 3

P3 3
• The Gantt chart is:

• Typically, higher average turnaround than SJF, but better response

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Multilevel Queue

• Ready queue is partitioned into separate queues:

foreground (interactive)
background (batch)

• Each queue has its own scheduling algorithm

– foreground – RR

– background – FCFS

• Scheduling must be done between the queues

– Fixed priority scheduling; (i.e., serve all from foreground then from background). Possibility
of starvation.

– Time slice – each queue gets a certain amount of CPU time which it can schedule amongst its
processes; i.e., 80% to foreground in RR

– 20% to background in FCFS

Multilevel Feedback Queue

• A process can move between the various queues; aging can be implemented this way

• Multilevel-feedback-queue scheduler defined by the following parameters:

– number of queues

– scheduling algorithms for each queue

– method used to determine when to upgrade a process

– method used to determine when to demote a process

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

– method used to determine which queue a process will enter when that process needs service

Deadlocks

• A set of blocked processes each holding a resource and waiting to acquire a resource held by another
process in the set.

• Example

– System has 2 disk drives.

– P1 and P2 each hold one disk drive and each needs another one.

• Example

– semaphores A and B, initialized to 1

P0 P1

wait (A); wait(B)

wait (B); wait(A)

System Model

• Resource types R1, R2, . . ., Rm

CPU cycles, memory space, I/O devices
• Each resource type Ri has Wi instances.
• Each process utilizes a resource as follows:
– request
– use
– release
Deadlock Characterization

Deadlock can arise if four conditions hold simultaneously.

• Mutual exclusion: only one process at a time can use a resource.
• Hold and wait: a process holding at least one resource is waiting to acquire additional resources held
by other processes.
• No preemption: a resource can be released only voluntarily by the process holding it, after that
process has completed its task.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

• Circular wait: there exists a set {P0, P1, …, P0} of waiting processes such that P0 is waiting for a
resource that is held by P1, P1 is waiting for a resource that is held by
P2, …, Pn–1 is waiting for a resource that is held by Pn, and P0 is waiting for a resource that is
held by P0.

Resource-Allocation Graph

A set of vertices V and a set of edges E.

• V is partitioned into two types:

– P = {P1, P2, …, Pn}, the set consisting of all the processes in the system.

– R = {R1, R2, …, Rm}, the set consisting of all resource types in the system.

• request edge – directed edge P1  Rj

• assignment edge – directed edge Rj  Pi

• Process

• Resource Type with 4 instances

• Pi requests instance of Rj

• Pi is holding an instance of Rj

Example of a Resource Allocation Graph

Basic Facts

• If graph contains no cyclesno deadlock.

• If graph contains a cycle

– if only one instance per resource type, then deadlock.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

– if several instances per resource type, possibility of deadlock.

Deadlock Prevention

• Mutual Exclusion – not required for sharable resources; must hold for non-sharable resources.
• Hold and Wait – must guarantee that whenever a process requests a resource, it does not hold
any other resources.
– Require process to request and be allocated all its resources before it begins execution, or
allow process to request resources only when the process has none.
– Low resource utilization; starvation possible.
• No Preemption –
– If a process that is holding some resources requests another resource that cannot be
immediately allocated to it, then all resources currently being held are released.
– Preempted resources are added to the list of resources for which the process is waiting.
– Process will be restarted only when it can regain its old resources, as well as the new ones
that it is requesting.
• Circular Wait – impose a total ordering of all resource types, and require that each process requests
resources in an increasing order of enumeration.
Deadlock Avoidance
Requires that the system has some additional a priori information available.
• Simplest and most useful model requires that each process declare the maximum number of
resources of each type that it may need.
• The deadlock-avoidance algorithm dynamically examines the resource-allocation state to ensure that
there can never be a circular-wait condition.
• Resource-allocation state is defined by the number of available and allocated resources, and
the maximum demands of the processes.
Safe State
• When a process requests an available resource, system must decide if immediate allocation leaves the
system in a safe state.
• System is in safe state if there exists a sequence <P1, P2, …, Pn> of ALL the processes is the systems
such that for each Pi, the resources that Pi can still request can be satisfied by currently available
resources + resources held by all the Pj, with j < i.
• That is:
– If Pi resource needs are not immediately available, then Pi can wait until all Pj have finished.
– When Pj is finished, Pi can obtain needed resources, execute, return allocated resources, and
terminate.
– When Pi terminates, Pi +1 can obtain its needed resources, and so on.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Avoidance algorithms
• Single instance of a resource type. Use a resource-allocation graph
• Multiple instances of a resource type. Use the banker’s algorithm
Resource-Allocation Graph Scheme
• Claim edge Pi  Rj indicated that process Pj may request resource Rj; represented by a dashed line.
• Claim edge converts to request edge when a process requests a resource.
• Request edge converted to an assignment edge when the resource is allocated to the process.
• When a resource is released by a process, assignment edge reconverts to a claim edge.
• Resources must be claimed a priori in the system.

Unsafe State In Resource-Allocation Graph

Banker’s Algorithm
• Multiple instances.
• Each process must a priori claim maximum use.
• When a process requests a resource it may have to wait.
• When a process gets all its resources it must return them in a finite amount of time.
• Let n = number of processes, and m = number of resources types.

• Available: Vector of length m. If available [j] = k, there are k instances of resource type Rj
available.
• Max: n x m matrix. If Max [i,j] = k, then process Pi may request at most k instances of
resource type Rj.
• Allocation: n x m matrix. If Allocation[i,j] = k then Pi is currently allocated k instances of
Rj.
• Need: n x m matrix. If Need[i,j] = k, then Pi may need k more instances of Rj to complete its
task.
Need [i,j] = Max[i,j] – Allocation [i,j].

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Example of Banker’s Algorithm

• 5 processes P0 through P4;

3 resource types:

A (10 instances), B (5instances), and C (7 instances).

• Snapshot at time T0:

Allocation Max Available

ABC ABC ABC

P0 010 753 332

P1 200 322

P2 302 902

P3 211 222

P4 002 433
• The content of the matrix Need is defined to be Max – Allocation.

Need

ABC

P0 743

P1 122

P2 600

P3 011

P4 431
• The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria.

Deadlock Detection

• Allow system to enter deadlock state

• Detection algorithm

• Recovery scheme

Single Instance of Each Resource Type

• Maintain wait-for graph

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

– Nodes are processes.

– Pi  Pj if Pi is waiting for Pj.

• Periodically invoke an algorithm that searches for a cycle in the graph. If there is a cycle, there exists
a deadlock.

• An algorithm to detect a cycle in a graph requires an order of n2 operations, where n is the number
of vertices in the graph.

Several Instances of a Resource Type

• Available: A vector of length m indicates the number of available resources of each type.

• Allocation: An n x m matrix defines the number of resources of each type currently allocated to each
process.
• Request: An n x m matrix indicates the current request of each process. If Request [ij] = k, then
process Pi is requesting k more instances of resource type. Rj.

Detection Algorithm

1. Let Work and Finish be vectors of length m and n, respectively Initialize:

(a) Work = Available

(b) For i = 1,2, …, n, if Allocationi  0, then

Finish[i] = false;otherwise, Finish[i] = true.
2. Find an index i such that both:

(a) Finish[i] == false

(b) Requesti  Work

If no such i exists, go to step 4.

3. Work = Work +
Allocationi Finish[i] = true
go to step 2.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Course material

4. If Finish[i] == false, for some i, 1  i  n, then the system is in deadlock state. Moreover, if
Finish[i] == false, then Pi is deadlocked.

Example of Detection Algorithm

• Five processes P0 through P4; three resource types

A (7 instances), B (2 instances), and C (6 instances).
• Snapshot at time T0:

Allocation Request Available

ABC ABC ABC

P0 010 000 000

P1 200 202

P2 303 000

P3 211 100

P4 002 002
• Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i.

• P2 requests an additional instance of type C.

Request

ABC

P0 000

P1 201

P2 001

P3 100

P4 002
• State of system?

– Can reclaim resources held by process P0, but insufficient resources to fulfill other processes;
requests.
– Deadlock exists, consisting of processes P1, P2, P3, and P4.

Recovery from Deadlock: Process Termination

• Abort all deadlocked processes.

• Abort one process at a time until the deadlock cycle is eliminated.

Downloaded by surya prakash (psurya0303@[Link])

 lOMoARcPSD|28935410

Course material

• In which order should we choose to abort?

– Priority of the process.

– How long process has computed, and how much longer to completion.

– Resources the process has used.

– Resources process needs to complete.

– How many processes will need to be terminated.

– Is process interactive or batch?

• Selecting a victim – minimize cost.

• Rollback – return to some safe state, restart process for that state.

• Starvation – same process may always be picked as victim, include number of rollback in cost factor.

Downloaded by surya prakash (psurya0303@[Link])