UNIT - II

CPU Scheduling - Scheduling Criteria, Scheduling Algorithms, Multiple -Processor

Scheduling. System call interface for process management-fork, exit, wait, waitpid, exec

Deadlocks - System Model, Deadlocks Characterization, Methods for Handling Deadlocks,

Deadlock Prevention, Deadlock Avoidance, Deadlock Detection, and Recovery from Deadlock

Scheduling criteria:

Many criteria have been suggested for comparing CPU-scheduling algorithms. The criteria
include the following:

CPU utilization: We want to keep the CPU 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).

Throughput: If the CPU is busy executing processes, then work is being done. One measure of
work is the number of processes completed per time unit, called throughput. For long processes,
this rate may be 1 process per hour; for short transactions, throughput might be 10 processes per
second.

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.

Waiting time: Waiting time is the sum of the periods spent waiting in the ready queue.

Response time: In an interactive system, turnaround time may not be the best criterion.
Another measure is the time from the submission of a request until the first response is
produced. This measure, called response time, is the amount of time it takes to start responding,
but not the time that it takes to output that response.
CPU Scheduling Algorithm:

CPU Scheduling deals with the problem of deciding which of the processes in the ready queue is
to be allocated first to the CPU. There are four types of CPU scheduling that exist.
1. First Come, First Served Scheduling (FCFS) Algorithm:
This is the simplest CPU scheduling algorithm. In this scheme, the process which requests the
CPU first, that is allocated to the CPU first. The implementation of the FCFS algorithm is easily
managed with a FIFO queue. When a process enters the ready queue its PCB is linked onto the
rear of the queue. The average waiting time under FCFS policy is quiet long. Consider the
following example:

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:

P1 P2 P3
0 24 27 30

 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:

P2 , P3 , P1

 The Gantt chart for the schedule is:

P2 P3 P1
0 3 6 30

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

 Average waiting time: (6 + 0 + 3)/3 = 3
 Much better than previous case
 Convoy effect: Assume we have one CPU-bound process and many I/O-bound
processes. As the processes flow armmd the system, the following scenario may result.
The CPU-bound process will get and hold the CPU. During this time, all the other
processes will finish their I/0 and will move into the ready queue, waiting for the CPU.
While the processes wait in the ready queue, the I/0 devices are idle. Eventually, the
CPU-bound process finishes its CPU burst and moves to an I/0 device. All the I/O-bound
processes, which have short CPU bursts, execute quickly and move back to the I/0
queues. At this point, the CPU sits idle. The CPU-bound process will then move back to
the ready queue and be allocated the CPU. Again, all the I/0 processes end up waiting in
the ready queue until the CPU-bound process is done. There is a convoy effect as all the
other processes wait for the one big process to get off the CPU. This effect results in
lower CPU and device utilization than might be possible if the shorter processes were
allowed to go first.
2.Shortest Job First Scheduling (SJF) Algorithm:
A different approach to CPU scheduling is the shortest-job-first (SJF) scheduling algorithm.
This algorithm associates with each process the length of the process's next CPU burst. When
the CPU is available, it is assigned to the process that has the smallest next CPU burst. If the
next CPU bursts of two processes are the same, FCFS scheduling is used to break the tie.
Note that a more appropriate term for this scheduling method would be the shortest-next-
CPU-burst algorithm, because scheduling depends on the length of the next CPU burst of a
process, rather than its total length.
Process Arrival Ti Burst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3
SJF scheduling chart

P4 P1 P3 P2
0 3 9 16 24

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

 Example of Shortest-remaining-time-first
Preemptive version called shortest-remaining-time-first
Now we add the concepts of varying arrival times and preemption to the analysis
Process Arrival Time Burst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
Preemptive SJF Gantt Chart

P1 P2 P4 P1 P3
0 1 5 10 17 26

Average waiting time = [(10-1)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5 msec

3.Priority Scheduling
In this scheduling a priority is associated with each process and the CPU is allocated
to the process with the highest priority. Equal priority processes are scheduled in
FCFS manner.
Priorities are generally indicated by some fixed range of numbers, such as 0 to 7 or 0
to 4,095. However, there is no general agreement on whether 0 is the highest or
lowest priority.
 Preemptive
 Nonpreemptive
Starvation : A major problem with priority scheduling algorithms is indefinite blocking,
or starvation. A process that is ready to run but waiting for the CPU can be considered
blocked. A priority scheduling algorithm can leave some lowpriority processes waiting
indefinitely

Aging A solution to the problem of indefinite blockage of low-priority processes is aging.

Aging is a techniqtJe of gradually increasing the priority of processes that wait in the
system for a long time.
 Example of Priority Scheduling

Process Burst Time Priority

P1 10 3

P2 1 1

P3 2 4

P4 1 5

P5 5 2

Priority scheduling Gantt Chart

Average waiting time = 8.2 msec

4. Round Robin (RR) Scheduling:

This type of algorithm is designed only for the time sharing system. It is similar to
FCFS scheduling with preemption condition to switch between processes. A small
unit of time called quantum time or time slice is used to switch between the
processes. The average waiting time under the round robin policy is quiet long.
Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
The Gantt chart is:

P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30
 If we use a time quantum of 4 milliseconds, then process P1 gets the first 4 milliseconds.
Since it requires another 20 milliseconds, it is preempted after the first time quantum, and
the CPU is given to the next process in the queue, process P2 . Process P2 does not need
4 milliseconds, so it quits before its time quantum expires. The CPU is then given to the
next process, process P3. Once each process has received 1 time quantum, the CPU is
returned to process P1 for an additional time quantum

calculate the average waiting time for the above schedule.

P1 waits for 6 millisconds (10- 4), P2 waits for 4 millisconds, and P3 waits for 7
millisconds.

Thus, the average waiting time is 17/3 = 5.66 milliseconds.

System call interface for process management-fork, exit, wait, waitpid, exec

System call interfaces are a crucial part of the operating system, providing a way
for user-level processes to request services or functionality from the kernel. In
process management, several system calls are commonly used to create, manage,
and control processes. Here are some important system calls related to process
management:

1. fork() System Call:

 Purpose: The fork() system call is used to create a new process that is a
copy of the calling process (the parent process).
 Usage: pid_t fork(void);
 Description: The new child process is an identical copy of the parent
process, except for the returned values. The child process gets its own
process ID (PID), and both parent and child continue execution from the
point where fork() was called. This system call is used for process
creation.
2. exit() System Call:
 Purpose: The exit() system call is used by a process to terminate its own
execution.
 Usage: void exit(int status);
  Description: It terminates the calling process and returns an exit status
to the parent process, which can be used to determine the success or
failure of the child process. The resources held by the process are
released.
3. wait() System Call:
 Purpose: The wait() system call is used by a parent process to wait for
the termination of its child processes.
 Usage: pid_t wait(int *status);
 Description: The calling process is suspended until one of its child
processes terminates. It returns the PID of the terminated child process
and stores the exit status of that child in the status pointer. This system
call is used for process synchronization and to retrieve the exit status of
child processes.
4. waitpid() System Call:
 Purpose: The waitpid() system call is an extended version of wait() that
allows a parent process to wait for a specific child process to terminate.
 Usage: pid_t waitpid(pid_t pid, int *status, int options);
 Description: It waits for a specific child process with the specified pid to
terminate and returns its PID and exit status. The options parameter
can be used to control the behavior of the call.
5. **exec() System Call (various variants, e.g., execve, execl, execvp, etc.):
 Purpose: The exec family of system calls are used to replace the current
process's image with a new process image.
 Usage: Varies depending on the specific exec call, but generally, it takes
the name of the program to be executed and its arguments.
 Description: These system calls are used to start a new program, loading
it into the current process's address space. After a successful exec, the
old program is replaced by the new one, and the new program starts
executing.

These system calls play a fundamental role in creating, managing, and

controlling processes within an operating system. They enable processes to be
created, terminated, and synchronized, and they allow for the replacement of
a process's code and data with a new program.
Deadlock:
In a multiprogramming environment several processes may compete for a finite number of
resources. A process request resources; if the resource is available at that time a process enters
the wait state. Waiting process may never change its state because the resources requested are
held by other waiting process. This situation is known as deadlock.
Example
• System has 2 disk drives.
• P1 and P2 each hold one disk drive and each needs another one

System Model:
A system consists of a finite number of resources to be distributed among a number of competing
processes. The resources are partitioned into several types each of which consists of a number of
identical instances. A process may utilized a resources in the following sequence
• Request: In this state one can request a resource.
• Use: In this state the process operates on the resource.
• Release: In this state the process releases the resources.

Deadlock Characteristics:
In a deadlock process never finish executing and system resources are tied up. A deadlock
situation can arise if the following four conditions hold simultaneously in a system.
• Mutual Exclusion: At a time only one process can use the resources. If another process
requests that resource, requesting process must wait until the resource has been released.
• Hold and wait: A process must be holding at least one resource and waiting to additional
resource that is currently held by other processes.
• No Preemption: Resources allocated to a process can’t be forcibly taken out from it unless it
releases that resource after completing the task.
• Circular Wait: A set {P0 , P1 , …….Pn} of waiting state/ process must exists such that P0 is
waiting for a resource that is held by P1 , P1 is waiting for the resource that is held by P2 …..
P(n – 1) is waiting for the resource that is held by Pn and Pn is waiting for the resources that is
held by P4 .
Resource Allocation Graph:
Deadlock can be described more clearly by directed graph which is called system resource
allocation graph.
The graph consists of a set of vertices ‘V’ and a set of edges ‘E’.
The set of vertices ‘V’ is partitioned into two different types of nodes such as P = {P1 , P2 ,
…….Pn}, the set of all the active processes in the system and R = {R1 , R2 , …….Rm}, the set
of all the resource type in the system.
A directed edge from process Pi to resource type Rj is denoted by Pi → Rj .
It signifies that process Pi is an instance of resource type Rj and waits for that resource.
A directed edge from resource type Rj to the process Pi which signifies that an instance of
resource type Rj has been allocated to process Pi . A directed edge Pi → Rj is called as request
edge and Rj → Pi is called as assignment edge.
When a process Pi requests an instance of resource type Rj then a request edge is inserted as
resource allocation graph. When this request can be fulfilled, the request edge is transformed to
an assignment edge. When the process no longer needs access to the resource it releases the
resource and as a result the assignment edge is deleted. The resource allocation graph shown in
below figure has the following situation.
• The sets P, R, E
P = {P1 , P2 , P3}
R = {R1 , R2 , R3 , R4}
E = {P1 → R1 ,P2 → R3 ,R1 → P2 ,R2 → P2 ,R2 → P1 ,R3 → P3}
The resource instances are
Resource R1 has one instance
Resource R2 has two instances.
Resource R3 has one instance
Resource R4 has three instances.
Example of a Resource Allocation Graph

The process states are:

Process P1 is holding an instance of R2 and waiting for an instance of R1 .
Process P2 is holding an instance of R1 and R2 and waiting for an instance R3 .
Process P3 is holding an instance of R3 .
The following example shows the resource allocation graph with a deadlock. P1 -> R1 -> P2 ->
R3 -> P3 -> R2 -> P1 P2 -> R3 -> P3 -> R2 -> P1

Resource Allocation Graph With A Deadlock

The following example shows the resource allocation graph with a cycle but no deadlock.
P1 -> R1 -> P3 -> R2 -> P1
No deadlock
P4 may release its instance of resource R2
Then it can be allocated to P3
Graph With A Cycle But No Deadlock

Methods for Handling Deadlocks

The problem of deadlock can deal with the following 3 ways.
 We can use a protocol to prevent or avoid deadlock ensuring that the system will never
enter to a deadlock state.
 We can allow the system to enter a deadlock state, detect it and recover.
 We can ignore the problem all together.
To ensure that deadlock never occur the system can use either a deadlock prevention or deadlock
avoidance scheme.
Deadlock Prevention:
Deadlock prevention is a set of methods for ensuring that at least one of these necessary
conditions cannot hold.
Mutual Exclusion: The mutual exclusion condition holds for non sharable. The example is a
printer cannot be simultaneously shared by several processes. Sharable resources do not require
mutual exclusive access and thus cannot be involved in a dead lock. The example is read only
files which are in sharing condition. If several processes attempt to open the read only file at the
same time they can be guaranteed simultaneous access.
Hold and wait:To ensure that the hold and wait condition never occurs in the system, we must
guaranty that whenever a process requests a resource it does not hold any other resources. There
are two protocols to handle these problems such as one protocol that can be used requires each
process to request and be allocated all its resources before it begins execution. The other protocol
allows a process to request resources only when the process has no resource. These protocols
have two main disadvantages. First, resource utilization may be low, since many of the resources
may be allocated but unused for a long period. Second, starvation is possible. A process that
needs several popular resources may have to wait indefinitely, because at least one of the
resources that it needs is always allocated to some other process.
No Preemption: To ensure that this condition does not hold, a protocol is used. If a process is
holding some resources and request another resource that cannot be immediately allocated to it.
The preempted one added to a list of resources for which the process is waiting. The process will
restart only when it can regain its old resources, as well as the new ones that it is requesting.
Alternatively if a process requests some resources, we first check whether they are available. If
they are, we allocate them. If they are not available, we check whether they are allocated to some
other process that is waiting for additional resources. If so, we preempt the desired resources
from the waiting process and allocate them to the requesting process. If the resources are not
either available or held by a waiting process, the requesting process must wait.
Circular Wait:We can ensure that this condition never holds by ordering of all resource type
and to require that each process requests resource in an increasing order of enumeration. Let R=
{R1 , R2 , …….Rn}be the set of resource types. We assign to each resource type a unique
integer number, which allows us to compare two resources and to determine whether one
precedes another in our ordering. Formally, we define a one to one function F: R → N, where N
is the set of natural numbers. For example, if the set of resource types R includes tape drives,
disk drives and printers, then the function F might be defined as follows:
F (Tape Drive) = 1,
F (Disk Drive) = 5,
F (Printer) = 12.
We can now consider the following protocol to prevent deadlocks: Each process can request
resources only in an increasing order of enumeration. That is, a process can initially request any
number of instances of a resource type, say Ri . After that, the process can request instances of
resource type Rj if and only if F (Rj ) > F (Ri ). If several instances of the same resource type are
needed, defined previously, a process that wants to use the tape drive and printer at the same
time must first request the tape drive and then request the printer.

Deadlock Avoidance:
Deadlock Avoidance Requires additional information about how resources are to be
used.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.Systems are in safe state if there exists a safe sequence of all
process. A sequence <P1,P2,…,Pn>of ALL the processes is the system 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 Pjhave
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.
  If system is in safe state => No deadlock.
 If system in not in safe state => possibility of deadlock .
 OS cannot prevent processes from requesting resources in a sequence that leads to
deadlock
 Avoidance => ensue that system will never enter an unsafe state, prevent getting into
deadlock.

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

Resource-Allocation Graph

P2 requesting R1, but R1 is already allocated to P1.

Both processes have a claim on resource R2

What happens if P2 now requests resource R2?

Unsafe State In Resource-Allocation Graph

  Cannot allocate resource R2 to process P2
 Why? Because resulting state is unsafe
 P1 could request R2, thereby creating deadlock!
Use only when there is a single instance of each resource type
 Suppose that process Pi requests a resource Rj
 The request can be granted only if converting the request edge to an
assignment edge does not result in the formation of a cycle in the resource
allocation graph.
 Here we check for safety by using cycle-detection algorithm.
Banker’s Algorithm:
This algorithm can be used in banking system to ensure that the bank never allocates
all its available cash such that it can no longer satisfy the needs of all its customer.
This algorithm is applicable to a system with multiple instances of each resource
type. When a new process enter in to the system it must declare the maximum
number of instances of each resource type that it may need. This number may not
exceed the total number of resources in the system. Several data structure must be
maintained to implement the banker’s algorithm.
Data Structures for the Banker’s Algorithm
 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]

Safety Algorithm

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

Work = Available

Finish [i] = false for i = 0, 1, …, n- 1

2. Find an i such that both:

(a) Finish [i] = false

(b) Needi  Work

If no such i exists, go to step 4

3. Work = Work + Allocationi

Finish[i] = true
go to step 2

4. If Finish [i] == true for all i, then the system is in a safe state.

Resource-Request Algorithm for Process Pi

Requesti = request vector for process Pi. If Requesti [j] = k then process Pi wants k
instances of resource type Rj

1. If Requesti  Needi go to step 2. Otherwise, raise error condition, since

process has exceeded its maximum claim

2. If Requesti  Available, go to step 3. Otherwise Pi must wait, since

resources are not available
3. Pretend to allocate requested resources to Pi by modifying the state as
follows:

Available = Available – Requesti;

Allocationi = Allocationi + Requesti;

Needi = Needi – Requesti;

 If safe  the resources are allocated to Pi

 If unsafe  Pi must wait, and the old resource-allocation state is
restored

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

Example: P1 Request (1,0,2)

 Check that Request  Available (that is, (1,0,2)  (3,3,2)  true

Allocation Need Available

ABC ABC ABC

P0 010 743 230

P1 302 020

P2 302 600

P3 211 011

P4 002 431

 Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2>
satisfies safety requirement

 Can request for (3,3,0) by P4 be granted?

 Can request for (0,2,0) by P0 be granted?

Deadlock Detection

If a system doesn’t employ either a deadlock prevention or deadlock avoidance, then

deadlock situation may occur. In this environment the system must provide

• An algorithm to recover from the deadlock.

• An algorithm to remove the deadlock is applied either to a system which pertains single in
instance each resource type or a system which pertains several instances of a resource type.

Single Instance of each Resource type

If all resources only a single instance then we can define a deadlock detection algorithm
which uses a new form of resource allocation graph called “Wait for graph”. We obtain this
graph from the resource allocation graph by removing the nodes of type resource and
collapsing the appropriate edges. The below figure describes the resource allocation graph
and corresponding wait for graph.

Resource-Allocation Graph and Wait-for 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 [i][j] = 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

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

 Algorithm requires an order of O(m x n2) operations to detect

whether the system is in deadlocked state

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 202

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

 In which order should we choose to abort?

1. Priority of the process

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

completion

3. Resources the process has used

4. Resources process needs to complete

5. How many processes will need to be terminated

6. Is process interactive or batch?

Resource Preemption

 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