Chapter 3: Processes

Operating System Concepts – 8th Edition Silberschatz, Galvin and Gagne ©2009
 Chapter 3: Processes
■ Process Concept
■ Process Scheduling APPLICATIONS
■ Operations on Processes
■ Inter-process
Communication
■ Examples of IPC Systems
OPERATING SYSTEM
■ Communication in Client-
Server Systems

COMPUTER HARDWARE

Operating System Concepts – 8th Edition 3.2 Silberschatz, Galvin and Gagne ©2009
 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 describe communication in
client-server systems

Operating System Concepts – 8th Edition 3.3 Silberschatz, Galvin and Gagne ©2009
 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
■ Process – a program in
PROCESS B
execution; process execution
printer.exe
must progress in sequential
fashion WIFI.exe

■ A process includes:
● program counter A.exe
● stack B.exe
● data section C.DAT

Operating System Concepts – 8th Edition 3.4 Silberschatz, Galvin and Gagne ©2009
 The Process
■ Multiple parts Process in Memory
● The program code, also called text section
● Current activity including program counter, processor
registers
● Stack containing temporary data

4 Function parameters, return addresses, local

variables
● Data section containing global variables

● Heap containing memory dynamically allocated during

run time
■ Program is passive entity, 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 – 8th Edition 3.5 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 3.6 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.7 Silberschatz, Galvin and Gagne ©2009
 CPU Switch From Process to Process

Operating System Concepts – 8th Edition 3.8 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.9 Silberschatz, Galvin and Gagne ©2009
 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 pro */

Operating System Concepts – 8th Edition 3.10 Silberschatz, Galvin and Gagne ©2009
 Ready Queue And Various
I/O Device Queues

Operating System Concepts – 8th Edition 3.11 Silberschatz, Galvin and Gagne ©2009
 Representation of Process Scheduling

Operating System Concepts – 8th Edition 3.12 Silberschatz, Galvin and Gagne ©2009
 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
● Sometimes the only
scheduler in a system

Operating System Concepts – 8th Edition 3.13 Silberschatz, Galvin and Gagne ©2009
 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
Operating System Concepts – 8th Edition 3.14 Silberschatz, Galvin and Gagne ©2009
 Addition of Medium Term Scheduling

Operating System Concepts – 8th Edition 3.15 Silberschatz, Galvin and Gagne ©2009
 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 -> 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 – 8th Edition 3.16 Silberschatz, Galvin and Gagne ©2009
 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
● 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

Operating System Concepts – 8th Edition 3.17 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 3.18 Silberschatz, Galvin and Gagne ©2009
 Process Creation

Operating System Concepts – 8th Edition 3.19 Silberschatz, Galvin and Gagne ©2009
 C Program Forking Separate Process
#include <sys/types.h>
#include <studio.h>
#include <unistd.h>
int main()
{
pid_t pid;
/* fork another process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
return 1;
}
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL);
}
else { /* parent process */
/* parent will wait for the child */
wait (NULL);
printf ("Child Complete");
}
return 0;
Operating System Concepts – 8th Edition } 3.20 Silberschatz, Galvin and Gagne ©2009
 A Tree of Processes on Solaris

Operating System Concepts – 8th Edition 3.21 Silberschatz, Galvin and Gagne ©2009
 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

● If parent is exiting

4 Some operating systems do not allow child to continue if its parent

terminates
– All children terminated - cascading termination

Operating System Concepts – 8th Edition 3.22 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 3.23 Silberschatz, Galvin and Gagne ©2009
 Communications Models

Operating System Concepts – 8th Edition 3.24 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.25 Silberschatz, Galvin and Gagne ©2009
 Producer-Consumer Problem

■ 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

Operating System Concepts – 8th Edition 3.26 Silberschatz, Galvin and Gagne ©2009
 Bounded-Buffer –
Shared-Memory Solution

■ Shared data

#define BUFFER_SIZE 10
typedef struct {
...
} item;
producer consumer
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
■ Solution is correct, but can only use BUFFER_SIZE-1 elements

Operating System Concepts – 8th Edition 3.27 Silberschatz, Galvin and Gagne ©2009
 Bounded-Buffer – Producer

producer consumer
while (true) {
/* Produce an item */
while (((in = (in + 1) % BUFFER SIZE count) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER SIZE;
}

Operating System Concepts – 8th Edition 3.28 Silberschatz, Galvin and Gagne ©2009
 Bounded Buffer – Consumer

producer consumer
while (true) {
while (in == out)
; // do nothing -- nothing to consume
// remove an item from the buffer
item = buffer[out];
out = (out + 1) % BUFFER SIZE;
return item;
}

Operating System Concepts – 8th Edition 3.29 Silberschatz, Galvin and Gagne ©2009
 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
■ 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)

Operating System Concepts – 8th Edition 3.30 Silberschatz, Galvin and Gagne ©2009
 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?

Operating System Concepts – 8th Edition 3.31 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.32 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.33 Silberschatz, Galvin and Gagne ©2009
 Indirect Communication
■ 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

Operating System Concepts – 8th Edition 3.34 Silberschatz, Galvin and Gagne ©2009
 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 – 8th Edition 3.35 Silberschatz, Galvin and Gagne ©2009
 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
● 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

Operating System Concepts – 8th Edition 3.36 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 3.37 Silberschatz, Galvin and Gagne ©2009
 Examples of IPC Systems - POSIX
■ POSIX Shared Memory
● Process first creates shared memory segment
segment id = shmget(IPC PRIVATE, size, S IRUSR | S
IWUSR);
● Process wanting access to that shared memory must attach to it
shared memory = (char *) shmat(id, NULL, 0);
● Now the process could write to the shared memory
sprintf(shared memory, "Writing to shared memory");
● When done a process can detach the shared memory from its address
space
shmdt(shared memory);

Operating System Concepts – 8th Edition 3.38 Silberschatz, Galvin and Gagne ©2009
 Examples of IPC Systems - 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()

Operating System Concepts – 8th Edition 3.39 Silberschatz, Galvin and Gagne ©2009
 Examples of IPC Systems – Windows XP

■ Message-passing centric via 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:

4 The client opens a handle to the subsystem’s connection port object.

4 The client sends a connection request.
4 The server creates two private communication ports and returns the
handle to one of them to the client.
4 The client and server use the corresponding port handle to send
messages or callbacks and to listen for replies.

Operating System Concepts – 8th Edition 3.40 Silberschatz, Galvin and Gagne ©2009
 Local Procedure Calls in Windows XP

Operating System Concepts – 8th Edition 3.41 Silberschatz, Galvin and Gagne ©2009
 Communications in Client-Server Systems

■ Sockets

■ Remote Procedure Calls

■ Pipes

■ Remote Method Invocation (Java)

Operating System Concepts – 8th Edition 3.42 Silberschatz, Galvin and Gagne ©2009
 Sockets
■ A socket is defined as an endpoint for communication

■ Concatenation of IP address and port

■ The socket 161.25.19.8:1625 refers to port 1625 on host 161.25.19.8

■ Communication consists between a pair of sockets

Operating System Concepts – 8th Edition 3.43 Silberschatz, Galvin and Gagne ©2009
 Socket Communication

Operating System Concepts – 8th Edition 3.44 Silberschatz, Galvin and Gagne ©2009
 Remote Procedure Calls
■ Remote procedure call (RPC) abstracts procedure calls between processes on
networked systems

■ Stubs – client-side proxy for the actual procedure on the server

■ The client-side stub locates the server and marshalls the parameters

■ The server-side stub receives this message, unpacks the marshalled

parameters, and performs the procedure on the server

Operating System Concepts – 8th Edition 3.45 Silberschatz, Galvin and Gagne ©2009
 Execution of RPC

Operating System Concepts – 8th Edition 3.46 Silberschatz, Galvin and Gagne ©2009
 Pipes
■ Acts as a conduit allowing two processes to communicate

■ Issues
● Is communication unidirectional or bidirectional?

● In the case of two-way communication, is it half or full-duplex?

● Must there exist a relationship (i.e. parent-child) between the
communicating processes?
● Can the pipes be used over a network?

Operating System Concepts – 8th Edition 3.47 Silberschatz, Galvin and Gagne ©2009
 Ordinary Pipes
■ Ordinary Pipes allow communication in standard producer-consumer style

■ Producer writes to one end (the write-end of the pipe)

■ Consumer reads from the other end (the read-end of the pipe)

■ Ordinary pipes are therefore unidirectional

■ Require parent-child relationship between communicating processes

Operating System Concepts – 8th Edition 3.48 Silberschatz, Galvin and Gagne ©2009
 Ordinary Pipes

Operating System Concepts – 8th Edition 3.49 Silberschatz, Galvin and Gagne ©2009
 Named Pipes
■ Named Pipes are more powerful than ordinary pipes

■ Communication is bidirectional

■ No parent-child relationship is necessary between the communicating processes

■ Several processes can use the named pipe for communication

■ Provided on both UNIX and Windows systems

Operating System Concepts – 8th Edition 3.50 Silberschatz, Galvin and Gagne ©2009
 End of Chapter 3

Operating System Concepts – 8th Edition Silberschatz, Galvin and Gagne ©2009
 Exercise
■ What output will be at Line A?

Operating System Concepts – 8th Edition 3.52 Silberschatz, Galvin and Gagne ©2009
 Exercise
#include <sys/types.h> ■ When the state of the
#include <studio.h>
#include <unistd.h> process is terminated, how
many times has this
int main(int argc, char** argv) process waited in the
{ waiting queue? Please
int i = 0;
explain your solution.
printf(“Hello\n");
for( i = 0; i < 5; i++) {
if( i % 2 != 0) {
printf(“new line %d\n”, i);
}
}
printf(“Bye\n");
exit(0);
}

Operating System Concepts – 8th Edition 3.53 Silberschatz, Galvin and Gagne ©2009
 Exercise
#include <sys/types.h>
#include <studio.h> ■ How many processes
#include <unistd.h> are created in total
int main (int argc, char **argv) after this program has
{
executed (including the
int pid;
printf(“Parent \n”); original process)?
pid = fork(); Please explain your
if (pid > 0){ solution by using
printf(“Parent \n”); process tree
}
else if (pid == 0)
{
printf(“Child \n”);
}
}

Operating System Concepts – 8th Edition 3.54 Silberschatz, Galvin and Gagne ©2009
 Homework
■ 3.2 page 149
■ 3.5 page 150
■ 3.12 – 3.14 page 151 – 152
■ 3.17 pages 153

■ Paper submission due to next class

Operating System Concepts – 8th Edition 3.55 Silberschatz, Galvin and Gagne ©2009