Process and CPU Scheduling

Part II
 Process Scheduling
A common representation of process
scheduling is queueing diagram.
 Process Scheduling
A common representation of process
scheduling is queueing diagram.
 Process Scheduling
Each rectangular box represent queue
 Process Scheduling
The circles represent the resources that serves the queues.
 Process Scheduling
Arrows indicate the flow of processes in the system.
 Process Scheduling
A new process is initially put in the ready
queue. It waits there until it is selected for
execution or dispatched.
 Process Scheduling
Once the process is allocated to the CPU,
below operations will execute.
 Process Scheduling
The process could issue an I/O request and
then be placed in an I/O queue.
 Process Scheduling
The process could issue an I/O request and
then be placed in an I/O queue.
 Process Scheduling
The process could issue an I/O request and
then be placed in an I/O queue.
 Process Scheduling
The process could create a new subprocess
and wait for the subprocesss termination.
 Process Scheduling
The process could create a new subprocess
and wait for the subprocesss termination.
 Process Scheduling
The process could be removed forcibly from the CPU,
as a result of an interrupt, and put back in the ready
queue.
 Process Scheduling
The process could be removed forcibly from the CPU,
as a result of an interrupt, and put back in the ready
queue.
 Schedulers
A process migrates among the various scheduling
queues throughout its lifetime.
The selection process is carried out by the
appropriate scheduler.
Long-term scheduler (or job scheduler) :- It
selects processes from the pool and loads them
into memory for execution.
Short-term scheduler (or CPU scheduler) :- It
selects from among the processes that are ready
to execute and allocates the CPU to one of them.
 Schedulers
Primary distinction between these two
schedulers lies in frequency of execution.
Short-term scheduler must select a new process
for the CPU frequently,
The short-term scheduler executes at least once every
100 milliseconds.
Because of the short time between executions, the
short-term scheduler must be fast.
If it takes 10 milliseconds to decide to execute a
process for 100 milliseconds, then 10/(100+10 ) =
9.0% of the CPU is being used (wasted) simply for
scheduling the work.
 Schedulers
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 (the number of processes in memory).
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.
Thus, the long term scheduler may need to be invoked only
when a process leaves the system.
Because of the longer interval between executions, the
long-term scheduler can afford to take more time to decide
which process should be selected for execution.
 Schedulers
It is important that the long-term scheduler make a careful
selection.
In general, most processes can be either I/O bound or CPU
bound.
I/O bound process: Spends more of its time doing I/O than
doing computations.
CPU bound process: Spends more of its time doing
computations.
If all process are I/O bound, the ready queue will almost
always empty.
If all process are CPU bound, the I/O waiting queue will
almost always empty.
The system with the best performance will have combination
of CPU bound and I/O bound processes.
 Schedulers
On some systems, the long-term scheduler may be absent or
minimal.
For example, time-sharing systems such as UNI X and Microsoft
Windows systems often have no long-term scheduler but simply put
every new process in memory for the short-term scheduler.
Some OS, such as time-sharing systems, may introduce an
intermediate level of scheduling called Medium-term
Scheduler.
The key idea behind a medium-term scheduler is
advantageous to remove processes from memory to reduce
the degree of multiprogramming( the number of process in
memory).
Later it can be reintroduced into memory and can be
continue.
This scheme is called Swapping.
Schedulers
 Context Switch
As we know, when interrupts cause the operating system to
change a CPU from its current task and to run a kernel
routine.
When an interrupt occurs,
The system needs to save the current context of the process currently
running on the CPU so that it can restore that context when its
processing is done.
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.
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.
 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.
Typical speeds are a few milliseconds.
Context-switch times are highly dependent on hard
ware support.
Its speed varies from machine to machine, depending
on the memory speed, the no of registers.
 ?
Two horses were born at the same time,
traveled the world, and then died at the
same time, but did not live to the same age.
How was this possible?
?
OPERATION ON PROCESS
 Introduction to
Operation on Process
The processes in most systems can execute
concurrently, and they may be created and
deleted dynamically.
Thus, these systems must provide a
mechanism for process creation and
termination.
In this section, we discuss the mechanisms
involved in creating processes
 Process Creation
A process may create several new process during
the course of execution.
Parent process create children processes, which,
in turn create other processes, forming a tree of
processes.
Most Operating systems identify processes
according to a unique process identifier (or pid).
Which is typically an integer number.
On UNIX, complete list of processes currently
active can be obtained using ps el command
 Process Creation
Resource sharing
In general, a process will need certain resources (CPU time,
memory, files, I/O devices) to accomplish its task.
When a process creates a sub process, that sub process
may be able to obtain its resources directly from the
operating system, or it may be constrained to a subset of
the resources of the parent process.
The parent may have to partition its resources among its
children, or it may be able to share some resources (such
as memory or files) among several of its children.
Restricting a child process to a subset of the parents
resources prevents any process from overloading the
system by creating too many sub processes.
 Process Creation
Execution
When a process creates a new process, two
possibilities exist in terms of execution :
The parent continues to execute concurrently with its
children.
The parent waits until some or all of its children have
terminated .
Address space
There are also two possibilities in terms of the address
space of the new process :
The child process is a duplicate of the parent process(it has
the same program and data as the parent).
The child process has a new program loaded into it.
 Process Creation
A new process is created by the fork() system call.
The new process consists of a copy of the address
space of the original process.
This mechanism allows the parent process to
communicate easily with its child process.
The exec () system call is used after a fork () system call
by one of the two processes to re place the process's
memory space with a new program.
The exec() system call loads a binary file into memory
and starts its execution.
In this manner, the two processes are able to
communicate and then go their separate ways.
Process Creation
 Process Termination
Process executes last statement and asks the operating
system to delete it (exit)
At that point, the process may return a status value
(typically an integer) to its parent process.
All the resources of the processincluding physical and
virtual memory, open files, and I/O buffersare
deallocate by the operating system.
 Process Termination
Parent may terminate execution of children processes
(abort)
Termination can occur in other circumstances as well. A
process can cause the termination of an other process via an
appropriate system call (for example, TerminateProcess () in
Win32).
Usually, such a system call can be invoked only by the parent of
the process that is to be terminated.
Otherwise, users could arbitrarily kill each other's jobs.
Note that a parent needs to know the identities of its children.
Thus, when one process creates a new process, the identity of
the newly created process is passed to the parent.
 Process Termination
A parent may terminate the execution of one of
its children for a variety of reasons, such as these:
The child has exceeded its usage of some of the
resources that it has been allocated.
To identify this has occurred, the parent must have a
mechanism to inspect the state of its children.
The task assigned to the child is no longer required.
The parent is exiting, and the operating system does
not allow a child to continue if its parent terminates.
 Interprocess Communication
Processes executing concurrently in the operating
system may be either independent processes or
cooperating processes.
A process is independent if it cannot affect or be
affected by the other processes executing in the
system.
Any process that does not share data with any other
process is independent .
A process is cooperating if it can affect or be affected
by the other processes executing in the system.
Clearly, any process that shares data with other
processes is a cooperating process.
 Interprocess Communication
There are several reasons for providing an environment
that allows process cooperation:
Information sharing:
Since several users may be interested in the same piece of
information(for instance, a shared file), we must provide
an environment to allow concurrent access to such
information.
Computation speedup:
If we want a particular task to run faster, we must break it
into subtasks, each of which will be executing in parallel
with the others.
Notice that such a speed up can be achieved only if the computer
has multiple processing elements (such as CPUs or I/O channels).
 Interprocess Communication
Modularity:
We may want to construct the system in a
modular fashion, dividing the system functions
into separate processes or threads.
Convenience:
Even an individual user may work on many tasks
at the same time.
For instance, a user may be editing, printing, and
compiling in parallel
 Interprocess Communication
Cooperating processes require an interprocess
communication (IPC) mechanism that will allow them to
exchange data and information.
There are two fundamental models of interprocess
communication:
Shared memory and
Message passing.
In the shared-memory model, a region of memory that is
shared by cooperating processes is established.
Processes can then exchange information by reading and
writing data to the shared region.
In the message passing model, communication takes place
by means of messages exchanged between the cooperating
processes.
Interprocess Communication
 ?
Which word, if pronounced right, is wrong,
but if pronounced wrong is right?
 ?
WRONG!!
 Shared-Memory Systems
Interprocess communication using shared
memory requires communicating processes to
establish a region of shared memory.
Typically, a shared-memory region resides in the
address space of the process creating the shared-
memory segment.
Other processes that wish to communicate using
this shared-memory segment must attach it to
their address space.
They can then exchange information by reading
and writing data in the shared areas.
 Shared-Memory Systems
To illustrate the concept of cooperating
processes,
let's consider the producer-consumer problem, which
is a common paradigm for cooperating processes.
A producer process produces information that is
consumed by a consumer process.
For example, a web server produces(i.e, provides)
HTML files and images, which are consumed (i.e,
read) by the client web browser requesting the
resource.
 Shared-Memory Systems
One solution to the producer-consumer problem
uses shared memory.
To allow producer and consumer processes to run
concurrently, we must have a buffer.
This buffer will reside in a region of memory that is
shared by the producer and consumer processes.
A producer can produce one item while the
consumer is consuming another item.
The producer and consumer must be synchronized, so
that the consumer does not try to consume an item
that has not yet been produced.
 Shared-Memory Systems
Two types of buffers can be used.
The unbounded buffer:
It places no practical limit on the size of the buffer.
The consumer may have to wait for new items, but
the producer can always produce new items.
The bounded buffer:
It assumes a fixed buffer size.
In this case, the consumer must wait if the buffer is
empty, and the producer must wait if the buffer is full.
 Message-Passing Systems
Message passing provides a mechanism to allow
processes to communicate and to synchronize their
actions with out sharing the same address space
It is particularly useful in a distributed environment, where
different computers connected by a network.
For example, a chat program used on the World Wide
Web.
A message-passing facility provides at least two
operations:
send(message)
receive(message).
 Message-Passing Systems
Messages sent by a process can be of either fixed
or variable size.
If processes P and Q want to communicate, they
must send messages to and receive messages
from each other; a communication link must exist
between them.
This link can be implemented in a variety of ways.
Direct or indirect communication
Synchronous or asynchronous communication
Automatic or explicit buffering
 Message-Passing Systems
Under direct communication, each process that wants to
communicate must explicitly name the recipient or sender
of the communication.
In this scheme, the send() and receive( ) primitives are
defined as:
send(P, message)Send a message to process P.
receive(Q, message)Receive a message from process Q .
A communication link in this scheme has the following
properties:
A link is established automatically
A link is associated with exactly two processes.
Between each pair of processes, there exists exactly one link.
 Message-Passing Systems
This scheme exhibits symmetry in addressing;
That is, both the sender process and the receiver process must
name the other to communicate.
A variant of this scheme employs asymmetry in addressing.
Here, only the sender names the recipient;
In this scheme, the send( ) and receive() primitives are defined
as follows:
send(P, message)
Send a message to process P.
receive(id, message)
Receive a message from any process;
The variable id is set to the name of the process with which
communication has taken place.
 Message-Passing Systems
With indirect communication, the messages are sent to and
received from mail boxes, or ports.
Each mail box has a unique identification.
send(A, message)
Send a message to mailbox A.
receive(A, message)
Receive a message from mailbox A.
A communication link in this scheme has the following
properties:
A link is established between a pair of processes only if both
members of the pair have a shared mailbox.
A link may be associated with more than two processes.
Between each pair of communicating processes, there may be a
number of different links.
 Message-Passing Systems
Message passing may be either blocking or non
blocking also known as synchronous and asynchronous.
Blocking send:
The sending process is blocked until the message is
received by the receiving processor by the mailbox.
Non blocking send:
The sending process sends the message and resumes
operation.
Blocking receive:
The receiver blocks until a message is available.
Non blocking receive:
The receiver retrieves either a valid message or a null.
 Message-Passing Systems
Whether communication is direct or indirect, messages exchanged
by communicating processes reside in a temporary queue.
Basically, such queues can be implemented in three ways:
Zero capacity:
The queue has a maximum length of zero; thus, the link cannot have any
messages waiting in it.
In this case, the sender must block until the recipient receives the
message.
Bounded capacity:
The queue has finite length n; thus, at most n messages can reside in it.
If the queue is not full when a new message is sent, the message is placed
in the and the sender can continue execution without waiting.
The links capacity is finite, however. If the link is full, the sender must
block until space is available in the queue.
Un bounded capacity:
The queues length is potentially infinite; thus, any number of messages
can wait in it. The sender never blocks.