Operating Systems 6
Operating Systems 6
Lecture # 6
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
Cooperating Processes
Advantages of process cooperation
Information sharing
Computation speed-up
Modularity
Convenience
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
Bounded-Buffer Problem
Empty Pool
Producer
Producer Consumer
Consumer
Full Pool
Bounded-Buffer 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
Producer Process
item nextProduced;
while (1) {
while (((in + 1) % BUFFER_SIZE) == out)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
}
Consumer Process
item nextConsumed;
while (1) {
while (in == out)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
}
Interprocess
Communication (IPC)
Mechanism for processes to
communicate and to synchronize
their actions.
Message system – processes
communicate with each other
without resorting to shared variables.
Interprocess
Communication (IPC)
IPC facility provides two operations:
Send (message) – message size fixed
or variable
Receive (message)
Interprocess
Communication (IPC)
If P and Q wish to communicate, they
need to:
establish a communication link
between them
exchange messages via send/receive
Interprocess
Communication (IPC)
Implementation of communication link
physical (e.g., shared memory,
hardware bus)
logical (e.g., logical properties)
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?
Implementation
Questions
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
Processes must name each other
explicitly:
send (P, message) – send a message
to process P
Receive (Q, message) – receive a
message from process Q
Direct Communication
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.
Indirect Communication …
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 …
Operations
create a new mailbox
send and receive messages through
mailbox
destroy a mailbox
Primitives are defined as:
send (A, message)
receive (A, message)
Indirect Communication …
Mailbox sharing
P1, P2, and P3 share mailbox A.
P1, sends; P2 and P3 receive.
Who gets the message?
Indirect Communication …
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
Non-blocking is considered
asynchronous
send and receive primitives may be
either blocking or non-blocking.
Buffering
Queue of messages attached to the link;
implemented in one of three ways.
Zero capacity – No messages Sender must wait
for receiver
Bounded capacity – n messages
Sender must wait if link full.
Unbounded capacity – infinite length
Sender never waits.