Process in Operating System
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.
Process memory is divided into four sections for efficient working :
The Text section is made up of the compiled program code, read in from non-volatile
storage when the program is launched.
The Data section is made up of the global and static variables, allocated and initialized
prior to executing the main.
The Heap is used for the dynamic memory allocation and is managed via calls to new,
delete, malloc, free, etc.
The Stack is used for local variables. Space on the stack is reserved for local variables
when they are declared.
The different Process States
Processes in the operating system can be in any of the following states:
NEW- The process is being created.
READY- The process is waiting to be assigned to a processor.
RUNNING- Instructions are being executed.
WAITING- The process is waiting for some event to occur(such as
an I/O completion or reception of a signal).
TERMINATED- The process has finished execution.
Process Control Block
There is a Process Control Block for each process, enclosing all the
information about the process. It is also known as the task control
block. It is a data structure, which contains the following:
Process State: It can be running, waiting, etc.
Process ID and the parent process ID.
CPU registers and Program Counter. Program Counter holds
the address of the next instruction to be executed for that
process.
CPU Scheduling information: Such as priority information and
pointers to scheduling queues.
Memory Management information: For example, page tables
or segment tables.
Accounting information: The User and kernel CPU time
consumed, account numbers, limits, etc.
I/O Status information: Devices allocated, open file tables, etc.
Process vs Program
Let us take a look at the differences between Process and Program:
Process Program
The process is basically an A Program is basically a collection of
instance of the computer instructions that mainly performs a
program that is being specific task when executed by the
executed. computer.
A process has a shorter
A Program has a longer lifetime.
lifetime.
A Process requires
A Program is stored by hard-disk and
resources such as memory,
does not require any resources.
CPU, Input-Output devices.
A process has a dynamic A Program has static code and static
instance of code and data data.
Basically, a process is
On the other hand, the program is
the running instance of
the executable code.
the code.
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.
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.
What are 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.
Types of Schedulers
There are three types of schedulers available:
1. Long Term Scheduler
2. Short Term Scheduler
3. Medium Term Scheduler
Let's discuss about all the different types of Schedulers in detail:
Long Term Scheduler
Long term scheduler runs less frequently. Long Term Schedulers
decide which program must get into the job queue. From the job
queue, the Job Processor, selects processes and loads them into the
memory for execution. Primary aim of the Job Scheduler is to maintain
a good degree of Multiprogramming. An optimal degree of
Multiprogramming means the average rate of process creation is
equal to the average departure rate of processes from the execution
memory.
Short Term Scheduler
This is also known as CPU Scheduler and runs very frequently. The
primary aim of this scheduler is to enhance CPU performance and
increase process execution rate.
Medium Term Scheduler
This scheduler removes the processes from memory (and from active
contention for the CPU), and thus reduces the degree of
multiprogramming. At some later time, the process can be
reintroduced into memory and its execution van be continued where it
left off. This scheme is called swapping. The process is swapped out,
and is later swapped in, by the medium term scheduler.
Swapping may be necessary to improve the process mix, or because
a change in memory requirements has overcommitted available
memory, requiring memory to be freed up. This complete process is
descripted in the below diagram:
What is Context Switch?
1. Switching the CPU to another process requires saving the state
of the old process and loading the saved state for the new
process. This task is known as a Context Switch.
2. The context of a process is represented in the Process Control
Block(PCB) of a process; it includes the value of the CPU
registers, the process state and memory-management
information. When a context switch occurs, the Kernel saves the
context of the old process in its PCB and loads the saved context
of the new process scheduled to run.
3. Context switch time is pure overhead, because the system
does no useful work while switching. Its speed varies from
machine to machine, depending on the memory speed, the
number of registers that must be copied, and the existence of
special instructions(such as a single instruction to load or store
all registers). Typical speeds range from 1 to 1000
microseconds.
4. Context Switching has become such a
performance bottleneck that programmers are using new
structures(threads) to avoid it whenever and wherever possible.
Scheduling Algorithms
To decide which process to execute first and which process to
execute last to achieve maximum CPU utilization, computer scientists
have defined some algorithms, they are:
1. First Come First Serve(FCFS) Scheduling
2. Shortest-Job-First(SJF) Scheduling
3. Priority Scheduling
4. Round Robin(RR) Scheduling
5. Multilevel Queue Scheduling
6. Multilevel Feedback Queue Scheduling
7. Shortest Remaining Time First (SRTF)
8. Longest Remaining Time First (LRTF)
9. Highest Response Ratio Next (HRRN)