computer architecture and operating systems cs 3230: operating system section lecture os-4 process...
TRANSCRIPT
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--;
}