5 - Communication Primitives

The document discusses the differences in interprocess communication between distributed systems and uniprocessor systems, emphasizing the reliance on message passing in distributed systems. It outlines various communication primitives, including message passing and remote procedure calls (RPC), and details the processes involved in RPC, such as client and server stubs. Additionally, it addresses challenges like server and client crashes, orphans, and strategies for managing them, including at-least-once and at-most-once semantics.

Uploaded by

srujansaireddy.p

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPTX, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

15 views49 pages

5 - Communication Primitives

Uploaded by

srujansaireddy.p

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPTX, PDF, TXT or read online on Scribd

You are on page 1/ 49

Communication

Primitives

1
Process Communication
• The single most important difference between a distributed
system and a uniprocessor system is the interprocess
communication.

• In a uniprocessor system, interprocess communication assumes

the existence of shared memory.
• A typical example is the producer-consumer problem.

• One process writes to  buffer reads from another process

• The most basic form of synchronization, the semaphore requires one
word (the semaphore variable) to be shared.
2
Process Communication
• In a distributed system, there’s no shared memory, so the entire
nature of interprocess communication must be completely rethought
from scratch.
• All communication in distributed system is based message
on
passing.
E.g. Proc. A wants to communicate with Proc. B
1. It first builds a message in its own address space
2. It executes a system call (send)
3. The OS fetches the message and sends it through network to B.

3
Process Communication
• A and B have to agree on the meaning of the bits being sent.
For example:
• How many volts should be used to signal a 0-bit? 1-bit?
• How does the receiver know which is the last bit of the message?
• How can it detect if a message has been damaged or lost?
• What should it do if it finds out?
• How long are numbers, strings, and other data items? And how are they
represented?

4
Types of Communication
Primitives
Widely used communication primitives in Distributed Operating
Systems

• Message Passing
• Using Send() and Receive() Primitives
• Remote Procedure Calls
• An extension of conventional procedure call (used
for transfer of
control and data within a single process)

5
Message Passing Model
• Two basic communication primitives
• Send() and Receive()
• Example:
send(&x, destination_id)
receive(&y, source_id)
• Found in Client/Server computing models

6
Message
passing
• Synchronous and asynchronous send routines

Basic “point-to-point” Send and Receive Routines

7
Client blocked
Client running
Client running

Message Trap to
Return from kernel,
process released

passing
kernel,
Process blocked

• Blocking and non-blocking routines

Message being sent

Blocking send primitive

Client
blocked

Client running
Client running

Trap Return

Message Message being sent

copied to
kernel
buffer
Non- 8
Using a
message buffer Buffered versus
Unbuffered Primitives

• No buffer allocated. Fine if

receive() is called before
send().
• Buffers allocated, freed, and
managed to store the
incoming message.
Usually a mailbox created.

9
Group communication routines

Broadcast: Sending same message to all processes concerned with problem.

Multicast - sending same message to defined group of processes.

1
0
Group communication routines

11
Group communication routines

Having one process collect individual values from set of processes.

12
Group communication routines

Reduce: Gather operation combined with specified arithmetic/logical operation.

Example: Values could be gathered and then added together by root:

13
Example

14
Example

15
Remote
Procedure
• The idea behind RPCCall
is to make a remote procedure call look as much as
possible like a local one.
• A remote procedure call occurs in the following steps:

• The client procedure calls the client stub in the normal way.
• The client stub builds a message and traps to the kernel.
• The kernel sends the message to the remote kernel.
• The remote kernel gives the message to the server stub.
• The server stub unpacks the parameters and calls the server.
• The server does the work and returns the result to the stub.
• The server stub packs it in a message and traps to the kernel.
• The remote kernel sends the message to the client’s kernel.
• The client’s kernel gives the message to the client stub.
• The stub unpacks the result and returns to the client.
16
Remote Procedure Call
Client machine Client stub Server stub Server machine