Chapter 3: Processes

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

 Process Concept
 Process Scheduling
 Operations on Processes
 Inter-process Communication (IPC)
 Examples of IPC Systems
 Communication in Client-Server Systems

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

 Identify the separate components of a process and illustrate how they

are represented and scheduled in an operating system.
 Describe how processes are created and terminated in an operating
system, including developing programs using the appropriate system
calls that perform these operations.

Operating System Concepts – 10th Edition 3.3 Silberschatz, Galvin and Gagne ©2018
 Process Concept
 An operating system executes a variety of programs that run as a
process.
 Process – a program in execution; process execution must progress
in sequential fashion. No parallel execution of instructions of a single
process
 Program is passive entity stored on disk (executable file); process is
active
• Program becomes process when an executable file is 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.4 Silberschatz, Galvin and Gagne ©2018
 Process Structure
• 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 in Memory

Operating System Concepts – 10th Edition 3.6 Silberschatz, Galvin and Gagne ©2018
 Memory Layout of a C Program

Operating System Concepts – 10th Edition 3.7 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

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

Operating System Concepts – 10th Edition 3.9 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
execution
 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.10 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
 Explore in detail in Chapter 4

Operating System Concepts – 10th Edition 3.11 Silberschatz, Galvin and Gagne ©2018
 Process Representation in Linux
Represented by the C structure
task_struct
pid t_pid; /* process identifier */
long state; /* state of the process */
unsigned int time_slice /* scheduling information */
struct task_struct *parent; /* this process’s parent
*/
struct list_head children; /* this process’s children
*/
struct files_struct *files; /* list of open files */
struct mm_struct *mm; /* address space of this
process */

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

 Maximize CPU use, quickly switch processes onto CPU for time
sharing
 Process “gives” up then CPU under two conditions:
 I/O request
 After N units of time have elapsed (need a timer)
 Once a process gives up the CPU it is added to the “ready queue”
 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.13 Silberschatz, Galvin and Gagne ©2018
 Ready and Wait Queues

Operating System Concepts – 10th Edition 3.14 Silberschatz, Galvin and Gagne ©2018
 Representation of Process Scheduling

 Queuing diagram represents queues, resources, flows

Operating System Concepts – 10th Edition 3.15 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
 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.16 Silberschatz, Galvin and Gagne ©2018
 CPU Switch From Process to Process
A context switch occurs when the CPU switches from
one process to another.

Operating System Concepts – 10th Edition 3.17 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
pure 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.18 Silberschatz, Galvin and Gagne ©2018
 Multitasking in Mobile Systems
 Some mobile systems (e.g., early version of iOS) allow only one process to
run, others suspended
 Starting with iOS 4, it 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

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

 System must provide mechanisms for:

• Process creation
• Process termination

Operating System Concepts – 10th Edition 3.20 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.21 Silberschatz, Galvin and Gagne ©2018
 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
• Parent process calls wait()waiting for the child to terminate

Operating System Concepts – 10th Edition 3.22 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.23 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);
 If no parent waiting (did not invoke wait()) process is a zombie
 If parent terminated without invoking wait(), process is an
orphan

Operating System Concepts – 10th Edition 3.24 Silberschatz, Galvin and Gagne ©2018
 Inter process Communication (IPC)

 Processes within a system may be independent or cooperating

• Cooperating processes can affect or be affected by other processes,
including sharing data
• Independent processes cannot affect other processes
 Reasons for having cooperating processes:
• Information sharing : Since several users may be interested in the
same piece of information (for instance, a shared file), we must
provide an environment to allow concurrent access to such
information.
• Computation speedup: If we want a particular task to run faster, we
must break it into subtasks, each of which will be executing in parallel
with the others. Notice that such a speedup can be achieved only if
the computer has multiple processing cores.

Operating System Concepts – 10th Edition 3.25 Silberschatz, Galvin and Gagne ©2018
• Modularity: We may want to construct the system in a modular
fashion, dividing the system functions into separate processes or
threads.
• Convenience : Even an individual user may work on many tasks at
the same time. For instance, a user may be editing, listening to music,
and compiling in parallel.

Cooperating processes need inter process communication (IPC)

Operating System Concepts – 10th Edition 3.26 Silberschatz, Galvin and Gagne ©2018
 Communications Models
 Two models of IPC (Inter process communication)
• Shared memory
• Message passing

Shared memory Message passing

Operating System Concepts – 10th Edition 3.27 Silberschatz, Galvin and Gagne ©2018
 Shared Memory Systems
 A region of memory that is shared by cooperating processes.
An area of memory shared among the processes that wish to
communicate
 The communication is under the control of the users processes not the
operating system.
 Major issues is to provide mechanism that will allow the user processes
to synchronize their actions when they access shared memory.

Operating System Concepts – 10th Edition 3.28 Silberschatz, Galvin and Gagne ©2018
 Message Passing Systems
 Mechanism for processes to communicate and to synchronize their
actions (messages are exchanged between processes) without
sharing the same address space.
 is particularly useful in a distributed environment, where the
communicating processes may reside on different computers
connected by a network.

 Message passing facility provides two operations:

• send(message)
• receive(message)

 The message size is either fixed or variable

Operating System Concepts – 10th Edition 3.29 Silberschatz, Galvin and Gagne ©2018
 Message Passing (cont’d))
 If only fixed-sized messages can be sent, the system-level
implementation is straightforward. This restriction, however, makes
the task of programming more difficult.

 Conversely, variable-sized messages require a more complex

system-level implementation, but the programming task becomes
simpler.

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

• Establish a communication link between them
• Exchange messages via send/receive

Operating System Concepts – 10th Edition 3.30 Silberschatz, Galvin and Gagne ©2018
 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.31 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
• The link may be unidirectional, but is usually bi-
directional

Operating System Concepts – 10th Edition 3.32 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
 Operations
• create a new mailbox (port)
• send and receive messages through mailbox
• delete a mailbox
 Primitives are defined as:
• send(A, message) – send a message to mailbox A
• receive(A, message) – receive a message from mailbox A

Operating System Concepts – 10th Edition 3.33 Silberschatz, Galvin and Gagne ©2018
 Indirect Communication (cont’d)
 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.34 Silberschatz, Galvin and Gagne ©2018
 Indirect Communication Issues
 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. (Algorithm like RR)

Operating System Concepts – 10th Edition 3.35 Silberschatz, Galvin and Gagne ©2018
 Blocking and Non-blocking schemes
 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.36 Silberschatz, Galvin and Gagne ©2018
 Buffering
 Whether communication is direct or indirect, messages exchanged by
communicating processes reside in a temporary queue.
 Such queues can be implemented in three ways:
• Zero capacity – no messages are queued on a link. Sender must
wait for receiver (rendezvous)
• Bounded capacity – finite length of n messages. Sender must wait
if link is full
• Unbounded capacity – infinite length Sender never waits

Operating System Concepts – 10th Edition 3.37 Silberschatz, Galvin and Gagne ©2018
 Example of IPC Systems
 There are four different IPC systems:
• POSIX API for shared memory
• Mach operating system, which uses message passing
• Windows IPC, which uses shared memory as a
mechanism for providing certain types of message
passing.
• Pipes, one of the earliest IPC mechanisms on UNIX
systems.

Operating System Concepts – 10th Edition 3.38 Silberschatz, Galvin and Gagne ©2018
 Mach
 Mach communication is message based
• Even system calls are messages
• Each task gets two mailboxes at creation- Kernel and Notify
• Only three system calls needed for message transfer
• msg_send(), msg_receive(), msg_rpc()
• Mailboxes needed for commuication, created via
• port_allocate()
• Send and receive are flexible, for example four options if mailbox
full:
 Wait indefinitely
 Wait at most n milliseconds
 Return immediately
 Temporarily cache a message

Operating System Concepts – 10th Edition 3.39 Silberschatz, Galvin and Gagne ©2018
 Windows
 Message-passing centric via advanced local
procedure call (LPC) facility
• Only works between processes on the same system
• Uses ports (like mailboxes) to establish and maintain
communication channels
 Communication works as follows:
• The client opens a handle (an abstract reference to a resource) to
the subsystem’s connection port object.
• The client sends a connection request.
• The server creates a private communication port and returns the
handle to the client.
• The client and server use the corresponding port handle to send
messages or callbacks and to listen for replies.

Operating System Concepts – 10th Edition 3.40 Silberschatz, Galvin and Gagne ©2018
 Local Procedure Calls in Windows

Operating System Concepts – 10th Edition 3.41 Silberschatz, Galvin and Gagne ©2018
 Communications in Client-Server Systems
 Sockets
 Remote Procedure Calls
 Remote Method Invocation (Java)

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

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