Chapter 3: Processes

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
 Chapter 3: Processes
 Process Concept
 Process Scheduling
 Operations on Processes
 Interprocess Communication

Operating System Concepts – 10th Edition 3.2 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.3 Silberschatz, Galvin and Gagne ©2018
 PROCESS CONCEPT

Operating System Concepts – 10th Edition 3.4 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.5 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.6 Silberschatz, Galvin and Gagne ©2018
 Process in Memory

Stack segment
(holds the called function parameters,
local variables)

Storage for dynamically allocated

variables

Data segment
(includes global
variables, arrays, etc., you use)

Text segment
(code segment)
A process needs this to
(instructions are here)
be in memory
(address space; memory image)

Operating System Concepts – 10th Edition 3.7 Silberschatz, Galvin and Gagne ©2018
 Process: program in execution

CPU
registers

Main
Memory
PC
(RAM)

IR

CPU state
of the process
(CPU context) process address space

(currently used portion of the address space

must be in memory)

Operating System Concepts – 10th Edition 3.8 Silberschatz, Galvin and Gagne ©2018
 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
 In a single-CPU system, only one process may be in running state;
many processes may be in ready and waiting states.

Operating System Concepts – 10th Edition 3.9 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.10 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.11 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.12 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.13 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.14 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.15 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.16 Silberschatz, Galvin and Gagne ©2018
 Diagram of Process State

Operating System Concepts – 10th Edition 3.17 Silberschatz, Galvin and Gagne ©2018
 Process: program in execution
 If we have a single program running in the system, then the task of OS is
easy:
 load the program, start it and program runs in CPU
 (from time to time it calls OS to get some service done)

 But if we want to start several processes, then the running program in CPU
(current process) has to be stopped for a while and other program (process)
has to run in CPU.

 To do this switch, we have to save the state/context (register values) of the

CPU which belongs to the stopped program, so that later the stopped
program can be re-started again as if nothing has happened.

Operating System Concepts – 10th Edition 3.18 Silberschatz, Galvin and Gagne ©2018
 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
 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

Operating System Concepts – 10th Edition 3.19 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.20 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.21 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.22 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.23 Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th Edition 3.24 Silberschatz, Galvin and Gagne ©2018
 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
 See next chapter

Operating System Concepts – 10th Edition 3.25 Silberschatz, Galvin and Gagne ©2018
 PROCESS SCHEDULING

Operating System Concepts – 10th Edition 3.26 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.27 Silberschatz, Galvin and Gagne ©2018
 Ready Queue And A Wait Queue

Operating System Concepts – 10th Edition 3.28 Silberschatz, Galvin and Gagne ©2018
 Representation of Process Scheduling
 Queueing diagram represents queues, resources, flows.
 Two types of queues are present: the ready queue and a set of wait queues.
 The circles represent the resources that serve the queues, and the arrows
indicate the flow of processes in the system.
Short term (CPU)
scheduler

Operating System Concepts – 10th Edition 3.29 Silberschatz, Galvin and Gagne ©2018
 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 (the
number of processes in memory)

Short-term
scheduler
CPU
Long-term
scheduler ready queue

Main Memory
job queue
Operating System Concepts – 10th Edition 3.30 Silberschatz, Galvin and Gagne ©2018
 Schedulers- Cont.
 CPU burst: the execution of the program in CPU between two I/O requests
(i.e. time period during which the process wants to continuously run in the
CPU without making I/O)
 We may have a short or long CPU burst.
 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

Operating System Concepts – 10th Edition 3.31 Silberschatz, Galvin and Gagne ©2018
 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

Medium term Medium term

scheduler scheduler

Short term (CPU)

scheduler

Operating System Concepts – 10th Edition 3.32 Silberschatz, Galvin and Gagne ©2018
 OPERATIONS ON PROCESSES

Operating System Concepts – 10th Edition 3.33 Silberschatz, Galvin and Gagne ©2018
 Operations on Processes

 System must provide mechanisms for:

 process creation,
 process termination,
 and so on as detailed next

Operating System Concepts – 10th Edition 3.34 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.35 Silberschatz, Galvin and Gagne ©2018
 A Tree of Processes in Linux

Operating System Concepts – 10th Edition 3.36 Silberschatz, Galvin and Gagne ©2018
 Process Creation (Cont.)
 Address space Parent Child
1)
AS AS
 1) Child duplicate of parent

 2) Child has a program loaded into it Parent Child

2)
AS AS

 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

Operating System Concepts – 10th Edition 3.37 Silberschatz, Galvin and Gagne ©2018
 Process Creation (Cont.)

Operating System Concepts – 10th Edition 3.38 Silberschatz, Galvin and Gagne ©2018
 Execution Trace: fork() with execlp()

Process-Parent Process-Child
stack n y stack n 0
PC
data data
…. ….
text n=fork(); text n=fork();
If (n == 0) If (n == 0)
new code
…exec() …exec()
else if (n>0) else if (n>0)
CPU ... ...

PC PC
x pid y pid
PCB-Parent PCB-Child
sys_fork() sys_execve()
Kernel {….} {….}
RAM
Slide borrowed from Dr. İbrahim Körpeoğlu, Bilkent University
Operating System Concepts – 10th Edition 3.39 Silberschatz, Galvin and Gagne ©2018
 C
Program
Forking
Separate
Process

Operating System Concepts – 10th Edition 3.40 Silberschatz, Galvin and Gagne ©2018
 Process via Windows API
Creating a Separate

Operating System Concepts – 10th Edition 3.41 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.42 Silberschatz, Galvin and Gagne ©2018
 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);

Operating System Concepts – 10th Edition 3.43 Silberschatz, Galvin and Gagne ©2018
 Process Termination

Parent Child

fork();
….
….
….
….
….
x = wait ();
exit (code);

PCB of parent PCB of child

sys_wait() sys_exit(..)
{ {
…return(..) …
Kernel } }
Slide borrowed from Dr. İbrahim Körpeoğlu, Bilkent University
Operating System Concepts – 10th Edition 3.44 Silberschatz, Galvin and Gagne ©2018
 INTER-PROCESS
COMMUNICATION

Operating System Concepts – 10th Edition 3.45 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.46 Silberschatz, Galvin and Gagne ©2018
 Interprocess Communication
 Processes within a system may be independent or cooperating
 Cooperating processes require a facility/mechanism for interprocess
communication (IPC)
 Two models of IPC
 a) Shared memory
 b) Message passing

(a) (b)
Operating System Concepts – 10th Edition 3.47 Silberschatz, Galvin and Gagne ©2018
 Interprocess Communication – Shared Memory

 A region of shared memory is established among

two or more processes.
 Establishment of that shared region is done via the
help of the kernel (via a system call).
 Then, processes can read and write shared
Process
memory region directly as ordinary memory access A
 During this time, kernel is not involved: the shared
communication is under the control of the users
region
processes not the operating system.
 Hence it is faster than message passing. Process
 Major issues is to provide mechanism that will B
allow the user processes to synchronize their
actions when they access shared memory.
 Synchronization is discussed in great details in
Chapter 5.
Kernel

Operating System Concepts – 10th Edition 3.48 Silberschatz, Galvin and Gagne ©2018
 Producer-Consumer Problem
 Paradigm for cooperating processes, producer process produces
information that is consumed by a consumer process.
 E.g., a compiler may produce assembly code, which is consumed by
an assembler.
 E.g., client–server paradigm: a Web server produces (that is,
provides) HTML files and images, which are consumed (that is, read)
by the client Web browser requesting the resource.
 One solution to the producer–consumer problem uses shared memory:
use a buffer of items that can be filled by the producer and emptied by
the consumer.

Producer Buffer Consumer

process process

Operating System Concepts – 10th Edition 3.49 Silberschatz, Galvin and Gagne ©2018
 Producer-Consumer Problem
 Two types of buffers can be used:
 unbounded-buffer places no practical limit on the size of the buffer
 Consumer may have to wait for new items,
 Producer can always produce new items.
 bounded-buffer assumes that there is a fixed buffer size
 Consumer must wait if the buffer is empty,
 Producer must wait if the buffer is full.
 The producer and consumer must be synchronized, so that the
consumer does not try to consume an item that has not yet been
produced.

Operating System Concepts – 10th Edition 3.50 Silberschatz, Galvin and Gagne ©2018
 Buffer State in Shared Memory

item buffer[BUFFER_SIZE]

Producer Consumer

int out;
int in;

Shared Memory

Operating System Concepts – 10th Edition 3.51 Silberschatz, Galvin and Gagne ©2018
 Bounded-Buffer – Shared-Memory Solution

 Shared data
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;

item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;

 Solution is correct, but can only use BUFFER_SIZE-1 elements

Operating System Concepts – 10th Edition 3.52 Silberschatz, Galvin and Gagne ©2018
 Buffer State in Shared Memory

Buffer Full

in out
((in+1) % BUFFER_SIZE == out) : considered full buffer

Buffer Empty

in out

In == out : empty buffer

Operating System Concepts – 10th Edition 3.53 Silberschatz, Galvin and Gagne ©2018
 Producer-Consumer Code
Bounded-Buffer
item next_produced;
while (true) { Producer
/* produce an item in next produced */
while (((in + 1) % BUFFER_SIZE) == out)
; /* do nothing */
buffer[in] = next_produced;
in = (in + 1) % BUFFER_SIZE;
}

item next_consumed;
while (true) { Consumer
while (in == out)
; /* do nothing */
item
next_consumed = buffer[out];
buffer[BUFFER_SIZE];
int in = 0; out = (out + 1) % BUFFER_SIZE;
int out = 0;
/* consume the item in next consumed */
Shared Memory }

Operating System Concepts – 10th Edition 3.54 Silberschatz, Galvin and Gagne ©2018
 Interprocess Communication – Message Passing
 Mechanism for processes to communicate
and to synchronize their actions
 Message system – processes
communicate with each other without
resorting to shared variables
 Particularly useful in a distributed
environment, where the communicating
processes may reside on different
computers connected by a network
 E.g. chat program used on the World Wide
Web: chat participants communicate by
exchanging messages.

 IPC facility provides two operations:

 send(message)
 receive(message)

 The message size is either fixed or variable

Operating System Concepts – 10th Edition 3.55 Silberschatz, Galvin and Gagne ©2018
 Message Passing (Cont.)

 If processes P and Q wish to communicate, they need to:


Establish a communication link between them
 Exchange messages via send/receive
 Implementation issues:
 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?

Operating System Concepts – 10th Edition 3.56 Silberschatz, Galvin and Gagne ©2018
 Message Passing (Cont.)

 Implementation of communication link

 Physical:
 Shared memory
 Hardware bus
 Network
 Logical:
 Direct or indirect
 Synchronous or asynchronous
 Automatic or explicit buffering

Operating System Concepts – 10th Edition 3.57 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.58 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 3.59 Silberschatz, Galvin and Gagne ©2018
 Indirect Communication
 Operations
 create a new mailbox (port)
 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

Process Process

send() receive()
Mailbox
{.. {…
{ }
Kernel

Operating System Concepts – 10th Edition 3.60 Silberschatz, Galvin and Gagne ©2018
 Indirect Communication
 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.

Operating System Concepts – 10th Edition 3.61 Silberschatz, Galvin and Gagne ©2018
 Synchronization
 Message passing may be either blocking or non-blocking
 Blocking is considered synchronous
 Blocking send -- the sender is blocked until the message is
received
 Blocking receive -- the receiver is blocked until a message is
available
 Non-blocking is considered asynchronous
 Non-blocking send -- the sender sends the message and
continue
 Non-blocking receive -- the receiver receives:
 A valid message, or
 Null message
 Different combinations possible
 If both send and receive are blocking, we have a rendezvous

Operating System Concepts – 10th Edition 3.62 Silberschatz, Galvin and Gagne ©2018
 Synchronization (Cont.)

 Producer-consumer becomes trivial

message next_produced;
while (true) {
/* produce an item in next produced */
send(next_produced);
}

message next_consumed;
while (true) {
receive(next_consumed);

/* consume the item in next consumed */

}

Operating System Concepts – 10th Edition 3.63 Silberschatz, Galvin and Gagne ©2018
 Buffering

 Queue of messages attached to the link.

 implemented in one of three ways
1. Zero capacity
 No messages are queued on a link.
 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

Operating System Concepts – 10th Edition 3.64 Silberschatz, Galvin and Gagne ©2018
 End of Chapter 3

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018