Module-6 process managedf;jsovj;ksdv;sdkvnksdnvldknvlkdfsment.ppt

Processes Management
Operating System Concepts
 Process Concept
 Process Scheduling
 Operations on Processes
 Cooperating Processes
 Interprocess Communication
 Communication in Client-Server Systems

Process Concept
 An operating system executes a variety of
programs:
 Batch system – jobs
 Time-shared systems – user programs or tasks
 Textbook uses the terms job and process
almost interchangeably.
 Process – a program in execution; process
execution must progress in sequential
fashion.
 A process includes:
 program counter
 stack
 data section

Process Concept

Process State
 As a process executes, it changes state
 new: The process is being created.
 running: Instructions are being executed.
 waiting: The process is waiting for some event to occur.
 ready: The process is waiting to be assigned to a processor.
 terminated: The process has finished execution.

Diagram of Process State

Process Control Block (PCB)
Information associated with each process.
 Process state
 Program counter
 CPU registers
 CPU scheduling information
 Memory-management information
 Accounting information
 I/O status information

Process Control Block (PCB)

Context Switching
 Switching the CPU to another process
requires a state save of the current process
and a state restore of a different process.
This task is known as context switching.
 The Context of a process is saved in PCB.
 Context Switching time is pure overhead.
 Its speed varies from machine to machine
depending upon memory speed and the
number of register.

CPU Switch From Process to
Process

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.
 All the queues are implemented by linked list.
 Each queue has a header contains pointers to
the first and final PCBs.
 In turn each PCB includes a pointer field that
points to the next PCB
 Process migration between the various queues.

Ready Queue And Various I/O Device Queues

Representation of Process
Scheduling

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.

Schedulers (Cont.)
 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:
 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.

Addition of Medium Term Scheduling

Process Creation
 Parent process create children processes, which,
in turn create other processes, forming a tree of
processes.
 Resource sharing
 Parent and children share all resources.
 Children share subset of parent’s resources.
 Parent and child share no resources.
 Execution
 Parent and children execute concurrently.
 Parent waits until children terminate.

Process Creation (Cont.)
 Address space
 Child duplicate of parent.
 Child has a program loaded into it.
 UNIX examples
 fork system call creates new process
 exec system call used after a fork to replace the process’ memory
space with a new program.

System

Process Termination
 Process executes last statement and asks the
operating system to delete it (exit).
 Output data from child to parent (via wait).
 Process’ resources are deallocated by operating system.
 Parent may terminate execution of children
processes (abort).
 Child has exceeded allocated resources.
 Task assigned to child is no longer required.
 Parent is exiting.
 Operating system does not allow child to continue if its parent
terminates.
 Cascading termination.

Interprocess Communication
(IPC)
Cooperating Processes:
 Independent process cannot affect or be affected
by the execution of another process.
 Cooperating process can affect or be affected by
the execution of another process
 Advantages of process cooperation
 Information sharing
 Computation speed-up
 Modularity
 Convenience

Producer-Consumer Problem
Shared-Memory System
 Paradigm for cooperating processes, producer
process produces information that is consumed
by a consumer process.
 unbounded-buffer places no practical limit on the size of the buffer.
 bounded-buffer assumes that there is a fixed buffer size.

Bounded-Buffer – Shared-Memory Solution
 Shared data
#define BUFFER_SIZE 10
Typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
in points to the next free position
out points to the first full position
In==out (buffer is empty)
((in +1)%BUFFER_SIZE))==out(buffer full)
 Solution is correct, but can only use
BUFFER_SIZE-1 elements

Bounded-Buffer – Producer Process
item nextProduced;
while (1) {
while (((in + 1) % BUFFER_SIZE) == out)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
}

Bounded-Buffer – Consumer Process
item nextConsumed;
while (1) {
while (in == out)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
}

Message Passing Systems
 Mechanism for processes to communicate and
to synchronize their actions without sharing
memory.
 Message system – processes communicate with
each other without resorting to shared variables.
 IPC facility provides two operations:
 send(message) – message size fixed or variable
 receive(message)
 If P and Q wish to communicate, they need to:
 establish a communication link between them
 exchange messages via send/receive
 Implementation of communication link
 physical (e.g., shared memory, hardware bus)
 logical (e.g., logical properties)

Implementation Questions
 How are links established?
 Can a link be associated with more than two
processes?
 How many links can there be between every pair
of communicating processes?
 What is the capacity of a link?
 Is the size of a message that the link can
accommodate fixed or variable?
 Is a link unidirectional or bi-directional?

Direct Communication
 Processes must name each other explicitly:
 send (P, message) – send a message to process P
 receive(Q, message) – receive a message from process Q
 Properties of communication link
 Links are established automatically.
 A link is associated with exactly one pair of communicating
processes.
 Between each pair there exists exactly one link.
 The link may be unidirectional, but is usually bi-directional.

Indirect Communication
 Messages are directed and received from
mailboxes (also referred to as ports).
 Each mailbox has a unique id.
 Processes can communicate only if they share a mailbox.
 Properties of communication link
 Link established only if processes share a common mailbox
 A link may be associated with many processes.
 Each pair of processes may share several communication
links.
 Link may be unidirectional or bi-directional.

 Operations
 create a new mailbox
 send and receive messages through mailbox
 destroy a mailbox
 Primitives are defined as:
send(A, message) – send a message to
mailbox A
receive(A, message) – receive a message
from mailbox A

 Mailbox sharing
 P1, P2, and P3 share mailbox A.
 P1, sends; P2 and P3 receive.
 Who gets the message?
 Solutions
 Allow a link to be associated with at most two processes.
 Allow only one process at a time to execute a receive operation.
 Allow the system to select arbitrarily the receiver. Sender is notified
who the receiver was.

Synchronization
 Message passing may be either blocking or non-
blocking.
 Blocking is considered synchronous
 Non-blocking is considered asynchronous
 send and receive primitives may be either
blocking or non-blocking.

Buffering
 Queue of messages attached to the link;
implemented in one of three ways.
1. Zero capacity – 0 messages
Sender must wait for receiver (rendezvous).
2. Bounded capacity – finite length of n messages
Sender must wait if link full.
3. Unbounded capacity – infinite length
Sender never waits.

Threads
 A thread is a basic unit of CPU utilization; it
comprises a thread ID, a register set, and a stack.
 The thread shares its code section , data section,
and other resources with other threads belongs to
the same process.
 A heavyweight process has a single thread of
control but a lightweight process has multiple
threads of control.
Example : A word processor may have a thread for
displaying graphics, another thread for
responding key strokes from the user and a third
thread for performing spelling and grammar
checking in the back ground.

Single and Multithreaded Processes

Benefits
 Responsiveness
 Resource Sharing
 Economy
 Utilization of MP Architectures

User Threads
 Thread management done by user-level threads
library
 A user thread is normally created by a threading
library and scheduling is managed by the
threading library itself (Which runs in user mode).
All user threads belong to process that created
them.
 The advantage of user threads is that they are
portable.
 Examples
- POSIX Pthreads
- Mach C-threads

Kernel Threads
 Supported by the Kernel
 A kernel thread is created and scheduled by the
kernel. Kernel threads are often more expensive
to create than user threads and the system calls
to directly create kernel threads are very platform
specific.
 Examples
- Windows 95/98/NT/2000
- Solaris
- Tru64 UNIX
- BeOS
- Linux

Multithreading Models
 Many-to-One
 One-to-One
 Many-to-Many

Many-to-One
 Many user-level threads mapped to single kernel
thread.
 Thread management is done by the thread library
in user space.
 It is efficient
 Multiple threads are unable to run in parallel on
multiprocessor because only one thread can
access the kernel at a time.
 Used on systems that do not support kernel
threads.

Many-to-One Model

One-to-One
 Each user-level thread maps to kernel thread.
 It provides more concurrency than many-to-one
model
 The drawback of this model is to create a kernel
thread for each user thread . This is a overhead.
 Examples
- Windows 95/98/NT/2000
- OS/2

One-to-one Model

Many-to-Many Model
 Allows many user level threads to be mapped to
many kernel threads.
 Allows the operating system to create a sufficient
number of kernel threads.
 Solaris 2
 Windows NT/2000 with the ThreadFiber package

Many-to-Many Model

Threading Issues
 Semantics of fork() and exec() system calls.
Create a new thread or duplicate the process
with all thread.
 Thread cancellation
Asynchronous or Deferred
 Signal handling
Synchronous and Asynchronous signal may be
handled by default signal handler or user-
defined signal handler.
 Thread pools
A thread pool limits the number of threads that
exist at one point.
 Thread specific data
Though the all the thread share the data ,
however in some circumstance each thread
might need its own copy of certain data. We call
such data thread specific data.

Process or CPU Scheduling
 Maximum CPU utilization obtained with
multiprogramming
 CPU–I/O Burst Cycle – Process execution
consists of a cycle of CPU execution and I/O wait.
 CPU burst distribution

Alternating Sequence of CPU And I/O Bursts

Histogram of CPU-burst Times

CPU Scheduler
 Selects from among the processes in memory
that are ready to execute, and allocates the CPU
to one of them.
 CPU scheduling decisions may take place when a
process:
1. Switches from running to waiting state.
2. Switches from running to ready state.
3. Switches from waiting to ready.
4. Terminates.
 Scheduling under 1 and 4 is nonpreemptive.
 All other scheduling is preemptive.

Criteria for Judge Best Algorithm
 CPU utilization – keep the CPU as busy as
possible
 Throughput – The number of processes that
complete their execution per time unit
 Turnaround time – amount of time to
execute a particular process
 Waiting time – amount of time a process has
been waiting in the ready queue
 Response time – amount of time it takes
from when a request was submitted until the
first response is produced, not output (for
time-sharing environment)

Optimization Criteria
 Max CPU utilization
 Max throughput
 Min turnaround time
 Min waiting time
 Min response time

First-Come, First-Served (FCFS) Scheduling
Process Burst Time
P1 24
P2 3
P3 3
 Suppose that the processes arrive in the order: P1 ,
P2 , P3
The Gantt Chart for the schedule is:
 Waiting time for P1 = 0; P2 = 24; P3 = 27
 Average waiting time: (0 + 24 + 27)/3 = 17
 Implemented by FIFO queue.
P1 P2 P3
24 27 30
0

FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order
P2 , P3 , P1 .
 The Gantt chart for the schedule is:
 Waiting time for P1 = 6; P2 = 0; P3 = 3
 Average waiting time: (6 + 0 + 3)/3 = 3
 Much better than previous case.
 Convoy effect short process behind long
process
 This is a nonpreemptive algorithm.
P1
P3
P2
6
3 30
0

Shortest-Job-First (SJF)
Scheduling
 Associate with each process the length of its next
CPU burst. Use these lengths to schedule the
process with the shortest time.
 Two schemes:
 nonpreemptive – once CPU given to the process it cannot be
preempted until completes its CPU burst.
 preemptive – if a new process arrives with CPU burst length less than
remaining time of current executing process, preempt. This scheme
is know as the
Shortest-Remaining-Time-First (SRTF).
 SJF is optimal – gives minimum average waiting time for a given set of
processes.

Example of Non-Preemptive SJF
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
 SJF (non-preemptive)
 Average waiting time = (0 + 6 + 3 + 7)/4 = 4
P1 P3 P2
7
3 16
0
P4
8 12

Example of Preemptive SJF
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
 SJF (preemptive)
 Average waiting time = (9 + 1 + 0 +2)/4 = 3
P1 P3
P2
4
2 11
0
P4
5 7
P2 P1
16

Example of Preemptive SJF

Determining Length of Next CPU
Burst
 Can only estimate the length.
 Can be done by using the length of previous CPU
bursts, using exponential averaging.
:
Define
4.
1
0
,
3.
burst
CPU
next
the
for
value
predicted
2.
burst
CPU
of
lenght
actual
1.







 1
n
th
n n
t
  .
1
1 n
n
n t 


 




Prediction of the Length of the Next CPU Burst

Examples of Exponential
Averaging
  =0
 n+1 = n
 Recent history does not count.
  =1
 n+1 = tn
 Only the actual last CPU burst counts.
 If we expand the formula, we get:
n+1 =  tn+(1 - )  tn-1 + …
+(1 -  )j  tn-j + …
+(1 -  )n+1 0
 Since both  and (1 - ) are less than or equal
to 1, each successive term has less weight than
its predecessor.

Priority Scheduling
 A priority number (integer) is associated with
each process
 The CPU is allocated to the process with the
highest priority (smallest integer  highest
priority).
 Preemptive
 Non-preemptive
 SJF is a priority scheduling where priority is the
predicted next CPU burst time.
 Problem  Starvation – low priority processes
may never execute.
 Solution  Aging – as time progresses increase
the priority of the process.
 Rumor has it that, when he shut down the IBM
7094 at MIT in 1973, he found a low-priority
process that had been submitted in 1967 and
had not yet been run.

Priority Scheduling

Round Robin (RR)
 It is designed for time sharing system. It is similar
to FCFS but preemption is added.
 A small unit of time, called time quantum is
defined.
 The ready queue is treated as circular queue.
 The scheduler goes around the ready queue,
allocating the CPU to each process for a 1 time
quantum.
 After this time has elapsed, the process is
preempted and added to the end of the ready
queue.
 Performance
 q large  FIFO
 q small  q must be large with respect to context switch, otherwise

Example of RR with Time Quantum =
20
Process Burst Time
P1 53
P2 17
P3 68
P4 24
 The Gantt chart is:
 Typically, higher average turnaround than SJF, but
better response.
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162

Time Quantum and Context Switch Time

Multilevel Queue
 Ready queue is partitioned into separate queues:
foreground (interactive)
background (batch)
 Each queue has its own scheduling algorithm,
foreground – RR
background – FCFS
 Scheduling must be done between the queues.
 Fixed priority preemptive scheduling; (i.e., serve all from foreground
then from background). Possibility of starvation.
 Time slice – each queue gets a certain amount of CPU time which it
can schedule amongst its processes;

Multilevel Queue Scheduling

Multilevel Feedback Queue
 A process can move between the various queues;
aging can be implemented this way.
 Multilevel-feedback-queue scheduler defined by
the following parameters:
 number of queues
 scheduling algorithms for each queue
 method used to determine when to upgrade a process
 method used to determine when to demote a process
 method used to determine which queue a process will enter when
that process needs service

Example of Multilevel Feedback
Queue
 Three queues:
 Q0 – time quantum 8 milliseconds
 Q1 – time quantum 16 milliseconds
 Q2 – FCFS
 Scheduling
 A new job enters queue Q0 . When it gains CPU, job receives 8
milliseconds. If it does not finish in 8 milliseconds, job is moved to
queue Q1.
 At Q1 job is again served and receives 16 additional milliseconds. If
it still does not complete, it is preempted and moved to queue Q2.

Multilevel Feedback Queues

Module-6 process managedf;jsovj;ksdv;sdkvnksdnvldknvlkdfsment.ppt

More Related Content

Similar to Module-6 process managedf;jsovj;ksdv;sdkvnksdnvldknvlkdfsment.ppt (20)

More from KAnurag2 (20)

Recently uploaded (20)

Module-6 process managedf;jsovj;ksdv;sdkvnksdnvldknvlkdfsment.ppt