Chapter 4: Processes

Processes
Focus :
 Process Concept
 Process Scheduling
 Operations on Processes
 Inter-process Communication
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 inter-process 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
 A process includes:
 Text section: Includes Program counter , processor registers
 Stack : contains temporary data like function parameters, return
addresses, local variables
 Data section : Contains global variables
 Heap : Contains memory dynamically allocated during run time
Structure of Process in Memory

Figure 3.1 Process in memory

Process State
 As a process executes, it changes state.
 Each process may be in one of the following 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

Figure 3.2 Diagram of process state

Process Control Block (PCB)
 Each process is represented in OS by a task
control block
 Process state : running, waiting, etc
 Program counter : address of next instruction to
be executed for this process
 CPU registers : contents of all process-centric
registers: EAX, ESI, ESP, EFLAGS, EIP, … etc
 CPU scheduling information : process priority,
scheduling queue pointers, … etc
 Memory-management information : memory
allocated to the process, segment registers,
page and segment tables… etc
 Accounting information : CPU used, clock time Figure 3.3 Process
elapsed since start, time limits, … etc Control Block
 I/O status information: – I/O devices allocated
to process, list of open files, … etc
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
 Context-switch time is overhead; the system does no
useful work while switching
Threads

 So far, we have implied that a process has a single thread of

execution. Performs only 1 task at a time.
 Consider having multiple program counters per process. Multiple
locations can execute at once. Multiple threads of control ->
threads.
Process Scheduling
 OS Objectives: To maximize CPU utilization, and, to frequently
switch among processes onto CPU for time sharing; so that users can
interact with programs.
 Process scheduler selects among available processes to be executed
on CPU.
 Single-CPU system, multi-CPU system; ?
Process Scheduling Queues
 Maintains scheduling queues of processes.
 Job queue – As the process enter the system, they are put into a
job queue, which consists of all processes in the system.
 Ready queue – set of all processes residing in main memory,
ready and waiting to execute. This queue is stored as a linked list.
 Device queues – set of processes waiting for an I/O device. Each
shared device has its associated device queue.
 Processes migrate among the various queues.
Ready Queue And Various I/O Device Queues

Figure 3.5 Ready Queue and various I/O devices

Representation of Process Scheduling

Figure 3.6 Queueing diagram representation of

process scheduling
Schedulers
 A process migrates among the various scheduling queues throughout
its lifetime. The operating system must select, for scheduling
purposes, processes from these queues in some fashion. The
selection process is carried out by the appropriate scheduler.
 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
(= Number of processes in memory i.e., in the ready queue)
 Stable degree: aver nb of process creation = aver nb of process
departure  Thus, invoked only when a process leaves the
system
 Short-term scheduler (or CPU scheduler) – selects which process
should be executed next and allocates CPU
 Sometimes the only scheduler in a system. Time-sharing systems
(UNIX, MS Windows)
 Short-term scheduler is invoked frequently (milliseconds) (must
be fast)
Addition of Medium Term Scheduling
Medium-term scheduler added in some OS in order to reduce
the degree of multi-programming (e.g. in some time-sharing
systems)
 Remove process from memory, store on disk, bring back in
from disk to continue execution: swapping
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
 Hence it is important that the long term scheduler selects a good
process mix of I/O bound and CPU bound.
 If all processes are I/O bound, the ready queue will almost always
be empty. Similarly if all processes are CPU bound, the I/O
waiting queue will be empty.
 The system with best performance will have a combination of
CPU- bound and I/O bound processes.
Answer the following in one word
1. Who is responsible for controlling degree of
multiprogramming?
2. In the context of CPU scheduling, we always want to
maximize CPU utilization and minimize ________.
Addition of Medium Term Scheduling
 Medium-term Scheduler is added in some OS in order to reduce
the degree of multiprogramming.
 It helps to remove process from memory, store on disk, bring
back in from disk to continue execution: Swapping

Figure 3.7 Addition of medium-term scheduler

 Swapping helps to improve process mix.

 Also necessary when memory needs to be freed up.
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= process state, all
register values, memory information.
 Save/restore contexts to/from PCBs when switching among
processes known as context switch.
 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.
 Typical speed is a few milliseconds depends on machine: memory
speed, number of registers, load/save instructions.
Operations on Processes
 Processes execute concurrently, are dynamically created/deleted.
 Operating systems must provide mechanisms for: Process creation and
process termination
 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
A tree of processes on a typical Solaris
Process Creation (Cont.)

 Execution options when a process creates a new

process.
 Parent and children execute concurrently.
 Parent waits until children terminate
 There are two possibilities in terms of the address
space:
 Child process is duplicate of parent process
 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
Process Creation
ess Creation in POSIX
Process Creation in UNIX

 Newly-created process is a child of the parent process

 Creates an exact copy of the process:
 Code, data, state
 Example state: file descriptors
 Parent is notified when a child terminates.
 If not, process remains a zombie
 Processes whose parent dies become children of
process with pid 1.
Process Termination
 Process executes last statement and asks the operating
system to delete it (exit)
 Output data from child to parent via wait system call.
 Process’ resources are de-allocated by operating
system
 Parent may terminate execution of children processes
for a variety of reasons, such as:
 Child has exceeded allocated resources
 Task assigned to child is no longer required
 If parent is exiting
 Some operating system do not allow child to

continue if its parent terminates.

Inter-process Communication
 Processes within a system may be independent or
cooperating
 Independent process cannot affect or be affected by the
execution of another process .
 Cooperating process can affect or be affected by other
processes, executing in the system.
 Clearly any process that shares data with other processes
is a cooperative process.
 Advantages of process cooperation
 Information sharing : Many users sharing the same file.
 Computation speed-up : multiple processing elements
 Modularity : Divide the system into separate processes.
 Convenience: same user working on many tasks
Contd..

 Cooperating processes need inter-process

communication (IPC) mechanism to exchange data
and information
 Two models of IPC :
 Shared memory: Easier to implement and faster
 Message passing: Useful for exchanging small
amounts of data
 Many OS’s implement both IPC models
Interprocess Communication

Message Passing Shared Memory

Figure 3.11 Communication models

Shared Memory
 An area of memory shared among the processes that wish to
communicate. Normally, OS prevent a process from accessing
another process’s memory. Processes can agree to remove this
restriction in shared-memory systems.
 The communication is under the control of the users processes not
the operating system.
 Application programmer explicitly writes the code for sharing
memory .Processes ensure that they are not writing to the same
location simultaneously.
 Major issues is to provide mechanism that will allow the user
processes to synchronize their actions when they access shared
memory.
 Solution to the producer-consumer problem.
 Producer-Consumer Problem
 Paradigm for cooperating processes, producer process
produces information that is consumed by a consumer
process. Example : Compiler-Assembler-loader
 Avail a buffer of items that can be filled by the producer and
emptied by the consumer. The buffer will reside in a region
of memory that is shared by producer and consumer. Two
types of buffers can be used:
 unbounded-buffer places no practical limit on the size
of the buffer.
 bounded-buffer assumes that there is a fixed buffer
size.
SM: Bounded-Buffer – Solution
 Shared data – buffer implemented as a circular array
#define BUFFER_SIZE 10
typedef struct {
..
} item; // item to be produced/consumed
item buffer[BUFFER_SIZE]; //shared buffer
int in = 0; //producer produces an item into in
int out = 0; //consumer consumes an item from out
 Solution is correct, but can only use BUFFER_SIZE-1
elements.
 Empty if in == out and Full if ((in + 1) % BUFFER_SIZE) =
out
Message Passing
 Message system – processes communicate with each other and
synchronize their actions.
 It is very useful when communicating processes are in different
computers.
 Message passing 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 : shared memory, hardware bus, network
 logical
Contd..
Here are different methods for logically implementing a link and
send() and receive() operations.
i) Direct or indirect communication
ii) Synchronous or asynchronous communication
iii) Automatic or explicit buffering
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
 Direct communication schemes
 Symmetry: both sender and receiver must name the other to
communicate
 Asymmetry: only the sender names the recipient
 Symmetry :Processes must name each other explicitly:
 send (P, message) – send a message to process P
 receive(Q, message) – receive message from process Q
 Asymmetry : Only the sender names the recipient. In this
scheme the primitives are defined as
 send (P, message) – send a message to process P
 receive(id, message) – receive message from any process.
 Kkk
Contd…

 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
Indirect Communication
 OS provides operations allowing a process to :
 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
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.
Synchronization

 Message passing may be either blocking or non-

blocking
 Blocking is considered synchronous
 Blocking send has the sender block until the
message is received by the mailbox.
 Blocking receive has the receiver block until
a message is available.
 Non-blocking is considered asynchronous
 Non-blocking send has the sender send the
message and continue
 Non-blocking receive has the receiver
receive a valid message or null
Buffering

 Messages exchanged by communicating processes

reside in a temporary queue. Such queues can be
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
Questions …..?