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 2023-24 Page 1 of 42
 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 2023-24 Page 2 of 42
 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

Ready Queue And Various I/O Device Queues

BGSCET 2023-24 Page 3 of 42

 Operarting Systems – BCS303

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)
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).
BGSCET 2023-24 Page 4 of 42
 Operarting Systems – BCS303

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 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.

BGSCET 2023-24 Page 5 of 42

 Operarting Systems – BCS303

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);
}
}

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

BGSCET 2023-24 Page 6 of 42

 Operarting Systems – BCS303

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.
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.

BGSCET 2023-24 Page 7 of 42

 Operarting Systems – BCS303

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 data. large 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.
✓ 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.

BGSCET 2023-24 Page 8 of 42

 Operarting Systems – BCS303

✓ 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;
/* 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)

BGSCET 2023-24 Page 9 of 42

 Operarting Systems – BCS303

✓ 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.
✓ 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

BGSCET 2023-24 Page 10 of 42

 Operarting Systems – BCS303

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.

BGSCET 2023-24 Page 11 of 42

 Operarting Systems – BCS303

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.
• 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.
BGSCET 2023-24 Page 12 of 42
 Operarting Systems – BCS303

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.
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

BGSCET 2023-24 Page 13 of 42

 Operarting Systems – BCS303

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.
• 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.

BGSCET 2023-24 Page 14 of 42

 Operarting Systems – BCS303

• 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

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

BGSCET 2023-24 Page 15 of 42

 Operarting Systems – BCS303

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 */
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 */
{
BGSCET 2023-24 Page 16 of 42
 Operarting Systems – BCS303

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 */
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");
BGSCET 2023-24 Page 17 of 42
 Operarting Systems – BCS303

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);
}
}

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 () ;
}

BGSCET 2023-24 Page 18 of 42

 Operarting Systems – BCS303

✓ 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.
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;
BGSCET 2023-24 Page 19 of 42
 Operarting Systems – BCS303

}
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]);
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.

BGSCET 2023-24 Page 20 of 42

 Operarting Systems – BCS303

✓ 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.
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.
BGSCET 2023-24 Page 21 of 42
 Operarting Systems – BCS303

✓ 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,
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,

BGSCET 2023-24 Page 22 of 42

 Operarting Systems – BCS303

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 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
BGSCET 2023-24 Page 23 of 42
 Operarting Systems – BCS303

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 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 2023-24 Page 24 of 42

 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 2023-24 Page 25 of 42

 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
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.

BGSCET 2023-24 Page 26 of 42

 Operarting Systems – BCS303

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.
• 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.

BGSCET 2023-24 Page 27 of 42

 Operarting Systems – BCS303

• 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:

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.

BGSCET 2023-24 Page 28 of 42

 Operarting Systems – BCS303

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.
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

BGSCET 2023-24 Page 29 of 42

 Operarting Systems – BCS303

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 P 2 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.
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:

BGSCET 2023-24 Page 30 of 42

 Operarting Systems – BCS303

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.
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.

BGSCET 2023-24 Page 31 of 42

 Operarting Systems – BCS303

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:

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.

BGSCET 2023-24 Page 32 of 42

 Operarting Systems – BCS303

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.
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
BGSCET 2023-24 Page 33 of 42
 Operarting Systems – BCS303

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 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.

BGSCET 2023-24 Page 34 of 42

 Operarting Systems – BCS303

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 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

BGSCET 2023-24 Page 35 of 42

 Operarting Systems – BCS303

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
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.
BGSCET 2023-24 Page 36 of 42
 Operarting Systems – BCS303

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.
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
BGSCET 2023-24 Page 37 of 42
 Operarting Systems – BCS303

user-level threads to run on an available LWP, a scheme known 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 2023-24 Page 38 of 42

 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 – arrival Turnaround time = Completion time -
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 2023-24 Page 39 of 42

 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 – arrival Turnaround time = Completion time - Arrival
time 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 – arrival Turnaround time = Completion time - Arrival
time time
Waiting time P1 = (0 – 0) + (6-2) + (12-10) + Turnaround time P1 = 18 - 0 = 18
(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

BGSCET 2023-24 Page 40 of 42

 Operarting Systems – BCS303

Waiting time P5 = (10–10) + (14-12)+(18-16) Turnaround time P5 = 19 - 10 = 9

=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

BGSCET 2023-24 Page 41 of 42

 Operarting Systems – BCS303

SJF non-preemptive
P2 P3 P5 P4 P1
0 1 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

BGSCET 2023-24 Page 42 of 42