Remote Procedure Callin

SR Programming LanguageBy

Tze-Kin Tsang

3/20/2000

Remote Procedure Call (RPC)

• Introduction

• Mechanisms for Remote Procedure Call

• Equivalence to Send/Receive Pairs

• Return, Reply, and Forward Statements

• Summary

Introduction:

• RPC involves two processes – the invoker/client and the server

• Client: the process doing the call• Server: the process created to service the call• Typically in different resources and might even be

on different virtual or physical machines• RPC is synchronous from the client’s perspective• The invoking process waits for results to be returned

from the call

• RPC is accomplished through the use of operations

• to initiate a RPC, the invoking process calls an operation, which is serviced by a proc

• a call invocation of a remote proc results in a process being created to service the invocation

• a remote procedure call resembles a sequential procedure call both syntactically and semantically

• the remote proc is transparent to the caller– does not know whether the call is located on a different

virtual or physical machine

• a remote procedure call takes longer than a local, sequential procedure call

Mechanisms for Remote Procedure Call

• The mechanisms for RPC are operations, call invocation, and procs.

• A new process is created to execute the proc’s code for the invocation.

• The invoked proc can be located in another resource, which might be located on another virtual or physical machine.

• The syntax and semantics of the local and remote calls are the same

• only the implementation and consequently the performance are different

Problems:• can lead to more than one process manipulating

the shared stack variables at the same time• for example, two processes, each execute an

invocation of push, can overflow the array.• synchronize the processes to avoid the problems

– semaphore

Equivalence to Send/Receive Pairs

• A (remote) procedure call can be written as a send to a proc to create the process plus a receive to get back results when the process has completed.

The following codes are equivalent.Op p (val x: int; var y: int; res z: int)

process q

var a, b, c: int

…

call p (a, b, c)

end

proc p (x, y, z)

z := x+4

y -:=10

end

Op p (x, y: int), r (y, z: int)

process q

var a, b, c: int

…

send p (a, b)

receive r (b, c)

end

proc p (x, y)

var z: int

z := x+4

y -:= 10

send r (y, z)

end

The following codes are equivalent.Op p (val x: int; var y: int; res z: int)

process q (i := 1 to …)

var a, b, c: int

…

call p (a, b, c)

end

proc p (x, y, z)

z := x+4

y -:=10

end

Op p (x, y: int; rcap: cap (y, z: int))

process q (i := 1 to …)

var a, b, c: int

…

op r (y, z: int)

send p (a, b, r)

receive r (b, c)

end

proc p (x, y, rcap)

var z: int

z := x+4

y -:= 10

send rcap (y, z)

end

Call Invocation VS Send/Receive Pair

• a call invocation provides a cleaner interface than does a send/receive pair

• a call invocation allows invocations of value-returning operations within expressions

• send/receive pair requires declaring a local operation to which results get sent and passing a capability for that operation

• Send/receive pairs are useful when a client wants to do some work between initiating a request for service and picking up results from that request

• call invocation precludes clients from performing other work while waiting for the server to give back results

Return, Reply, and Forward Statements

• provide additional flexibility in handling remote procedure calls

• appear in the body of a proc

• alter the way results are passed back to the invoking process

Return

• It has the form: return

• A return statement terminates both the call invocation and the process that executes the return

• any results of the invocation (variable, result parameters, and return value) are returned to the invoker

• When a proc does not want to wait for its completion, it may execute a return statement

• if the proc was invoked by send– return statement just terminates the process that

executes the return– any results from the proc are not actually

returned

Reply

• It has the form: reply

• The reply statement is used by a proc to continue execution after servicing an invocation of the proc

• terminates the invocation being serviced by the enclosing proc

• a process that executes a reply statement continues executing with the statement following the reply

• no effect to a send invocation

• a subsequent reply has no effect to an invocation for which a reply has already been executed

Forward

• The forward statement defers replying to a called invocation and instead passes on this reponsibility

• transparent to the original invoker

• it has the form:

forward operation (expr, expr, …)

• takes the operation invocation currently being serviced

• evaluates a possibly new set of arguments

• invokes the named operation

• an invocation can be forwarded to any operation having the same signature

• the caller remains blocked until the new invocation has been serviced to completion

• the forwarding process continues with the next statement, but no subsequent changes to variables will be seen by other process

• a subsequent forward of the same invocation = a send invocation from the forwarding process

• a subsequent reply to a forwarded invocation has no effect

• a subsequent return has the usual effect of causing the executing process to exit the block

Resource fun ()

op f (x: int) returns z: int

op g (y: int) returns z: int

process p

var a := f(1); write (a)

end

proc f(x) returns z

forward g (2*x)

… # continue executing, perhaps changing z

end

proc g(y) returns z

z := y+10

end

end

A realistic example:

Client processes make requests for service to a central allocator process. The allocator assigns a server process to the request by forwarding the invocation to it. The allocator might represent a file server that determines on which server the requested file is located and forwards the client’s request to the server, which typically would be located on a different machine.

Summary• Remote Procedure Call involves two

processes, a client and a server.

• RPC is another use of operation

• The mechanisms for RPC are operation declarations, call invocations, and procs.

• RPC is equivalent to send/receive pairs

• The return, reply, and forward statements provide additional flexibility in handling remote procedure calls.