Chapter 4 Notes

Operating System (22516)
Unit -IV CPU Scheduling and Algorithms

4.1 Scheduling Types- Scheduling Objectives, CPU and I/O burst cycle, Pre-emptive,
Non-pre-emptive scheduling, Scheduling Criteria.
4.2 Types of Scheduling algorithms- First Come First Serve (FCFS), Shortest Job First
(SJF), Shortest Remaining Time (SRTN), Round Robin (RR), Priority Scheduling,
Multi-level Queue Scheduling.
4.3 Deadlock- System Model, Necessary Conditions leading to Deadlock, Deadlock
Handling- Prevention, Avoidance.
4.1 Scheduling Types:

CPU scheduling is the basis of multi programmed operating systems. By switching
the CPU among processes, the operating system can make the computer more
productive.
In a single-processor system, only one process can run at a time. Others must wait
until the CPU is free and can be rescheduled. The objective of multiprogramming
is to have some process running at all times, to maximize CPU utilization. A process
is executed until it must wait, typically for the completion of some I/O request.
In a simple computer system, the CPU then just sits idle. All this waiting time is
wasted; no useful work is accomplished. Several processes are kept in memory at
one time. When one process has to wait, the operating system takes the CPU away
from that process and gives the CPU to another process. This pattern continues.
Every time one process has to wait, another process can take over use of the CPU.
Scheduling of this kind is a fundamental operating-system function. Almost all
computer resources are scheduled before use. The CPU is, of course, one of the
primary computer resources. Thus, its scheduling is central to operating-system
design.
Notes Prepared by - Prof Dhanashri Agrawal || SSVPS BSD Polytechnic Dhule -1-
CPU and I/O Burst Cycle:

Process execution consists of a cycle of CPU execution and I/O wait. Processes
alternate between these two states.
Process execution begins with a CPU burst. That is

followed by an I/O burst, which is followed by
another CPU burst, the another I/O burst, and so
on. Eventually, the final CPU burst ends with a
system request to terminate execution. An I/O-
bound program typically has many short CPU
bursts. A CPU-bound program might have a few
long CPU bursts. This distribution can be important
in the selection of an appropriate CPU scheduling
algorithm.
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 scheduler selects a process from the processes in memory that are ready
to execute and allocates the CPU to that process.
• Note that the ready queue is not necessarily a first-in, first-out (FIFO) queue.,
a ready queue can be implemented as a FIFO queue, a priority queue, or
simply an unordered linked list. however, all the processes in the ready
queue are lined up waiting for a chance to run on the CPU.
• The records in the queues are generally process control blocks (PCBs) of the
processes.
Preemptive Scheduling
CPU-scheduling decisions may take place under the following four circumstances:
1. When a process switches from the running state to the waiting state (for
example, as the result of an I/O request or an invocation of wait for the
termination of one of the child processes)
2. When a process switches from the running state to the ready state (for
example, when an interrupt occurs)
3. When a process switches from the waiting state to the ready state (for
example, at completion of I/O)
4. When a process terminates
For situations 1 and 4, there is no choice in terms of scheduling. A new process
(if one exists in the ready queue) must be selected for execution. There is a
choice, however, for situations 2 and 3.
When scheduling takes place only under circumstances 1 and 4, we say that the
scheduling scheme is non preemptive or cooperative; otherwise, it is preemptive.
Under non preemptive scheduling, once the CPU has been allocated to a process,
the process keeps the CPU until it releases the CPU either by terminating or by
switching to the waiting state. This scheduling method was used by Microsoft
Windows 3.x; Windows 95 introduced preemptive scheduling, and all subsequent
versions of Windows operating systems have used preemptive scheduling.
The Mac OS X operating system for the Macintosh also uses preemptive scheduling;
previous versions of the Macintosh operating system relied on cooperative
scheduling.
Cooperative scheduling is the only method that can be used on certain hardware
platforms, because it does not require the special hardware (for example, a timer)
needed for preemptive scheduling.
Dispatcher
Another component involved in the CPU-scheduling function is the dispatcher. The
dispatcher is the module that gives control of the CPU to the process selected by
the short-term scheduler. This function involves the following:
• Switching context
• Switching to user mode
• Jumping to the proper location in the user program to restart that
program. The dispatcher should be as fast as possible, since it is invoked
during every process switch. The time it takes for the dispatcher to stop
one process and start another running is known as the dispatch latency.
Scheduling Criteria
Many criteria have been suggested for comparing CPU-scheduling algorithms.
Which characteristics are used for comparison can make a substantial difference in
which algorithm is judged to be best. The criteria include the following:
CPU utilization: We want to keep the CPU as busy as possible. Conceptually, CPU
utilization can 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 that are completed per time unit,
called throughput. For long processes, this rate may be one process per hour; for
short transactions, it may be ten processes per second.
Turnaround time: From the point of view of a particular process, the important
criterion is how long it takes to execute that process. 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: The CPU-scheduling algorithm does not affect the amount of time
during which a process executes or does I/O; it affects only the amount of time that
a process spends waiting in the ready queue. 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. Often, a process can produce some output fairly early and can continue
computing new results while previous results are being output to the user. Thus,
another measure is the time from the submission of a request until the first
response is produced. This measure, called response time, is the time it takes to
start responding, not the time it takes to output the response. The turnaround time
is generally limited by the speed of the output device. It is desirable to maximize
CPU utilization and throughput and to minimize turnaround time, waiting time, and
response time.
4.2 Types of scheduling algorithm:

CPU scheduling deals with the problem of deciding which of the processes in the
ready queue is to be allocated the CPU. There are many different CPU-scheduling
algorithms.
1. First Come First Served (FCFS)
2. Shortest Job First (SJF)
3. Round Robin (RR)
4. Priority scheduling
5. Multilevel queue
1. First Come First Served (FCFS):

First come first serve (FCFS) scheduling algorithm simply schedules the jobs
according to their arrival time. The job which comes first in the ready queue will
get the CPU first. The lesser the arrival time of the job, the sooner will the job get
the CPU. FCFS scheduling may cause the problem of starvation if the burst time of
the first process is the longest among all the jobs.
Let us consider an example where 4 processes with different burst times arrive at
different times.
Process Burst Time Arrival time
P1 6 2
P2 8 1
P3 3 0
P4 4 4
• At arrival time 0
Gantt chart:
P3
0
The process P2 arrives at time 1, but the process P3 is still executing. The
process P2 will be kept in a queue which will be executed after the existing
process finishes its execution. Also at time 2, Process P1 arrives and waits in the
queue as there is another process being executed.
Gantt chart:
P3 P2 P1
0 3 11
At arrival time 5, Process P4 arrives and waits in the queue.

After process P1 executed P4 is start executing.
Gantt Chart:
P3 P2 P1 P4
0 3 11 17 21
Process Burst Arrival Completion Turn Around Waiting

Time Time Time Time Time
P1 6 2 17 15 9
P2 8 1 11 10 9
P3 3 0 3 3 3
P4 4 4 21 17 13
Avg waiting time=9+9+3+13/4=34/4=8.5
Advantages of FCFS:
• Simple
• Easy
• First come, First served
Dis-advantages of FCFS:
• The scheduling method is non preemptive, the process will run to the
completion.
• Due to the non-preemptive nature of the algorithm, the problem of
starvation may occur.
• Although it is easy to implement, but it is poor in performance since the
average waiting time is higher as compare to other scheduling algorithms.
2. Shortest Job First (SJF):
SJF scheduling algorithm, schedules the processes according to their burst time. In
SJF scheduling, the process with the lowest burst time, among the list of available
processes in the ready queue, is going to be scheduled next. This scheduling
method can be preemptive or non-preemptive. It significantly reduces the average
waiting time for other processes awaiting execution.
However, it is very difficult to predict the burst time needed for a process hence
this algorithm is very difficult to implement in the system.
Non-Preemptive SJF:
In non-preemptive scheduling, once the CPU cycle is allocated to process, the
process holds it till it reaches a waiting state or terminated.
Consider the following five processes each having its own unique burst time and
arrival time.
Process Arrival Time Burst Time

P1 2 6
P2 5 2
P3 1 8
P4 0 3
P5 4 4
At Arrival time 0, P4 process Arrives and start execution
Gantt chart
P4
0
At time 1, Process P3 arrives. But, P4 still needs 2 execution units to complete. It

will continue execution.
At time 2, process P1 arrives and is added to the waiting queue. P4 will continue
execution.
At time 3, process P4 will finish its execution. The burst time of P3 and P1 is
compared. Process P1 is executed because its burst time is less compared to P3.
P4 P1
0 3
execution.
execution.
At time 9, process P1 will finish its execution. The burst time of P3, P5, and P2 is
compared. Process P2 is executed because its burst time is the lowest.
P4 P1 P2
0 3 9
At arrival time 10, P2 is executing and P3 and P5 are in the waiting queue.
At arrival time 11, process P2 will finish its execution. The burst time of P3 and P5
is compared. Process P5 is executed because its burst time is lower.
P4 P1 P2
0 3 9 11
At time 15, process P5 will finish its execution.

P4 P1 P2 P5
0 3 9 11 15
At time = 23, process P3 will finish its execution.

Final Gantt Chart:
P4 P1 P2 P5 P3
0 3 9 11 15 23
Process Burst Time Arrival Completion Turn Around Waiting

Time Time Time Time
P1 6 2 9 7 1
P2 2 5 11 6 4
P3 8 1 23 22 14
P4 3 0 3 3 0
P5 4 4 15 11 7
Preemptive SJF
In Preemptive SJF Scheduling, jobs are put into the ready queue as they come. A
process with shortest burst time begins execution. If a process with even a shorter
burst time arrives, the current process is removed or preempted from execution,
and the shorter job is allocated CPU cycle.

P1 2 6
P2 5 2
P3 1 8
P4 0 3
P5 4 4
At time 0, P4 arrives and starts execution.

Gantt Chart:
P4
0
At time 1, Process P3 arrives. But, P4 has a shorter burst time. It will continue
execution.
At time 2, process P1 arrives with burst time 6. The burst time is more than that
of P4. Hence, P4 will continue execution.
At time 3, process P4 will finish its execution. The burst time of P3 and P1 is
compared. Process P1 is executed because its burst time is lower.
P4 P1
0 3 4
At time 4, process P5 will arrive. The burst time of P3, P5, and P1 is compared.
Process P5 is executed because its burst time is lowest. Process P1 is preempted.
P4 P1 P5
0 3 4 5
At time 5, process P2 will arrive. The burst time of P1, P2, P3, and P5 is compared.
Process P2 is executed because its burst time is least. Process P5 is preempted.
P4 P1 P5 P2
0 3 4 5
At time 6, process P2 is executing.

At time 7, P2 finishes its execution. The burst time of P1, P3, and P5 is compared.
Process P5 is executed because its burst time is lesser.
P4 P1 P5 P2 P5
0 3 4 5 7
At time 10, P5 will finish its execution. The burst time of P1 and P3 is compared.
Process P1 is executed because its burst time is less.
P4 P1 P5 P2 P5 P1
0 3 4 5 7 10
At time 15, P1 finishes its execution. P3 is the only process left. It will start
execution.
P4 P1 P5 P2 P5 P1 P3
0 3 4 5 7 10 15
At time =23, P3 finishes its execution.

Final Gantt chart:
P4 P1 P5 P2 P5 P1 P3
0 3 4 5 7 10 15 23

Time Time Time Time
P1 6 2 15 13 7
P2 2 5 7 2 0
P3 8 1 23 22 14
P4 3 0 3 3 0
P5 4 4 10 6 2
Advantages of SJF
• SJF is frequently used for long term scheduling.
• It reduces the average waiting time over FIFO (First in First Out) algorithm.
• SJF method gives the lowest average waiting time for a specific set of
processes.
• It is appropriate for the jobs running in batch, where run times are known
in advance.
• For the batch system of long-term scheduling, a burst time estimate can be
obtained from the job description.
• For Short-Term Scheduling, we need to predict the value of the next burst
time.
• Probably optimal with regard to average turnaround time.
Dis-advantages of SJF:
• Job completion time must be known earlier, but it is hard to predict.
• It is often used in a batch system for long term scheduling.
• SJF can’t be implemented for CPU scheduling for the short term. It is
because there is no specific method to predict the length of the upcoming
CPU burst.
• This algorithm may cause very long turnaround times or starvation.
• Requires knowledge of how long a process or job will run.
• It leads to the starvation that does not reduce average turnaround time.
• It is hard to know the length of the upcoming CPU request.
• Elapsed time should be recorded, that results in more overhead on the
processor.
3. Round Robin (RR):

Round Robin scheduling algorithm is one of the most popular scheduling
algorithm which can actually be implemented in most of the operating systems.
This is the preemptive version of first come first serve scheduling. The Algorithm
focuses on Time Sharing. In this algorithm, every process gets executed in
a cyclic way. A certain time slice is defined in the system which is called
time quantum. Each process present in the ready queue is assigned the CPU for
that time quantum, if the execution of the process is completed during that time
then the process will terminate else the process will go back to the ready
queue and waits for the next turn to complete the execution.

P1 1 3
P2 1 3
P3 3 4
P4 3 4
Time Quantum : 3
http://vlabs.iitb.ac.in/vlabs-
dev/vlab_bootcamp/bootcamp/CRUX/labs/exp1/simulation.html

Time Time Time Time
P1 3 1 4 3 0
P2 3 1 6 5 2
P3 4 3 14 11 7
P4 4 3 15 12 8
4. Priority Scheduling:
In Priority scheduling, there is a priority number assigned to each process. In
some systems, the lower the number, the higher the priority. While, in the
others, the higher the number, the higher will be the priority. The Process with
the higher priority among the available processes is given the CPU. There are
two types of priority scheduling algorithm exists. One is Preemptive priority
scheduling while the other is Non-Preemptive Priority scheduling.
The priority number assigned to each of the process may or may not vary. If the
priority number doesn't change itself throughout the process, it is called static
priority, while if it keeps changing itself at the regular intervals, it is called dynamic
priority.
Non-Preemptive Priority Scheduling

In the Non-Preemptive Priority scheduling, The Processes are scheduled according
to the priority number assigned to them. Once the process gets scheduled, it will
run till completion. Generally, the lower the priority number, the higher is the
priority of the process.
Example
In the Example, there are 7 processes P1, P2, P3, P4, P5, P6 and P7. Their priorities,
Arrival Time and burst time are given in the table.
Process Priority Arrival Burst

ID Time Time
1 2 0 3
2 6 2 5
3 3 1 4
4 5 4 2
5 7 6 9
6 4 5 4
7 10 7 10
We can prepare the Gantt chart according to the non-Preemptive priority

scheduling.
The Process P1 arrives at time 0 with the burst time of 3 units and the priority
number 2. Since No other process has arrived till now hence the OS will schedule it
immediately.
P1
0 3
Meanwhile the execution of P1, two more Processes P2 and P3 are arrived. Since
the priority of P3 is 3 hence the CPU will execute P3 over P2.
P1 P3
0 3 7
Meanwhile the execution of P3, All the processes get available in the ready queue.
The Process with the lowest priority number will be given the priority. Since P6 has
priority number assigned as 4 hence it will be executed just after P3.
P1 P3 P6
0 3 7 11
After P6, P4 has the least priority number among the available processes; it will get
executed for the whole burst time.
P1 P3 P6 P4
0 3 7 11 13
Since all the jobs are available in the ready queue hence All the Jobs will get
executed according to their priorities. If two jobs have similar priority number
assigned to them, the one with the least arrival time will be executed.
1. Turn Around Time = Completion Time - Arrival Time

2. Waiting Time = Turn Around Time - Burst Time
Proce Priori Arriv Bur Completi Turnarou Waiti Respon

ss Id ty al st on Time nd Time ng se Time
Time Tim Time
e
1 2 0 3 3 3 0 0
2 6 2 5 18 16 11 13
3 3 1 4 7 6 2 3
4 5 4 2 13 9 7 11
5 7 6 9 27 21 12 18
6 4 5 4 11 6 2 7
7 10 7 10 37 30 18 27
Avg Waiting Time = (0+11+2+7+12+2+18)/7 = 52/7 units
Preemptive Priority Scheduling

In Preemptive Priority Scheduling, at the time of arrival of a process in the ready
queue, its Priority is compared with the priority of the other processes present in
the ready queue as well as with the one which is being executed by the CPU at that
point of time. The One with the highest priority among all the available processes
will be given the CPU next.
The difference between preemptive priority scheduling and non-preemptive

priority scheduling is that, in the preemptive priority scheduling, the job which is
being executed can be stopped at the arrival of a higher priority job.
Once all the jobs get available in the ready queue, the algorithm will behave as non-
preemptive priority scheduling, which means the job scheduled will run till the
completion and no preemption will be done.
Example
There are 7 processes P1, P2, P3, P4, P5, P6 and P7 given. Their respective priorities,
Arrival Times and Burst times are given in the table below.
Process Priority Arrival Burst

Id Time Time
1 2(L) 0 1
2 6 1 7
3 3 2 3
4 5 3 6
5 4 4 5
6 10(H) 5 15
7 9 15 8
GANTT chart Preparation
At time 0, P1 arrives with the burst time of 1 units and priority 2. Since no other
process is available hence this will be scheduled till next job arrives or its
completion (whichever is lesser).
At time 1, P2 arrives. P1 has completed its execution and no other process is

available at this time hence the Operating system must schedule it regardless of
the priority assigned to it.
The Next process P3 arrives at time unit 2, the priority of P3 is higher to P2. Hence
the execution of P2 will be stopped and P3 will be scheduled on the CPU.
During the execution of P3, three more processes P4, P5 and P6 becomes available.
Since, all these three have the priority lower to the process in execution so PS can't
preempt the process. P3 will complete its execution and then P5 will be scheduled
with the priority highest among the available processes.
Meanwhile the execution of P5, all the processes got available in the ready queue.
At this point, the algorithm will start behaving as Non-Preemptive Priority
Scheduling. Hence now, once all the processes get available in the ready queue, the
OS just took the process with the highest priority and execute that process till
completion. In this case, P4 will be scheduled and will be executed till the
completion.
Since P4 is completed, the other process with the highest priority available in the
ready queue is P2. Hence P2 will be scheduled next.
P2 is given the CPU till the completion. Since its remaining burst time is 6 units
hence P7 will be scheduled after this.
The only remaining process is P6 with the least priority, the Operating System has
no choice unless of executing it. This will be executed at the last.
The Completion Time of each process is determined with the help of GANTT chart.
The turnaround time and the waiting time can be calculated by the following
formula.
Proces Priority Arrival Burst Completion Turn- Waiting

s Id Time Time Time around Time
Time
1 2 0 1 1 1 0
2 6 1 7 22 21 14
3 3 2 3 5 3 0
4 5 3 6 16 13 7
5 4 4 5 10 6 1
6 10 5 15 45 40 25
7 9 6 8 30 24 16
Avg Waiting Time = (0+14+0+7+1+25+16)/7 = 63/7 = 9 units
6. Multi-level scheduling queue:

Multilevel queue scheduling is used when processes in the ready queue can be
divided into different classes where each class has its own scheduling needs. For
instance, foreground or interactive processes and background or batch processes
are commonly divided. Foreground and background processes have different time
requirements and hence will have different scheduling needs. In this case,
multilevel queue scheduling will be used.
A round-robin method with various time quantum is typically utilized for such
maintenance. Several types of scheduling algorithms are designed for
circumstances where the processes can be readily separated into groups. There are
two sorts of processes that require different scheduling algorithms because they
have varying response times and resource requirements. The foreground
(interactive) and background processes (batch process) are distinguished.
Background processes take priority over foreground processes.
The ready queue has been partitioned into seven different queues using the
multilevel queue scheduling technique. These processes are assigned to one
queue based on their priority, such as memory size, process priority, or type.
The method for scheduling each queue is different. Some queues are utilized for
the foreground process, while others are used for the background process. The
foreground queue may be scheduled using a round-robin method, and the
background queue can be scheduled using an FCFS strategy.
Let's take an example of a multilevel queue-scheduling algorithm with five queues
to understand how this scheduling works:
1. System Processes
2. Interactive Processes
3. Interactive Editing Processes
4. Batch Processes
5. Student Process
Every queue would have an absolute priority over the low-priority queues. No
process may execute until the high-priority queues are empty. In the above
instance, no other process may execute until and unless the queues for system,
interactive, and editing processes are empty. If an interactive editing process enters
the ready queue while a batch process is underway, the batch process will be
preempted.
There are the descriptions of the processes that are used in the above example:
System Process
The OS has its process to execute, which is referred to as the System Process.
Interactive Process
It is a process in which the same type of interaction should occur.

Batch Process
Batch processing is an operating system feature that collects programs and data
into a batch before processing starts.
Student Process
The system process is always given the highest priority, whereas the student
processes are always given the lowest.
Advantages
1. You can use multilevel queue scheduling to apply different scheduling methods
to distinct processes.
2. It will have low overhead in terms of scheduling.
Disadvantages
1. There is a risk of starvation for lower priority processes.
2. It is rigid in nature.
4.3 Deadlock
Every process needs some resources to complete its execution. However, the
resource is granted in a sequential order.
• The process requests for some resource.
• OS grant the resource if it is available otherwise let the process waits.
• The process uses it and release on the completion.
A Deadlock is a situation where each of the computer process waits for a resource
which is being assigned to some another process. In this situation, none of the
process gets executed since the resource it needs, is held by some other process
which is also waiting for some other resource to be released.
Let us assume that there are three processes P1, P2 and P3. There are three
different resources R1, R2 and R3. R1 is assigned to P1, R2 is assigned to P2 and R3
is assigned to P3.
After some time, P1 demands for R1 which is being used by P2. P1 halts its
execution since it can't complete without R2. P2 also demands for R3 which is being
used by P3. P2 also stops its execution because it can't continue without R3. P3 also
demands for R1 which is being used by P1 therefore P3 also stops its execution.
In this scenario, a cycle is being formed among the three processes. None of the
process is progressing and they are all waiting. The computer becomes
unresponsive since all the processes got blocked.
Sr. Deadlock Starvation
1 Deadlock is a situation Starvation is a situation

where no process got where the low priority
blocked and no process process got blocked and
proceeds the high priority
processes proceed.
2 Deadlock is an infinite Starvation is a long

waiting. waiting but not infinite.
3 Every Deadlock is always Every starvation need not

a starvation. be deadlock.
4 The requested resource The requested resource

is blocked by the other is continuously be used
process. by the higher priority
processes.
5 Deadlock happens when It occurs due to the

Mutual exclusion, hold uncontrolled priority and
and wait, No preemption resource management.
and circular wait occurs

simultaneously.
Necessary conditions for Deadlock:
1. Mutual Exclusion:
A resource can only be shared in mutually exclusive manner. It implies, if two
process cannot use the same resource at the same time.
2. Hold And wait:
If one process holding a resource and waiting for another resource that is held by
another process. Then it leads to a deadlock.
3. Circular wait:
All the processes must be waiting for the resources in a cyclic manner so that the
last process is waiting for the resource which is being held by the first process.
4. No preemption:
The process which once scheduled will be executed till the completion. No other
process can be scheduled by the scheduler meanwhile.
Method of handling Deadlock:

1. Deadlock Ignorance:
Deadlock Ignorance is the most widely used approach among all the mechanism.
This is being used by many operating systems mainly for end user uses. In this
approach, the Operating system assumes that deadlock never occurs. It simply
ignores deadlock. This approach is best suitable for a single end user system where
User uses the system only for browsing and all other normal stuff.
There is always a tradeoff between Correctness and performance. The operating
systems like Windows and Linux mainly focus upon performance. However, the
performance of the system decreases if it uses deadlock handling mechanism all
the time if deadlock happens 1 out of 100 times then it is completely unnecessary
to use the deadlock handling mechanism all the time.
In these types of systems, the user has to simply restart the computer in the case
of deadlock. Windows and Linux are mainly using this approach.
2. Deadlock Prevention:
Deadlock happens only when Mutual Exclusion, hold and wait, No preemption and
circular wait holds simultaneously. If it is possible to violate one of the four
conditions at any time then the deadlock can never occur in the system.
The idea behind the approach is very simple that we have to fail one of the four
conditions but there can be a big argument on its physical implementation in the
system.
3. Deadlock Avoidance:
In deadlock avoidance, the operating system checks whether the system is in safe
state or in unsafe state at every step which the operating system performs. The
process continues until the system is in safe state. Once the system moves to
unsafe state, the OS has to backtrack one step.
In simple words, The OS reviews each allocation so that the allocation doesn't cause
the deadlock in the system.
4. Deadlock detection and recovery

This approach let the processes fall in deadlock and then periodically check
whether deadlock occur in the system or not. If it occurs then it applies some of the
recovery methods to the system to get rid of deadlock.
Deadlock Prevention:
In deadlock, if we can be able to violate one of the four necessary conditions and
don't let them occur together then we can prevent the deadlock.
Let's see how we can prevent each of the conditions.
1. Mutual Exclusion
Mutual section from the resource point of view is the fact that a resource can never
be used by more than one process simultaneously which is fair enough but that is
the main reason behind the deadlock. If a resource could have been used by more
than one process at the same time then the process would have never been waiting
for any resource.
However, if we can be able to violate resources behaving in the mutually exclusive
manner then the deadlock can be prevented.
2. Hold and Wait

Hold and wait condition lies when a process holds a resource and waiting for some
other resource to complete its task. Deadlock occurs because there can be more
than one process which are holding one resource and waiting for other in the cyclic
order.
However, we have to find out some mechanism by which a process either doesn't
hold any resource or doesn't wait. That means, a process must be assigned all the
necessary resources before the execution starts. A process must not wait for any
resource once the execution has been started.
This can be implemented practically if a process declares all the resources initially.
However, this sounds very practical but can't be done in the computer system
because a process can't determine necessary resources initially.
Process is the set of instructions which are executed by the CPU. Each of the
instruction may demand multiple resources at the multiple times. The need cannot
be fixed by the OS.
The problem with the approach is:
1. Practically not possible.
2. Possibility of getting starved will be increases due to the fact that some process
may hold a resource for a very long time.
3. No Preemption
Deadlock arises due to the fact that a process can't be stopped once it starts.
However, if we take the resource away from the process which is causing deadlock
then we can prevent deadlock.
This is not a good approach at all since if we take a resource away which is being
used by the process then all the work which it has done till now can become
inconsistent.
Consider a printer is being used by any process. If we take the printer away from
that process and assign it to some other process then all the data which has been
printed can become inconsistent and ineffective and also the fact that the process
can't start printing again from where it has left which causes performance
inefficiency.
4. Circular Wait
To violate circular wait, we can assign a priority number to each of the resource. A
process can't request for a lesser priority resource. This ensures that not a single
process can request a resource which is being utilized by some other process and
no cycle will be formed.
Among all methods, Circular wait is the only approach that can be implemented
practically.

Chapter 4 Notes

Uploaded by

Copyright:

Available Formats

You might also like

Chapter 4 Notes

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 4 Notes

Uploaded by

Copyright:

Available Formats

Operating System (22516)

Unit -IV CPU Scheduling and Algorithms

4.1 Scheduling Types:

CPU and I/O Burst Cycle:

Process execution begins with a CPU burst. That is

4.2 Types of scheduling algorithm:

1. First Come First Served (FCFS):

At arrival time 5, Process P4 arrives and waits in the queue.

Process Burst Arrival Completion Turn Around Waiting

2. Shortest Job First (SJF):

Process Arrival Time Burst Time

At Arrival time 0, P4 process Arrives and start execution

At time 1, Process P3 arrives. But, P4 still needs 2 execution units to complete. It

At time 15, process P5 will finish its execution.

At time = 23, process P3 will finish its execution.

Process Burst Time Arrival Completion Turn Around Waiting

Process Arrival Time Burst Time

At time 0, P4 arrives and starts execution.

At time 6, process P2 is executing.

At time =23, P3 finishes its execution.

Process Burst Time Arrival Completion Turn Around Waiting

3. Round Robin (RR):

Process Arrival Time Burst Time

Process Burst Time Arrival Completion Turn Around Waiting

Non-Preemptive Priority Scheduling

Process Priority Arrival Burst

We can prepare the Gantt chart according to the non-Preemptive priority

1. Turn Around Time = Completion Time - Arrival Time

Proce Priori Arriv Bur Completi Turnarou Waiti Respon

Avg Waiting Time = (0+11+2+7+12+2+18)/7 = 52/7 units

Preemptive Priority Scheduling

The difference between preemptive priority scheduling and non-preemptive

Process Priority Arrival Burst

At time 1, P2 arrives. P1 has completed its execution and no other process is

Proces Priority Arrival Burst Completion Turn- Waiting

Avg Waiting Time = (0+14+0+7+1+25+16)/7 = 63/7 = 9 units

6. Multi-level scheduling queue:

It is a process in which the same type of interaction should occur.

Sr. Deadlock Starvation

1 Deadlock is a situation Starvation is a situation

2 Deadlock is an infinite Starvation is a long

3 Every Deadlock is always Every starvation need not

4 The requested resource The requested resource

5 Deadlock happens when It occurs due to the

and circular wait occurs

Method of handling Deadlock:

4. Deadlock detection and recovery

2. Hold and Wait

You might also like