Operarting Systems – BCS303

Module -02 Process Management

Chapter 3 - Process Concepts
 Process is an active entity. A process is a sequence of instruction execution. Process
exists in a limited span of time. Two or more process may execute the same program
by using its own data & resources.
 A program is a passive entity which is made up of program statement. Program
contains instructions.
 The Process
o A process is more than the program code which is also called text section.
o It contains program counter which represents the current activity and also the
contents of the processor's registers.
o A process also consists of a process stack section which contains temporary data
&data section which contains global variables.
o A process may also include a heap, which is memory that is dynamically
allocated during process run time.
o The structure of a process in memory is shown in below figure 3.1.

Figure 3.1
 Process State
o As process executes it changes its state and each process may be in one of the
following states:
o New: The process is being created
o Running: Instructions are being executed
o Waiting: The process is waiting for some event to occur
o Ready: The process is waiting to be assigned to a process
o Terminated: The process has finished execution
o Only one process can be running on any processor at any instant. Many processes
may be ready and waiting.
o The state diagram corresponding to these states is shown below figure 3.2.

BGSCET/AIML 2023-24 Page 1 of 43

 Operarting Systems – BCS303

Figure 3.2

Process Control Block (PCB)

A process in an operating system is represented by a data structure known as a Process
Control Block (PCB) and it is also called as task control block. The following figure 3.3shows
the process control block.

Figure 3.3
The PCB contains important information about the specific process including,
Process state: The current state of the process i.e., whether it is ready, running, waiting, halted
and so on.
Program counter: Indicates the address of the next instruction to be executed for a process.
CPU registers: The registers vary in number and type. Along with program counter this state
information should be saved to allow process to be continued correctly after an interrupt occurs
as shown in below figure 3.4.
CPU scheduling information: This information includes a process priority, pointers to
scheduling queues, and any other scheduling parameters.
Memory-management information: This information may include the value of base and limit
registers, the page tables, or the segment tables, depending on the memory system used by the
OS.
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.

BGSCET/AIML 2023-24 Page 2 of 43

 Operarting Systems – BCS303

Figure 3. 4 CPU switch from process to process

Threads.
 A process is a program that performs a single thread of execution. For example,
when a process is running a word-processor program, a single thread of instruction is
being executed. This single thread of control allows the process to perform only one
task at one time. The user cannot simultaneously type in characters and run the spell
checker within the same process.
 Many modern operating systems have extended the process concept to allow a
process to have multiple threads of execution and thus to perform more than one task
at a time. On a system that supports threads, the PCB is expanded to include
information for each thread. Eg: Windows OS and UNIX

3.2 Process Scheduling

The following are the different types of process scheduling queues.
Job queue – set of all processes in the system
Ready queue – set of all processes residing in main memory, ready and waiting to
execute
Device queues – set of processes waiting for an I/O device
Processes migrate among the various queues

BGSCET/AIML 2023-24 Page 3 of 43

 Operarting Systems – BCS303

Ready Queue And Various I/O Device Queues

Ready Queue:

The process that are placed in main m/y and are already and waiting to executes are placed
in a list called the ready queue. This is in the form of linked list. Ready queue header contains
pointer to the first & final PCB in the list. Each PCB contains a pointer field that points next
PCB in ready queue.

Device Queue:The list of processes waiting for a particular I/O device is called device. When
the CPU is allocated to a process it may execute for some time & may quit or interrupted or
wait for the occurrence of a particular event like completion of an I/O request but the I/O may
be busy with some other processes. In this case the process must wait for I/O. This will be
placed in device queue. Each device will have its own queue.

The process scheduling is represented using a queuing diagram. Queues are represented by
the rectangular box & resources they need are represented by circles. It contains two queues
ready queue & device queues. Once the process is assigned to CPU and is executing the
following events can occur,
 It can execute an I/O request and is placed in I/O queue.
 The process can create a sub process & wait for its termination.
 The process may be removed from the CPU as a result of interrupt and can be put
back into ready queue.

Schedulers:
The following are the different type of schedulers
Long-term scheduler (or job scheduler) – selects which processes should be brought
into the ready queue.
Short-term scheduler (or CPU scheduler) – selects which process should be executed next
and allocates CPU.
Medium-term schedulers
Short-term scheduler is invoked very frequently (milliseconds) . (must be fast)
BGSCET/AIML 2023-24 Page 4 of 43
 Operarting Systems – BCS303

Long-term scheduler is invoked very infrequently (seconds, minutes) (may be slow)

The long-term scheduler controls the degree of multiprogramming
->Processes can be described as either:
x I/O-bound process – spends more time doing I/O than computations, many short CPU
bursts CPU-bound process – spends more time doing computations; few very long
CPU bursts 2.3

3.3 Operations 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.
Process Creation
o A process may create several new processes by some create-process system call, during
the course of execution.
o The creating process is called parent process and the created one is called the child
process. Each of the new process may in turn create other processes, forming a tree of
processes. Processes are identified by unique process identifier ( orpid).
o Below Figure shows the process tree for the solaris OS. The process at the top of the tree
is sched process, with pid of 0,and this creates several children processes. The sched
process creates several children processes including pageout and fsflush. These
processes are responsible for managing memory and file systems. The sched process also
creates the init process, which serves as the root parent process for all user processes.
These processes are responsible for managing memory and file systems.

Figure 3.5
o inetd and dtlogin are two children of init where inetd is responsible for networking
services such as telnet and ftp; dtlogin is the process representing a user login screen.
o When a user logs in, dtlogin creates an X-windows session (Xsession), which in turns
creates the sdt_shel process. Below sdt_shel, a user's command-line shell, the C-shell or
BGSCET/AIML 2023-24 Page 5 of 43
 Operarting Systems – BCS303

csh is created. In this command line interface, the user can then invoke various child
processes, such as the ls and cat commands.
o There is also csh process with pid of 7778 representing a user who has logged onto the
system using telnet. This user has started the Netscape browser (pid of 7785) and the
emacs editor (pid of 8105).
o A process needs certain resources to accomplish its task. Along with the various logical
and physical resources that a process obtains when it is created, initialization data may
be passed along by the parent process to the child process.
o When a process creates a new process, two possibilities exist in terms of execution.
o The parent continues to execute concurrently with its children.
o The parent waits until some or all of the children have terminated.
o There are also two possibilities in terms of the address space of the new process.
1. The child process is a duplicate of the parent process.
2. The child process has a new program loaded into it.
o In UNIX OS, fork () system call creates new process. In windows Create Process() does
the job.
o Exec () system call is called after a fork () to replace the process memory space with a
new program.

o The C program shown below illustrates these system calls.

int main()
{
Pid_tpid;
pid = fork();/* fork another process */
if (pid< 0)/* error occurred */
{
fprintf(stderr, "Fork Failed");
exit(-1);
}
else if (pid == 0) /* child process */
{
execlp("/bin/ls", "ls", NULL);
}
else /* parent process */
{
wait (NULL);/* parent will wait for the child to complete */
printf ("Child Complete");
exit(0);
}
}

BGSCET/AIML 2023-24 Page 6 of 43

 Operarting Systems – BCS303

o If there are two different processes running a copy of the same program, the pid for child
is zero and for the parent it is greater than zero. The parent process waits for the child
process to complete with the wait () system call.
o When the child process completes, the parent process resumes from the call to wait(),
where it completes using exit() system call. This is shown in below figure 3.6.

Figure 3.6
Process Termination
o A process terminates when it finishes executing its last statement and asks the operating
system to delete it by using exit() system call.
o Process resources are deallocated by the operating system. A process can terminate another
process via Terminate Process() system call. A Parent may terminate execution of
children processes (abort) for the following reasons.
o Child has exceeded usage of allocated resources.
o Task assigned to child is no longer required.
o If parent is exiting some operating system do not allow child to continue if its parent
terminates.
o Some systems does not allow child to exist if its parent has terminated. If process
terminates then all its children must also be terminated, this phenomenon is referred as
cascading termination.

3.4 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. Any process that shares data with other processes is a
cooperating process.
 Advantages of process cooperation are,
o Information sharing: several users may be interested in same piece of
information, so an environment must be provided to allow concurrent access
to such information.

BGSCET/AIML 2023-24 Page 7 of 43

 Operarting Systems – BCS303

o Computation speed-up: If we want particular task to run faster, it can be

broken into subtasks, each of which will be executing in parallel with each
other.
o Modularity: If the system is to be constructed in modular fashion, then
system functions can be divided into separate processes or threads.
o Convenience: An individual user may work on many tasks at the same time.

Cooperating processes require an Inter-process Communication (IPC) mechanism that will allow
them to exchange data and information. There are two fundamental models of IPC as shown in
figure 3.7.
1. Shared memory: A region of memory that is shared by cooperating processes is
established. Processes then exchange information by reading and writing data to the shared
region.
2. Message passing: Communication takes place by means of message exchange between the
cooperating processes.

Figure 3.7 Communication models (a) Message passing. (b) Shared memory.
The differences between these two models are,
Message passing Shared memory
Useful for exchanging small amount of
large data
data.
easy to implement Complex
Slower Faster
system calls are required only to establish
implemented using system calls
Shared memory region
Shared Memory System
 A region of memory that is shared by cooperating processes is established.
Processes then exchange information by reading and writing data to the shared region.
 To illustrate cooperating processes, consider producer-consumer problem.
 Producer process produces information that is consumed by a consumer process.

BGSCET/AIML 2023-24 Page 8 of 43

 Operarting Systems – BCS303

 One solution to producer-consumer problem uses shared memory. To allow producer and
consumer processes to run concurrently, there must be a buffer of items that can be filled
by a producer and emptied by consumer. The buffer will reside in a shared memory region.
 The 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 by the producer.
 Two types of buffers can be used.
o Unbounded-buffer: 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.
o Bounded-buffer: assumes that there is a fixed buffer size, so the consumer must wait
if the buffer is empty, and the producer must wait if the buffer is full.
 The following variables reside in a region of memory shared by the producer and
consumer processes
#define BUFFER_SIZE 10
typedefstruct {
……..
……..

}item;

item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
 The shared buffer is implemented as a circular array with two logical pointers in and out.
The variable in points to the next free position in the buffer; out points to the first full
position in the buffer. The buffer is empty when in= =out, the buffer is full when ((in+
1)% BUFFER_SIZE) = = out.
 The code for the producer process is shown below.
itemnextProduced;
while (true)
{
/* produce an item in nextProduced*/
while ( ((in + 1) % BUFFER_SIZE) = = out); //do nothing
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
}
 The code for the consumer process is shown below.
itemnextConsumed;
while (true)
{
while (in = = out); //do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
BGSCET/AIML 2023-24 Page 9 of 43
 Operarting Systems – BCS303

/* consume the item in nextConsumed*/

}
Message Passing System
 Communication takes place by means of message exchange between the cooperating
processes.
 Message passing facility provides two operations.
 Send (message)
 Receive (message)
 Message size can be fixed or variable.
 If P and Q wish to communicate, they need to establish a communication link between
them and communication link can be,
 physical (eg: shared memory, hardware bus)
 logical (eg: logical properties)
 Several methods for logically implementing a link are,
o Direct or Indirect communication
o Synchronous or asynchronous communication
o Automatic or explicit buffering
Naming
 Processes that want to communicate must have a way to refer to each other. They can
use either direct or indirect communication.
 Under Direct Communication processes must name each other explicitly
 The send() and receive() primitives are defined as,
o Send (P, message) – send a message to process P.
o Receive (Q, message) – receive a message from process Q.
 Properties of communication link in this scheme are,
o Links are established automatically between every pair of processes that want to
communicate.
o A link is associated with exactly two communicating processes.
o Between each pair there exists exactly one link.
 This scheme exhibits two types of addressing,
o Symmetry: Both sender and receiver must name the other to communicate.
o Asymmetry: Only the sender names the recipient, the recipient is not
required to name the sender. The send() and receive() primitives are
defined as,
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.
 In Indirect Communication messages are sent and received from mailboxes (also
referred to as ports)
 A mailbox can be viewed abstractly as an object into which messages can be placed by
processes and from which messages can be removed.

BGSCET/AIML 2023-24 Page 10 of 43

 Operarting Systems – BCS303

 Each mailbox has a unique id and processes can communicate only if they share a
mailbox.
 The send() and receive() primitives are defined as,
o Send (A, message) – send a message to mailbox A
o Receive (A, message) – receive a message from mailbox A
 Properties of communication link are,
o Links are established only if processes share a common mailbox.
o A link may be associated with many processes.
o Each pair of processes may share several communication links.
 OS allows the process to do the following operations
o create a new mailbox
o send and receive messages through mailbox
o destroy a mailbox
Synchronization
 Message passing may be either blocking or non-blocking. Blocking is considered
synchronous. Non-blocking is considered asynchronous.
o Blocking send: The sending process is blocked until the message is received by the
receiving process or by the mailbox.
o Non-blocking send: The sending process sends the message and resumes operation.
o Blocking receive: The receiver blocks until a message is available.
o Non-blocking receive: The receiver retrieves either a valid message or a null.
Buffering
 Messages exchanged by communicating processes reside in a temporary queue, and such
queues can be implemented in one of three ways,
1. Zero capacity – Maximum length is zero and sender must wait for the receiver.
2. Bounded capacity – finite length ofn messages, sender must wait if link is full.
3. Unbounded capacity – infinite length and sender never waits.

**********************

Module -02 Chapter 4 Multithreaded Programming

4.1Overview
 A thread is a basic unit of CPU utilization.
 It comprises a thread ID, a program counter, a register set, and a stack. It shares
its code section, data section, and other operating-system resources, such as open
files and signals with other threads belonging to the same process.
 A traditional (or heavyweight) 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.
BGSCET/AIML 2023-24 Page 11 of 43
 Operarting Systems – BCS303

 The below figure 4.1. Illustrates the difference between a traditional single
threaded process and a multithreaded process.

Figure 4.1
4.1.1 Motivation
o Many software packages that run on modern desktop PCs are multithreaded.
o An application is implemented as a separate process with several threads of
control. Eg: A Web browser might have one thread to display images or text
while another thread retrieves data from the network.
o As process creation takes more time than threadcreation it is more efficient to use
process that contains multiple threads. So, that the amount of time that a client have
to wait for its request to be serviced from the web server will be less.
o Threads also play an important role in remote procedure call.

4.1.2 Benefits
The benefits of multithreaded programming
1. Responsiveness: Multithreading allows program to continue running even if
part of it is blocked or is performing a lengthy operation, thereby increasing
responsiveness to the user.
2. Resource Sharing: Threads share the memory and resources of the process to
which they belong. The benefit of sharing code and data is that it allows an
application to have several different threads of activity within the same
address space.

BGSCET/AIML 2023-24 Page 12 of 43

 Operarting Systems – BCS303

3. Economy: Because of resource sharing context switching and thread creation

are fast when working with threads.
4. Utilization of multiprocessor architectures: Threads can run in parallel on
different processors. Multithreading on multi-CPU machine increases
concurrency.

4.2 Multithreading Models

 Support for threads may be provided either at user level for user threads or by the
kernel for kernel threads.
 There must be a relationship between user threadsand kernel threads. Three
common ways of establishing this relationship are,
4.2.1 Many-to-One
 Many user-level threads are mapped to single kernel thread as shown in below
figure 4.2.
 This model is efficient as the thread management is done by the thread library
in user space, but the entire process will block if a thread makes a blocking
system call.
 As only one thread can access the kernel thread at a time, multiple threads are
unable to run in parallel on multiprocessors.
 Examples: Solaris Green Threads, GNU Portable Threads

Figure 4.2
4.2.2 One-to-One
 Each user-level thread maps to kernel thread as shown in figure.
 It provides more concurrency than Many-to-One model by allowing thread to
run when a thread makes a blocking system call.
 It allows multiple threads to run in parallel on multiprocessors.

BGSCET/AIML 2023-24 Page 13 of 43

 Operarting Systems – BCS303

 The only drawback is, creating a user thread requires creating the
corresponding kernel thread and it burdens performance of an application.
 Examples: Windows NT/XP/2000, Linux

Figure 4.3

4.2.3 Many-to-Many Model

 One-to-One model restricts creating more user threads and Many-to-One
model allows creating more user threads but kernel can schedule only one
thread at a time. These drawbacks can be overcome by Many-to-Many model
as shown in below figure 4.4.
 Many-to-Many model allows many user level threads to be mapped to many
kernel threads.
 It allows the operating system to create a sufficient number of kernel threads.
 When thread performs a blocking system call, the kernel can schedule another
thread for execution.
 It allows user-level thread to be bound to a kernel thread and this is referred as
two- level model as shown in below figure 4.5.
 Examples: IRIX, HP-UX, Solaris OS

Figure 4.4 Figure 4.5

BGSCET/AIML 2023-24 Page 14 of 43

 Operarting Systems – BCS303

4.3 Thread Libraries

 A thread library provides the programmer an API for creating and managing threads.
 There are two primary ways of implementing a thread library.
o The first approach is to provide a library entirely in user space with no
kernel support. All code and data structures for the library exist in user space.
o The second approach is to implement a kernel-level library supported
directly by the operating system.
 Three primary thread libraries are
o POSIX Pthreads: extension of posix standard, they may be provided as either
a user bor kernel library.
o Win32 threads: is a kernel level library available on windows systems.
o Java threads: API allows creation and management directly in Java programs.
However, on windows java threads are implemented using win32 and on
UNIX and Linux using Pthreads
4.3.1 Pthreads
 Pthreads, the threads extension of the POSIX standard, may be provided as either a
user or kernel-level library.
 Pthreads refers to the POSIX standard (IEEE 1003.1c) defining an API for thread
creation and synchronization.
 This is a specification for thread behavior, not an implementation.
 Operating system designers may implement the specification in any way they wish.
Numerous systems implement the Pthreads specification, including Solaris, Linux,
Mac OS X, and Tru64 UNIX.
 Shareware implementations are available in the public domain for the various
Windows operating systems as well.

Multithreaded C program using the Pthreads API

#include <pthread.h>
#include <stdio.h>
int sum; /* this data is shared by the thread(s) */
void *runner(void *param); /* the thread */
int main(intargc, char *argv[])
{
pthread_ttid; /* the thread identifier */
pthread_attr_tattr; /* set of thread attributes */
BGSCET/AIML 2023-24 Page 15 of 43
 Operarting Systems – BCS303

if (argc != 2)
{
fprintf(stderr,"usage: a.out<integer value>\n");
return -1;
}
if (atoi(argv[1]) < 0)
{
fprintf(stderr,"%d must be>= 0\n",atoi(argv[1]));
return -1;
}
pthread_attr_init(&attr); /* get the default attributes */
pthread_create(&tid,&attr,runner,argv[1]); /* create the thread */
pthread_join(tid,NULL); /*wait for the thread to exit */
printf("sum = %d\n",sum);
}
void *runner(void *param) /* The thread will begin control in this function */
{
inti, upper= atoi(param);
sum = 0;
for (i = 1; i<= upper; i++)
sum += i;
pthread_exit(0) ;
}

4.3.2 Win32 Threads

 The Win32 thread library is a kernel-level library available on Windows systems.
 The technique for creating threads using the Win32 thread library is similar to the
Pthreads technique in several ways. We must include the windows.h header file when
using the Win32 API.
 Threads are created in the Win32 API using the CreateThread() function and a set of
attributes for the thread is passed to this function.
 These attributes include security information, the size of the stack, and a flag that can
be set to indicate if the thread is to start in a suspended state.
 The parent thread waits for the child thread using the WaitForSingleObject() function,
which causes the creating thread to block until the summation thread has exited.
Multithreaded C program using the Win32 API
#include <Windows.h>
#include <stdio.h>
DWORD Sum; /* data is shared by the thread(s) */
/* the thread runs in this separate function */
BGSCET/AIML 2023-24 Page 16 of 43
 Operarting Systems – BCS303

DWORD WINAPI Summation(LPVOID Param)

{
DWORD Upper = *(DWORD*)Param;
for (DWORD i = 0; i<= Upper; i++)
Sum += i;
return 0;
}

int main(intargc, char *argv[])

{
DWORD ThreadId;
HANDLE ThreadHandle;
intParam;

if (argc != 2) /* perform some basic error checking */

{
fprintf(stderr," An integer parameter is required\n");
return -1;
}
Param = atoi(argv[1]);
if (Param< 0)
{
fprintf(stderr,"An integer>= 0 is required\n");
return -1;
}
/*create the thread*/
ThreadHandle = CreateThread(NULL, 0, Summation, &Param, 0, &ThreadId);
// NULL:default security attributes
// 0: default stack size
// Summation: thread function
// &Param: parameter to thread function
// 0: default creation flags
//ThreadId: returns the thread identifier

if (ThreadHandle != NULL)
{
WaitForSingleObject(ThreadHandle,INFINITE);// now wait for the thread to
finish
CloseHandle(ThreadHandle); // close the thread handle
printf("surn = %d\n" ,Sum);
}
}

BGSCET/AIML 2023-24 Page 17 of 43

 Operarting Systems – BCS303

4.3.3 Java Threads

 The Java thread API allows thread creation and management directly in Java
programs.
 Threads are the fundamental model of program execution in a Java program, and the
Java language and its API provide a rich set of features for the creation and
management of threads.
 All Java programs comprise at least a single thread of control and even a simple Java
program consisting of only a main() method runs as a single thread in the JVM.
 There are two techniques for creating threads in a Java program. One approach is to
create a new class that is derived from the Thread class and to override its run()
method. An alternative and more commonly used technique is to define a class that
implements the Runnable interface. The Runnable interface is defined as follows:
public interface Runnable
{
public abstract void run () ;
}
 When a class implements Runnable, it must define a run() method. The code
implementing the run() method runs as a separate thread.
 Creating a Thread object does not specifically create the new thread but it is the start()
method that actually creates the new thread. Calling the start() method for the new
object does two things:
o It allocates memory and initializes a new thread in the JVM.
o It calls the run() method, making the thread eligible to be run by the JVM.
 As Java is a pure object-oriented language, it has no notion of global data. If two
or more threads have to share data means then the sharing occurs by passing reference
to the shared object to the appropriate threads.
 This shared object is referenced through the appropriate getSum() and setSum()
methods.
 As the Integer class is immutable, that is, once its value is set it cannot change, a new
sum class is designed.
 The parent threads in Java uses join() method to wait for the child threads to finish
before proceeding.
Java program for the summation of a non-negative integer.
BGSCET/AIML 2023-24 Page 18 of 43
 Operarting Systems – BCS303

class Sum
{
privateint sum;
publicintgetSum()
{
return sum;
}

public void setSum(int sum)

{
this.sum = sum;
}
}
class Summation implements Runnable
{
privateint upper;
private Sum sumValue;

public Summation(int upper, Sum sumValue)

{
this.upper = upper;
this.sumValue = sumValue;
}
public void run()
{
int sum = 0;
for (inti = 0; i<= upper; i++)
sum += i;
sumValue.setSum(sum);
}
}
public class Driver
{
public static void main(String[] args)
{
if (args.length> 0)
{
if (Integer.parseint(args[O]) < 0)
System.err.println(args[O] + "must be>= 0.");
else
{
Sum sumObject = new Sum(); //create the object to be shared
int upper= Integer.parseint(args[O]);
BGSCET/AIML 2023-24 Page 19 of 43
 Operarting Systems – BCS303

Thread thrd =new Thread(new Summation(upper, sumObject));

thrd.start();
try
{
thrd. join () ;
System.out.println("The sum of "+upper+" is "+sumObject.getSum());
}
catch (InterruptedExceptionie) { }
}
}
else
System.err.println("Usage: Summation <integer value>");
}

4.4 Threading Issues

4.3.1 The fork() and exec() System Calls
 The semantics of the fork() and exec() system calls change in a multithreaded
program. Some UNIX systems have chosen to have two versions of fork(),one
that duplicates all threads and another that duplicates only the thread that invoked
the fork() system call.
 If a thread invokes the exec() system call, the program specified in the parameter
to exec() will replace the entire process including all threads.
 Which of the two versions of fork() to use depends on the application. If exec() is
called immediately after forking, then duplicating all threads is unnecessary, as the
program specified in the parameters to exec() will replace the process. In this
instance, duplicating only the calling thread is appropriate.
4.4.2 Thread Cancellation
 Thread cancellation is the task of terminating a thread before it has completed.
For example, if multiple threads are concurrently searching through a database
and one thread returns the result, the remaining threads might be cancelled.
 A thread that is to be cancelled is often referred to as the target thread.
Cancellation of a target thread may occur in two different scenarios:
o Asynchronous cancellation: One thread immediately terminates the target
thread.

BGSCET/AIML 2023-24 Page 20 of 43

 Operarting Systems – BCS303

o Deferred cancellation: The target thread periodically checks whether it

should terminate, allowing it an opportunity to terminate itself in an orderly
fashion.
 The difficulty with asynchronous cancellation occurs in situations where
resources have been allocated to a cancelled thread or where a thread is cancelled
while in the midst of updating data it is sharing with other threads. This becomes
especially troublesome with asynchronous cancellation. Often, the operating
system will reclaim system resources from a cancelled thread but will not reclaim
all resources. Therefore, cancelling a thread asynchronously may not free a
necessary system-wide resource.
 With deferred cancellation, one thread indicates that a target thread is to be
cancelled, but cancellation occurs only after the target thread has checked a flag to
determine if it should be cancelled or not. This allows a thread to check whether it
should be cancelled at a point when it can be cancelled safely. Pthreads refers to
such points as cancellation points.
4.4.3 Signal Handling
 A signal is used in UNIX systems to notify a process that a particular event has
occurred.
 A signal may be received either synchronously or asynchronously, depending on
the source of and the reason for the event being signaled.
 All signals, whether synchronous or asynchronous, follow the same pattern:
o A signal is generated by the occurrence of a particular event.
o A generated signal is delivered to a process.
o Once delivered, the signal must be handled.
 Examples of synchronous signals include illegal memory access and division by
0. If a running program performs either of these actions, a signal is generated.
Synchronous signals are delivered to the same process that performed the
operation that caused the signal.
 When a signal is generated by an event external to a running process, that process
receives the signal asynchronously. Examples of such signals include
terminating a process with specific keystrokes (such as <control><C>) and having
a timer expires. An asynchronous signal is sent to another process.
 Every signal may be handled by one of two possible handlers,

BGSCET/AIML 2023-24 Page 21 of 43

 Operarting Systems – BCS303

o A default signal handler

o A user-defined signal handler
 Every signal has a default signal handler that is run by the kernel when handling
that signal.
 This default action can be overridden by a user-defined signal handler that is
called to handle the signal.
 Signals may be handled in different ways. Some signals (such as changing the
size of a window) may simply be ignored; others (such as an illegal memory
access) may be handled by terminating the program.
 Delivering signals is more complicated in multithreaded programs. The following
options exist to deliver a signal:
o Deliver the signal to the thread to which the signal applies.
o Deliver the signal to every thread in the process.
o Deliver the signal to certain threads in the process.
o Assign a specific thread to receive all signals for the process.
4.4.4 Thread Pools
 The idea behind a thread pool is to create a number of threads at process startup
and place them into a pool, where they sit and wait for work.
 When a server receives a request, it awakens a thread from this pool and passes the
request to it to service.
 Once the thread completes its service, it returns to the pool and waits for more work.
 If the pool contains no available thread, the server waits until one becomes free.
 The benefits of Thread pools are,
o Servicing a request with an existing thread is usually faster than waiting to
create a thread.
o A thread pool limits the number of threads that exist at any one point. This
is particularly important on systems that cannot support a large number of
concurrent threads.
 The number of threads in the pool can be set based on factors such as the number of
CPUs in the system, the amount of physical memory, and the expected number of
concurrent client requests.
4.4.5 Thread-Specific Data
 Threads belonging to a process share the data of the process. This sharing of data
provides one of the benefits of multithreaded programming. But, in some

BGSCET/AIML 2023-24 Page 22 of 43

 Operarting Systems – BCS303

circumstances, each thread might need its own copy of certain data. Such data is
called as thread-specific data. For example, in a transaction-processing system, we
might service each transaction in a separate thread. Furthermore, each transaction
may be assigned a unique identifier.
 Most thread libraries including Win32 and Pthreads provide support for thread-
specific data.

4.4.6 Scheduler Activations

 Many systems implementing either the many-to-many or two-level model place an
intermediate data structure between the user and kernel threads. This data structure
is known as a lightweight process, or LWP as shown in the following figure.

Figure 4.6
 An application may require any number of LWPs to run efficiently.
 In a CPU-bound application running on a single processor only one thread can run at
once, so one LWP is sufficient. An application that is I/O- intensive may require
multiple LWPs to execute.
 One scheme for communication between the user-thread library and the kernel is
known as scheduler activation. It works as follows: The kernel provides an
application with a set of virtual processors (LWPs), and the application can
schedule user threads onto an available virtual processor. The kernel must inform an
application about certain events. This procedure is known as an upcall.
 Upcalls are handled by the thread library with an upcall handler, and upcall handlers
must run on a virtual processor.
 One event that triggers an upcall occurs when an application thread is about to block.
In this situation, the kernel makes an upcall to the application informing it that a

BGSCET/AIML 2023-24 Page 23 of 43

 Operarting Systems – BCS303

thread is about to block and identifying the specific thread. The kernel then allocates
a new virtual processor to the application.
 The application runs an upcall handler on this new virtual processor, which saves the
state of the blocking thread and gives up the virtual processor on which the blocking
thread is running. The upcall handler then schedules another thread that is eligible to
run on the new virtual processor.
 When the event that the blocking thread was waiting for occurs, the kernel makes
another upcall to the thread library informing it that the previously blocked thread is
now eligible to run.
 The upcall handler for this event also requires a virtual processor, and the kernel may
allocate a new virtual processor or preempt one of the user threads and run the upcall
handler on its virtual processor.
 After marking the unblocked thread as eligible to run, the application schedules an
eligible thread to run on an available virtual processor.

Differentiate between process and thread

Process Thread
1. It is called heavyweight process. It is called lightweight process.
Thread switching does not need interface with
2. Process switching needs interface with OS.
OS.
Multiple processes use more resources than Multiple threaded processes use fewer
3.
multiple threads. resources than multiple processes.
In multiple process implementations each
4. process executes same code but has its own All threads can share same set of open files.
memory and file resources.
If one server process is blocked no other
While one server thread is blocked and waiting,
5. server process can execute until the first
second thread in the same task could run.
process unblocked.
In multiple processes each process operates One thread can read, write or even completely
6.
independently of others. wipeout another threads stack.

BGSCET/AIML 2023-24 Page 24 of 43

 Operarting Systems – BCS303

Module -02 Chapter 5 Process Scheduling

5.1 Basic Concepts
 In a single-processor system, only one process can run at a time and others must wait until
the CPU is free and can be rescheduled.
 The objective of multiprogramming is to have some process running at all times, to
maximize CPU utilization.
 With multiprogramming, several processes are kept in memory at one time. When one
process has to wait, the operating system takes the CPU away from that process and gives
the CPU to another process.
 The CPU is one of the primary computer resources. Thus, its scheduling is central to
 Operating-system design.

5.1.1 CPU-I/O Burst Cycle

 Process execution consists of a cycle of CPU execution and I/O wait
 Process execution starts with CPU burst and this is followed by I/O burst as
shown in below figure5.1.
 The final CPU burst ends with a system request to terminate execution.

Figure 5.1
 The duration of CPU bursts vary from process to process and from computer to
computer.
 The frequency curve is as shown below figure5.2.

BGSCET/AIML 2023-24 Page 25 of 43

 Operarting Systems – BCS303

Figure 5.2

5.1.2 CPU Scheduler

o Whenever the CPU becomes idle, the operating system must select one of the
processes in the ready queue to be executed. This selection is carried out by the
short-term scheduler (or CPU scheduler).
o The scheduler selects a process from the processes in memory that are ready to
execute and allocates the CPU to that process.
o A ready queue can be implemented as a FIFO queue, a priority queue, a tree, or
simply an unordered linked list. But all the processes in the ready queue are lined
up waiting for a chance to run on the CPU. The records in the queues are Process
Control Blocks (PCBs) of the processes.
5.1.3 Preemptive scheduling
o CPU-scheduling decisions may take place under the following four
circumstances.
1. When a process switches from the running state to the waiting state (for
example, as the result of an I/O request or an invocation of wait for the
termination of one of the child processes)
2. When a process switches from the running state to the ready state (for
example, when an interrupt occurs)
3. When a process switches from the waiting state to the ready state (for example,
at completion of I/O)
4. When a process terminates

BGSCET/AIML 2023-24 Page 26 of 43

 Operarting Systems – BCS303

o When scheduling takes place only under circumstances 1 and 4, we say that the
scheduling scheme is non-preemptive or cooperative; otherwise, it is
preemptive.
o Under 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. A scheduling algorithm is preemptive if, once a
process has been given the CPU and it can be taken away.
5.1.4 Dispatcher
o Another component involved in the CPU-scheduling function is the dispatcher.
o The dispatcher is the module that gives control of the CPU to the process selected
by the short-term scheduler.
o This function involves the following:
 Switching context
 Switching to user mode
 Jumping to the proper location in the user program to restart that program
o The dispatcher should be as fast as possible, since it is invoked during every
process switch.
o The time it takes for the dispatcher to stop one process and start another running
is known as the dispatch latency.

5.2. Scheduling Criteria

Many criteria have been suggested for comparing CPU scheduling algorithms. The criteria
include the following:
 CPU utilization: CPU must be kept as busy as possible.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).
 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 10 processes per second.

BGSCET/AIML 2023-24 Page 27 of 43

 Operarting Systems – BCS303

 Turnaround time: 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/O.
 Waiting time: The CPU scheduling algorithm does not affect the amount of time during
which a process executes or does I/O; 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.
 Response time: The measure of 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.

5.3 Scheduling Algorithms

5.3.1 First-Come-First-Served (FCFS) scheduling algorithm.
o The simplest CPU-scheduling algorithm is the first-come, first-served (FCFS)
scheduling algorithm.
o With this scheme, the process that requests the CPU first is allocated the CPU first.
o The implementation of the FCFS policy is easily managed with a FIFO queue.
o When a process enters the ready queue, its PCB is linked onto the tail of the queue.
o When the CPU is free, it is allocated to the process at the head of the queue. The running
process is then removed from the queue.
o The average waiting time under the FCFS policy is often quite long. Consider the
following set of processes that arrive at time 0, with the length of the CPU burst given in
milliseconds:

o If the processes arrive in the order P1, P2, P3, and are served in FCFS order, we get the
result shown in the following Gantt chart:

BGSCET/AIML 2023-24 Page 28 of 43

 Operarting Systems – BCS303

o The waiting time is 0 milliseconds for process P1, 24 milliseconds for process P2, and 27
milliseconds for process P3. Thus, the average waiting time is (0 + 24 + 27)/3 = 17
milliseconds.
o The FCFS scheduling algorithm is non-preemptive. Once the CPU has been allocated
to a process, that process keeps the CPU until it releases the CPU, either by terminating
or by requesting I/O. The FCFS algorithm is thus particularly troublesome for time-
sharing systems, where it is important that each user get a share of the CPU at regular
intervals.
5.3.2 Shortest-Job-First scheduling algorithm
o This algorithm associates with each process the length of the process's next CPU
burst.
o When the CPU is available, it is assigned to the process that has the smallest next
CPU burst.
o If the next CPU bursts of two processes are the same, FCFS scheduling is used to
break the tie.
o As an example of SJF scheduling, consider the following set of processes, with the
length of the CPU burst given in milliseconds:

o Using SJF scheduling, we would schedule these processes according to the following
Gantt chart:

o The waiting time is 3 milliseconds for process P1, 16 milliseconds for process P2, 9
milliseconds for process P3, and 0 milliseconds for process P4. Thus, the average
waiting time is (3 + 16 + 9 + 0)/4 = 7 milliseconds.

BGSCET/AIML 2023-24 Page 29 of 43

 Operarting Systems – BCS303

o The SJF scheduling algorithm is optimal; it gives the minimum average waiting time
for a given set of processes. Moving a short process before a long one, decreases the
waiting time of the short process more than it increases the waiting time of the long
process. Consequently, the average waiting time decreases.
o The SJF algorithm can be either preemptive or non-preemptive. The choice arises
when a new process arrives at the ready queue while a previous process is still
executing. The next CPU burst of the newly arrived process may be shorter than what
is left of the currently executing process. A preemptive SJF algorithm will preempt
the currently executing process, whereas a non-preemptive SJF algorithm will allow
the currently running process to finish its CPU burst. Preemptive SJF scheduling is
sometimes called shortest-remaining-time-first scheduling.
o As an example, consider the following four processes, with the length of the CPU
burst given in milliseconds:

o If the processes arrive at the ready queue at the times shown and need the indicated
burst times, then the resulting preemptive SJF schedule is as depicted in the following
Gantt chart:

o Process P1 is started at time 0, since it is the only process in the queue. Process P2
arrives at time 1.
o The remaining time for process P1 (7 milliseconds) is larger than the time required by
process P2 (4 milliseconds), so process P1 is preempted, and process P2 is scheduled.
The average waiting time for this example is ((10 -1) + (1-1) + (17 -2) + (5- 3))/4 =
26/4 = 6.5 milliseconds. Non-preemptive SJF scheduling would result in an average
waiting time of 7.75 milliseconds.
5.3.3 Priority Scheduling algorithm
o The SJF algorithm is a special case of the general priority scheduling algorithm.
BGSCET/AIML 2023-24 Page 30 of 43
 Operarting Systems – BCS303

o A priority is associated with each process, and the CPU is allocated to the process
with the highest priority.
o Equal-priority processes are scheduled in FCFS order.
o An SJF algorithm is simply a priority algorithm where the priority (p) is the inverse
of the (predicted) next CPU burst. The larger the CPU burst, the lower the priority,
and vice versa.
o As an example, consider the following set of processes, assumed to have arrived at
time 0, in the order P1, P2, … , P5, with the length of the CPU burst given in
milliseconds:

o Using priority scheduling, we would schedule these processes according to the

following Gantt chart:

o The average waiting time is 8.2 milliseconds.

o Priority scheduling can be either preemptive or non-preemptive. When a process
arrives at the ready queue, its priority is compared with the priority of the currently
running process. A preemptive priority scheduling algorithm will preempt the CPU if
the priority of the newly arrived process is higher than the priority of the currently
running process. A non-preemptive priority scheduling algorithm will simply put the
new process at the head of the ready queue.
o A major problem with priority scheduling algorithms is indefinite blocking, or
starvation. A process that is ready to run but waiting for the CPU can be considered
blocked. A priority scheduling algorithm can leave some low- priority processes
waiting indefinitely. In a heavily loaded computer system, a steady stream of higher-
priority processes can prevent a low-priority process from ever getting the CPU.

BGSCET/AIML 2023-24 Page 31 of 43

 Operarting Systems – BCS303

o A solution to the problem of indefinite blockage of low-priority processes is aging.

Aging is a technique of gradually increasing the priority of processes that wait in the
system for a long time.
5.3.4 Round-Robin Scheduling algorithm
o The round-robin (RR) scheduling algorithm is designed especially for timesharing
systems.
o It is similar to FCFS scheduling, but preemption is added to switch between processes.
o A small unit of time, called a time quantum or time slice, is defined. A time
quantum is generally from 10 to 100 milliseconds.
o The ready queue is treated as a circular queue. The CPU scheduler goes around the
ready queue, allocating the CPU to each process for a time interval of up to 1 time
quantum.
o To implement RR scheduling, we keep the ready queue as a FIFO queue of processes.
New processes are added to the tail of the ready queue.
o The CPU scheduler picks the first process from the ready queue, sets a timer to
interrupt after 1 time quantum, and dispatches the process. One of two things will
then happen.
 The process may have a CPU burst of less than 1 time quantum. In this case, the
process itself will release the CPU voluntarily. The scheduler will then proceed to
the next process in the ready queue.
 Otherwise, if the CPU burst of the currently running process is longer than 1 time
quantum, the timer will go off and will cause an interrupt to the operating system.
A context switch will be executed, and the process will be put at the tail of the
ready queue. The CPU scheduler will then select the next process in the ready
queue.
o The average waiting time under the RR policy is often long. Consider the following
set of processes that arrive at time 0, with the length of the CPU burst given in
milliseconds:

BGSCET/AIML 2023-24 Page 32 of 43

 Operarting Systems – BCS303

o If we use a time quantum of 4 milliseconds, then process P1 gets the first 4

milliseconds. Since it requires another 20 milliseconds, it is preempted after the first
time quantum, and the CPU is given to the next process in the queue i.e. process P2.
Since process P2 does not need 4 milliseconds, it quits before its time quantum
expires.
o The CPU is then given to the next process P3. Once each process has received 1 time
quantum, the CPU is returned to process P1 for an additional time quantum. The
resulting RR schedule is

o The average waiting time is 17/3 = 5.66 milliseconds.

o The RR scheduling algorithm is thus preemptive.
o If there are n processes in the ready queue and the time quantum is q, then each
process gets 1/n of the CPU time in chunks of at most q time units. Each process must
wait no longer than (n-1) * q time units until its next time quantum. For example,
with five processes and a time quantum of 20 milliseconds, each process will get up
to 20 milliseconds every 100 milliseconds.

5.3.5 Multilevel Queue Scheduling algorithm

o Another class of scheduling algorithms has been created for situations in which
processes are easily classified into different groups. For example, a common division
is made between foreground (interactive) processes and background (batch)
processes.
o These two types of processes have different response-time requirements and may
have different scheduling needs.
o Foreground processes have priority over background processes.
o A multilevel queue scheduling algorithm partitions the ready queue into several
separate queues as shown in below figure 5.3.
o The processes are permanently assigned to one queue based on some property of the
process, such as memory size, process priority, or process type.
o Each queue has its own scheduling algorithm. For example, separate queues might be
used for foreground and background processes.
BGSCET/AIML 2023-24 Page 33 of 43
 Operarting Systems – BCS303

o The foreground queue might be scheduled by an RR algorithm, while the

background queue is scheduled by an FCFS algorithm.

Figure 5.3
o 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.
o An example of a multilevel queue scheduling algorithm with five queues, listed
below in order of priority:
1. System processes
2. Interactive processes
3. Interactive editing processes
4. Batch processes
5. Student processes
o Each queue has absolute priority over lower-priority queues. No process in the batch
queue could run unless the queues for system processes, interactive processes, and
interactive editing processes were all empty.
o If an interactive editing process entered the ready queue while a batch process was
running, the batch process would be preempted.
o Another possibility is to time-slice among the queues. So, each queue gets a certain
portion of the CPU time, which it can then schedule among its various processes. For
example, the foreground queue can be given 80 percent of the CPU time for RR

BGSCET/AIML 2023-24 Page 34 of 43

 Operarting Systems – BCS303

scheduling among its processes, whereas the background queue receives 20 percent
of the CPU to give to its processes on an FCFS basis.

5.5.6 Multilevel Feedback-Queue Scheduling algorithm

o When the multilevel queue scheduling algorithm is used, processes are permanently
assigned to a queue when they enter the system.
o The multilevel feedback-queue scheduling algorithm allows a process to move
between queues. The idea is to separate processes according to the characteristics of
their CPU bursts.
o 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.
o A process that waits too long in a lower-priority queue may be moved to a higher-
priority queue. This form of aging prevents starvation.
o For example, consider a multilevel feedback-queue scheduler with three queues,
numbered from 0 to 2 as shown in below figure 5.4.
o The scheduler first executes all processes in queue 0. Only when queue 0 is empty it
will execute processes in queue 1.
o Similarly, processes in queue 2 will only be executed if queues 0 and 1 are empty. A
process that arrives for queue 1 will preempt a process in queue 2.
o A process in queue 1 will in turn be preempted by a process arriving for queue 0.

Figure 5.4
o A process entering the ready queue is put in queue 0. A process in queue 0 is given a
time quantum of 8 milliseconds. If it does not finish within this time, it is moved to
the tail of queue 1. If queue 0 is empty, the process at the head of queue 1 is given a
BGSCET/AIML 2023-24 Page 35 of 43
 Operarting Systems – BCS303

quantum of 16 milliseconds. If it does not complete, it is preempted and is put into

queue 2. Processes in queue 2 are scheduled on an FCFS basis but they run only when
0 and 1 are empty queue.
o This scheduling algorithm gives highest priority to any process with a CPU burst of 8
milliseconds or less. Such a process will quickly get the CPU, finish its CPU burst,
and go off to its next I/O burst. Processes that need more than 8 but less than 24
milliseconds are also served quickly, although with lower priority than shorter
processes. Long processes automatically sink to queue 2 and are served in FCFS
order with any CPU cycles left over from queues 0 and 1.
o A multilevel feedback-queue scheduler is defined by the following parameters:
 The number of queues.
 The scheduling algorithm for each queue.
 The method used to determine when to upgrade a process to a higher-priority
queue.
 The method used to determine when to demote a process to a lower-priority
queue.
 The method used to determine which queue a process will enter when that
process needs service.

5.4 Multiple-Processor Scheduling.

 Approaches to Multiple-Processor Scheduling
o One approach to CPU scheduling in a multiprocessor system is where all scheduling
decisions, I/O processing, and other system activities are handled by a single processor
i.e., the master server. The other processors execute only user code. This
asymmetric multiprocessing is simple because only one processor accesses the
system data structures, reducing the need for data sharing.
o A second approach uses symmetric multiprocessing (SMP), where each processor is
self-scheduling. All processes may be in a common ready queue, or each processor
may have its own private queue of ready processes.
 Some of the issues related to SMP are,
a. Processor Affinity

BGSCET/AIML 2023-24 Page 36 of 43

 Operarting Systems – BCS303

o The data most recently accessed by the process is populated in the cache for the
processor and successive memory accesses by the process are often satisfied in
cache memory.
o If the process migrates to another processor, the contents of cache memory must
be invalidated for the processor being migrated from, and the cache for the
processor being migrated to must be re-populated. Because of the high cost of
invalidating and re-populating caches, most SMP systems try to avoid migration of
processes from one processor to another and instead tries to keep a process running
on the same processor. This is known as processor affinity, i.e., a process has an
affinity for the processor on which it is currently running.
o Processor affinity takes several forms. When an operating system has a policy of
attempting to keep a process running on the same processor but not guaranteeing
that it will do so, a situation is known as soft affinity. Here, it is possible for a
process to migrate between processors.
o Some systems such as Linux provide system calls that support hard affinity,
thereby allowing a process to specify that it must not migrate to other processors.
b. Load Balancing
o On SMP systems, it is important to keep the workload balanced among all
processors to utilize the benefits of having more than one processor. Otherwise, one
or more processors may sit idle while other processors have high workloads along
with lists of processes awaiting the CPU.
o Load balancing attempts to keep the workload evenly distributed across all
processors in an SMP system.
o There are two general approaches to load balancing: push migration and pull
migration.
o With push migration, a specific task periodically checks the load on each processor
and if it finds an imbalance it evenly distributes the load by moving (or pushing)
processes from overloaded to idle or less-busy processors.
o Pull migration occurs when an idle processor pulls a waiting task from a busy
processor.
c. Symmetric Multithreading
o SMP systems allow several threads to run concurrently by providing multiple
physical processors.
BGSCET/AIML 2023-24 Page 37 of 43
 Operarting Systems – BCS303

o An alternative strategy is to provide multiple logical processors rather than

physical processors. Such a strategy is known as symmetric multithreading (or
SMT).
o The idea behind SMT is to create multiple logical processors on the same physical
processor, presenting a view of several logical processors to the operating system,
even on a system with only a single physical processor.
o Each logical processor has its own architecture state, which includes general-
purpose and machine-state registers and is responsible for its own interrupt
handling, meaning that interrupts are delivered to and handled by logical processors
rather than physical ones. Otherwise, each logical processor shares the resources of
its physical processor, such as cache memory and buses.
o The following figure 5.5 illustrates a typical SMT architecture with two physical
processors, each housing two logical processors. From the operating system's
perspective, four processors are available for work on this system.

Figure 5.5

5.5 Thread Scheduling

Threading issue
 On operating systems that support user-level and kernel-level threads, the kernel-level
threads are being scheduled by the operating system.
 User-level threads are managed by a thread library, and the kernel is unaware of them. To
run on a CPU, user-level threads must be mapped to an associated kernel-level thread,
although this mapping may be indirect and may use a lightweight process (LWP).
 One distinction between user-level and kernel-level threads lies in how they are
scheduled. On systems implementing the many-to-one and many-to-many models, the
thread library schedules user-level threads to run on an available LWP, a scheme known
BGSCET/AIML 2023-24 Page 38 of 43
 Operarting Systems – BCS303

as process-contention scope (PCS), since competition for the CPU takes place among
threads belonging to the same process.
 To decide which kernel thread to schedule onto a CPU, the kernel uses system-
contention scope (SCS). Competition for the CPU with SCS scheduling takes place
among all threads in the system.
 PCS is done according to priority. The scheduler selects the runnable thread with the
highest priority to run. User-level thread priorities are set by the programmer. PCS will
preempt the currently running thread in favour of a higher-priority thread.

Pthread Scheduling algorithm

o Pthreads identifies the following contention scope values:
 PTHREAD_SCOPE_PROCESS schedules threads using PCS scheduling.
 PTHREAD_SCOPE_SYSTEM schedules threads using SCS scheduling.
o On systems implementing the many-to-many model, the
PTHREAD_SCOPE_PROCESS policy schedules user-level threads onto available
LWPs.
o The number of LWPs is maintained by the thread library using scheduler activations.
The PTHREAD_SCOPE_SYSTEM scheduling policy will create and bind an LWP
for each user-level thread on many-to-many systems, effectively mapping threads
using the one-to-one policy.
o The Pthread IPC provides the following two functions for getting and setting the
contention scope policy;
 pthread_attr_setscope (pthread_attr_t *attr, int scope)
 pthread_attr_getscope (pthread_attr_t *attr, int *scope)
o The first parameter for both functions contains a pointer to the attribute set for the
thread.
o The second parameter for the pthread_attr_setscope () function is passed either the
THREAD_SCOPE_SYSTEM or PTHREAD_SCOPE_PROCESS value, indicating
how the contention scope is to be set. In the case of pthread_attr_getscope(), this
second parameter contains a pointer to an int value that is set to the current value of
the contention scope. If an error occurs, each of these functions returns non-zero
values.

BGSCET/AIML 2023-24 Page 39 of 43

 Operarting Systems – BCS303

1. For the process listed below, draw Gantt charts using preemptive and
non-preemptive priority scheduling algorithm. A larger priority number
has a higher priority.
Jobs Arrival time Burst time Priority
J1 0 6 4
J2 3 5 2
J3 3 3 6
J4 5 5 3

Answer
Gantt chart Preemptive
J1 J3 J1 J4 J2
0 3 6 9 14 19

Gantt chart Non-Preemptive

J1 J3 J4 J2
0 6 9 14 19
2. Consider the following set of processes, with length of the CPU burst time
given in milliseconds:
Process Arrival time Burst time Priority
P1 0 10 3
P2 0 1 1
P3 3 2 3
P4 5 1 4
P5 10 5 2
a) Draw four Gantt chart illustrating the execution of these processes using FCFS, SRTF,
a non-preemptive priority and RR (Quantum = 2) scheduling.
b) What is the turn around time of each processes for each of the scheduling algorithm
in (a)
c) What is the waiting time of each process for each of the scheduling algorithm in (a).
Answer
Gantt chart - FCFS
P1 P2 P3 P4 P5
0 10 11 13 14 19

Waiting time = execution start time – Turnaround time = Completion time -

arrival time Arrival time
Waiting time P1 = 0 – 0 = 0 Turnaround time P1 = 10 - 0 = 10
Waiting time P2 = 10 - 0 = 10 Turnaround time P2 = 11 - 0 = 11
Waiting time P3 = 11 - 3 = 8 Turnaround time P3 = 13 - 3 = 10

BGSCET/AIML 2023-24 Page 40 of 43

 Operarting Systems – BCS303

Waiting time P4 = 13 - 5 = 8 Turnaround time P4 = 14 - 5 = 9

Waiting time P5 = 14 – 10 = 4 Turnaround time P5 = 19 - 10 = 9
Average WT: = (0+10+8+8+4)/5=6 ATAT= (10+11+10+9+9)/5= 9.8

Gantt chart - SRTF

P2 P1 P3 P4 P1 P1 P5
0 1 3 5 6 10 14 19
Waiting time = execution start time – Turnaround time = Completion time -
arrival time Arrival time
Waiting time P1 = ( 1 – 0) + (6 – 3) = 4 Turnaround time P1 = 14 - 0 = 14
Waiting time P2 = 0 - 0 = 0 Turnaround time P2 = 1 - 0 = 1
Waiting time P3 = 3 - 3 = 0 Turnaround time P3 = 5 - 3 = 2
Waiting time P4 = 5 - 5 = 0 Turnaround time P4 = 6 - 5 = 1
Waiting time P5 = 14 – 10 = 4 Turnaround time P5 = 19 - 10 = 9
Average WT: = (4+0+0+0+4)/5= 1.6 ATAT= (14+1+2+1+9)/5= 5.4

Gantt chart – non-preemptive priority ( low number high priority)

P2 P1 P5 P3 P4
0 1 11 16 18 19

Waiting time = execution start time – Turnaround time = Completion time -

arrival time Arrival time
Waiting time P1 = 1 – 0 = 1 Turnaround time P1 = 11 - 0 = 11
Waiting time P2 = 0 - 0 = 0 Turnaround time P2 = 1 - 0 = 1
Waiting time P3 = 16 - 3 = 13 Turnaround time P3 = 18 - 3 = 15
Waiting time P4 = 18 - 5 = 13 Turnaround time P4 = 19 - 5 = 14
Waiting time P5 = 11 – 10 = 1 Turnaround time P5 = 16 - 10 = 6
Average WT: = (1+0+13+13+1)/5= 5.6 ATAT= (11+1+15+14+6)/5= 9.4

Gantt chart – RR (Quantum = 2)

P1 P2 P3 P4 P1 P1 P5 P1 P5 P1 P5
0 2 3 5 6 8 10 12 14 16 18 19

Waiting time = execution start time – Turnaround time = Completion time -

arrival time Arrival time
Waiting time P1 = (0 – 0) + (6-2) + (12- Turnaround time P1 = 18 - 0 = 18
10) + (16-14)= 8
Waiting time P2 = 2 - 0 = 2 Turnaround time P2 = 3 - 0 = 3
Waiting time P3 = 3 - 3 = 0 Turnaround time P3 = 5 - 3 = 2
Waiting time P4 = 5 - 5 = 0 Turnaround time P4 = 6 - 5 = 1
Waiting time P5 = (10–10) + (14-12)+(18- Turnaround time P5 = 19 - 10 = 9
BGSCET/AIML 2023-24 Page 41 of 43
 Operarting Systems – BCS303

16) = 4
Average WT: = (8+2+0+0+4)/5= 2.8 ATAT= (18+3+2+1+9)/5= 6.6

3. Consider the following set of processes with arrival time:

Process Arrival time Burst time
P1 0 10
P2 0 1
P3 1 2
P4 2 4
P5 2 3
i) Draw Gantt charts using FCFS, SJF preemptive and non-preemptive scheduling.
ii) Calculate the average waiting time for each of the scheduling algorithm.

Answer
FCFS
P1 P2 P3 P4 P5
0 10 11 13 17 20

Waiting time = execution start time – arrival time

Waiting time P1 = 0-0 = 0
Waiting time P2 = 10-0=10
Waiting time P3 = 11-1=10
Waiting time P4 = 13-2 = 11
Waiting time P5 = 17-2 =15
Average Waiting time = (0+10+10+11+15)/5 = 9.2

SJF Preemptive
P2 P3 P3 P5 P4 P1
0 1 2 3 6 10 20

Waiting time = execution start time – arrival time

Waiting time P1 = 10-0 =10
Waiting time P2 = 0-0=0
Waiting time P3 = 1-1=0
Waiting time P4 = 6-2 = 4
Waiting time P5 = 3-2 =1
Average Waiting time = (10+0+0+4+1)/5 = 3

SJF non-preemptive
P2 P3 P5 P4 P1
0 1 3 6 10 20

BGSCET/AIML 2023-24 Page 42 of 43

 Operarting Systems – BCS303

Waiting time = execution start time – arrival time

Waiting time P1 = 10-0 =10
Waiting time P2 = 0-0=0
Waiting time P3 = 1-1=0
Waiting time P4 = 6-2 = 4
Waiting time P5 = 3-2 =1
Average Waiting time = (10+0+0+4+1)/5 = 3

BGSCET/AIML 2023-24 Page 43 of 43