1. structuring rpc systems - procedural decomposition

2. generating rpc infrastructure - stubs and skeletons

3. the rpc model

   1. specification, design, implementation

   2. implementation - by hand, from libraries, custom generation

4. rpc support - data, control, generation

   1. data - xdr, other presentation-level tools; usually libraries

   2. control - how the os implements rpc; system calls and libraries

   3. communication - how the rpc works; kernel code

   4. generation - goo between the application and the system

5. rpc system design is natural - perhaps too much

   1. often externally constrained - service locations

   2. hiding latency is a good design problem - prefetch; call fragmentation

   3. what's being designed - client, server, or both

6. implementing rpc

   1. stubs are the endpoints in the rpc chain - the client and server are on the other side of the stubs

   2. stubs marshal data and work the rpc protocol

   3. the server side also demultiplexes rpc calls, if necessary

   4. naming - preserving the procedure name across machines

7. generating rpc code

   1. rpc code has variable variablility - the further from the ends, the less it varies

   2. variability is directly related to the ends - the procedures

   3. variability is usually trivial - order, number, type

   4. this can be handled automatically

8. rpcgen - part of onc rpc

   1. reads a description of the remote procedure and generates code

      1. types and constants, marshalling procedure, client-side communications stub, server-side communications stub

   2. the problem of infinte regress - how does the client call the remote procedure? how does the client call the rpc stub? . . .

      1. and for the server too

   3. the client (and server) provides an interface routine to the rpc code

This page last modified on 1 March 2001.