Transcript Lecture OS - University of Wisconsin

Computer Architecture and
Operating Systems
CS 3230: Operating System Section
Lecture OS-4
Process Communication
Department of Computer Science and Software Engineering
University of Wisconsin-Platteville
Outlines
 Cooperating Process
 Inter-Process Communication
 Communication by Memory Sharing
Concurrency
 Multiple applications
 Multiprogramming
 Structured application
 Application can be a set of concurrent processes
 Operating-system structure
 Operating system is a set of processes or threads
Cooperating Processes
 Process Types:
 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
 Computation speed-up
• Improve performance by overlapping activities or
performing work in parallel


Enable an application to have a better program structure
as a set of cooperating processes
Information sharing
Cooperating Processes
 Cooperating issues:
 How do the processes communicate?
 How do the processes share data?
 Operating System Concerns:
 Keep track of active processes
 Allocate and de-allocate resources
 Protect data and resources
 Result of process must be independent of the speed of
execution of other concurrent processes
Process Communications
 Communication types:
 Message passing : Inter-Process Communication (IPC)
 Shared Memory
Inter-Process Communication
 Mechanism for processes to communicate
 IPC facility provides two operations:
 send (message) – message size fixed or variable
 receive (message)
 The communicating processes can be (peer to
peer) or (client-server)
 If P and Q wish to communicate, they need to:


establish a communication link between them
exchange messages via send/receive
IPC Addressing: Direct
 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
IPC Addressing: Indirect
 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
IPC Addressing: Indirect
 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
IPC Addressing: Indirect
 Mailbox sharing problem
 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
IPC Synchronization
 Process can:
 block until the message is sent/received (blocking) safer, easier to code, slower
 proceed immediately (non-blocking) - faster, harder to
code, riskier, needs OS support
 Process can:
 block until the message it sent is received (synchronous)
- easier to code, deadlock, slower
 proceed without receipt confirmation (asynchronous) faster, needs message acknowledgement
IPC Link Buffering
 Link Capacity : the number of message that can be
temporarily queued in a given link
 Zero capacity: (queue of length 0)


No messages wait
Sender must block until receiver receives the message
 Limited capacity: (queue of length n)
 If receiver’s queue is not full, new message is put on
queue, and sender can continue executing immediately
 If queue is full, sender must block until space is available
in the queue
 Unlimited capacity: (infinite queue)
 Sender can always continue
Cooperation Among Processes
by Memory Sharing
 One process is a producer of information; another
is a consumer of that information
 Processes communicate through shared variables


Producer writes data to a shared buffer
Consumer reads data from the shared buffer
 Shared buffer:
 unbounded-buffer no practical limit on the size of the
buffer
 bounded-buffer there is a fixed buffer size
 Synchronization problems
 Critical section problem (next lecture)
Example: Bounded Buffer
Shared data
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int counter = 0;
Example: Bounded Buffer
Producer process
item nextProduced;
while (1) {
while (counter == BUFFER_SIZE)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
counter++;
}
Example: Bounded Buffer
Consumer process
item nextConsumed;
while (1) {
while (counter == 0)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
}