Operating systems

MODULE-2 PROCESS MANAGEMENT

3.1 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

 A process is more than the program code which is also called text section.
 It contains program counter which represents the current activity and also the
contents of the processor's registers.
 A process also consists of a process stack section which contains temporary data &
data section which contains global variables.
 A process may also include a heap, which is memory that is dynamically allocated
during process run time.
 The structure of a process in memory is shown in below figure.

 Process State

 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
 Only one process can be running on any processor at any instant. Many processes
may be ready and waiting.
 The state diagram corresponding to these states is shown below figure.

Sujatha GS, Asst prof Dept of Computer Science Page 1

Operating systems

 Process Control Block

 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 shows the process control block.

 The PCB contains important information about the specific process including,

o Process state: The current state of the process i.e., whether it is ready, running, waiting, halted
and so on.
o Program counter: Indicates the address of the next instruction to be executed for a process.
o 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.
o CPU scheduling information: This information includes a process priority, pointers to
scheduling queues, and any other scheduling parameters.
o 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.

Sujatha GS, Asst prof Dept of Computer Science Page 2

Operating systems

o Accounting information: This information includes the amount of CPU and real
time used, time limits, account numbers, job or process numbers, and so on.
o 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.

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 

Sujatha GS, Asst prof Dept of Computer Science Page 3

Operating systems

3.2 Process Scheduling

The process scheduler selects an available process for execution on the CPU.

 Scheduling queues

 The following are the different types of process scheduling queues.

o Job queue: set of all processes in the system.

o Ready queue: The processes that are placed in main memory and are ready and
waiting to execute are placed in a list called the ready queue. This is in the form
of linked list, the header contains pointer to the first and final PCB in the list.
Each PCB contains a pointer field that points to next PCB in ready queue.

o Device queue: The list of processes waiting for a particular I/O device is called
device queue. When the CPU is allocated to a process it may execute for
sometime and 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 and it will be placed in device
queue. Each device will have its own queue.

 The below figure Shows Ready queue and various I/O Device queues

 The process scheduling is represented using a queuing diagram as shown in below

figure. Queues are represented by the rectangular box and resources they need are
represented by circles, and the arrows indicate the flow of processes in the system.

Sujatha GS, Asst prof Dept of Computer Science Page 4

Operating systems

 A new process is initially put in the ready queue and it waits there until it is selected
for execution or dispatched. Once the process is assigned CPU and is executing, the
following events can occur,
o It can execute an I/O request and is placed in I/O queue.
o The process can create a sub process & wait for its termination.
o 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 types of schedulers,

o Long-term scheduler (or job scheduler): selects which processes should be

brought into the ready queue. Long-term scheduler is invoked very
infrequently (in terms of seconds or minutes). The long-term scheduler controls
the degree of multiprogramming (number of processes in main memory).
o Short-term scheduler (or CPU scheduler): selects which process should be
executed next and allocates CPU. Short-term scheduler is invoked very
frequently.
o Medium-term schedulers: Some OS introduces intermediate level of
scheduling called Medium-term schedulers as shown in below figure. It can be
advantageous to remove processes from memory and thus reduce the degree of
multiprogramming. The process can be later reintroduced into memory, and its
execution can be continued where it left off. The process Is swapped out, and
is later swapped in, by the medium-term scheduler.

Sujatha GS, Asst prof Dept of Computer Science Page 5

Operating systems

 Processes can be described as either:

o I/O-bound process: processes spend more time doing I/O than computations.
o CPU-bound process: processes spend more time doing computations; and
generates I/O request less frequently.

 Context Switch

 When an interrupt occurs, the system needs to save the current context of the
process running on the CPU. The context is represented in the PCB of the process.
 When CPU switches to another process, the system must save the state of the old
process and load the saved state for the new process. A state save of the current state
of the CPU, and then state restore to resume operations is performed.
 Context-switch time is overhead and the system does no useful work while
switching. Context-switch times are highly dependent on hardware support. Context-
switch speed varies from machine to machine, depending on the memory speed, the
number of registers that must be copied, and the existence of special instructions.

Sujatha GS, Asst prof Dept of Computer Science Page 6

Operating systems

3.3 Process Operations

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

 A process may create several new processes by some create-process system call,
during the course of execution.
 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 ( or pid).
 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.
 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.
 When a user logs in, dtlogin creates an X-windows session (X session), 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.
 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).
 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.
 When a process creates a new process, two possibilities exist in terms of execution.
1. The parent continues to execute concurrently with its children.
2. The parent waits until some or all of the children have terminated.
 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.
 In UNIX OS, fork () system call creates new process. In windows Create Process ()
does the job.
 Exec () system call Is called after a fork () to replace the process memory space with
a new program.

Sujatha GS, Asst prof Dept of Computer Science Page 7

Operating systems

 The C program shown below illustrates these system calls. 

 int main()
{
Pid_t pid;
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 /*parentprocess*/
{
wait(NULL);/*parent will wait for the child to complete*/
printf ("Child Complete");
exit(0);
}
}

Sujatha GS, Asst prof Dept of Computer Science Page 8

Operating systems

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

 Process Termination

 A process terminates when it finishes executing its last statement and asks the
operating system to delete it by using exit() system call.
 Process resources are de allocated 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.
 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 Inter-process Communication (IPC)
 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.
Sujatha GS, Asst prof Dept of Computer Science Page 9
Operating systems

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

Communication models (a) Message passing. (b) Shared memory.

 The differences between these two models are,

Message passing Shared memory

a. Useful for exchanging small
a. large data
amount of data.
b. easy to implement b. complex
c. slower c. faster
d. system calls are required only to
d. implemented using system calls
establish 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.

Sujatha GS, Asst prof Dept of Computer Science Page 10

Operating systems

 Two types of buffers can be used.

• 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.
• 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
typedef struct {
……..
……..

}item;

Itembuffer[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.
Item next Produced;
while(true)
{
/*produce an item in next Produced*/
While (((in+1)%BUFFER_SIZE)==out);//do nothing
Buffer [in] = next Produced;
in =(in +1)%BUFFER_SIZE;
}

 The code fo r the consumer process is shownbelow.

item next Consumed;

While (true)
{
While (in==out);//do nothing
nextConsumed = buffer[out];
out = (out+1)%BUFFER_SIZE;
/*consume the item in next Consumed*/
}

Sujatha GS, Asst prof Dept of Computer Science Page 11

Operating systems

 Message Passing System

 Communication takes place by means of message exchange between the

cooperating processes.
 Message passing facility provides two operations.
o Send (message)
o 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,
o Physical (eg: shared memory, hardware bus)
o logical(eg: logical properties)
 Several methods for logically implementing a link are,
o Director 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 mail boxes
(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.

Sujatha GS, Asst prof Dept of Computer Science Page 12

Operating systems

 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 of n messages, sender must wait if
link is full.
3. Unbounded capacity–infinite length and sender never waits.

Sujatha GS, Asst prof Dept of Computer Science Page 13

Operating systems

MULTI THREADED PROGRAMMING

 Threads

 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. Illustrates the difference between a traditional single threaded
Process and a multithreaded process.

 Motivation

 Many software packages that run on modern desktop PCs are multithreaded.
 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.
 As process creation takes more time than thread creation 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.
 Threads also play an important role in remote procedure call.

Sujatha GS, Asst prof Dept of Computer science Page 1

Operating systems

 Benefits

 The benefits of multi threaded 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
ondifferentprocessors.Multithreadingonmulti-
CPUmachineincreasesconcurrency.

 Multi threading 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 threads and kernel threads. Three
Common ways of establishing this relationship are,

 Many-to-One

 Many user-level threads are mapped to single kernel thread as shown in below figure
 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

Sujatha GS, Asst prof Dept of Computer science Page 2

Operating systems

 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

 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. (Left side)
 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. (Right side)
 Examples: IRIX, HP-UX, Solaris OS.

Sujatha GS, Asst prof Dept of Computer science Page 3

Operating systems

 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 P threads : extension of posix standard, they may be provided as either
a user bor kernel library.
o Win 32 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 P threads

 P threads

 P threads, the threads extension of the POSIX standard, may be provided as either
a user or kernel-level library.
 P threads refers to the POSIX standard (IEEE1003.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 P threads 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 P threads 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 (int argc,char*argv[])
{
pthread_t tid; /*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)

Sujatha GS, Asst prof Dept of Computer science Page 4

Operating systems

{
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*/

{
Int i,upper=atoi(param);
sum = 0;
for(i=1;i<=upper;i++)
sum +=i;
pthread_exit(0);
}

 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 P
threads technique in several ways. We must include the windows.h header file when
using the Win32API.
 Threads are created in theWin32 API using the Create Thread ()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 Wait For Single Object ()
function, which causes the creating thread to block until the summation thread as
exited.

Multi threaded 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;
return0;
}

Sujatha GS, Asst prof Dept of Computer science Page 5

Operating systems

Int main(int argc,char*argv[])

{
DWORD ThreadId;
HANDLE ThreadHandle;
int Param;

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;
}
/*createthethread*/
ThreadHandle=Create Thread(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(Thread Handle!=NULL)
{
Wait For Single Object (Thread Handle,INFINITE);
//now wait for the thread to finish Close Handle (Thread Handle); // close the
thread handle printf ("surn=%d\n", Sum);
}
}

 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()

Sujatha GS, Asst prof Dept of Computer science Page 6

Operating systems

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.

Class Sum
{
Private int sum;
Public int getSum()
{
Return sum;
}

Public void setSum (int sum)

{
this.sum=sum;
}
}

Class Summation implements Runnable

{
Private int upper;

Sujatha GS, Asst prof Dept of Computer science Page 7

Operating systems

Private Sum sum Value;

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]+"mustbe>=0.");
else
{
S sum sumObject=newSum(); //create the object to be
shared
In intupper=Integer.parseint(args[O]);
Treadthrd=newThread(newSummation(upper,sumObject));thrd.s();
try
thrd. join ();
System.out.println("The sum of"+upper+"is"+sum Object .get Sum());
}
Catch (Interrupted Exception ie){}
}
}
else
System. err. Println ("Usage: Summation<integer value>");
}

Sujatha GS, Asst prof Dept of Computer science Page 8

Operating systems

 Threading Issues

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

 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 a synchronous 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. P threads refers to
such points as cancellation points.

 Signal Handling

 A signal is used in UNIX systems to notify a process that a particular event has
occurred.

Sujatha GS, Asst prof Dept of Computer science Page 9

Operating systems

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

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.

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

Sujatha GS, Asst prof Dept of Computer science Page 10

Operating systems

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.

 Thread-Specific Data

 Threads belonging to a process share the data of the process. This sharing of data
provides one of the benefits of multi threaded 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 P threads provide support for thread-
specific data.

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

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

Sujatha GS, Asst prof Dept of Computer science Page 11

Operating systems

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.

 Differences

 The differences between process and thread are,

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

Sujatha GS, Asst prof Dept of Computer science Page 12

Operating systems

PROCESS SHEDULING

 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 multi programming 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.

 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 figure.
 The final CPU burst ends with a system request to terminate execution.

 The duration of CPU bursts vary from process to process and from computer to
computer.

 The frequency curve is as shown below figure.

Sujatha GS, Asst prof Dept of Computer science Page 13

Operating systems

 CPU Scheduler

 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).
 The scheduler selects a process from the processes in memory that are ready to
execute and allocates the CPU to that process.
 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.

 Preemptive scheduling

 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

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

Sujatha GS, Asst prof Dept of Computer science Page 14

Operating systems

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.

 Dispatcher

 Another component involved in the CPU-scheduling function is the dispatcher.

 The dispatcher is the module that gives control of the CPU to the process selected
by the short-term scheduler.
 This function involves the following:
o Switching context
o Switching to user mode
o Jumping to the proper location in the user program to restart that program

 The dispatcher should be as fast as possible, since it is invoked during every

process switch.
 The time it takes for the dispatcher to stop one process and start another running is
known as the dispatch latency.

 Scheduling Criteria

 Many criteria have been suggested for comparing CPU scheduling algorithms. The
Criteria include the following :

o 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).
o 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 through put. For long processes, this rate may be one process per hour; for
short transactions, it may be10 processes per second.
o 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.
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.
o 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.

 Scheduling Algorithms

CPU Scheduling deals with the problem of deciding which of the processes in the ready
queue is to be allocated the CPU. Following are some scheduling algorithms,

Sujatha GS, Asst prof Dept of Computer science Page 15

Operating systems

o FCFS Scheduling.
o Round Robin Scheduling.
o SJF Scheduling.
o Priority Scheduling.
o Multilevel Queue Scheduling.
o Multilevel Feedback Queue Scheduling.

 First-Come-First-Served (FCFS) Scheduling

 The simplest CPU-scheduling algorithm is the first-come, first-served (FCFS)

scheduling algorithm.
 With this scheme, the process that requests the CPU first is allocated the CPU first.
 The implementation of the FCFS policy is easily managed with a FIFO queue.
 When a process enters the ready queue, its PCB is linked onto the tail of the queue.
 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.
 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:

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

 The waiting time is 0 milliseconds for process P1, 24 milliseconds for process P 2, and
27 milliseconds for process P3 . Thus, the average waiting time is (0 + 24 + 27)/3 =
17milliseconds.
 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.

 Shortest-Job-First Scheduling

 This algorithm associates with each process the length of the process's next CPU burst.
 When the CPU is available, it is assigned to the process that has the smallest next CPU
burst.

Sujatha GS, Asst prof Dept of Computer science Page 16

Operating systems

 If the next CPU bursts of two processes are the same, FCFS scheduling is used to
break the tie.
 As an example of SJF scheduling, consider the following set of processes, with the
length of the CPU burst given in milliseconds:

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

 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.
 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.
 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.
 As an example, consider the following four processes, with the length of the CPU
burst given in milliseconds:

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

Sujatha GS, Asst prof Dept of Computer science Page 17

Operating systems

 Process P1 is started at time 0, since it is the only process in the queue. Process P2
arrives at time1.
 The remaining time for process P1 (7 milliseconds) is larger than the time required by
process P2 (4milliseconds), 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.

 Priority Scheduling

 The SJF algorithm is a special case of the general priority scheduling algorithm.
 A priority is associated with each process, and the CPU is allocated to the process
with the highest priority.
 Equal-priority processes are scheduled in FCFS order.
 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.
 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:

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

following Gantt chart:

 The average waiting time is 8.2 milliseconds.

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

Sujatha GS, Asst prof Dept of Computer science Page 18

Operating systems

 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.
 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 along time.

 Round-Robin Scheduling

 The round-robin (RR) scheduling algorithm is designed especially for timesharing

systems.
 It is similar to FCFS scheduling, but preemption is added to switch between processes.
 A small unit of time, called a time quantum or time slice, is defined. A time quantum
is generally from 10 to 100 milliseconds.
 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.
 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.
 The CPU scheduler picks the first process from the ready queue, sets a timer to
interrupt after1time quantum, and dispatches the process. One of two things will then
happen.
o 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.
o 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.
 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 :

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

4milliseconds. Since it requires another 20 milliseconds ,it is preempted after the first

Sujatha GS, Asst prof Dept of Computer science Page 19

Operating systems

Time quantum, and the CPU is given to the next process in the queue ie. Process P2. Since
process P2 does not need 4 milliseconds, it quits before its time quantum expires.
 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

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

 The RR scheduling algorithm is thus preemptive.
 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.

 Multi level Queue Scheduling

 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 fore ground (inter active) processes and back ground (batch)
processes.
 These two types of processes have different response-time requirements and may have
Different scheduling needs.
 Foreground processes have priority over background processes.
 A multilevel queue scheduling algorithm partitions the ready queue into
several separate queues as shown in below figure.
 The processes are permanently assigned to one queue based on some property of the
process, such as memory size, process priority, or process type.
 Each queue has its own scheduling algorithm. For example, separate queues might be
used for foreground and back ground processes.
 The foreground queue might be scheduled by an RR algorithm, while the background
queue is scheduled by an FCFS algorithm.

Sujatha GS, Asst prof Dept of Computer science Page 20

Operating systems

 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 back ground queue.
 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
 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.
 If an interactive editing process entered the ready queue while a batch process was
running, the batch process would be preempted.
 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.

 Multi level Feedback- Queue Scheduling

 When the multilevel queue scheduling algorithm is used, processes are permanently
assigned to a queue when they enter the system.
 The multi level 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.

Sujatha GS, Asst prof Dept of Computer science Page 21

Operating systems

 If a process uses too much CPU time, it will be moved to a lower-priority queue. This
scheme leaves I/O-bound and inter active processes in the higher-priority queues.
 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.
 For example, consider a multilevel feedback-queue scheduler with three queues,
numbered from 0 to 2 as shown in below figure.
 The scheduler first executes all processes in queue0. Only when queue0 is empty it
will execute processes in queue1.
 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 queue2.
 A process in queue 1 will in turn be preempted by a process arriving for queue 0.

 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 1are empty queue.
 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 and1.
 A multilevel feedback-queue scheduler is defined by the following parameters:
o The number of queues.
o The scheduling algorithm for each queue.
o The method used to determine when to upgrade a process to a higher-priority
queue.
o The method used to determine when to demote a process to a lower-priority
queue.
o The method used to determine which queue a process will enter when
that process needs service.

Sujatha GS, Asst prof Dept of Computer science Page 22

Operating systems

 Multiple-Processor Scheduling

 Approaches to Multiple- Processor Scheduling

 One approach to CPU scheduling in a multi processor 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 multi processing is simple because only one processor
accesses the system data structures, reducing the need for data sharing.
 A second approach uses symmetric multi processing (SMP), where each
processor is self-scheduling. All processes may be in a common ready queue, or
each process or may have its own private queue of ready processes.

 Some of the issues related to SMP are,

a. Processor Affinity

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

 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.
 Load balancing attempts to keep the workload evenly distributed across all
processors in an SMP system.
 There are two general approaches to load balancing: push migration and pull
migration.

Sujatha GS, Asst prof Dept of Computer science Page 23

Operating systems

 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.
 Pull migration occurs when an idle processor pulls a waiting task from a busy
processor.

c. Symmetric Multithreading

 SMP systems allow several threads to run concurrently by providing multiple

physical processors.
 An alternative strategy is to provide multiple logical processors rather than
physical processors. Such a strategy is known as symmetric multithreading (or
SMT).
 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.
 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
there sources of its physical processor, such as cache memory and buses.
 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.

 Thread Scheduling

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

Sujatha GS, Asst prof Dept of Computer science Page 24

Operating systems

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 on to 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.

 P thread Scheduling

 P threads identifies the following contention scope values:

o PTHREAD_SCOPE_PROCESS schedules threads using PCS scheduling.

o PTHREAD_SCOPE_SYSTEM schedules threads using SCS scheduling.

 On systems implementing the many-to-many model, the

PTHREAD_SCOPE_PROCESS policy schedules user-level threads onto
available LWPs.
 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.
 The Pthread IPC provides the following two functions for getting and
setting the contention scope policy;

o pthread_attr_setscope(pthread_attr_t*attr,int scope)
o pthread_attr_getscope(pthread_attr_t*attr,int* scope)

 The first parameter for both functions contains a pointer to the attribute set
for the thread.
 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.

Sujatha GS, Asst prof Dept of Computer science Page 25