Mark Stanovich Operating Systems COP 4610. Primitives to Build Distributed Applications send and receive Used to synchronize cooperating processes running.

Mark StanovichOperating Systems

COP 4610

Primitives to Build Distributed Applicationssend and receive

Used to synchronize cooperating processes running on different machines

Communicate through mailboxes (ports) Temporary holding areas for messages

Atomic operations send/receive the entire message or nothing

More on send and receiveTo put a message to the network

send(message, destination_mbox)receive(buffer, mbox)

Waits until a message arrives Copies the message into a given buffer

Remote Procedure Call (RPC)Allows you to invoke a procedure on either a

local or remote machineClient

RemoteMachineSay(“Meow”);Server

MachineSay(“Meow”);

Implemented on top of two-way messaging

RPC IllustratedServer (callee)Client (caller)

OS or Network

Server stubClient stub

call reply callreply

Procedure StubsProvide the invocation interface

programmerse.g. foo(int a)

Client stubBuild messages (a.k.a. marshalling)Send messagesWait for responseUnpack replyReturn result

Server StubCreate N threads to wait for requestsLoop

Wait for commandDecode and unpack request parameters

(unmarshalling)Call procedureBuild replay message with resultsSend reply

RPC vs. Procedure CallFrom the programmer’s viewpoint

Similar semanticsPointers are instantiated before transmission

Data structures pointed by the pointer are copied

Processes running on the remote machine is in a different address space

Implementation IssuesStubs are automatically generatedNeed to have a well-known port to talk to

serversServer can upgrade the implementation

without recompiling client applications

Interprocess CommunicationRPC is just another way to communicate

between processesExample uses

Microkernel operating systems Portions of an OS are implemented at the user level

to minimize the kernel-level codeObject linking and embedding (OLE)

Mix-and-match applications

Using RPC for IPC+ Fault isolation: bugs are unlikely to

propagate across different address spaces+ Modularity: independent component

upgrades+ Location transparency: a service can be

provided from local or remote machines

Using RPC for IPC- Poor performance- Increased number of failure modes

Network failure Machine failure

- More outcomes for procedure execution No execution Partial execution ...