Jamison Collins (indecent_and_obscene@yahoo.com)
Tue, 16 May 2000 01:17:51 -0700 (PDT)

Implementing Remote Procedure Calls

Remote Procedure Calls are a useful paradigm for
communication in a high level programming language.
Communication using them ought to be less error prone
and impose less overhead that using traditional
message passing techniques.

RPCs are implemented using Stubs. From the user's
standpoint, a normal procedure call has occured, when
in reality control has transferred to the local stub,
which is responsible for packaging the arguments and
handing them to the RPCRuntime. The runtime then
transfers the arguments to the server, who receives
them and gives them to the server stub, who unpacks
the arguments for local execution. This procedure is
executed again, in reverse order to return the
function result. The appropriate stubs can be
automatically generated by a tool.

This paper was primarily concerned with demonstrating
the feasibility and success in implementing this
concept. As a result, performance evaluation is
fairly minimal. We can see that their implementation
does fall far short of their performance goals for
calls with few arguments. Unfortunately, that is the
common case which has already been optimized to avoid
unnecessary packet sends. Thus, it has been shown
that it is feasible to produce an RPC package, but not
that the desired level of performance can be met.

RPC is likely the simplest possible interface that can
be used for remote communication. However, I'm
concerned as to it's performance compared to other
methods of communication. It would have been useful
to try to compare the performance of the optimized RPC
interface against a standard messae passing interface
if, for example, a certain amount of data was sent to
the server, which used that data to perform 3
functions and then returned the results in 1 packet


Do You Yahoo!?
Send instant messages & get email alerts with Yahoo! Messenger.