Chapter #03 Processes

Process
A process is a program in execution which then forms the basis of all computation. The process is not as same as program
code but a lot more than it. A process is an 'active' entity as opposed to the program which is considered to be a 'passive'
entity. Attributes held by the process include hardware state, memory, CPU, etc.
To put it in simple terms, we write our computer programs in a text file and when we execute this program, it becomes a
process which performs all the tasks mentioned in the program.
When a program is loaded into the memory and it becomes a process, it can be divided into four sections ─ stack, heap,
text and data. The following image shows a simplified layout of a process inside main memory −

S.N. Component & Description

1
Stack: The process Stack contains the temporary data such as method/function
parameters, return address and local variables.

2 Heap: This is dynamically allocated memory to a process during its run time.

3 Text: This includes the current activity represented by the value of Program Counter
and the contents of the processor's registers.

4 Data: This section contains the global and static variables.

Program
A program is a piece of code which may be a single line or millions of lines. A computer program is usually written by a
computer programmer in a programming language. For example, here is a simple program written in C programming
language −
#include <stdio.h>

int main() {
printf("Hello, World! \n");
return 0;
}

A computer program is a collection of instructions that performs a specific task when executed by a computer. When we
compare a program with a process, we can conclude that a process is a dynamic instance of a computer program.
A part of a computer program that performs a well-defined task is known as an algorithm. A collection of computer
programs, libraries and related data are referred to as a software.

Process vs Program
 Process Program

A Program is basically a collection of instructions that

The process is basically an instance of the
mainly performs a specific task when executed by the
computer program that is being executed.
computer.

A process has a shorter lifetime. A Program has a longer lifetime.

A Process requires resources such as A Program is stored by hard-disk and does not require any
memory, CPU, Input-Output devices. resources.

A process has a dynamic instance of code

A Program has static code and static data.
and data

Basically, a process is the running

On the other hand, the program is the executable code.
instance of the code.

Process Life Cycle

When a process executes, it passes through different states. These stages may differ in different operating systems, and
the names of these states are also not standardized.
In general, a process can have one of the following five states at a time.

S.N. State & Description

1
Start
 This is the initial state when a process is first started/created.

2
Ready
The process is waiting to be assigned to a processor. Ready processes are waiting
to have the processor allocated to them by the operating system so that they can run.
Process may come into this state after Start state or while running it by but
interrupted by the scheduler to assign CPU to some other process.

3
Running
Once the process has been assigned to a processor by the OS scheduler, the
process state is set to running and the processor executes its instructions.

4
Waiting
Process moves into the waiting state if it needs to wait for a resource, such as waiting
for user input, or waiting for a file to become available.

5
Terminated or Exit
Once the process finishes its execution, or it is terminated by the operating system,
it is moved to the terminated state where it waits to be removed from main memory.
Process Control Block (PCB)
A Process Control Block is a data structure maintained by the Operating System for every process. The PCB is identified
by an integer process ID (PID). A PCB keeps all the information needed to keep track of a process as listed below in the
table −

S.N. Information & Description

1
Process State
The current state of the process i.e., whether it is ready, running, waiting, or whatever.

2
Process privileges
This is required to allow/disallow access to system resources.

3
Process ID
Unique identification for each of the process in the operating system.
4
Pointer
A pointer to parent process.

5
Program Counter
Program Counter is a pointer to the address of the next instruction to be executed for
this process.

6
CPU registers
Various CPU registers where process need to be stored for execution for running
state.

7
CPU Scheduling Information
Process priority and other scheduling information which is required to schedule the
process.

8
Memory management information
This includes the information of page table, memory limits, Segment table depending
on memory used by the operating system.

9
Accounting information
This includes the amount of CPU used for process execution, time limits, execution
ID etc.

10
IO status information
This includes a list of I/O devices allocated to the process.
The architecture of a PCB is completely dependent on Operating System and may contain different information in different
operating systems. Here is a simplified diagram of a PCB −

The PCB is maintained for a process throughout its lifetime, and is deleted once the process terminates.
 Process Scheduling
When there are two or more runnable processes then it is decided by the Operating system which one to run first then it is
referred to as Process Scheduling.
A scheduler is used to make decisions by using some scheduling algorithm.
Given below are the properties of a Good Scheduling Algorithm:
• Response time should be minimum for the users.
• The number of jobs processed per hour should be maximum i.e Good scheduling algorithm should give maximum
throughput.
• The utilization of the CPU should be 100%.
• Each process should get a fair share of the CPU.
The act of determining which process is in the ready state, and should be moved to the running state is known
as Process Scheduling.
The prime aim of the process scheduling system is to keep the CPU busy all the time and to deliver minimum response
time for all programs. For achieving this, the scheduler must apply appropriate rules for swapping processes IN and OUT of
CPU.
Scheduling fell into one of the two general categories:

• Non Pre-emptive Scheduling: When the currently executing process gives up the CPU voluntarily.
• Pre-emptive Scheduling: When the operating system decides to favour another process, pre-empting the currently
executing process.
Scheduling Queues
• All processes, upon entering into the system, are stored in the Job Queue.
• Processes in the Ready state are placed in the Ready Queue.
• Processes waiting for a device to become available are placed in Device Queues. There are unique device queues
available for each I/O device.

A new process is initially put in the Ready queue. It waits in the ready queue until it is selected for execution(or
dispatched). Once the process is assigned to the CPU and is executing, one of the following several events can occur:

• The process could issue an I/O request, and then be placed in the I/O queue.
• The process could create a new subprocess and wait for its termination.
• The process could be removed forcibly from the CPU, as a result of an interrupt, and be put back in the ready
queue.
 Fig: Queueing-Diagram Representation of process scheduling
In the first two cases, the process eventually switches from the waiting state to the ready state, and is then put back in the
ready queue. A process continues this cycle until it terminates, at which time it is removed from all queues and has its PCB
and resources deallocated.
 State queues
• The OS maintains a collection of queues that represent the state of all processes in the system
– typically one queue for each state
• e.g., ready, waiting, …
– each PCB is queued onto a state queue according to the current state of the process it represents
– as a process changes state, its PCB is unlinked from one queue, and linked onto another
• The PCBs are moved between queues, which are represented as linked lists
PCBs and state queues
• PCBs are data structures

– dynamically allocated inside OS memory

• When a process is created:
– OS allocates a PCB for it
– OS initializes PCB
– (OS does other things not related to the PCB)
– OS puts PCB on the correct queue
• As a process computes:
– OS moves its PCB from queue to queue
• When a process is terminated:
– PCB may be retained for a while (to receive signals, etc.)
– eventually, OS deallocates the PCB
Schedulers
Schedulers are special system software which handle process scheduling in various ways. Their main
task is to select the jobs to be submitted into the system and to decide which process to run.
Schedulers are of three types −

• Long-Term Scheduler
• Short-Term Scheduler
• Medium-Term Scheduler

Long Term Scheduler

It is also called a job scheduler. A long-term scheduler determines which programs are admitted to
the system for processing. It selects processes from the queue and loads them into memory for
execution. Process loads into the memory for CPU scheduling.
The primary objective of the job scheduler is to provide a balanced mix of jobs, such as I/O bound
and processor bound. It also controls the degree of multiprogramming. If the degree of
multiprogramming is stable, then the average rate of process creation must be equal to the average
departure rate of processes leaving the system.
On some systems, the long-term scheduler may not be available or minimal. Time-sharing operating
systems have no long term scheduler. When a process changes the state from new to ready, then
there is use of long-term scheduler.

Short Term Scheduler

It is also called as CPU scheduler. Its main objective is to increase system performance in
accordance with the chosen set of criteria. It is the change of ready state to running state of the
process. CPU scheduler selects a process among the processes that are ready to execute and
allocates CPU to one of them.
Short-term schedulers, also known as dispatchers, make the decision of which process to execute
next. Short-term schedulers are faster than long-term schedulers.

Medium Term Scheduler

Medium-term scheduling is a part of swapping. It removes the processes from the memory. It
reduces the degree of multiprogramming. The medium-term scheduler is in-charge of handling the
swapped out-processes.
A running process may become suspended if it makes an I/O request. A suspended processes cannot
make any progress towards completion. In this condition, to remove the process from memory and
make space for other processes, the suspended process is moved to the secondary storage. This
process is called swapping, and the process is said to be swapped out or rolled out. Swapping may
be necessary to improve the process mix.
 Fig: Addition of Medium-term scheduling to the queueing diagram.

Comparison among Scheduler

S.N. Long-Term Scheduler Short-Term Scheduler Medium-Term Scheduler

1 It is a job scheduler It is a CPU scheduler It is a process swapping

scheduler.

2 Speed is lesser than short Speed is fastest among Speed is in between both
term scheduler other two short and long term
scheduler.

3 It controls the degree of It provides lesser control It reduces the degree of

multiprogramming over degree of multiprogramming.
multiprogramming

4 It is almost absent or It is also minimal in time It is a part of Time sharing

minimal in time sharing sharing system systems.
system
5 It selects processes from It selects those It can re-introduce the
pool and loads them into processes which are process into memory and
memory for execution ready to execute execution can be continued.

Context Switch
A context switch is the mechanism to store and restore the state or context of a CPU in Process
Control block so that a process execution can be resumed from the same point at a later time. Using
this technique, a context switcher enables multiple processes to share a single CPU. Context
switching is an essential part of a multitasking operating system features.
When the scheduler switches the CPU from executing one process to execute another, the state from
the current running process is stored into the process control block. After this, the state for the process
to run next is loaded from its own PCB and used to set the PC, registers, etc. At that point, the second
process can start executing.

Context switches are computationally intensive since register and memory state must be saved and
restored. To avoid the amount of context switching time, some hardware systems employ two or more
sets of processor registers. When the process is switched, the following information is stored for later
use.

• Program Counter
• Scheduling information
• Base and limit register value
• Currently used register
• Changed State
• I/O State information
• Accounting information