The document discusses interprocess communication (IPC) in systems, focusing on shared memory and message passing models. It outlines the advantages and reasons for process cooperation, including information sharing and speedup, and details on producer-consumer problems in IPC. Additionally, it explains methods of synchronization, different types of communication links, and the mechanisms behind message passing.

1. Amrita
School
of
Engineering,
Bangalore
Ms. Harika Pudugosula
Teaching Assistant
Department of Electronics & Communication Engineering

2. 2
 Operation on Procesess
 Process Creation
 Process Termination
 Interprocess Communication - Introduction

3. 3
 Interprocess Communication
 Shared - Memory Systems
 Message - Passing Systems
• Naming
• Synchronization
• Buffering

4. 4
Interprocess Communication
• Processes within a system may be independent or cooperating
• Independent process does not affect and does not get affected by other
process, they don’t share data
• Cooperating process can affect or be affected by other processes,
including sharing data
• Reasons and Advantages of process cooperation
• Information sharing - allow concurrent access of shared files
• Computation speedup - execution of process in parallel fashion
• Modularity - construct the system in a modular fashion
• Convenience - compilation of files in parallel

5. 5
Interprocess Communication
• Cooperating processes need
interprocess communication
(IPC)
• Two models of IPC
• Shared memory systems
• Message passing systems
fig: Communications models. (a) Message passing. (b)
Shared memory

6. Interprocess Communication

7. 7
Interprocess Communication
Shared - Memory Systems
• IPC using shared memory requires communicating processes to
establish a region of shared memory
• Shared-memory region lies in the address space of the process
creating the shared-memory segment
• What happens if other processes wishes to communicate ?

8. Producer-Consumer Problem
• Paradigm for cooperating processes, producer process produces
information that is consumed by a consumer process
• For example, a compiler may produce assembly code that is
consumed by an assembler, client–server paradigm, printer - printer
driver
• Producer - Consumer processes runs concurrently and must be
synchronized
• buffer will reside in a region of memory that is shared by the producer and
consumer processes
• Two types of buffer used in Producer - Consumer problems
• unbounded-buffer
• bounded-buffer
8

9. Producer-Consumer Problem
• unbounded-buffer
- no practical limit on the size of the buffer
- producer - always produces new item
- consumer - waits for new items
• bounded-buffer
- there is a fixed buffer size
- producer - consumer has to wait
producer - if buffer is full
consumer - if buffer is empty
9

10. Bounded-Buffer – Shared-Memory Solution
• Shared data
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0; /* points to next free position in the buffer */
int out = 0; /* points to first full position in the buffer */
• Solution is correct, but can only use BUFFER_SIZE-1 elements
10

11. Bounded-Buffer – Producer
item next_produced;
while (true) {
/* produce an item in next produced */
while (((in + 1) % BUFFER_SIZE) == out) ;
/* do nothing */
buffer[in] = next_produced;
in = (in + 1) % BUFFER_SIZE;
}
11

12. Bounded Buffer – Consumer
item next_consumed;
while (true) {
while (in == out)
; /* do nothing */
next_consumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
/* consume the item in next consumed */
}
12

13. Interprocess Communication – Shared Memory
• An area of memory shared among the processes that wish to
communicate
• The communication is under the control of the users processes not
the operating system.
• Major issues is to provide mechanism that will allow the user
processes to synchronize their actions when they access shared
memory.
• Synchronization is discussed in further classes
13

14. • Mechanism for processes to communicate and to synchronize their
actions
• Message system – processes communicate with each other without
resorting to shared variables or same shared address space
• For example, an Internet chat program
• IPC facility provides two operations:
• send(message)
• receive(message)
• The message size is either fixed or variable
14
Interprocess Communication – Message passing

15. • if the message size is fixed
• system-level implementation is straight - forward
• task of programming more difficult
• if the message size is variaable
• system-level implementation is complex
• task of programming simpler
15
Interprocess Communication – Message passing

16. • If processes P and Q wish to communicate, they need to:
• Establish a communication link between them
• Exchange messages via send/receive
• Implementation issues:
• 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?
16
Interprocess Communication – Message passing

17. • Implementation of communication link
• Physical:
• Shared memory
• Hardware bus
• Network
• Logical:
• Direct or indirect
• Synchronous or asynchronous
• Automatic or explicit buffering
17
Interprocess Communication – Message passing

18. Direct Communication
• Processes must name each other explicitly the recipient or sender
of the communication
• 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
18

19. Direct Communication
• This scheme exhibits symmetry in addressing
• both the sender process and the receiver process must name the other
to communicate
• A variant of this scheme employs asymmetry in addressing
• only the sender names the recipient; the recipient is not required to
name the sender
• send (P, message)—Send a message to process P
• receive(id, message)—Receive a message from any process. The
variable id is set to the name of the process with which communication
has taken place
19

20. 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
20

21. • Mailbox sharing
• P1, P2, and P3 share mailbox A
• P1, sends a message to A; P2 and P3 receives from A
• 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.
21
Indirect Communication

22. • If mailbox owned by Process
• Mailbox is part of the address space of the process
• Each mailbox has a unique owner
• Distinguish between the owner (which can only receive
messages through this mailbox) and the user (which can only
send messages to the mailbox)
• Mailbox terminates, then mailbox disappears
22
Indirect Communication

23. • If mailbox owned by an OS
• Provides a mechanism that allows a process to do
• Create a new mailbox
• Send and receive messages through the mailbox
• Delete a mailbox
• Can ownership and receiving privileges of mailbox be
passed to other mailbox ?
23
Indirect Communication

24. • Primitives are defined as:
send(A, message) – send a message to mailbox A
receive(A, message) – receive a message from mailbox A
24
Indirect Communication

25. Synchronization
• Message passing may be either blocking or non-blocking
• Blocking is considered synchronous
• Blocking send -- the sender is blocked until the message is
received
• Blocking receive -- the receiver is blocked until a message is
available
• Non-blocking is considered asynchronous
• Non-blocking send -- the sender sends the message and continue
• Non-blocking receive -- the receiver receives:
- A valid message, or
- Null message
• Different combinations possible
• If both send and receive are blocking, we have a rendezvous
25

26. Producer-consumer becomes trivial - when we use blocking send() and
receive() statements
message next_produced;
while (true) {
/* produce an item in next produced*/
send(next_produced);
}
message next_consumed;
while (true) {
receive(next_consumed);
/* consume the item in next consumed */
}
26
Synchronization

27. Buffering
• Communicating processes reside in temporary queue
• Queue of messages attached to the link.
• Implemented in one of three ways
1. Zero capacity – max. length = 0, no messages are queued
Sender must wait for receiver (rendezvous) - with no buffering
2. Bounded capacity – finite length of n messages
Sender must wait if link full
3. Unbounded capacity – infinite length
Sender never waits
- automatic buffering
27

28. 28
References
1. Silberscatnz and Galvin, “Operating System Concepts,” Ninth Edition,
John Wiley and Sons, 2012.

29. 29
Thank you