Chapter 3:

Process Concept
 Chapter 3: Process-Concept

Process Concept
Process Scheduling
Operations on Processes
Interprocess Communication
Examples of IPC Systems
Communication in Client-Server Systems

3.2
 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

3.3
 Process Concept
 An operating system executes a variety of programs:
 Batch system – jobs

 Time-shared systems – user programs or tasks

 We use the terms job and process almost interchangeably

 Process – a program in execution; process execution must
progress in sequential fashion
 A process includes:
 program counter (Address of next instruction to execute)

 stack

 data section

3.4
Process in Memory

3.5
 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

3.6
Diagram of Process State

3.7
 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

3.8
Process Control Block (PCB)

3.9
CPU Switch From Process to Process

3.10
 Process Scheduling Queues

 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

3.11
Ready Queue And Various I/O Device Queues

3.12
Representation of Process Scheduling

3.13
 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

3.14
 Addition of Medium Term Scheduling

Mid-term scheduler

Long-term scheduler Short-term scheduler

3.15
 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

3.16
 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
 Time dependent on hardware support

3.17
 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
1. Parent and children share all resources
2. Children share subset of parent’s resources
3. Parent and child share no resources
 Execution
1. Parent and children execute concurrently
2. Parent waits until children terminate

3.18
 Process Creation (Cont)
 Address space
1. Child duplicate of parent
2. 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

3.19
Process Creation

3.20
C Program Forking Separate Process
int main()
{
pid_t pid;
/* fork another process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
exit(-1);
}
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL);
}
else { /* parent process */
/* parent will wait for the child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);
}
}
3.21
A tree of processes on a typical Solaris

3.22
 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 OS

 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

Some operating systems do not allow child to

continue if its parent terminates
– All children terminated - cascading termination
3.23
 Interprocess 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,
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
3.24
 Communications Models

Message passing Shared memory

3.25
 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

Producer Consumer

3.26
 Bounded-Buffer – Shared-Memory Solution

out
 Shared data In
#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

3.27
 Bounded-Buffer – Producer
out
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;
}

In

3.28
 Bounded Buffer – Consumer
out
while (true) {
In
while (in == out)
; // do nothing -- nothing to consume

// remove an item from the buffer

item = buffer[out];
out = (out + 1) % BUFFER SIZE;
return item;
}

3.29
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)

3.30
 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?

3.31
 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

3.32
 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

3.33
 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

3.34
 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.
3.35
 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

3.36
 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

3.37
 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);

3.38
C Program illustrating POSIX Shared-memory API

3.39
 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 communication, created via
port_allocate()

3.40
 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:

The client opens a handle to the subsystem’s connection

port object
The client sends a connection request
The server creates two private communication ports
and returns the handle of one of them to the client
The clientand server use the corresponding port handle
to send messages or callbacks and to listen for replies
3.41
Local Procedure Calls in Windows XP

3.42
Communications in Client-Server Systems

Sockets
Remote Procedure Calls
Pipes

3.43
 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

3.44
Socket Communication

3.45
 Sockets
 Java provides three different types of sockets.
Connection-oriented (TCP) sockets are
implemented with socket class.
Connectionless (UDP) sockets use the
DatagramSocket class.
The MulticastSocket class is a subclass of the
DatagramSocket class. A multicast socket allows
data to be sent to multiple recipients.
 Example: a data server uses connection-oriented
TCP sockets.
 Allows clients to request the current date and time from
the server.
3.46
Date Server

3.47
Date Client

3.48
 Date Client
 The client creates a Socket and requests a
connection with the server at IP address 127.0.0.1
on port 6013.
 The IP address 127.0.0.1 is a special address known
as the loopback, it is referring to itself. It allows a
client and server on the same host to
communicate using TCP/IP protocol.
 Socket is a low level form of communications,
allows only an unstructured stream of bytes to be
exchanged.
 Two higher-level methods: RPCs and Pipes
3.49
 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

3.50
Marshalling Parameters

3.51
Execution of
RPC

3.52
 Pipes
 A pipe allows two processes to communicate.
 One of the first IPC mechanism in early UNIX.
 Four issues must be considered to implement a pipe:
 Unidirectional or bidirectional communication ?

 If two-way, half duplex or full duplex ?

 Must a relationship (such as parent – child) exist between

the communicating processes ?
 Can the pipes communicate over a network, or just reside
on the same machine ?
 Two types of pipes
 Ordinary Pipes

 Named Pipes 3.53

 Ordinary Pipes
 Ordinary pipes allow two processes to communicate
in producer-consumer fashion.
 The producer writes to one end of the pipe (write-
end), and the consumer reads from the other end of
the pipe (read-end).
 It’s unidirectional (one way)
 On UNIX systems, ordinary pipes are constructed
using
pipe (int fd[])
 fd[]: file descriptor, fd[0]:read-end of the pipe
 Fd[1]: write-end of the pipe
3.54
 Ordinary Pipes

File descriptors for an ordinary pipe

3.55
 Ordinary Pipes
 UNIX treats a pipe as a special type of file. Pipes
can be accessed using read() and write() system
calls.
 An ordinary pipe can not be accessed from outside
the process that creates it.
 A parent process creates a pipe and uses it to
communicate with a child process it creates via
fork().
 A child process inherits open files (also pipes) from
its parent.

3.56
Ordinary Pipes in UNIX

3.57
Ordinary Pipes in UNIX

3.58
 Windows anonymous pipes
 Ordinary pipes on Windows systems are termed
anonymous pipes.
 Unidirectional, employ parent-child relationships.
 Win 32 API to create a pipe
CreatePipe()

ReadFile() and WriteFile() to read and to write

 Four parameters for CreatePipe()

 Separate handles for reading and writing

 A STARTUPINFO structure instance (to specify the child

process is to inherit the handles of the pipe)
 Pipe size (in bytes)
3.59
Windows anonymous pipes (parent process)

3.60
Windows anonymous pipes (parent process)

3.61
Windows anonymous pipes (child process)

3.62
 Named Pipes
 Ordinary pipes exist only while the processes are
communicating with one another.
 On both UNIX and Windows systems, once the
processes have finished communicating and
terminated, the ordinary pipes ceases to exist.
 Named pipes provide bidirectional communication
and no parent-child relationship.
 Once a named pipe is established, several processes
can use it for communication. Thus, a named pipe
may have several writers.
 Named pipes continue to exist after communicating
processes have finished.
3.63
 Named Pipes on UNIX Systems
 Named pipes are referred to as FIFOs in UNIX.
 Once created, they appear as typical files in the file
system.
 A FIFO is created with mkfifo() system call and
manipulated with open(), read(), write(), and close()
system calls.
 FIFOs are bidirectional with half-duplex transmission.
But only byte-oriented data may be transmitted.
 The communicating processes must on the same
machine. Sockets must be used if intermachine
communication is required.
3.64
 Named Pipes on Windows Systems
 Named pipes on Windows systems provide a richer
communication mechanism.
 Full duplex communication is allowed, and the
communicating processes may reside on different
machines.
 Byte- or message-oriented data can be transmitted.
 Named pipes are created with CreateNamePipe()
function, a client can connect to a pipe using
ConnectNamePipe().
 Communication over named pipe: ReadFile() and
WriteFile() funcitons.
3.65
 Pipes in Practice
 Pipes are used quite open in UNIX command line
environment.
 Setup a pipe between ls and more commands
(which are running as individual processes) allows
the output of ls to be delivered as the input of
more.
 A pipe can be constructed on the command line
using the “|” character.
ls | more
 Windows systems
dir | more
3.66
End of Chapter 3

摘錄自商業週刊 1297