Process Management

Process Concept
Process is the execution of a program that performs
the actions specified in that program. It can be
defined as an execution unit where a program runs.
The OS helps you to create, schedule, and
terminates the processes which is used by CPU. A
process created by the main process is called a
child process.
Process operations can be easily controlled with the
help of PCB(Process Control Block). You can
consider it as the brain of the process, which
contains all the crucial information related to
processing like process id, priority, state, CPU
registers, etc.
In this Operating system tutorial, you will learn:
• What is a Process?
• What is Process Management?
• Process Architecture
• Process Control Blocks
• Process States
• Process Control Block(PCB)
What is Process Management?
Process management involves various tasks like creation,
scheduling, termination of processes, and a dead lock.
Process is a program that is under execution, which is an
important part of modern-day operating systems. The OS
must allocate resources that enable processes to share
and exchange information. It also protects the resources
of each process from other methods and allows
synchronization among processes.
It is the job of OS to manage all the running
processes of the system. It handles operations by
performing tasks like process scheduling and such
as resource allocation.
Process Control Blocks
The PCB is a full form of Process Control Block. It is
a data structure that is maintained by the Operating
System for every process. The PCB should be
identified by an integer Process ID (PID). It helps
you to store all the information required to keep
track of all the running processes.
It is also accountable for storing the contents of
processor registers. These are saved when the
process moves from the running state and then
returns back to it. The information is quickly
updated in the PCB by the OS as soon as the
process makes the state transition.
Process States

Process States Diagram

A process state is a condition of the process at a
specific instant of time. It also defines the current
position of the process.
There are mainly seven stages of a process which
are:
• New: The new process is created when a specific
program calls from secondary memory/ hard
disk to primary memory/ RAM a
• Ready: In a ready state, the process should be
loaded into the primary memory, which is ready
for execution.
• Waiting: The process is waiting for the allocation
of CPU time and other resources for execution.
• Executing: The process is an execution state.
• Blocked: It is a time interval when a process is
waiting for an event like I/O operations to
complete.
• Suspended: Suspended state defines the time
when a process is ready for execution but has
not been placed in the ready queue by OS.
• Terminated: Terminated state specifies the time
when a process is terminated
After completing every step, all the resources are
used by a process, and memory becomes free.
Process Control Block(PCB)
Every process is represented in the operating
system by a process control block, which is also
called a task control block.
Here, are important components of PCB
 Process Control Block(PCB)
• Process state: A process can be new, ready,
running, waiting, etc.
• Program counter: The program counter lets you
know the address of the next instruction, which
should be executed for that process.
• CPU registers: This component includes
accumulators, index and general-purpose
registers, and information of condition code.
• CPU scheduling information: This component
includes a process priority, pointers for
scheduling queues, and various other
scheduling parameters.
• Accounting and business information: It includes
the amount of CPU and time utilities like real
time used, job or process numbers, etc.
• Memory-management information: This
information includes the value of the base and
limit registers, the page, or segment tables.
This depends on the memory system, which is
used by the operating system.
• I/O status information: This block includes a list of
 open files, the list of I/O devices that are
allocated to the process, etc.
Summary:
• A process is defined as the execution of a
program that performs the actions specified in
that program.
• Process management involves various tasks like
creation, scheduling, termination of processes,
and a dead lock.
• The important elements of Process architecture
are 1)Stack 2) Heap 3) Data, and 4) Text
• The PCB is a full form of Process Control Block. It
is a data structure that is maintained by the
Operating System for every process
• A process state is a condition of the process at a
specific instant of time.
• Every process is represented in the operating
system by a process control block, which is
also called a task control block.

Process Scheduling
Process Scheduling is an OS task that schedules
processes of different states like ready, waiting, and
running.
Process scheduling allows OS to allocate a time
interval of CPU execution for each process. Another
important reason for using a process scheduling
system is that it keeps the CPU busy all the time.
This allows you to get the minimum response time
for programs.
In this process scheduling tutorial, you will learn:
• What is Process Scheduling?
• Process Scheduling Queues
• Two State Process Model
• Scheduling Objectives
• Type of Process Schedulers
• Long Term Scheduler
• Medium Term Scheduler
• Short Term Scheduler
• Difference between Schedulers
• What is Context switch?
Process Scheduling Queues
Process Scheduling Queues help you to maintain a
distinct queue for each and every process states
and PCBs. All the process of the same execution
state are placed in the same queue. Therefore,
whenever the state of a process is modified, its
PCB needs to be unlinked from its existing queue,
which moves back to the new state queue.

• of the absence of an I/O device.

In the above-given Diagram,
• Rectangle represents a queue.
• Circle denotes the resource
• Arrow indicates the flow of the process.
• Every new process first put in the Ready queue .It
waits in the ready queue until it is finally
processed for execution. Here, the new
process is put in the ready queue and wait until
it is selected for execution or it is dispatched.
• One of the processes is allocated the CPU and it
is executing
• The process should issue an I/O request
• Then, it should be placed in the I/O queue.
• The process should create a new subprocess
• The process should be waiting for its termination.
• It should remove forcefully from the CPU, as a
 result interrupt. Once interrupt is completed, it
should be sent back to ready queue.
Two State Process Model
Two-state process models are:
• Running
• Not Running
Running
In the Operating system, whenever a new process
is built, it is entered into the system, which should
be running.
Not Running
The process that are not running are kept in a
queue, which is waiting for their turn to execute.
Each entry in the queue is a point to a specific
process.
Scheduling Objectives
Here, are important objectives of Process
scheduling
• Maximize the number of interactive users within
acceptable response times.
• Achieve a balance between response and
utilization.
• Avoid indefinite postponement and enforce
priorities.
• It also should give reference to the processes
holding the key resources.
Type of Process Schedulers
A scheduler is a type of system software that allows
you to handle process scheduling.
There are mainly three types of Process
Schedulers:
1Long Term
2Short Term
3Medium Term

Long Term Scheduler

Long term scheduler is also known as a job
scheduler. This scheduler regulates the program
and select process from the queue and loads them
into memory for execution. It also regulates the
degree of multi-programing.
However, the main goal of this type of scheduler is
to offer a balanced mix of jobs, like Processor, I/O
jobs., that allows managing multiprogramming.See
More

Medium Term Scheduler

Medium-term scheduling is an important part of
swapping. It enables you to handle the swapped
out-processes. In this scheduler, a running process
can become suspended, which makes an I/O
request.
A running process can become suspended if it
makes an I/O request. A suspended processes
can't make any progress towards completion. In
order to remove the process from memory and
make space for other processes, the suspended
process should be moved to secondary storage.
Short Term Scheduler
Short term scheduling is also known as CPU
scheduler. The main goal of this scheduler is to
boost the system performance according to set
criteria. This helps you to select from a group of
processes that are ready to execute and allocates
CPU to one of them. The dispatcher gives control of
the CPU to the process selected by the short term
scheduler.
Difference between Schedulers
Long-Term Vs. Short Term Vs. Medium-Term
Long-Term Short-Term

Long term is also known as a job Short term is also known a

scheduler scheduler

It is either absent or minimal in a It is insignificant in the time

time-sharing system. order.

Speed is the fastest comp

Speed is less compared to the
the short-term and medium
short term scheduler.
scheduler.

Allow you to select processes

It only selects processes th
from the loads and pool back into
a ready state of the execu
the memory

Offers full control Offers less control

What is Context switch?
It is a method to store/restore the state or of a CPU
in PCB. So that process execution can be resumed
from the same point at a later time. The context
switching method is important for multitasking OS.
Summary:
• Process scheduling is an OS task that schedules
the processes of different states like ready,
waiting, and running.
• Two-state process models are 1) Running, and )
Not Running
• Process scheduling maximizes the number of
interactive users, within acceptable response
times.
• A scheduler is a type of system software that
allows you to handle process scheduling.
• Three types of the scheduler are 1) Long term 2)
Short term 3) Medium-term
• Long term scheduler regulates the program and
select process from the queue and loads them
into memory for execution.
• The medium-term scheduler enables you to
handle the swapped out-processes.
• The main goal of short term scheduler is to boost
the system performance according to set
criteria
• Long term is also known as a job scheduler,
whereas the short term is also known as CPU
scheduler, and the medium-term is also called
swapping scheduler.
CPU Scheduling
Basic Concepts
• Almost all programs have some alternating cycle of CPU
number crunching and waiting for I/O of some kind.
( Even a simple fetch from memory takes a long time
relative to CPU speeds. )
• In a simple system running a single process, the time spent
waiting for I/O is wasted, and those CPU cycles are lost
forever.
• A scheduling system allows one process to use the CPU while
another is waiting for I/O, thereby making full use of
otherwise lost CPU cycles.
• The challenge is to make the overall system as "efficient" and
"fair" as possible, subject to varying and often dynamic
conditions, and where "efficient" and "fair" are somewhat
subjective terms, often subject to shifting priority policies.
5.1.1 CPU-I/O Burst Cycle
• Almost all processes alternate between two states in a
continuing cycle, as shown in Figure 5.1 below :
A CPU burst of performing calculations, and
An I/O burst, waiting for data transfer in or out of the
system.
• CPU bursts vary from process to process, and from program to
program.

CPU Scheduler
• Whenever the CPU becomes idle, it is the job of the CPU
Scheduler ( a.k.a. the short-term scheduler ) to select
another process from the ready queue to run next.
• The storage structure for the ready queue and the algorithm
used to select the next process are not necessarily a FIFO
queue. There are several alternatives to choose from, as
well as numerous adjustable parameters for each
algorithm, which is the basic subject of this entire chapter.
Preemptive Scheduling
• CPU scheduling decisions take place under one of four
conditions:
When a process switches from the running state to the
waiting state, such as for an I/O request or invocation
of the wait( ) system call.
When a process switches from the running state to the
ready state, for example in response to an interrupt.
When a process switches from the waiting state to the
ready state, say at completion of I/O or a return from
wait( ).
 When a process terminates.
• For conditions 1 and 4 there is no choice - A new process must
be selected.
• For conditions 2 and 3 there is a choice - To either continue
running the current process, or select a different one.
• If scheduling takes place only under conditions 1 and 4, the
system is said to be non-preemptive, or cooperative. Under
these conditions, once a process starts running it keeps
running, until it either voluntarily blocks or until it
finishes. Otherwise the system is said to be preemptive.
• Windows used non-preemptive scheduling up to Windows 3.x,
and started using pre-emptive scheduling with Win95.
Macs used non-preemptive prior to OSX, and pre-emptive
since then. Note that pre-emptive scheduling is only
possible on hardware that supports a timer interrupt.
• Note that pre-emptive scheduling can cause problems when
two processes share data, because one process may get
interrupted in the middle of updating shared data
structures.
• Preemption can also be a problem if the kernel is busy
implementing a system call ( e.g. updating critical kernel
data structures ) when the preemption occurs. Most
modern UNIXes deal with this problem by making the
process wait until the system call has either completed or
blocked before allowing the preemption Unfortunately this
solution is problematic for real-time systems, as real-time
response can no longer be guaranteed.
• Some critical sections of code protect themselves from
concurrency problems by disabling interrupts before
entering the critical section and re-enabling interrupts on
exiting the section. Needless to say, this should only be
done in rare situations, and only on very short pieces of
code that will finish quickly, ( usually just a few machine
instructions. )
Dispatcher
The dispatcher is the module that gives control of the
CPU to the process selected by the scheduler. This
 function involves:
Switching context.
Switching to user mode.
Jumping to the proper location in the newly loaded
program.
The dispatcher needs to be as fast as possible, as it is run
on every context switch. The time consumed by the
dispatcher is known as dispatch latency.

Scheduling Criteria
• There are several different criteria to consider when trying to
select the "best" scheduling algorithm for a particular
situation and environment, including:
CPU utilization - Ideally the CPU would be busy 100%
of the time, so as to waste 0 CPU cycles. On a real
system CPU usage should range from 40% ( lightly
loaded ) to 90% ( heavily loaded. )
Throughput - Number of processes completed per unit
time. May range from 10 / second to 1 / hour
depending on the specific processes.
Turnaround time - Time required for a particular
process to complete, from submission time to
completion. ( Wall clock time. )
Waiting time - How much time processes spend in the
ready queue waiting their turn to get on the CPU.
( Load average - The average number of processes
sitting in the ready queue waiting their turn to
get into the CPU. Reported in 1-minute, 5-
minute, and 15-minute averages by "uptime"
and "who". )
Response time - The time taken in an interactive
program from the issuance of a command to the
 commence of a response to that command.
• In general one wants to optimize the average value of a criteria
( Maximize CPU utilization and throughput, and minimize
all the others. ) However some times one wants to do
something different, such as to minimize the maximum
response time.
• Sometimes it is most desirable to minimize the variance of a
criteria than the actual value. I.e. users are more accepting
of a consistent predictable system than an inconsistent one,
even if it is a little bit slower.

Scheduling Algorithms
The following subsections will explain several common
scheduling strategies, looking at only a single CPU burst each
for a small number of processes. Obviously real systems have to
deal with a lot more simultaneous processes executing their
CPU-I/O burst cycles.
First-Come First-Serve Scheduling, FCFS
• FCFS is very simple - Just a FIFO queue, like customers
waiting in line at the bank or the post office or at a copying
machine.
• Unfortunately, however, FCFS can yield some very long
average wait times, particularly if the first process to get
there takes a long time. For example, consider the
following three processes:
Process Burst Time
P1 24
P2 3
P3 3
• In the first Gantt chart below, process P1 arrives first. The
average waiting time for the three processes is ( 0 + 24 +
27 ) / 3 = 17.0 ms.
• In the second Gantt chart below, the same three processes have
 an average wait time of ( 0 + 3 + 6 ) / 3 = 3.0 ms. The total
run time for the three bursts is the same, but in the second
case two of the three finish much quicker, and the other
process is only delayed by a short amount.

• FCFS can also block the system in a busy dynamic system in

another way, known as the convoy effect. When one CPU
intensive process blocks the CPU, a number of I/O
intensive processes can get backed up behind it, leaving
the I/O devices idle. When the CPU hog finally
relinquishes the CPU, then the I/O processes pass through
the CPU quickly, leaving the CPU idle while everyone
queues up for I/O, and then the cycle repeats itself when
the CPU intensive process gets back to the ready queue.

Shortest-Job-First Scheduling, SJF

• The idea behind the SJF algorithm is to pick the quickest

fastest little job that needs to be done, get it out of the way
first, and then pick the next smallest fastest job to do next.
• ( Technically this algorithm picks a process based on the next
shortest CPU burst, not the overall process time. )
• For example, the Gantt chart below is based upon the
following CPU burst times, ( and the assumption that all
jobs arrive at the same time. )
Process Burst Time
P1 6
P2 8
P3 7
P4 3
• In the case above the average wait time is ( 0 + 3 + 9 + 16 ) / 4
= 7.0 ms, ( as opposed to 10.25 ms for FCFS for the same
processes. )
• SJF can be proven to be the fastest scheduling algorithm, but it
suffers from one important problem: How do you know
how long the next CPU burst is going to be?
◦ For long-term batch jobs this can be done based upon the
limits that users set for their jobs when they submit
them, which encourages them to set low limits, but
risks their having to re-submit the job if they set the
limit too low. However that does not work for short-
term CPU scheduling on an interactive system.
◦ Another option would be to statistically measure the run
time characteristics of jobs, particularly if the same
tasks are run repeatedly and predictably. But once
again that really isn't a viable option for short term
CPU scheduling in the real world.
◦ A more practical approach is to predict the length of the
next burst, based on some historical measurement of
recent burst times for this process. One simple, fast,
and relatively accurate method is the exponential
average, which can be defined as follows. ( The
book uses tau and t for their variables, but those are
hard to distinguish from one another and don't work
well in HTML. )
• estimate[ i + 1 ] = alpha * burst[ i ] + ( 1.0 - alpha ) * estimate[
i]
◦ In this scheme the previous estimate contains the history
of all previous times, and alpha serves as a weighting
factor for the relative importance of recent data
versus past history. If alpha is 1.0, then past history
is ignored, and we assume the next burst will be the
same length as the last burst. If alpha is 0.0, then all
measured burst times are ignored, and we just
assume a constant burst time. Most commonly alpha
 is set at 0.5, as illustrated in Figure 5.3:

• SJF can be either preemptive or non-preemptive. Preemption

occurs when a new process arrives in the ready queue that
has a predicted burst time shorter than the time remaining
in the process whose burst is currently on the CPU.
Preemptive SJF is sometimes referred to as shortest
remaining time first scheduling.
• For example, the following Gantt chart is based upon the
following data:
Process Arrival Time Burst Time
P1 0 8
P2 1 4
P3 2 9
p4 3 5

• The average wait time in this case is ( ( 5 - 3 ) + ( 10 - 1 ) +

( 17 - 2 ) ) / 4 = 26 / 4 = 6.5 ms. ( As opposed to 7.75 ms
for non-preemptive SJF or 8.75 for FCFS. )
Priority Scheduling
• Priority scheduling is a more general case of SJF, in which
each job is assigned a priority and the job with the highest
priority gets scheduled first. ( SJF uses the inverse of the
next expected burst time as its priority - The smaller the
expected burst, the higher the priority. )
• Note that in practice, priorities are implemented using integers
within a fixed range, but there is no agreed-upon
convention as to whether "high" priorities use large
numbers or small numbers. This book uses low number for
high priorities, with 0 being the highest possible priority.
• For example, the following Gantt chart is based upon these
process burst times and priorities, and yields an average
waiting time of 8.2 ms:
Process Burst Time Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2

• Priorities can be assigned either internally or externally.

Internal priorities are assigned by the OS using criteria
such as average burst time, ratio of CPU to I/O activity,
system resource use, and other factors available to the
kernel. External priorities are assigned by users, based on
the importance of the job, fees paid, politics, etc.
• Priority scheduling can be either preemptive or non-
preemptive.
• Priority scheduling can suffer from a major problem known as
indefinite blocking, or starvation, in which a low-priority
task can wait forever because there are always some other
 jobs around that have higher priority.
◦ If this problem is allowed to occur, then processes will
either run eventually when the system load lightens
( at say 2:00 a.m. ), or will eventually get lost when
the system is shut down or crashes. ( There are
rumors of jobs that have been stuck for years. )
◦ One common solution to this problem is aging, in which
priorities of jobs increase the longer they wait. Under
this scheme a low-priority job will eventually get its
priority raised high enough that it gets run.

Round Robin Scheduling

• Round robin scheduling is similar to FCFS scheduling, except

that CPU bursts are assigned with limits called time
quantum.
• When a process is given the CPU, a timer is set for whatever
value has been set for a time quantum.
◦ If the process finishes its burst before the time quantum
timer expires, then it is swapped out of the CPU just
like the normal FCFS algorithm.
◦ If the timer goes off first, then the process is swapped out
of the CPU and moved to the back end of the ready
queue.
• The ready queue is maintained as a circular queue, so when all
processes have had a turn, then the scheduler gives the first
process another turn, and so on.
• RR scheduling can give the effect of all processors sharing the
CPU equally, although the average wait time can be longer
than with other scheduling algorithms. In the following
example the average wait time is 5.66 ms.
Process Burst Time
P1 24
P2 3
P3 3
• The performance of RR is sensitive to the time quantum
selected. If the quantum is large enough, then RR reduces
to the FCFS algorithm; If it is very small, then each
process gets 1/nth of the processor time and share the CPU
equally.
• BUT, a real system invokes overhead for every context switch,
and the smaller the time quantum the more context
switches there are. ( See Figure 5.4 below. ) Most modern
systems use time quantum between 10 and 100
milliseconds, and context switch times on the order of 10
microseconds, so the overhead is small relative to the time
quantum.

• Turn around time also varies with quantum time, in a non-

apparent manner. Consider, for example the processes
shown in Figure 5.5:
• In general, turnaround time is minimized if most processes
finish their next cpu burst within one time quantum. For
example, with three processes of 10 ms bursts each, the
average turnaround time for 1 ms quantum is 29, and for
10 ms quantum it reduces to 20. However, if it is made too
large, then RR just degenerates to FCFS. A rule of thumb
is that 80% of CPU bursts should be smaller than the time
quantum.

Multilevel Queue Scheduling

• When processes can be readily categorized, then multiple

separate queues can be established, each implementing
whatever scheduling algorithm is most appropriate for that
type of job, and/or with different parametric adjustments.
• Scheduling must also be done between queues, that is
scheduling one queue to get time relative to other queues.
Two common options are strict priority ( no job in a lower
priority queue runs until all higher priority queues are
empty ) and round-robin ( each queue gets a time slice in
turn, possibly of different sizes. )
• Note that under this algorithm jobs cannot switch from queue
 to queue - Once they are assigned a queue, that is their
queue until they finish.

Multilevel Feedback-Queue Scheduling

• Multilevel feedback queue scheduling is similar to the

ordinary multilevel queue scheduling described above,
except jobs may be moved from one queue to another for a
variety of reasons:
◦ If the characteristics of a job change between CPU-
intensive and I/O intensive, then it may be
appropriate to switch a job from one queue to
another.
◦ Aging can also be incorporated, so that a job that has
waited for a long time can get bumped up into a
higher priority queue for a while.
• Multilevel feedback queue scheduling is the most flexible,
because it can be tuned for any situation. But it is also the
most complex to implement because of all the adjustable
parameters. Some of the parameters which define one of
these systems include:
◦ The number of queues.
◦ The scheduling algorithm for each queue.
◦ The methods used to upgrade or demote processes from
 one queue to another. ( Which may be different. )
◦ The method used to determine which queue a process
enters initially.

References:
• Abraham Silberschatz, Greg Gagne, and Peter Baer Galvin,
"Operating System Concepts, Eighth Edition ", Chapter 5