Operating System

By
Mr. Parag R. Sali
Lecturer
Department of Computer Technology
SNJB’s Shri. Hiralal Hastimal ( Jain Brothers)
Polytechnic, Chandwad
Program Name: Computer Engineering Group
Program Code : CO/CM/IF/CW
Semester : Fifth
Course Title : Operating System
Course Code : 22516

3.2 Process Scheduling

 Process Scheduling

The objective of multiprogramming is to have some process running at all times,

to maximize CPU utilization. The objective of time sharing is to switch the CPU
among processes so frequently that users can interact with each program while
it is running.

To meet these objectives, the process scheduler selects an available process

(possibly from a set of several available processes) for program execution on the
CPU. For a single-processor system, there will never be more than one running
process. If there are more processes, the rest will have to wait until the CPU is
free and can be rescheduled.
The ready queue and various I/O device queues.
 Scheduling Queues
As processes enter the system, they are put into a job queue, which consists of all
processes in the system. The processes that are residing in main memory and are
ready and waiting to execute are kept on a list called the ready queue. This queue is
generally stored as a linked list. A ready-queue header contains pointers to the first
and final PCBs in the list. Each PCB includes a pointer field that points to the next PCB
in the ready queue.
The system also includes other queues. When a process is allocated the CPU, it
executes for a while and eventually quits, is interrupted, or waits for the occurrence
of a particular event, such as the completion of an I/O request. Suppose the process
makes an I/O request to a shared device, such as a disk. Since there are many
processes in the system, the disk may be busy with the I/O request of some other
process. The process therefore may have to wait for the disk. The list of processes
waiting for a particular I/O device is called a device queue. Each device has its own
device queue
Queueing-diagram representation of process scheduling.
A common representation of process scheduling is a queueing diagram,
such as that in Figure Each rectangular box represents a queue.

Two types of queues are present: the ready queue and a set of device
queues. The circles represent the resources that serve the queues, and the
arrows indicate the flow of processes in the system.

A new process is initially put in the ready queue. It waits there until it is
selected for execution, or dispatched. Once the process is allocated the CPU
and is executing, one of several events could occur:
• The process could issue an I/O request and then be placed in an I/O queue.
• The process could create a new child process and wait for the child’s
termination.
• The process could be removed forcibly from the CPU, as a result of an
interrupt, and be put back in the ready queue.

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.
Schedulers
A process migrates among the various scheduling queues throughout its lifetime.
The operating system must select, for scheduling purposes, processes from these
queues in some fashion. The selection process is carried out by the appropriate
scheduler.
Often, in a batch system, more processes are submitted than can be executed
immediately. These processes are spooled to a mass-storage device (typically a disk),
where they are kept for later execution. The long-term scheduler, or job scheduler,
selects processes from this pool and loads them into memory for execution. The
short-term scheduler, or CPU scheduler, selects from among the processes that are
ready to execute and allocates the CPU to one of them.
The primary distinction between these two schedulers lies in frequency of
execution. The short-term scheduler must select a new process for the CPU
frequently. A process may execute for only a few milliseconds before waiting for
an I/O request. Often, the short-term scheduler executes at least once every
100 milliseconds. The long-term scheduler executes much less frequently;
minutes may separate the creation of one new process and the next. The long-
term scheduler controls the degree of multiprogramming
It is important that the long-term scheduler make a careful selection. In general,
most processes can be described as either I/O bound or CPU bound. An I/O-
bound process is one that spends more of its time doing I/O than it spends
doing computations. A CPU-bound process, in contrast, generates I/O requests
infrequently, using more of its time doing computations. It is important that the
long-term scheduler select a good process mix of I/O-bound and CPU-bound
processes. If all processes are I/O bound, the ready queue will almost always be
empty, and the short-term scheduler will have little to do.

If all processes are CPU bound, the I/O waiting queue will almost always be
empty, devices will go unused, and again the system will be unbalanced. The
system with the best performance will thus have a combination of CPU-bound
and I/O-bound processes.
On some systems, the long-term scheduler may be absent or minimal.
For example, time-sharing systems such as UNIX and Microsoft Windows
systems often have no long-term scheduler but simply put every new process in
memory for the short-term scheduler. The stability of these systems depends
either on a physical limitation (such as the number of available terminals) or on
the self-adjusting nature of human users. If performance declines to
unacceptable levels on a multiuser system, some users will simply quit.
Some operating systems, such as time-sharing systems, may introduce an
additional, intermediate level of scheduling. This medium-term scheduler is
diagrammed in Figure. The key idea behind a medium-term scheduler is that
sometimes it can be advantageous to remove a process from memory (and from
active contention for the CPU) and thus reduce the degree of multiprogramming.
Later, the process can be reintroduced into memory, and its execution can 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.
Addition of medium-term scheduling to the queueing diagram.
 Context Switch
Interrupts cause the operating system to change a CPU from its current task and to
run a kernel routine. Such operations happen frequently on general-purpose
systems. When an interrupt occurs, the system needs to save the current context
of the process running on the CPU so that it can restore that context when its
processing is done, essentially suspending the process and then resuming it. The
context is represented in the PCB of the process. It includes the value of the CPU
registers, the process state , and memory-management information.

Generically, we perform a state save of the current state of the CPU, be it in kernel
or user mode, and then a state restore to resume operations.
Switching the CPU to another process requires performing a state save of the
current process and a state restore of a different process. This task is known as a
context switch. 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. Context-switch time is pure overhead, because the system does no useful
work while switching. Switching 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). A typical speed is a few milliseconds.