PCC-IT303 Operating Systems

Unit 2
Process Management,
Process Communication and Synchronization

by
Dr. Arati K Manjaramkar
Asst. Professor
Dept. of Information Technology
SGGSIE&T
 Chapter 2: Process Management

• Process Management:
• Process,
• Process description,
• Process states,
• Process control,
• Threads,
• Processes and Threads,
• Uniprocessor Scheduling: Types of scheduling, CPU
scheduling algorithms: FCFS, SJF, Priority, Round Robin,
Scheduling,
• Thread Scheduling,
• Multiprocessor Scheduling concept,
• Real Time Scheduling concept.
Objectives

• To introduce the notion of a process -- a program in

execution, which forms the basis of all computation

• To describe the various features of processes,

including scheduling, creation and termination, and
communication

• To explore interprocess communication using shared

memory and message passing
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
• Multiple parts
The program code, also called text section
Current activity including program counter, processor registers
Stack containing temporary data
Function parameters, return addresses, local variables
Data section containing global variables
Heap containing memory dynamically allocated during run time
 Process Concept (Cont.)

• Program is passive entity stored on disk (executable

file), process is active
• Program becomes process when executable file loaded
into memory
• Execution of program started via GUI mouse clicks,
command line entry of its name, etc
• One program can be several processes
• Consider multiple users executing the same program
Process in Memory
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
• (also called task control block)
• Process state – running, waiting, etc
• Program counter – location of instruction to
next execute
• CPU registers – contents of all process-centric
registers, accumulators, index registers, stack
pointers, and general-purpose registers
• CPU scheduling information- priorities,
scheduling queue pointers
• Memory-management information – memory
allocated to the process
• Accounting information – CPU used, clock
time elapsed since start, time limits
• I/O status information – I/O devices allocated
to process, list of open files
CPU Switch From Process to Process
 Threads

So far, process has a single thread of execution

Consider having multiple program counters per process
Multiple locations can execute at once
Multiple threads of control -> threads
Must then have storage for thread details, multiple
program counters in PCB
 Process Scheduling

• Maximize CPU use, quickly switch processes onto

CPU for time sharing
• Process scheduler selects among available processes
for next execution on CPU
• Maintains scheduling queues of processes
• Job queue – set of all processes in the system
• Ready queue – set of all processes residing in main
memory, ready and waiting to execute
• Device queues – set of processes waiting for an I/O
device
• Processes migrate among the various queues
Ready Queue And Various I/O Device Queues
Representation of Process Scheduling

Queueing diagram represents queues, resources, flows

Schedulers
• Short-term scheduler (or CPU scheduler) – selects which process should be executed next
and allocates CPU
Sometimes the only scheduler in a system
Short-term scheduler is invoked frequently (milliseconds)  (must be fast)
• Long-term scheduler (or job scheduler) – selects which processes should be brought into
the ready queue
Long-term scheduler is invoked 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
• Long-term scheduler strives for good process mix
 Addition of Medium Term Scheduling
Medium-term scheduler can be added if degree of multiple programming
needs to decrease
Remove process from memory, store on disk, bring back in from disk
to continue execution: swapping
 Multitasking in Mobile Systems

• Some mobile systems (e.g., early version of iOS) allow only

one process to run, others suspended
• Due to screen real estate, user interface limits iOS provides for a
• Single foreground process- controlled via user interface
• Multiple background processes– in memory, running, but not on the
display, and with limits
• Limits include single, short task, receiving notification of events,
specific long-running tasks like audio playback
• Android runs foreground and background, with fewer limits
• Background process uses a service to perform tasks
• Service can keep running even if background process is suspended
• Service has no user interface, small memory use
Context Switch

• 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 via a context switch
• Context of a process represented in the PCB
• Context-switch time is overhead; the system does no
useful work while switching
• The more complex the OS and the PCB ➔ the longer
the context switch
• Time dependent on hardware support
• Some hardware provides multiple sets of registers per
CPU ➔ multiple contexts loaded at once
Operations on Processes

System must provide mechanisms for:

process creation,
process termination,
and so on …
 Two-State Process Model

Dispatch

Enter Not Exit

Running Running

Pause

(a) State transition diagram

 Pause

(a) State transition diagram

Queue
Enter Dispatch Exit
Processor

Pause

(b) Queuing diagram

Figure 3.5 Two-State Process Model

Table : Reasons for Process Creation
 Process Creation

Process Parent
spawning Child process
process
• when the • is the • is the new
OS creates a original, process
process at creating,
the explicit process
request of
another
process
Process Creation

• Parent process create children processes, which, in

turn create other processes, forming a tree of
processes
• Generally, process identified and managed via a
process identifier (pid)
• Resource sharing options
• Parent and children share all resources
• Children share subset of parent’s resources
• Parent and child share no resources
• Execution options
• 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
C Program Forking Separate Process
 Process Termination

• Process executes last statement and then asks the

operating system to delete it using the exit() system
call.
Returns status data from child to parent (via wait())
Process’ resources are deallocated by operating system
• Parent may terminate the execution of children
processes using the abort() system call. Some
reasons for doing so:
Child has exceeded allocated resources
Task assigned to child is no longer required
The parent is exiting and the operating systems does not
allow a child to continue if its parent terminates
Process Termination

• Some operating systems do not allow child to exists if its

parent has terminated. If a process terminates, then all its
children must also be terminated.
• cascading termination. All children, grandchildren, etc. are
terminated.
• The termination is initiated by the operating system.
• The parent process may wait for termination of a child process
by using the wait()system call. The call returns status
information and the pid of the terminated process
pid = wait(&status);
• If no parent waiting (did not invoke wait()) process is a
zombie
• If parent terminated without invoking wait , process is an
orphan
 Normal completion The process executes an OS service call to indicate that it has completed
running.

Time limit exceeded The process has run longer than the specified total time limit. There are a
number of possibilities for the type of time that is measured. These include total
elapsed time ("wall clock time"), amount of time spent executing, and, in the
case of an interactive process, the amount of time since the user last provided
any input.

Table : Memory unavailable The process requires more memory than the system can provide.

Reasons for Bounds violation The process tries to access a memory location that it is not allowed to access.

Process Protection error The process attempts to use a resource such as a file that it is not allowed to use,
or it tries to use it in an improper fashion, such as writing to a read-only file.

Termination Arithmetic error The process tries a prohibited computation, such as division by zero, or tries to
store numbers larger than the hardware can accommodate.

Time overrun The process has waited longer than a specified maximum for a certain event to
occur.

I/O failure An error occurs during input or output, such as inability to find a file, failure to
read or write after a specified maximum number of tries (when, for example, a
defective area is encountered on a tape), or invalid operation (such as reading
from the line printer).

Invalid instruction The process attempts to execute a nonexistent instruction (often a result of
branching into a data area and attempting to execute the data).

Privileged instruction The process attempts to use an instruction reserved for the operating system.

Data misuse A piece of data is of the wrong type or is not initialized.

Operator or OS intervention For some reason, the operator or the operating system has terminated the process
(e.g., if a deadlock exists).

Parent termination When a parent terminates, the operating system may automatically terminate all
(Table is located on page 115 of the offspring of that parent.
in the Stalling’s textbook)
Parent request A parent process typically has the authority to terminate any of its offspring.
Five-State Process Model

Dispatch
Admit Release
New Ready Running Exit
Timeout

Event
Occurs Event
Wait

Blocked

Figure 3.6 Five-State Process Model

 Process A

Process B

Process C

Dispatcher

0 5 10 15 20 25 30 35 40 45 50

= Running = Ready = Blocked

Figure 3.7 Process States for Trace of Figure 3.4

 Ready Queue Release
Admit Dispatch
Processor

Timeout

Blocked Queue
Event Event Wait
Occurs
(a) Single blocked queue

Ready Queue Release

Admit Dispatch
Processor

Timeout

Event 1 Queue
Event 1 Event 1 Wait
Occurs

Event 2 Queue
Event 2 Event 2 Wait
Occurs

Event n Queue
Event n Event n Wait
Occurs

(b) Multiple blocked queues

Figure 3.8 Queuing Model for Figure 3.6

Suspended Processes

Swapping
involves moving part of all of a process from main memory to disk

when none of the processes in main memory is in the Ready state, the OS
swaps one of the blocked processes out on to disk into a suspend queue
 (a) With One Suspend State

New

Ad
t
Dispatch
mi
Admit Release

mi
Ad
New Ready Suspend Running Exit

t
Timeout
Activate Dispatch
Ready/ Release

it
Ready Running Exit

Occurs Occurs

a
e

Event Event
at

tW
Suspend
iv

Suspend Timeout
ct

t W ve n
A

t
ai
Occurs
Event

Suspend

en
Suspend Blocked

Ev
Activate
Blocked/
Suspend (a)Blocked
With One Suspend State
Suspend

(b) With Two Suspend States

New

Figure 3.9 Process State Transition Diagram with Suspend States

Ad
t
mi

mi
Ad

Suspe
t

nd
 (a) With One Suspend State

New

Ad
t
mi

mi
Ad

Suspe

t
nd

Activate Dispatch
Ready/ Release
Suspend Ready Running Exit
Suspend Timeout
t
ai
Occurs

Occurs
W
Event

Event

ent
E v

Activate
Blocked/
Suspend
Blocked
Suspend

(b) With Two Suspend States

Figure 3.9 Process State Transition Diagram with Suspend States

Characteristics of a Suspended Process
•The process is not immediately available for execution
•The process was placed in a suspended state by an agent: either
itself, a parent process, or the OS, for the purpose of preventing
its execution

•The process may or may not be waiting on an event

•The process may not be removed from this state until the
agent explicitly orders the removal
Table : Reasons for Process Suspension
 Multiprocess Architecture – Chrome Browser

• Many web browsers ran as single process (some still do)

• If one web site causes trouble, entire browser can hang or crash
• Google Chrome Browser is multiprocess with 3 different types
of processes:
• Browser process manages user interface, disk and network I/O
• Renderer process renders web pages, deals with HTML,
Javascript. A new renderer created for each website opened
• Runs in sandbox restricting disk and network I/O, minimizing effect of
security exploits
• Plug-in process for each type of plug-in
 Interprocess Communication
• Processes within a system may be independent or cooperating
• Cooperating process can affect or be affected by other processes,
including sharing data
• Reasons for cooperating processes:
• Information sharing
• Computation speedup
• Modularity
• Convenience
• Cooperating processes need interprocess communication
(IPC)
• Two models of IPC
• Shared memory
• Message passing
Communications Models
(a) Message passing. (b) shared memory.
 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
CPU Scheduling

Basic Concepts
Scheduling Criteria
Scheduling Algorithms
Thread Scheduling
Multiple-Processor Scheduling
Real-Time CPU Scheduling
Operating Systems Examples
Algorithm Evaluation
Basic Concepts

• 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 followed by I/O burst
• CPU burst distribution is of main
concern
Histogram of CPU-burst Times
CPU Scheduler

Short-term scheduler selects from among the processes in

ready queue, and allocates the CPU to one of them
Queue may be ordered in various ways
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
Consider access to shared data
Consider preemption while in kernel mode
Consider interrupts occurring during crucial OS activities
Dispatcher

Dispatcher module gives control of the CPU to the

process selected by the short-term scheduler; this
involves:
switching context
switching to user mode
jumping to the proper location in the user program to
restart that program
Dispatch latency – time it takes for the dispatcher to
stop one process and start another running
 Scheduling Criteria

• CPU utilization – keep the CPU as busy as possible

• Throughput – # 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)
Scheduling Algorithm Optimization Criteria

• Max CPU utilization

• Max throughput
• Min turnaround time
• Min waiting time
• Min response time
Scheduling Algorithms
• To decide which process to execute first and which process to
execute last to achieve maximum CPU utilization, computer
scientists have defined some algorithms, they are:

o First Come First Serve (FCFS) Scheduling

o Shortest-Job-First (SJF) Scheduling
o Priority Scheduling
o Round Robin (RR) Scheduling
o Multilevel Queue Scheduling
o Multilevel Feedback Queue Scheduling
 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:

P1 P2 P3
0 24 27 30

Waiting time for P1 = 0; P2 = 24; P3 = 27

Average waiting time: (0 + 24 + 27)/3 = 17
 FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order:
P2 , P3 , P1
The Gantt chart for the schedule is:

P2 P3 P1
0 3 6 30

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

** To avoid Convoy Effect,

preemptive scheduling algorithms like Round Robin Scheduling can be used – as the
smaller processes don’t have to wait much for CPU time – making their execution faster
and leading to less resources sitting idle.
FCFS Scheduling (Cont.)
FCFS Scheduling (Cont.)
Problems with FCFS Scheduling
• Below we have a few shortcomings or problems with the
FCFS scheduling algorithm:
• It is Non Pre-emptive algorithm, which means the process
priority doesn't matter. If a process with very least priority is
being executed, more like daily routine backup process,
which takes more time, and all of a sudden some other high
priority process arrives, like interrupt to avoid system crash,
the high priority process will have to wait, and hence in this
case, the system will crash, just because of improper process
scheduling.
• Not optimal Average Waiting Time.
• Resources utilization in parallel is not possible, which leads
to Convoy Effect, and hence poor resource (CPU, I/O etc)
utilization.
 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
SJF is optimal – gives minimum average waiting time for a given
set of processes
• The difficulty is knowing the length of the next CPU
request
• Could ask the user
Example of SJF
ProcessArrival Time Burst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3

SJF scheduling chart

P4 P1 P3 P2
0 3 9 16 24

Average waiting time = (3 + 16 + 9 + 0) / 4 = 7

 Example of Shortest-remaining-time-first
Now we add the concepts of varying arrival times and preemption to the
analysis
ProcessAarri Arrival TimeTBurst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
Preemptive SJF Gantt Chart
P1 P2 P4 P1 P3
0 1 5 10 17 26

Average waiting time = [(10-1)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5 msec

 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
Nonpreemptive

SJF is priority scheduling where priority is the inverse of

predicted next CPU burst time

Problem  Starvation – low priority processes may never execute

(Statistically assigned)

Solution  Aging – as time progresses increase the priority of the

process that wait in ready queue for long time (Dynamically
assigned by OS)
 Example of Priority Scheduling

ProcessA arri Burst TimeT Priority

P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2

Priority scheduling Gantt Chart

Average waiting time = 8.2 msec

Round Robin (RR)

• Each process gets a small unit of CPU time (time quantum q),
usually 10-100 milliseconds. After this time has elapsed, the
process is preempted and added to the end of the ready queue.
• 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 at once. No process waits more
than (n-1)q time units.
• Timer interrupts every quantum to schedule next process
• Performance
• q large  FIFO
• q small  q must be large with respect to context switch, otherwise
overhead is too high
 Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
The Gantt chart is:

P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30

Typically, higher average turnaround than SJF, but better response

q should be large compared to context switch time
q usually 10ms to 100ms, context switch < 10 usec
Time Quantum and Context Switch Time
 Multilevel Queue

Ready queue is partitioned into separate queues, eg:

foreground (interactive)
background (batch)
Process permanently in a given queue
Each queue has its own scheduling algorithm:
foreground – RR
background – FCFS
Scheduling must be done between the queues:
Fixed priority 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; i.e., 80% to foreground in RR 20% to
background in FCFS
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 – RR with time quantum 8 milliseconds
Q1 – RR time quantum 16 milliseconds
Q2 – FCFS

Scheduling
A new job enters queue Q0 which is served
FCFS
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 FCFS and receives
16 additional milliseconds
If it still does not complete, it is preempted
and moved to queue Q2
Thread Scheduling

• Distinction between user-level and kernel-level threads

• When threads supported, threads scheduled, not processes
• Many-to-one and many-to-many models, thread library
schedules user-level threads to run on LWP
• Known as process-contention scope (PCS) since
scheduling competition is within the process
• Typically done via priority set by programmer
• Kernel thread scheduled onto available CPU is system-
contention scope (SCS) – competition among all threads in
system
 Multiple-Processor Scheduling

• CPU scheduling more complex when multiple CPUs are available

• Homogeneous processors within a multiprocessor
• Asymmetric multiprocessing – only one processor accesses the
system data structures, alleviating the need for data sharing
• Symmetric multiprocessing (SMP) – each processor is self-
scheduling, all processes in common ready queue, or each has its
own private queue of ready processes
• Currently, most common
• Processor affinity – process has affinity for processor on which it
is currently running
• soft affinity
• hard affinity
• Variations including processor sets
 Multiple-Processor Scheduling – Load Balancing

• If SMP, need to keep all CPUs loaded for efficiency

• Load balancing attempts to keep workload evenly
distributed
• Push migration – periodic task checks load on each
processor, and if found pushes task from overloaded CPU
to other CPUs
• Pull migration – idle processors pulls waiting task from
busy processor
 Multicore Processors

• Recent trend to place multiple processor cores on

same physical chip
• Faster and consumes less power
• Multiple threads per core also growing
• Takes advantage of memory stall to make progress on
another thread while memory retrieve happens
 Real-Time CPU Scheduling

Can present obvious challenges

Soft real-time systems – no guarantee as to
when critical real-time process will be
scheduled
Hard real-time systems – task must be
serviced by its deadline
Two types of latencies affect performance
1. Interrupt latency – time from
arrival of interrupt to start of
routine that services interrupt
2. Dispatch latency – time for schedule
to take current process off CPU and
switch to another
 Real-Time CPU Scheduling (Cont.)

Conflict phase of dispatch

latency:
1. Preemption of any process
running in kernel mode
2. Release by low-priority
process of resources needed
by high-priority processes
 Priority-based Scheduling
• For real-time scheduling, scheduler must support preemptive,
priority-based scheduling
But only guarantees soft real-time

• For hard real-time must also provide ability to meet deadlines

• Processes have new characteristics: periodic ones require
CPU at constant intervals
Has processing time t, deadline d, period p
0≤t≤d≤p
Rate of periodic task is 1/p
Virtualization and Scheduling
Virtualization software schedules multiple guests onto CPU(s)
Each guest doing its own scheduling
Not knowing it doesn’t own the CPUs
Can result in poor response time
Can effect time-of-day clocks in guests
Can undo good scheduling algorithm efforts of guests