Computer Architecture and Operating Systems

CS 3230: Operating System Section

Lecture OS-4Process 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 10typedef 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--;

}