By Andrew D. Birrell and Bruce Jay Nelson

Adapted from an earlier presentation byAbdussalam Alawini

Contents1. Introduction

Context Remote Procedure Call vs Local Procedure Call Design Choices

2. RPC Implementation Basic Structure Binding Network Protocol Exception Handling Use of Processes

3. Evaluation

CS533 contextWe’ve studied the:

Procedural (thread-based) modelMessage passing (event-based) modelDuality of the two modelsWrappers to translate calls between models

Here we study an implementation of a procedural model on a distributed, message passing substrate Conceptually, threads pass from one machine to

the other and back againThe programmer is unaware of the underlying

message-based substrate

What is A “Remote” Procedure Call?

CommunicationNetwork

Server

Client

Z=F(x,y) F(x,y)

result

Compute

F(x,y)

Design AlternativesExplicit message passing

i.e. force the programmer to change modelsShared virtual address space

Access remote data ... but how to move computation?

Remote forkParallelism in addition to distribution

Remote procedure callthreads libraries, such as Pthreads, make a

similar choice

Goals of implementing RPCSimplicity

Make RPCs as similar to procedure calls as possible

Simplify distrusted computation

Efficiency Anticipated heavy use justifies special support

SecuritySecure end-to-end communications with RPC

RPC Structure Caller Machine

User (application code module)User-StubCaller instance of RPCRuntime (RPC

communications package)Callee Machine

Server (server code module)Server-stubCallee instance of RPCRuntime

User Application

User-stub

CallerRPCRuntim

e

Network

Libraries(Server code)

Server-stub

CalleeRPCRuntim

e

NormalLocal

Proc Call

ImportInterface

ExportInterface

Pack target spec + proc

arguments Call

Packet transmit packet “Reliably”

Pass them to server-

stub

Unpack & make local call

Do work and

return results

Results Packet

Caller Machine Callee Machine

User Application

User-stub

CallerRPCRuntim

e

Network

Libraries(Server code)

Server-stub

CalleeRPCRuntim

e

Interface Interface

Caller Machine Callee Machine

Programmer

Lupine(Auto

Generation)

Part of Cedar

Mesa Interface Modules

Binding Process

How does a client of the binding mechanism specify what to be bound to?Naming

How does the caller specify the callee machine address and the specific procedure to invoke?Locating

Naming (Interface Name)

Type: Which interface the caller expects the callee to implement. Service Name (e.g Mail-server)

Instance: Which particular implementer of an abstract interface is desired.Machine Address (e.g Specific mail-server

address)

Importer of an interface

Exporter of an interface

Binding

Design Alternatives for Location1- Include network address in user application

Binding is too early!

2- Broadcasting Protocol Too much interference with innocent

bystanders Not convenient for binding machines not in the

same local networkNot scalable

Grapevine DatabaseLocating an appropriate exporter

Type (Group)

Member-list

FileAccess {Ebbets, Luther, Facc}

Instance(Individual)

Connect-site

Ebbets 3#22#

Luther 3#276#

Facc 3#43#

Export Interface

Type FileAccessInstance Ebbets

Import Interface

Type FileAccessInstance Ebbets

Grapevine

Database

Server 1

(Ebbets)

3#22#

Server 2

(Luther)

3#276#

Server3

(Facc) 3#43#

Steps of Exporting an Interface(Making it available to a client)

Callee Machine

ServerRPCRuntime Server-stub

Grapevine Database

Export [FA,

Ebbets]

Export [FA, Ebbets,…]

Record in table

SetConnect

Do update

AddMember

Return

Do update

Call server-

sub

Call ExportInterface(Interface Name,

Dispatcher)

ExportInterface make sure that

type and instance is correct

RPCRuntimeRecord exported

interface in a table

Table [tableIndex,InterfaceName,Di

spatcherProd, UniqueID]

Set the address of the current

machine in the connect-site

Adds the instance to the member-

list of the type of the instance

Interface exported

(Can be accessed remotely)

Steps of Binding An Importer to An Exporter Interface(Getting ready for remote calls)

Caller Machine

Callee Machine

User User-stub

RPCRuntime RPCRuntime

Server-stub

Server

Import [FA,

Ebbets]

Import [FA,

Ebbets]

GetConnect

Bind[FA,

Ebbets]

Grapevine

DatabaseLookup

Recordresult

ReturnTablelookup

X= openFile(

y)

openFile -> 2

transmitCheck UID

In table

2 -> openFile

X= openFile(

y)

Call user-stub“I need to import

Interface[FA, Ebbets”

Call ImportInterface“Here’s the type and instance we

need”

OK, I will ask grapevine DB

and get the NT address of exporting Interface

Here’s the NT address

“connect-site”

Alright, I’ll call the exporter

RPCRuntime to get the binding info

Normal call to procedure openFile(y)

OK, now I’ve got UID, TableIndex, and exporter NT Address. I will record them

Exporter Interface is

ready for your next remote

procedure calls

Now let see how this will

work

1- Retrieve interface binding

information2- Prepare call

packet

Alright, I will transmit it to the

machine with address “connect-site”

1-Lookup current exports

2- verify UID3- send call packet to

dispatcher

After unpacking,Dispatcher

uses the info to map to the

right procedure

Call the local procedure

using provided arguments

Lookup the table of current

exportsSend the

corresponding binding info

Binding Mechanism Advantages Stateless

Importing an interface has no effect on the state of the exporting machine

The use of UID means that bindings are implicitly broken if the exporter crashes and restarts.

Restricting the set of users who can update Grapevine DB .To avoid security problems.

Several choices of binding timeImporter specifies the type only

Packet-Level Transport Protocol (Why?)Substantial performance gains Minimize the elapsed real-time between

initializing a call and getting results.Unacceptable to have large amount of state

info.Unacceptable to have expensive handshaking.

Guarantee procedure in the server has been invoked precisely onceNot just “at most once” or “at least once”

Caller Machine

User RPC+Stub

Call Send CallPacket

Wait Ack or Result

Return

Invoke proc

Send results

Do call

Return

Callee Machine

ServerRPC+Stub

Seq#[Machine Id, Process]

“Activity” is the

Machine Id, and Processes’ Ids

Each activity has at most 1

remote call at any time

Proposes 1- Ensure the

result packet is for this call

2- Callee can eliminate

duplicates

Desired Procedure Info:

UId, Table Index, Procedure entry

point.

Procedure arguments which

is the input or output that will be

used by RP

RPC compares Seq# in CID to the

one it has in a table that

maintains seq# of the last call

invoked by each calling activity

ResultCallID

results

If caller Seq# EQ Cseq then Ack if needed

if callerSeq# LT Cseq then drop “repeated”If callerSeq# GT Cseq then new call packet

Monotonic for each activity.

No repeats (calls might eliminated

as dup. )

CallID

DP info

Call Arugs

Result packet is sufficient Ack to the

caller.

Is this “Stack Ripping”?In manual stack management the necessary

data is taken off the stack and put on the heap

In RPC it’s taken off the stack and put in a messageSent to the other sidePut on a different stack ...

Similar to taking the state off the stack and putting it in a continuation. Executed by a separate event handler

Caller Machine User RPC+Stub

CallSend

CallPktWait for Ack

Build next pkt

Transmit itWait for ack

Start arg record

Idle

Do call

Return

Callee Machine ServerRPC+Stub

RetransmitWait for ack

Wait for result

Return

Acknowledgment

AcknowledgeWait next pkt

Invoke call

Acknowledge

Send resultWait for ack

RetransmitWait for ack

CallID, Pkt=0, PlsAck,…

Call

CallID, Pkt=0,

Ack

CallID, Pkt=1, dontAck,….

Data

CallID, Pkt=1, PlsAck ,….

Data

CallID, Pkt=1,

Ack

CallID, Pkt=2, dontAck ,….

Result

CallID, Pkt=2, PlsAck ,….

Result

CallID, Pkt=2,

Ack

Call pkt must be acknowledged

Arguments going to be in 2

packets

Send the rest of the data in Data

Pkt

In case of lost packet, long call duration or long

gaps between calls retransmit the last pkt and ask for ack

Satisfying Ack: process waits for

resultsCaller sends probe pkts periodically

(can detect communication

failure)

Now all arguments are ready, so the dispatching

process starts

Send resultsAnd wait for another call

“works as an Ack”

Return results to caller process

(user code)

No subsequent call arrived, so ask the caller to do an explicit Ack that it has received the

results

Exception Handing (Remote Process Exception) Two level of exception

Communication Failure Exception (Explained with complicated call example), considered to be the primary difference between procedure call and RPC

Remote Process Exception

Exception HandlingCaller

Machine User RPC+Stub

Call Send CallPacket

ReturnWith

exception

Invoke proc

Send Exception

Do call

ReturnWith

exception

Callee Machine

ServerRPC+Stub

ExceptionCallI

DException

CallID

DP info

Call Arugs

Wait Ack, Result

or Exception

Caller does sends regular call packet as we saw before

If an exception occur, the

process passes the exception

to RPC

Prepare and send exception packet instead

of results packet

Don’t invoke new call, instead raise an exception in

the calling process

If the catch phrase

terminated by a jump, then the callee will be

notified

Call with Exception results

Catch exception

Send EH results

CallID

DP info

Results Arugs Invoke proc

that caused the excep

Continue doing call

Exception handling results

packet.

Events processed normally

If there’s a catch phrase, exception will

be handled and results will be sent back to the callee

machine

Exception

Use of Processes

`

3

Idle Server Processes

Processes Waiting For RPC packet 7

SrcProcessDestProcess

7 3

Process 7 made a remote

procedure call to process 3

This part is the process

identifiers, which is part of the activity info

within the CallID

Interrupt handler in RPC

look at the destProcess, if the process is waiting then it

transfers the pkt directly

Caller Machine Callee Machine

Network

RPC will exchange

SrcProcess with DestProcess so

that it can return the

results to the right process

SrcProcessDestProcess

7 3

If there’s no corresponding process waiting for this packet then it will be

dispatched to one of the free processes

(Current, New, or Dup)

RPC now transmit the

packet back to the caller (result,

exception, or Ack)

OptimizationsUse of thread pool (idle processes) in caller and

callee machines to reduce process creation costs.The use of process source and destination allow

processes to get the packets they’re waiting for directly from the interrupt handler.

Use of subsequent packet for implicit acknowledgments of previous packets.

Avoid the cost of establishing and terminating connections by the implementation of packet-level protocol.

Performance evaluation They’ve measured the elapsed time between

two machines for 12,000 calls for each of the following procedures:0-10 arguments/results.1-100 word array.Caller Resume and unwind exception handling.

Performance results

Performance summaryFor transferring large amounts of data in one

direction products other than RPC have advantage. Transfer fewer packets in the other direction

They haven’t measure the performance of exporting or importing interfaces.

Used by: Alpine [File server supports multi-machine

transactions]Control communication for an Ethernet-based

for telephone and audio projectNetworking games.

ConclusionRPC is used to communicate between processes

in different address spacesMay be on separate machines or on the same

machineCommunication is implicit

RPC makes distributed programming easierAllows thread-based programming model on

distributed platformsReliably transfers data and control