❖ Process Management:

• Process Concept

• Process Scheduling

• Operations on Processes

• Inter process communication

❖ Multi-thread Programming:
• Multi-threading Model

• Threads Libraries

• Threading Issues

❖ Process Scheduling:
• Basic Concepts

• Scheduling Criteria

• Scheduling Algorithms

• Thread Scheduling

• Multiple-processor Scheduling
 OperatingSystems M23BCS303
21CS44

PROCESSMANAGEMENT
MODULE 2
PROCESSMANAGEMENT
Process Concept

 A process is a program under execution.

 Its current activity is indicated by PC (ProgramCounter) and the contents of the processor's
registers.

The Process

Process memory is divided into four sections as shown in the figure below:
 The stack is used to store temporary data such as local variables, function parameters, function
return values, return address etc.
 The heap which is memory that is dynamically allocated during process runtime
 The data section stores global variables.
 The text section comprises the compiled program code.
 Note that, there is a free space between the stack and the heap. When the stack is full, it grows
downwards and when the heap is full, it grows upwards.

Figure: Process in memory.

ProcessState:
A Process has 5 states. Each process may be in one of the following states–

1. New- The process is in the stage of being created.

2. Ready- The process has all the resources it needs to run. It is waiting to be assigned to
the processor.
3. Running–Instructions are being executed.
4. Waiting- The process is waiting for some event to occur. For example, the process may
be waiting for keyboard input, disk access request, inter-process messages, a timer to go
off, or a child process to finish.
5. Terminated –The process has completed its execution.

133
 OperatingSystems M23BCS303
21CS44

Figure: Diagram of process state

Process Control Block

For each process there is a Process Control Block (PCB), which stores the process-specific information
as shown below –

 Process State– The state of the process may be new, ready, running, waiting, and so on.
 Program counter –The counter indicates the address of the next instruction to be executed for
this process.
 CPU registers - The registers vary in number and type, depending on the computer
architecture. They include accumulators, index registers, stack pointers, and general-purpose
registers. Along with the program counter, this state information must be saved when an
interrupt occurs, to allow the process to be continued correctly afterward.
 CPU scheduling information- This information includes a process priority, pointers to
scheduling queues, and any other scheduling parameters.
 Memory-management information– This includes information such as the value of the base
and limit registers, the page tables, or the segment tables.
 Accounting information– This information includes the amount of CPU and real time used,
time limits, account numbers, job or process numbers, and so on.
 I/O status information – This information includes the list of I/O devices allocated to the
process, a list of open files, and so on.

The PCB simply serves as the repository for any information that may vary from process to process.

Figure: Process control block (PCB)

233
 OperatingSystems M23BCS303
21CS44

CPU Switch from Process to Process

Figure: Diagram showing CPU switch from process to process.

Process Scheduling

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.

Ready Queue and Various I/O Device Queues

Figure: The ready queue and various I/O device queues

333
 OperatingSystems M23BCS303
21CS44

 A common representation of process scheduling is a queueing diagram. Each rectangular box

in the diagram 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 in the ready queue until it is selected
for execution and is given the CPU. 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 sub process 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.
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.

Figure: Queuing –diagram representation of process scheduling.

433
 OperatingSystems M23BCS303
21CS44

Schedulers
Schedulers are software which selects an available program to be assigned to CPU.

 A long-term scheduler or Job-scheduler–selects jobs from the job pool (of secondary
memory, disk) and loads them into the memory.
If more processes are submitted, than that can be executed immediately, such processes will be
in secondary memory. It runs infrequently, and can take time to select the next process.
 The short-term scheduler, or CPU Scheduler– selects job from memory and assigns the
CPU to it. It must select the new process for CPU frequently.
 The medium-term scheduler- selects the process in ready queue and re introduced into the
memory.

Processes can be described as either:

 I/O-bound process–spends more time doing I/O than computations,
 CPU-bound process–spends more time doing computations and few I/O operations.

An efficient scheduling system will select a good mix of CPU-bound processes and I/O bound
processes.
 If the scheduler selects more I/O bound process, then I/O queue will be full and ready
queue will be empty.
 If the scheduler selects more CPU bound process, then ready queue will be full and I/O
queue will be empty.

Time sharing systems employ a medium-term scheduler. It swaps out the process from ready
queue and swap in the process to ready queue. When system loads get high, this scheduler will
swap one or more processes out of the ready queue for a few seconds, in order to allow smaller
faster jobs to finish up quickly and clear the system.

Advantages of medium-term scheduler–

 To remove process from memory and thus reduce the degree of multi-programming
(number of processes in memory).
 To make a proper mix of processes (CPU bound and I/O bound)

533
 OperatingSystems M23BCS303
21CS44

Context switching
 The task of switching a CPU from one process to another process is called context switching.
Context-switch times are highly dependent on hardware support (Number of CPU registers).
 Whenever an interrupt occurs (hardware or software interrupt), the state of the currently
running process is saved into the PCB and the state of an other process is restored from the
PCB to the CPU.
 Context switch time is an overhead, as the system does not do useful work while switching.

Operations on Processes

 A process may create several new processes. The creating process is called a parent
process, and the new processes are called the children of that process. Each of these new
processes may in turn create other processes. Every process has a unique process ID.
 On typical Solaris systems, the process at the top of the tree is the ‘sched’ process with
PID of 0. The ‘sched’ process creates several children processes – init, pageout and
fsflush. Pageout and fsflush are responsible for managing memory and file systems. The
init process with a PID of 1, serves as a parent process for all user processes.

A process will need certain resources (CPU time, memory, files, I/O devices) to accomplish its
task. When a process creates a sub process, the sub process may be able to obtain its resources
in two ways:
 Directly from the operating system
 Sub process may take there sources of the parent process. The resource can be taken
from parent in two ways –
 The parent may have to partition its resources among its children
 Share the resources among several children.

633
 OperatingSystems M23BCS303
21CS44

There are two options for the parent process after creating the child:

 Wait for the child process to terminate and then continue execution. The parent makes a wait()
system call.
 Run concurrently with the child, continuing to execute without waiting.

Two possibilities for the address space of the child relative to the parent:

 The child may be an exact duplicate of the parent, sharing the same program and data
segments in memory. Each will have their own PCB, including program counter,
registers, and PID. This is the behavior of the fork system call in UNIX.
 The child process may have a new program loaded into its address space, with all new
code and data segments. This is the behavior of the spawn system calls in Windows.

In UNIX OS, a child process can be created by fork() system call. The fork system call, if
successful, returns the PID of the child process to its parents and returns a zero to the child
process. If failure, it returns -1 to the parent. Process IDs of current processor its direct parent
can be accessed using the getpid( ) and getppid( ) system calls respectively.

The parent waits for the child process to complete with the wait()system call. When the child
process completes, the parent process resumes and completes its execution.

733
 OperatingSystems 21CS44
BCS303

In windows the child process is created using the function create_process(). The create process()
returns 1, if the child is created and returns 0, if the child is not created.

Process Termination
 A process terminates when it finishes executing its last statement and asks the operating
system to delete it, by using the exit () system call. All of the resources assigned to the process
like memory, open files, and I/O buffers, are de-allocated by the operating system.
 A process can cause the termination of another process by using appropriate system call. The
parent process can terminate its child processes by knowing of the PID of the child.
 A parent may terminate the execution of children for a variety of reasons, such as:
 The child has exceeded its usage of the resources, it has been allocated.
 The task assigned to the child is no longer required.
 The parent is exiting, and the operating system terminates all the children. This is
called cascading termination.

Inter process Communication

Interprocess Communication-Processes executing may be either co-operative or independent

processes.
 Independent Processes – processes that cannot affect other processes or be affected by other
processes executing in the system.
 Cooperating Processes–processes that can affect other processes or be affected by other
processes executing in the system.

Co-operation among processes are allowed for following reasons–

 Information Sharing-There may be several processes which need to access the same file. So
the information must be accessible at the same time to all users.
 Computation speedup-Often a solution to a problem can be solved faster if the problem can
be broken down into sub-tasks, which are solved simultaneously (particularly when multiple
Processors are involved.)
 Modularity-A system can be divided into cooperating modules and executed by sending
information among one another.
 Convenience-Even a single user can work on multiple tasks by information sharing.

8
40
 OperatingSystems 21CS44
BCS303
Cooperating processes require some type of inter-process communication. This is allowed by two
models:
1. Shared Memory systems
2. Message passing systems.

Sl No Shared Memory Message passing

A region of memory is shared by
Message exchange is done among the
1. Communicating processes, into which the
processes by using objects.
information is written and read
2. Useful for sending large block of data Useful for sending small data.
System call issued only to create System call is used during every
3.
Shared memory Read and write operation.
Message is sent faster, as there are no
4. Message is communicated slowly.
System calls

 Shared Memory is faster once it is set up, because no system calls are required and access
occurs at normal memory speeds. Shared memory is generally preferable when large amounts
of information must be shared quickly on the same computer.
 Message Passing requires system calls for every message transfer, and is therefore slower, but
it is simpler to set up and works well across multiple computers. Message passing is generally
preferable when the amount and/or frequency of data transfers is small.

9
40
 OperatingSystems 21CS44
BCS303

Shared-Memory Systems

 A region of shared-memory is created within the address space of a process, which needs to
communicate. Other process that needs to communicate uses this shared memory.
 The form of data and position of creating shared memory area is decided by the process.
Generally, a few messages must be passed back and forth between the cooperating processes
first in order to set up and coordinate the shared memory access.
 The process should take care that the two processes will not write the data to the shared
memory at the same time.

Producer-Consumer Example Using Shared Memory

 This is a classic example, in which one process is producing data and another process is
consuming the data.
 The data is passed via an intermediary buffer (shared memory). The producer puts the data to
the buffer and the consumer takes out the data from the buffer. 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. In this situation, the consumer must wait until an item is produced.
 There are two types of buffers into which information can be put–
 Unbounded buffer
 Bounded buffer

 With Unbounded buffer, there is no limit on the size of the buffer, and so on the
data produced by producer. But the consumer may have to wait for new items.
 With bounded-buffer–As the buffer size is fixed. The producer has to wait if the buffer is
full and the consumer has to wait if the buffer is empty.

This example uses shared memory as a circular queue. The in and out are two pointers to the array.
Note in the code below that only the producer changes "in", and only the consumer changes "out".

First the following data is set up in the shared memory area:

10
40
 OperatingSystems 21CS44
BCS303

The producer process–

Note that the buffer is full when [(in+1)%BUFFER_SIZE==out]

The consumer process– Note that the buffer is empty when[ in==out]

Message-Passing Systems

A mechanism to allow process communication without sharing address space. It is used in distributed
systems.
 Message passing systems uses system calls for "send message" and" receive message".
 A communication link must be established between the cooperating processes before messages
can be sent.
 There are three methods of creating the link between the sender and the receiver-
o Direct or indirect communication (naming)
o Synchronous or asynchronous communication(Synchronization)
o Automatic or explicit buffering.

11
40
 OperatingSystems 21CS44
BCS303

1. Naming
Processes that want to communicate must have a way to refer to each other. They can use either direct
or indirect communication.
a) Direct communication: The sender and receiver must explicitly know each other’s name. The
syntax for send() and receive() functions are as follows-

 send(P,message)–send a message to process P

 receive(Q,message)– receive a message from process Q

Properties of communication link:

 A link is established automatically between every pair of processes that wants to
communicate. The processes need to know only each other's identity to communicate.
 A link is associated with exactly one pair of communicating processes
 Between each pair, there exists exactly one link.

Types of addressing indirect communication –

 Symmetric addressing – the above-described communication is symmetric communication.

Here both the sender and the receiver processes have to name each other to communicate.
 Asymmetric addressing – Here only the sender’s name is mentioned, but the receiving data
can be from any system.
send(P, message)---Send a message to process P
receive(id, message).Receive a message from any process

Disadvantages of direct communication – any changes in the identifier of a process, may have to
change the identifier in the whole system (sender and receiver), where the messages are sent and
received.

b) Indirect communication uses shared mail-boxes or ports.

A mailbox or port is used to send and receive messages. Mailbox is an object into which messages
can be sent and received. It has a unique ID. Using this identifier messages are sent and received.

Two processes can communicate only if they have a shared mailbox. The send and receive functions
are –
 send(A,message)–send a message to mail-box A
 receive(A,message)–receive a message from mail-box A

Properties of communication link:

 A link is established between a pair of processes only if they have a shared mailbox

44
12
 OperatingSystemsBCS303
21CS44

 A link may be associated with more than two processes

 Between each pair of communicating processes, there may be any number of links, each link
is associated with one mailbox.
 A mail-box can be owned by the operating system. It must take steps to–
 Create a new mail-box
 Send and receive messages from mailbox
 Delete mail boxes.

2. Synchronization
The send and receive messages can be implemented as either blocking or non-blocking.

 Blocking (synchronous) send- sending process is blocked (waits) until the message is
received by receiving process or the mailbox.
 Non-blocking (asynchronous)send –sends the message and continues(does not wait)
 Blocking(synchronous)receive-The receiving process is blocked until a message is
available
 Non-blocking (asynchronous) receive - receives the message without block. The
received message may be a valid message or null.

3. Buffering
When messages are passed, a temporary queue is created. Such queue can be of three capacities:

 Zero capacity – The buffer size is zero (buffer does not exist). Messages are not stored in the
queue. The senders must block until receivers accept the messages.
 Bounded capacity- The queue is of fixed size(n). Senders must block if the queue is full. After
sending ‘n’ bytes the sender is blocked.
 Unbounded capacity –The queue is of infinite capacity.The sender never blocks.

13
 OperatingSystems 21CS44
BCS303

MULTITHREADEDPROGRAMMING
 A thread is a basic unit of CPU utilization.
 It consists of
 thread ID
 PC
 register-set and
 stack.
 It shares with other threads belonging to the same processs its code-section & data-section.
 A traditional (or heavy weight) process has a single thread of control.
 If a process has multiple threads of control, it can perform more than one task at a time. such a
process is called multithreaded process

Fig: Single-threaded and multithreaded processes

Motivation for Multithreaded Programming

1. The software-packages that run on modern PCs are multi-threaded. An application is implemented as a
separate process with several threads of control. For ex: A word processor may have
 First thread for displaying graphics
 Second thread for responding to key strokes and
 Third thread for performing grammar checking.

14
 OperatingSystems 21CS44
BCS303

2. In some situations, a single application may be required to perform several similar tasks. For ex: A web-
server may create a separate thread for each client requests. This allows the server to service several
concurrent requests.

3. RPC servers are multithreaded.

 When a server receives a message, it services the message using separate concurrent
threads.
4. Most OS kernels are multithreaded;
 Several threads operate in kernel, and each thread performs a specific task, such
as managing devices or interrupt handling.

Benefits of Multithreaded Programming

 Responsiveness A program may be allowed to continue running even if part of it is blocked.

Thus, increasing responsiveness to the user.

 Resource Sharing By default, threads share the memory (and resources) of the process to
which they belong. Thus, an application is allowed to have several different threads of
activity within the same address-space.
 Economy Allocating memory and resources for process-creation is costly. Thus, it is more
economical to create and context-switch threads.
 Utilization of Multiprocessor Architectures In a multiprocessor architecture, threads may
be running in parallel on different processors. Thus, parallelism wills be increased.

MULTITHREADING MODELS

 Support for threads may be provided at either

1. The user level, for user threads or
2. By the kernel, for kernel threads.
 User-threads are supported above the kernel and are managed without kernel support. Kernel- threads
are supported and managed directly by the OS.
 Three ways of establishing relationship between user-threads & kernel-threads:
1. Many-to-one model
2. One-to-one model and
3. Many-to-many model.

15
 OperatingSystems 21CS44
BCS303

Many-to-One Model
 Many user- level threads are mapped to one kernel thread.
Advantages:
 Thread management is done by the thread library in users pace, so it is efficient.
Disadvantages:
 The entire process will block if a thread makes a blocking system-call.
 Multiple threads are unable to run in parallel on multiprocessors.
 For example:
 Solaris green threads
 GNU portable threads.

Fig: Many-to-one model

One-to-One Model
 Each user thread is mapped to a kernel thread.
Advantages:
 It provides more concurrency by allowing another thread to run when a thread
makes a blocking system-call.
 Multiple threads can run in parallel on multiprocessors.
Disadvantage:
 Creating a user thread requires creating the corresponding kernel thread.
 For example:
 Windows NT/XP/2000,Linux

Fig: one-to-one model

16
 OperatingSystems 21CS44
BCS303

Many-to-Many Model
 Many user-level threads are multiplexed to a smaller number of kernel threads.
Advantages:
 Developers can create as many user threads as necessary
 The kernel threads can run in parallel on a multiprocessor.
 When a thread performs a blocking system-call, kernel can schedule another thread for
execution.
Two Level Model
 A variation on the many-to-many model is the two level-model
 Similar to M:N, except that it allows a user thread to be bound to kernel thread.
 For example:
 HP-UX
 Tru64UNIX

Fig: Many-to-many model Fig: Two-level model

Thread Libraries
 It provides the programmer with an API for the creation and management of threads.

 Two ways of implementation:

1. First Approach:
Provides a library entirely in user space with no kernel support. All code and data structures for the
library exist in the user space.
2. Second Approach
Provides a library entirely in user space with no kernel support. All code and data structures for the
library exist in the user space.

17
 OperatingSystems 21CS44
BCS303

Three main thread libraries:

1. POSIXP threads
2. Win32 and
3. Java.

Pthreads
 This is a POSIX standard API for thread creation and synchronization.
 This is a specification for thread-behavior, not an implementation.
 OS designers may implement the specification in anyway they wish.
 Commonly used in: UNIX and Solaris.

18
 OperatingSystems 21CS44
BCS303

Win 32 threads
 Implements the one-to-one mapping
 Each thread contains
 A thread-id
 Register set
 Separate user and kernel stacks
 Private data storage area
 The register set, stacks, and private storage area are known as the context of the
threads The primary data structures of a thread include:
 ETHREAD(executive thread block)
 KTHREAD(kernel thread block)
 TEB(thread environment block)

Java Threads
 Threads are the basic model of program-execution in
 Java program and
 Java language.
 The API provides a rich set of features for the creation and management of threads.
 All Java programs comprise at least a single thread of control.
 Two techniques for creating threads:
1. Create a new class that is derived from the Thread class and override its run() method.
2. Define a class that implements the Runnable interface. The Runnable interface is
defined as follows:

19
 OperatingSystems 21CS44
BCS303

THREADINGISSUES

fork()andexec()System-calls
 fork() is used to create a separate, duplicate process.
 If one thread in a program calls fork(), then
1. Some systems duplicates all threads and
2. Other systems duplicate only the thread that invoked the fork().
 If a thread invokes the exec(),the program specified in the parameter to exec() will replace the
entire process including all threads.
Thread Cancellation
 This is the task of terminating a thread before it has completed.
 Target thread is the thread that is to be cancelled
 Thread cancellation occurs in two different cases:
1. Asynchronous cancellation: One thread immediately terminates the target thread.
2. Deferred cancellation: The target thread periodically checks whether it should be
terminated.
Signal Handling
 In UNIX, a signal is used to notify a process that a particular event has occurred.
 All signals follow this pattern:
1. A signal is generated by the occurrence of a certain event.
2. A generated signal is delivered to a process.
3. Once delivered, the signal must be handled.
 A signal handler is used to process signals.
 A signal may be received either synchronously or asynchronously, depending on the source.
1. Synchronous signals
 Delivered to the same process that performed the operation causing the signal.
 E.g. illegal memory access and division by 0.
2. Asynchronous signals
 Generated by an event external to a running process.
 E.g. user terminating a process with specific key strokes<ctrl><c>.

20
 OperatingSystems 21CS44
BCS303

 Every signal can be handled by one of two possible handlers:

1. A Default Signal Handler
 Run by the kernel when handling the signal.
2. A User-defined Signal Handler
 Overrides the default signal handler.
 In single-threaded programs,delivering signals is simple (sincesignalsarealways
delivered to a process).
 In multithreaded programs, delivering signals is more complex. Then, the following
options exist:
1. Deliver the signal to the thread to which the signal applies.
2. Deliver the signal to every thread in process
3. Deliver the signal to certain threads in the process.
4. Assign a specific thread to receive all signals for the process.

THREAD POOLS
 The basic idea is to
 Create a no of threads at process-startup and
 Place the threads into a pool (where they sit and wait for work).
 Procedure:
1. When a server receives a request, it awakens a thread from the pool.
2. If any thread is available, the request is passed to it for service.
3. Once the service is completed, the thread returns to the pool.
 Advantages:
 Servicing a request with an existing thread is usually faster than waiting to create a
thread.
 The pool limits the no. of threads that exist at any one point.
 No. of threads in the pool can be based on actors such as
 no.of CPUs
 amount of memory and
 expected no. of concurrent client-requests.

THREADSPECIFICDATA
 Threads belonging to a process share the data of the process.
 This sharing of data provides one of the benefits of multithreaded programming.
 In some circumstances, each thread might need its own copy of certain data. We will call such data
thread-specific data.
 For example, in a transaction-processing system, we might service each transaction in a separate
thread.

21
 OperatingSystems 21CS44
BCS303

 Further more, each transaction maybe assigned a unique identifier. To associate each
thread with its unique identifier, we could use thread-specific data.

SCHEDULER ACTIVATIONS
 Both M:M and Two-level models require communication to maintain the
appropriate number of kernel threads allocated to the application.
 Scheduler activations provide upcalls a communication mechanism from the
kernel to the thread library
 This communication allows an application to maintain the correct number kernel
threads
 One scheme for communication between the user-thread library and the kernel is
known as scheduler activation.

22
 OperatingSystems 21CS44
BCS303

PROCESS SCHEDULING

Basic Concepts
 In a single-processor system,
 Only one process may run at a time.
 Other processes must wait until the CPU is rescheduled.
 Objective of multiprogramming:
 To have some process running at all times, in order to maximize CPU
utilization.

CPU-I/0Burst Cycle
 Process execution consists of a cycle of
 CPU execution and
 I/O wait
 Process execution begins with a CPU burst, followed by an I/O burst, then another
CPU burst, etc…
 Finally, a CPU burst ends with a request to terminate execution.
 An I/O-bound program typically has many short CPU bursts.
 ACPU-bound programming have a few long CPU bursts.

Fig Alternating sequence of CPU and I/O bursts

23
 OperatingSystems 21CS44
BCS303

Fig:Histogram of CPU-burst durations

CPU Scheduler
 This scheduler
 Selects awaiting-process from the ready-queue and
 Allocates CPU to the waiting-process.
 The ready-queue could be a FIFO, priority queue, tree and list.
 The records in the queues are generally process control blocks (PCBs)oftheprocesses.

CPU Scheduling
 Four situations under which CPU scheduling decisions take place:
1. When a process switches from the running state to the waiting state. For ex; I/O
request.
2. When a process switches from the running state to the ready state. For ex: when an
interrupt occurs.
3. When a process switches from the waiting state to the ready state. For ex: completion
of I/O.
4. When a process terminates.
 Scheduling under1and 4 is non-preemptive. Scheduling under 2and 3is preemptive.

Non Preemptive Scheduling

 Once the CPU has been allocated to a process, the process keeps the CPU until it
releases the CPU either
 By terminating or
 By switching to the waiting state.

Preemptive Scheduling
 This is driven by the idea of prioritized computation.
 Processes that are runnable may be temporarily suspended
 Disadvantages:
1. Incurs a cost associated with access to shared-data.
2. Affects the design of the OS kernel.

24
 OperatingSystems 21CS44
BCS303

Dispatcher
 It gives control of the CPU to the process selected by the short-term scheduler.
 The function involves:
1. Switching context
2. Switching to user mode&
3. Jumping to the proper location in the user program to restart that program
 It should be as fast as possible, since it is invoked during every process switch.
 Dispatch latency means the time taken by the dispatcher to
 Stop one process and
 Start another running.

SCHEDULINGCRITERIA:

In choosing which algorithm to use in a particular situation, depends upon the properties of the
various algorithms. Many criteria have been suggested for comparing CPU- scheduling
algorithms. The criteria include the following:
1. CPU utilization: We want to keep the CPU as busy as possible. Conceptually, CPU
utilization can range from 0 to 100 percent. In a real system, it should range from 40
percent (for a lightly loaded system) to 90 percent (for a heavily used system).
2. Throughput: If the CPU is busy executing processes, then work is being done. One
measure of work is the number of processes that are completed per time unit, called
throughput. For long processes, this rate may be one process per hour; for short
transactions, it may be ten processes per second.

3. Turnaround time. This is the important criterion which tells how long it takes to execute
that process. The interval from the time of submission of a process to the time of
completion is the turnaround time. Turnaround time is the sum of the periods spent
waiting to get into memory, waiting in the ready queue, executing on the CPU, and doing
I/0.
4. Waiting time: The CPU-scheduling algorithm does not affect the amount of time during
which a process executes or does I/0, it affects only the amount of time that a process
spends waiting in the ready queue. Waiting time is the sum of the periods spent waiting in
the ready queue.
5. Response time: In an interactive system, turnaround time may not be the best criterion.
Often, a process can produce some output fairly early and can continue computing new
results while previous results are being output to the user. Thus, another measure is the
time from the submission of a request until the first response is produced. This measure,
called response time, is the time it takes to start responding, not the time it takes to output
the response. The turnaround time is generally limited by the speed of the output device.

25
 OperatingSystems 21CS44
BCS303

SCHEDULING ALGORITHMS
 CPU scheduling deals with the problem of deciding which of the processes in the
ready-queue is to be allocated the CPU.
 Following are some scheduling algorithms:
1. FCFS scheduling (FirstComeFirstServed)
2. Round Robin scheduling
3. SJF scheduling (ShortestJobFirst)
4. SRT scheduling
5. Priority scheduling
6. Multilevel Queue scheduling and
7. Multilevel Feedback Queue scheduling

FCFS Scheduling
 The process that requests the CPU first is allocated the CPU first.
 The implementation is easily done using a FIFO queue.
 Procedure:
1. When a process enters the ready-queue, its PCB is linked onto the tail of the queue.
2. When the CPU is free, the CPU is allocated to the process at the queue’s head.
3. The running process is then removed from the queue.

 Advantage:
1. Code is simple to write & understand.
 Disadvantages:
1. Convoy effect: All other processes wait for one big process to get off the CPU.
2. Non-preemptive (a process keeps the CPU until it releases it).
3. Not good for time-sharing systems.
4. The average waiting time is generally not minimal.

 Example: Suppose that the processes arrive in the order P1,P2,P3.

 The Gantt Chart for the schedule is as follows:

 Waiting time for P1=0;P2=24;P3=27

Average waiting time:(0+24+27)/3=17ms

 Suppose that the processes arrive in the order P2,P3,P1.

26
 OperatingSystems 21CS44
BCS303

 The Gantt chart for the schedule is as follows:

 Waiting time for P1=6;P2=0;P3=3

 Average waiting time:(6+0+3)/3=3ms

SJFScheduling
 TheCPUisassignedtotheprocessthathasthesmallestnextCPUburst.
 If two processes havethe same length CPUburst, FCFS scheduling is used to breakthetie.
 For long-term scheduling in abatchsystem,we canuse theprocess time limit specified by
the user, as the‘length’
 SJF can't be implemented at the level of short-term scheduling, because there is no way
to know the length of the next CPUburst
 Advantage:
1. The SJF is optimal, i.e. it gives the minimum average waiting time for a given
set of processes.
 Disadvantage:
1. DeterminingthelengthofthenextCPUburst.

 SJFalgorithmmaybeeither1)non-preemptiveor2)preemptive.
1. NonpreemptiveSJF
ThecurrentprocessisallowedtofinishitsCPUburst.
2. PreemptiveSJF
IfthenewprocesshasashorternextCPUburstthanwhatisleftofthe
executingprocess,thatprocessispreempted.ItisalsoknownasSRTF
scheduling(Shortest-Remaining-Time-First).

 Example(fornon-preemptiveSJF):Considerthefollowingsetofprocesses, with the length

of the CPU-burst time given inmilliseconds.

 Fornon-preemptiveSJF,theGanttChartisasfollows:

27
 OperatingSystems 21CS44
BCS303

 WaitingtimeforP1=3;P2=16;P3=9;4=0Averagewaitingtime:(3+16+9+
0)/4=7

preemptiveSJF/SRTF:Considerthefollowingsetofprocesses,withthelength

oftheCPU-bursttimegiveninmilliseconds.
 ForpreemptiveSJF,theGanttChartisasfollows:

 Theaverage waitingtimeis((10 -1)+(1-1) +(17-2)+(5-3))/4=26/4=6.5.

PriorityScheduling
 Apriorityisassociatedwitheachprocess.
 TheCPUisallocatedtotheprocesswiththehighestpriority.
 Equal-priorityprocessesarescheduledinFCFSorder.
 Prioritiescanbedefinedeitherinternallyorexternally.
1. Internally-definedpriorities.
 Usesomemeasurablequantitytocomputethepriorityofaprocess.
 Forexample:timelimits,memoryrequirements,no.fopenfiles.
2. Externally-definedpriorities.
 Set bycriteria that are external to the OS For
example:
 importanceoftheprocess,politicalfactors
 Priorityschedulingcanbeeitherpreemptiveornon-preemptive.
1.Preemptive
TheCPUispreemptedifthepriorityofthenewlyarrivedprocessis higher than the
priority of the currently running process.
2. NonPreemptive
Thenewprocessisputattheheadoftheready-queue
 Advantage:
 Higherpriorityprocessescanbeexecutedfirst.
 Disadvantage:
 Indefinite blocking, where low-priority processes are left waiting
indefinitely for CPU. Solution: Aging is a technique of increasing priority of
processes that wait in system for a long time.

28
 OperatingSystems 21CS44
BCS303

 Example: Consider the following set of processes, assumed to have arrived at time 0, in
the order PI, P2, ..., P5, with the length of the CPU-burst time given inmilliseconds.

 TheGanttchartforthescheduleisasfollows:

 Theaveragewaitingtimeis8.2milliseconds.

RoundRobinScheduling
 Designedespeciallyfortimesharingsystems.
 ItissimilartoFCFSscheduling,butwithpreemption.
 Asmallunitoftimeiscalledatimequantum(ortimeslice).
 Timequantumisrangesfrom10to100ms.
 Theready-queueistreatedasacircularqueue.
 TheCPUscheduler
 goesaroundtheready-queueand
 allocates the CPU to each process for a time interval of up to 1 time
quantum.
 Toimplement:
Theready-queueiskeptasaFIFOqueueof processes
 CPUscheduler
1. Picksthefirstprocessfromtheready-queue.
2. Setsatimertointerruptafter1time quantumand
3. Dispatchestheprocess.
 Oneoftwothingswillthenhappen.
1. The process may have a CPU burst of less than 1 time quantum. In this case, the
process itself will release the CPU voluntarily.
2. If the CPU burst of the currently running process is longer than 1time quantum, the
timer will go off and will cause an interrupt to the OS. The process will be put at
the tail of the ready-queue.
 Advantage:
 HigheraverageturnaroundthanSJF.
 Disadvantage:
 BetterresponsetimethanSJF.
 Example: Consider the following set of processes that arrive at time 0, with the length
of the CPU-burst time given inmilliseconds.

29
 OperatingSystems 21CS44
BCS303

 TheGanttchartforthescheduleisasfollows:

 Theaveragewaitingtimeis17/3=5.66milliseconds.

 TheRRschedulingalgorithmis preemptive.
No process is allocated the CPU for more than 1 time quantum in a row.If a
process' CPU burst exceeds 1 time quantum, that processis preempted and is put
back in the ready- queue.
 Theperformanceofalgorithmdependsheavilyonthesizeofthetime quantum.
1. Iftimequantum=verylarge,RRpolicyisthesameastheFCFSpolicy.
2. If time quantum=very small, RR approach appears to the users as though each of n
processes has its own processor running at l/n the speed of the real processor.
 In software, we need to consider the effect of context switching on the performance of
RR scheduling
1. Larger the time quantum for a specific process time, less time is spend on context
switching.
2. The smaller the time quantum, more overhead is added for the purpose of
context- switching.

Fig:Howasmallertimequantumincreasescontextswitches

30
 OperatingSystems 21CS44
BCS303

Fig:Howturnaroundtimevarieswiththetimequantum
MultilevelQueueScheduling
 Usefulforsituationsinwhichprocessesareeasilyclassifiedintodifferent groups.
 Forexample,acommondivisionismade between
 foreground(orinteractive)processesand
 background(orbatch)processes.
 Theready-queueispartitionedintoseveralseparatequeues(Figure2.19).
 Theprocessesarepermanentlyassignedtoonequeuebasedonsomepropertylike
 memorysize
 processpriorityor
 processtype.
 Eachqueuehasitsownschedulingalgorithm.
Forexample,separatequeuesmightbeusedforforegroundandbackground processes.

FigMultilevelqueuescheduling

31
 OperatingSystems 21CS44
BCS303

 There must be scheduling among the queues, which is commonly implemented as

fixed-priority preemptive scheduling.
 For example, the foreground queue may have absolute priority over the background
queue.
 Time slice: each queue gets a certain amount of CPU time which itcanschedule
amongst its processes; i.e., 80% to foreground in RR 20% to background in FCFS

MultilevelFeedbackQueueScheduling
 Aprocessmaymovebetweenqueues
 The basic idea: Separate processes according to the features of their CPU bursts. Forexample
1. If a process uses too much CPU time, it will be moved to a lower-priority queue. This
scheme leaves I/O-bound and interactive processes in the higher-priority queues.
2. If a process waits too long in a lower-priority queue, it may be moved to ahigher-
priority queue This form of aging prevents starvation.

Figure2.20Multilevelfeedbackqueues

Ingeneral,amultilevelfeedbackqueueschedulerisdefinedbythefollowingparameters:

1. Thenumberofqueues.
2. Theschedulingalgorithmforeachqueue.
3. Themethodusedtodeterminewhentoupgradeaprocesstoahigher priorityqueue.
4. Themethodusedtodeterminewhentodemoteaprocesstoalowerpriorityqueue.
5. Themethodusedto determinewhichqueueaprocesswillenter whenthatprocess needs
service

32
 OperatingSystems 21CS44
BCS303

MULTIPLEPROCESSORSCHEDULING
 IfmultipleCPUsareavailable,theschedulingproblembecomesmorecomplex.
 Twoapproaches:
AsymmetricMultiprocessing
The basic idea is:
 Amasterserverisasingleprocessorresponsibleforallschedulingdecisions,I/O processing and
other systemactivities.
 Theotherprocessorsexecuteonlyusercode.
 Advantage: This is simple because only one processor accesses the system data
structures, reducing the need for data sharing.
SymmetricMultiprocessing
Thebasicidea is:
 Eachprocessorisself-scheduling.
 Todoscheduling,theschedulerforeachprocessor
 Examinestheready-queueand
 Selectsaprocesstoexecute.
Restriction:Wemustensurethattwoprocessorsdonotchoosethesameprocess andthat processes are
not lost from the queue.

ProcessorAffinity
 InSMPsystems,
1. Migrationofprocessesfromoneprocessortoanotherareavoidedand
2. Insteadprocessesarekeptrunningonsameprocessor.Thisisknownas processor
affinity.
 Twoforms:
1. SoftAffinity
 WhenanOStrytokeepaprocessononeprocessorbecauseof policy, but
cannot guarantee it will happen.
 Itispossibleforaprocesstomigratebetween processors.
2. HardAffinity
 WhenanOShavetheabilitytoallowaprocesstospecifythatitisnotto migrate to
other processors. Eg: Solaris OS
LoadBalancing
 Thisattemptstokeeptheworkloadevenlydistributedacrossallprocessorsinan SMPsystem.
 Twoapproaches:
1. PushMigration
Aspecific taskperiodicallychecks the load oneach processor andif it findsan imbalance, it
evenly distributes the load to idle processors.
2. PullMigration
Anidleprocessorpullsawaitingtaskfromabusyprocessor.

33
 OperatingSystems 21CS44
BCS303

SymmetricMultithreading
 Thebasicidea:
1. Createmultiplelogicalprocessorsonthesamephysicalprocessor.
2. Presentaviewofseverallogicalprocessorstothe OS.
 Eachlogicalprocessorhasitsownarchitecturestate,whichincludesgeneral- purpose and
machine-state registers.
 Eachlogicalprocessorisresponsibleforitsowninterrupthandling.
 SMTisafeatureprovidedinhardware,notsoftware.

THREADSCHEDULING
 OnOSs,itiskernel-levelthreadsbutnotprocessesthatarebeingscheduledbytheOS.
 User-levelthreadsare managedbyathreadlibrary,andthekernelisunawareofthem.
 To run on a CPU, user-level threads must be mapped to an associated kernel-
levelthread.

ContentionScope
 Twoapproaches:
1. Process-Contentionscope
 Onsystemsimplementingthe many-to-one andmany-to-manymodels,the thread
library schedules user-level threads to run on an available LWP.
 CompetitionfortheCPUtakesplaceamongthreadsbelongingtothe sameprocess.
2. System-Contentionscope
 TheprocessofdecidingwhichkernelthreadtoscheduleontheCPU.
 CompetitionfortheCPUtakesplaceamongallthreadsinthesystem.
 Systemsusingtheone-to-onemodelschedulethreadsusingonlySCS.

PthreadScheduling
 PthreadAPIthatallowsspecifyingeitherPCSorSCSduringthreadcreation.
 Pthreadsidentifiesthefollowingcontentionscopevalues:
1. PTHREAD_SCOPEJPROCESSschedulesthreadsusingPCSscheduling.
2. PTHREAD-SCOPE_SYSTEMschedulesthreadsusingSCSscheduling.
 PthreadIPC providesfollowing twofunctionsforgettingandsettingthecontention scopepolicy:
1. pthread_attr_setscope(pthread_attr_t*attr,intscope)
2. pthread_attr_getscope(pthread_attr_t*attr,int*scop)

34