Remote Procedure Call

Remote Procedure Call (RPC) is a special case of the general purpose message-passing model of IPC (Inter Process Communication) that has become a widely accepted IPC Mechanism in distributed computing systems. The popularity of RPC as the primary communication mechanism for distributed applications is due to its following features:

·        Simple Call Syntax

·        Familiar Semantics

·        Well – Defined Interface

·        Ease of Use

·        Generality

·        Efficiency

 Transparency of RPC:

The main reason for the popularity of RPC is the transparency given by it to the users in executing the Remote procedures (i.e.) it seems that the remote procedures are being executed in the local environment. The transparency is of two types namely

·        Syntactic Transparency means that the remote procedure call should have exactly the same syntax as a local procedure call.

·        Semantic Transparency means that the semantics of a remote procedure call are identical to those of a local procedure call

 The RPC Model:

            The RPC mechanism is an extension of the procedure call mechanism in the sense that it enables a call to be made to a procedure that does not reside in the address space of the calling process.        

The two major components of the RPC model are

·        Calling Procedure is located in the local machine and contacts the remote procedure to be executed by placing a request message to the called procedure.

·        Called Procedure (remote Procedure) may be located in the same computer as the calling procedure or on a different computer. Gets the parameters from the request message sent by the calling procedure and executes accordingly giving the results via a reply message to the calling process.

 The two types of messages involved in the implementation of an RPC system are as follows

·        Call Messages that are sent by the client to the server for requesting execution of a particular remote procedure

·        Reply Messages that are sent by the server to the client for returning the result of remote procedure execution

 Implementing RPC Mechanism:

          The implementation of an RPC mechanism is based on the concept of stubs, which provide a perfectly normal procedure call abstraction by concealing from programs the interface to the underlying RPC System.

             The implementation of an RPC mechanism usually involves the following five elements of program

·        The Client

·        The Client Stub

·        The RPC Runtime

·        The Server Stub

·        The Server

             The Client is a user process that initiates a remote procedure call. To make a remote procedure call, the client makes a perfectly normal local call that invokes a corresponding procedure in the client stub.

The Client Stub is responsible for carrying out the following two tasks:

·        On receipt of call request from client, it packs a specification of the target procedure and the arguments into a message and then asks the local RPC Runtime to send it to the server stub

·        On receipt of the result of procedure execution, it unpacks the result and passes it to the client.

             The RPC Runtime handles the transmission of messages across the network between client and server machines. It is responsible for retransmissions, acknowledgements, packet routing and encryption. The RPC runtime in the client machine receives the call request message from the client stub and sends it to the server machine. The RPC Runtime on the server machine receives the message containing the result of procedure execution from the server stub and sends it to the client machine.

 The Server Stub is responsible for carrying out the following two tasks:

·        On receipt of the call request message from the local RPC Runtime, the server stub unpacks it and makes a perfectly normal call to invoke the appropriate procedure in the server

·        On receipt of the result of procedure execution from the serve, the server stub packs the result into a message and then asks the local RPC Runtime to send it to the client stub

             The Server on receiving a call request from the server stub, the server executes the appropriate procedure and returns the result of procedure execution to the server stub.