Remote procedure call explained

In distributed computing, a remote procedure call (RPC) is when a computer program causes a procedure (subroutine) to execute in a different address space (commonly on another computer on a shared computer network), which is written as if it were a normal (local) procedure call, without the programmer explicitly writing the details for the remote interaction. That is, the programmer writes essentially the same code whether the subroutine is local to the executing program, or remote. This is a form of client–server interaction (caller is client, executor is server), typically implemented via a request–response message passing system. In the object-oriented programming paradigm, RPCs are represented by remote method invocation (RMI). The RPC model implies a level of location transparency, namely that calling procedures are largely the same whether they are local or remote, but usually, they are not identical, so local calls can be distinguished from remote calls. Remote calls are usually orders of magnitude slower and less reliable than local calls, so distinguishing them is important.

RPCs are a form of inter-process communication (IPC), in that different processes have different address spaces: if on the same host machine, they have distinct virtual address spaces, even though the physical address space is the same; while if they are on different hosts, the physical address space is different. Many different (often incompatible) technologies have been used to implement the concept.

History and origins

Request–response protocols date to early distributed computing in the late 1960s, theoretical proposals of remote procedure calls as the model of network operations date to the 1970s, and practical implementations date to the early 1980s. Bruce Jay Nelson is generally credited with coining the term "remote procedure call" in 1981.[1]

Remote procedure calls used in modern operating systems trace their roots back to the RC 4000 multiprogramming system,[2] which used a request-response communication protocol for process synchronization.[3] The idea of treating network operations as remote procedure calls goes back at least to the 1970s in early ARPANET documents.[4] In 1978, Per Brinch Hansen proposed Distributed Processes, a language for distributed computing based on "external requests" consisting of procedure calls between processes.[5]

One of the earliest practical implementations was in 1982 by Brian Randell and colleagues for their Newcastle Connection between UNIX machines.[6] This was soon followed by "Lupine" by Andrew Birrell and Bruce Nelson in the Cedar environment at Xerox PARC.[7] [8] [9] Lupine automatically generated stubs, providing type-safe bindings, and used an efficient protocol for communication.[8] One of the first business uses of RPC was by Xerox under the name "Courier" in 1981. The first popular implementation of RPC on Unix was Sun's RPC (now called ONC RPC), used as the basis for Network File System (NFS).

In the 1990s, with the popularity of object-oriented programming, an alternative model of remote method invocation (RMI) was widely implemented, such as in Common Object Request Broker Architecture (CORBA, 1991) and Java remote method invocation. RMIs, in turn, fell in popularity with the rise of the internet, particularly in the 2000s.

Message passing

RPC is a request–response protocol. An RPC is initiated by the client, which sends a request message to a known remote server to execute a specified procedure with supplied parameters. The remote server sends a response to the client, and the application continues its process. While the server is processing the call, the client is blocked (it waits until the server has finished processing before resuming execution), unless the client sends an asynchronous request to the server, such as an XMLHttpRequest. There are many variations and subtleties in various implementations, resulting in a variety of different (incompatible) RPC protocols.

An important difference between remote procedure calls and local calls is that remote calls can fail because of unpredictable network problems. Also, callers generally must deal with such failures without knowing whether the remote procedure was actually invoked. Idempotent procedures (those that have no additional effects if called more than once) are easily handled, but enough difficulties remain that code to call remote procedures is often confined to carefully written low-level subsystems.

Sequence of events

  1. The client calls the client stub. The call is a local procedure call, with parameters pushed on to the stack in the normal way.
  2. The client stub packs the parameters into a message and makes a system call to send the message. Packing the parameters is called marshalling.
  3. The client's local operating system sends the message from the client machine to the server machine.
  4. The local operating system on the server machine passes the incoming packets to the server stub.
  5. The server stub unpacks the parameters from the message. Unpacking the parameters is called unmarshalling.
  6. Finally, the server stub calls the server procedure. The reply traces the same steps in the reverse direction.

Standard contact mechanisms

To let different clients access servers, a number of standardized RPC systems have been created. Most of these use an interface description language (IDL) to let various platforms call the RPC. The IDL files can then be used to generate code to interface between the client and servers.

Analogues

Notable RPC implementations and analogues include:

Language-specific

Application-specific

General

See also

External links

Notes and References

  1. PhD thesis . Bruce Jay Nelson . Remote Procedure Call . PARC CSL-81-9 (Also CMU-CS-81-119) . Xerox Palo Alto Research Center . May 1981 . Bruce Jay Nelson .
  2. Web site: Per Brinch Hansen • IEEE Computer Society. www.computer.org. 2015-12-15.
  3. Book: Brinch Hansen, Per. RC 4000 Computer Software: Multiprogramming System. Regnecentralen. 1969. Copenhagen, Denmark.
  4. A High-Level Framework for Network-Based Resource Sharing . James E. White . December 23, 1975 . . RFC 707 . 10.17487/RFC0707 . July 11, 2011 . free .
  5. Distributed processes: a concurrent programming concept. Brinch Hansen. Per. November 1978. Communications of the ACM. 21. 11. 934–941. 10.1145/359642.359651. 10.1.1.107.3108. 11610744 .
  6. The Newcastle Connection . Brownbridge . David R. . Marshall . Lindsay F. . Randell . Brian . Brian Randell . Software: Practice and Experience . 12 . 12 . 1982 . 10.1002/spe.4380121206 . 1147–1162 . 1840438 . 2016-08-16 . dead . https://web.archive.org/web/20160816184205/http://www.cs.ncl.ac.uk/research/pubs/articles/papers/399.pdf . 2016-08-16 .
  7. 10.1145/2080.357392. 1984. Implementing remote procedure calls. ACM Transactions on Computer Systems. 2. 39–59. Birrell. Andrew D.. Nelson. Bruce Jay. 11525846 .
  8. Web site: 1994 – Andrew Birrell, Bruce Nelson: Remote Procedure Call . . Software System Award citation . July 11, 2011 . dead . https://web.archive.org/web/20120402204704/http://awards.acm.org/citation.cfm?id=5125494&srt=all&aw=149&ao=SOFTWSYS&yr=1994 . April 2, 2012 .
  9. Web site: SIGOPS Hall of Fame Award . . Special Interest Group on Operating Systems . July 11, 2011 .
  10. http://www.computerworld.com.au/index.php/id;1422447371;pp;3;fp;4194304;fpid;1 The A-Z of Programming Languages: Modula-3 - a-z of programming languages
  11. http://www.monkey.org/~provos/libevent/doxygen-1.4.10/ libevent: Main Page
  12. Web site: Protocol Buffers - Google's data interchange format . Google project website . November 1, 2011 .
  13. Web site: gRPC open-source universal RPC framework . Google project website . September 7, 2016.
  14. Web site: Google Web Toolkit . Google project website . November 1, 2011 .

This article is licensed under the GNU Free Documentation License. It uses material from the Wikipedia article "Remote procedure call".

Except where otherwise indicated, Everything.Explained.Today is © Copyright 2009-2024, A B Cryer, All Rights Reserved. Cookie policy.