Process Management

Process Management
In a distributed environment process
management deals with the best use
of the processor resources of the
entire system by sharing them among
all the processes.
There are three important concepts
used to achieve this goal:
1.Processor Allocation.
2.Process Migration.
3.Threads.
 Process Migration
It is the relocation of the process from
the source node to the destination node
to which it has been assigned.
Process migration involves the following
steps:
1. Selection of the process that has to

be migrated.
2. Selection of the destination node to
which the process has to be migrated.
3. Actual transfer of the process node
Desirable features of good
process migration
Transparency
1.Object Access Level
2. System call & Interprocess
communication level
Minimal Interference
Minimal Residual dependencies
Efficiency
Robustness
Communication between co-processes
of a job
Process transfer mechanisms..
Four major sub-activities are involved in
the process migration:
i) Freezing the process at its source
node and restarting the process at
the destination node.
ii) Transfer of the process address space
from the source to the destination.
iii) Forwarding the messages meant for
the migrant process.
iv) Handling the cooperation between
the processes that have been
seperated due to process migration
Mechanisms for freezing and restarting a
process:
Immediate and delayed blocking of
the process.
Fast & slow I/O operations
Information about open files.
Reinstantiating the process on the
destination node.
Address space transferring
mechanisms.
Total freezing
Pretransferring
Transfer on reference
 Total freezing mechanisms.
Time Source node Destination node

Execution
suspended
Migration decision made
FRE-
ZZING Transfer of address
space
TIME

Execution resumed
 Pretransfer mechanisms
Time Destination node
Source Node

Migration decision made

Execution
suspended Transfer of
address
Freezing space
time
Execution
resumed
 Transfer on reference
Source node Destination node
Time

Execution
suspended Migration decision made
Freezing
time

Execution resumed

On demand transfer
of addressing space
 Message forwarding mechanisms
Ensure that all pending, en-route and
future messages arrive at process’s
new location.
Messages to be forwarded can be
classified into :
i. Message received at source node after process’s
execution stopped on its source node and not yet
started on destination node.
Message received at source after execution
started on destination.
Messages to be sent to migrant process from any
other node after it has started executing on
destination node.
Mechanisms for message
forwarding

Mechanism of resending message

Origin site mechanism
Link traversal mechanism
Link update mechanism
Mechanisms for handling co-
processes
Disallowing separation of the of co-
processes.
Home node or origin site concept.
Process Migration in
Heterogeneous environment
Homogeneous environment – consistent
data interpretation, no need of data
translation
Heterogeneous environment – data
must be translated from source CPU
format to destination CPU format.
- heterogeneous sys having ‘n’ CPU types
must have ‘n(n-1)’ pieces of translation
s/w.
 Processor Serializing
type 1

Deserializing
1 2
8 External data
3 Bounds
Processor Processor
type 4
representation type 2 complexity of
7
4 translation s/w
6 5

Processor
type 3
Issues in handling Floating point
number representation
Handling Exponent
-problem with design of external data
representation.
-guarantee that external data representation
have at least as many bits as longest
exponent of any processor in the
distributed sys.
Handling Mantissa
Handling Signed- infinity & signed-zero
representation
Advantages of Process Migration
Reducing avg. response time of
processors
Speeding up individual jobs
Gaining higher throughput
Using resources effectively
Reducing n/w traffic
Improving Sys. Reliability
Improving Sys. Security
Threads
 Threads
 A thread is a light-weight process (LWP), a means of achieving
multitasking.
 LWP shares all (or most of) its logical address space and
system resources with other processes and has its own private
Process ID and parenthood relationships with other processes.
 A LWP is scheduled as a regular process.

Advantages of Threads
 Creating a thread is cheaper than a process (~10-20 times)
 Switching to a different thread in same process is (much)
cheaper (5-50 times).
 Threads allow parallelism to be combined with sequential
execution and blocking system calls.
 Threads within same process can share data and other
resources more conveniently and efficiently .
Thread Implementation
Combining kernel-level lightweight
processes and user-level threads.
Multithreaded Servers
Model Characteristics

No Parallelism, blocking system

Single-threaded process
calls
Parallelism, nonblocking system
Finite-state machine
calls

Group of threads Parallelism, blocking system calls

Three ways to construct a server.

Models for organizing
threads
Depending on the application’s needs ,the threads of a
process of the application can be organized in different ways.

Three commonly used ways to organize the threads of a

process are:
 Dispatcher-workers model
 Team model
 Pipeline model

Dispatcher-workers model:
In this model ,the process consists of a single dispatcher
thread and multiple worker threads.
Dispatcher-worker model.
 Models for organizing threads
Contd..
Team Model:
 All the threads behave as equals as there is no dispatcher-
worker relationship for processing client’s requests.

 Each thread gets and processes client’s requests on it’s own.

 This model is used for implementing specialized thread within

the process.

Pipeline Model :
 In this model the threads of the process are pipelined so that
the output generated by the first thread is used for processing
by the second thread and the output generated by the second
thread is used for processing by the third thread and so on.
Issues in designing a Threads
package
Threads Creation:
Threads can be created either statically or dynamically.
Static approach :
In the static approach, the number of the threads of a process remains fixed
for it’s entire lifetime.

Dynamic approach:
The number of threads of a process keeps changing dynamically.

Threads Termination:
Thread may either destroy itself when it finishes it’s job by making an exit
call or can be killed from outside by using the kill command.

Threads Synchronization:
Some mechanism must be used to prevent multiple threads from trying to
access the same data simultaneously. For this to occur safely ,each thread
must ensure that it has exclusive access for this variable for some time.
 Issues in designing a Threads
package-Contd
 A segment of the code in which a thread may be accessing
some shared variables is called critical region.Hence the
threads using the same data must be mutually exclusive in
time.
 Two mostly used mutually exclusive techniques :
i) mutex variable
ii) condition variable

i) Mutex variable:
• A mutex variable is like a binary semaphore that is always in
one of the two states ,locked and unlocked.
• A thread that wants to execute in a critical region performs a
lock operation on the corresponding mutex variable.
Issues in designing a Threads package-
Contd
• Only one thread can hold a particular lock at a time. Once a thread acquires
a lock, other threads cannot get that same lock until the first thread releases
the lock.

• If the mutex variable is already locked ,then either the thread is blocked and
entered in the queue or status code indicating failure is returned to the
thread.
Disadvantage:
Their use is limited to guarding entries to critical regions.

ii) Condition variable:

Condition variable is associated with the mutex variable and reflects the
boolean state of the variable.
Wait and Signal are the two operations provided for a condition variable.
Issues in designing a Threads
package-Contd..
When a thread performs a wait operation on a condition variable,the
associated mutex variable is unlocked ,and the thread is blocked until a
signal operation is performed indicating that the event being waited is
occurred.

When a thread performs a signal operation on a condition variable,the

associated mutex variable is locked ,and the thread that was blocked
waiting on the condition variable starts executing in the critical region.

Threads scheduling:
Priority Assignment facility:
In this facility, priority is assigned to various threads of an application
to ensure that the important ones can be run on higher priority.
The priority based scheduling is either pre-emptive or non-preemptive.
 Issues in designing a Threads
package-Contd..
Flexibility to vary quantum size dynamically:
A scheduling scheme may vary the size of the time quantum inversely with
the total number of threads in the system to timeshare the CPU cycles
among the threads.
Handoff Scheduling:
This mechanism allows a thread to name it’s successor.
Affinity Scheduling:
In this scheme,a thread is scheduled on the CPU it last ran on and that
part of the address space is still in that CPU’s cache.

Signal Handling:
 The signal provide software generated interrupts and exceptions.
Interrupts are externally generated disruptions of a thread or a
process,whereas exceptions are caused by the occurrence of unusual
conditions using a thread’s execution.
Implementation of Thread Package

Thread package can be implemented either in user space

or in kernel depending upon which there are two
approaches
• User level approach
• Kernel level approach
User Level Approach
User space consists of runtime systems that is a collection of
thread management routines.
Run time systems maintains status information table to keep
track of status of each thread.
This table has one entry per thread consisting of fields for
register values, state, priority and other information of thread.
Calls of thread packages are maintained as call to runtime
system procedures that performs the functions corresponding to
calls.
Two level scheduling is performed in this approach.
User Level Approach contd…

Scheduler in the kernel allocates quanta to heavy weight

process and divides quantum allocated to the process among
the threads allocated to the process.
Existence of the thread is made invisible to the kernel.
Used by SunOS 4.1 lightweight processes package.
Advantages of User level approach
Thread package can be implemented on top of an existing
operating system that does not support threads
Due to two level scheduling, users have flexibility to use their
own customized algorithm to schedule the threads of process as
a result of which user can design most appropriate algorithm for
the application.
Switching the context from one thread to another is faster.
Disadvantages of User level approach
Use of round Robin scheduling policy to timeshare the CPU
cycles among the threads on a quantum-by quantum basis is
not possible due to lack of lack of clock interrupts within a single
process.
Implementation of blocking system calls is not straightforward
because if thread directly makes a blocking system calls all
threads of the process will be stopped and kernel will schedule
another process to run.
Kernel Level Approach
No runtime system is used and threads are managed by kernel.
Thread status information table is maintained within the kernel.
When thread blocks kernel selects another thread that may
belong to either to the same process previously running or to
different process.
Existence of thread is known to the kernel and single level
scheduling is used.
Advantages of Kernel Level Approach
Implementation of Round robin scheduling policy is more
practicable as clock interrupts periodically and kernel can keep
track of amount of CPU time consumed by thread. When thread
finishes it can be interrupted by kernel and CPU can be given to
another thread.
Implementation of blocking system calls is straightforward
because when thread makes a call ,it traps to the kernel where
it is suspended and kernel starts a new thread.
Disadvantages of Kernel Level Approach
Concepts of thread can be incorporated in design of kernel of
operating system as a result of which thread package cannot be
incorporated.
Users do not have flexibility of choosing their own scheduling
algorithm because single level scheduler is used that is built into
kernel.
Switching the context from one thread to another is not fast
because trap to the kernel is laid for it.
Thread management
Library procedures for managing threads in Thread package are:
pthread_create: to create a new thread in a new address space
as a calling thread. This thread executes concurrently with the
parent thread.
pthread_exit: to terminate the calling thread.
pthread_join: to cause the calling thread to block itself until the
thread specified in this routine arguments terminates.
pthread_cancel: used by thread to cancel another thread.
Pthread_detach: used by parent thread to disown the child
thread.
Threads Synchronization
DCE threads package provides support for both mutex variables
and condition variables for thread synchronization.Mutex
variables are used when access to a shared resource by
multiple threads.
The DCE threads package supports foll.mutex variables
Fast: It is the one that causes the thread to block when the
thread attempts to lock an already locked mutex variable.
Recursive: it is the one that allows thread to lock an already
locked mutex variable.
Nonrecursive:It is the one that neither allows the thread to lock
an already locked mutex variable nor causes the thread to
block.
Threads Synchronization contd…
DCE thread calls for the thread synchronization:
pthread_mutex_init:It is used to dynamically create a mutex
variable.
pthread_mutex_destroy:It is used to dynamically delete a mutex
variable.
pthread_mutex_lock:It is used to lock a mutex variable.
pthread_mutex_unlock:It is used to unlock a mutex variable.
pthread_cond_init:It is used to dynamically create mutex
variable.
pthread_cond_destroy:It is used to dynamically destroy a mutex
variable.
pthread_cond_signal:It is used to wake up a thread waiting on a
condition variable.
pthread_cond_broadcast:It is used to wake up all threads
waiting on condition variables.
Threads Scheduling
Supports priority based thread scheduling.
It allows the user to specify not only the priorities for individual
threads but also for scheduling algorithms.
Threads scheduling algorithms are:
First in,first out (FIFO): First thread of the first nonempty highest
priority queue is always selected to run.It continues to execute
until it either blocks or exits.
Round Robin: First nonempty highest priority queue is located.
Each thread is run for a fixed quantum.
Default: Threads are run one after the another using time-
sliced,round robin algorithm.The quantum allocated to the
thread depends upon the priority.
Signal Handling
Signals may be generated due:
Exceptional condition occurring due to thread`s execution
such as floating-point exception which is handled by thread in
which it occurs.
External interrupts when user interrupts by hitting a key on the
keyboard.
DCE also includes POSIX sigwait and sigaction services for
signal handling.
sigwait allows the thread to block until one of the specified set of
interrupt-based signals is delivered.
sigation allows for per-thread handlers to be installed for
catching exception based signals.