1 / 25

CSS490 RPC and RMI Textbook Ch4

CSS490 RPC and RMI Textbook Ch4. Instructor: Munehiro Fukuda These slides were compiled from the course textbook, the reference books, and the instructor’s original materials. Why RPC. Calling a function at a remote server:. Advanced form of communication Sockets and MPI: data transfer

gotzon
Download Presentation

CSS490 RPC and RMI Textbook Ch4

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSS490 RPC and RMI Textbook Ch4 Instructor: Munehiro Fukuda These slides were compiled from the course textbook, the reference books, and the instructor’s original materials. CSS490 RPC

  2. Why RPC Calling a function at a remote server: • Advanced form of communication • Sockets and MPI: data transfer • RPC: control transfer • Transparency in function calls • No distinguish between local and remote calls • Also applied to IPC on the same machine • Ease of use • Compiled-time argument type checking • Automatic interface generation CSS490 RPC

  3. RPC Model Caller (Client) Callee (Server) Request message including arguments RPC and wait Request message accepted Execution environment created Execution of function body Send reply and wait for the next request Suspended Reply message Including a return value Resume execution CSS490 RPC

  4. Implementation Issues • Transparency property • Syntactic transparency • Semantic transparency • Analogy in semantics b/w local and remote procedure calls • Caller capable of passing arguments • Caller suspended till a return from a function • Callee capable of returning a value to caller • Difference in semantics b/w local and remote procedure calls • No call by reference and no pointer-involved arguments • Error handling required for communication • Performance much slower than local calls. CSS490 RPC

  5. PRC id type (call) args msg id client id msg id reply status type (reply) fesults failur RPC Mechanism Interface Definition Language File Client Program Server Program Define arguments Register remote functions Return Call Return Call IDL Compiler Server Stub Client Stub (5) Exception? Message Decoding Encoding Message Decoding Encoding (4) Invalid arguments? marshaling (3) Invalid procedure? Retransmission acknowledgments Routing encryption RPC Runtime RPC Runtime (2) Unauthorized client? Receive Send Receive Send (1) Intelligible messages? CSS490 RPC

  6. Stateful/Stateless Servers • Stateful servers: • Servers keep track of client information. • RPC reply depends on that client information. • Pros: Simplify client design • Cons: A server crash loses client information. A client crash leaves old client information at server. • Stateless servers: • Clients must maintain Inter-call information. • RPC reply is always the same. • Most RPC implementations take this design. CSS490 RPC

  7. Server Creation Semantics • Instance-per-Call Servers • A new server process launched every call • Statelss servers only • OS resource allocation/de-allocation involved every call • Instance-per-Session Servers • A server process maintained for the entire session with a client • Stateful servers: inter-call state maintained for a single client • OS resource allocation/de-allocation involved every session • Persistent Servers • A server process remains in existence indefinitely. • Stateful and shared servers: concurrency control required • OS resource allocation/de-allocation involved only once CSS490 RPC

  8. class objA { objB b; objC c; } class objB { } class objC { } Parameter-Passing Semantics • Call by Value • Most PRCs take this semantics. • Voluminous data incurs copying overhead. • Call by Reference • Passing pointers and references are meaningless. • Then, how about object-based systems? • The value of a variable is a reference to an object • Call by object reference • Additional remote object invocations • Call by visit: all related objects moved to a server every RPC. • Call by move: all related objects moved and left to a server upon the first RPC. Server Client CSS490 RPC

  9. Call Semantics What if Node 1 temporally crashed Before a RPC response? • RPC may result in failure and thus be called multiple times. • Last-One Call Semantics • Killing all orphan calls before restarting a new call • Last-of-Many Call Semantics • Neglecting all orphan calls using identifiers • At-Least-Once Call Semantics • Accepting the first response (maybe an orphan response) • Exactly-Once Call Semantics • The strongest semantics as learnt in message passing Node 1 Orphan call 2nd call Node 2 Node 3 CSS490 RPC

  10. Client-Server Binding (SunRPC) Server Machine Client Machine • (1) pmap_set(prognum, versnum, protocol, port) • (2) and (3) pmap_getport(addr, prognum, versnum, protocol) • To check the status of portmap, rpcinfo (2) Locating server Portmap Daemon port: 111 Client (3) Server port (xxx) port: xxx (1) register (4) RPC with port xxx Server write(), read(), Sendto(), recvfrom() write(), read(), Sendto(), recvfrom() Transport level or below TCP or UDP TCP or UDP Network (LAN/WAN) CSS490 RPC

  11. Performance Improvement in RPC • Callback RPC • Clinet: • specify a function that should be called back from the server. • Keep working its computation without blocked on a RPC. • Server: • Call back the client function as a response. • Multithreaded Client/Server • Client: • Can avoid a block on RPC by having two threads. • Hide network latency • Server: • Keep accepting requests from clients • Overlap server’s disk access with server computation CSS490 RPC

  12. SunRPC Modify by yourself example_client example_client.o example_client.c Client program rpcgen –a example.x Your client example_clnt.o example_clnt.c Client stub gcc –c -o example_h.c example.x Header ld -o Interface descriptions example_xdr.c example_xdr.o Marshalling example_svc.o example_svc.c Server program Server stub example_server example_server.o example_server.c Modify by yourself Your server CSS490 RPC

  13. Sun RPC (Interface definition) /* * example.x - Speicification of some arithmetic/string service. * Define 2 procedures: * fact( int n ) returns n!. * power( double x, double y ) returns x^^y. * strconc( struct strings ) concatenates src to dest. */ const BUFFER_SIZE = 1024; struct doubles { double a; double b; }; struct strings { char src[BUFFER_SIZE]; char dst[BUFFER_SIZE]; }; program EXAMPLE_PROG { version EXAMPLE_VERS { int FACT( int ) = 1; /* procedure number = 1 */ double POWER( doubles ) = 2; /* procedure number = 2 */ string STRCONC( strings ) = 3; /* procedure number = 3 */ } = 1; /* version number = 1 */ } = 0x31234567; /* program number = 0x31234567 */ CSS490 RPC

  14. Sun RPC (Client) #include "example.h" void example_prog_1(char *host) { CLIENT *clnt; int *result_1; int fact_1_arg; double *result_2; doubles power_1_arg; char * *result_3; strings strconc_1_arg; clnt = clnt_create (host, EXAMPLE_PROG, EXAMPLE_VERS, "udp"); if (clnt == NULL) { clnt_pcreateerror (host); exit (1); } fact_1_arg = 10; result_1 = fact_1(&fact_1_arg, clnt); if (result_1 == (int *) NULL) { clnt_perror (clnt, "call failed"); } printf( "fact( 10 ) = %d\n", *result_1 ); power_1_arg.a = 2.0; power_1_arg.b = 6.0; result_2 = power_1(&power_1_arg, clnt); if (result_2 == (double *) NULL) { clnt_perror (clnt, "call failed"); } printf( "power( 2.0, 6.0 ) = %f\n", *result_2 ); strncpy( strconc_1_arg.dst, "xyz\0", BUFFER_SIZE ); strncpy( strconc_1_arg.src, "abc\0", BUFFER_SIZE ); result_3 = strconc_1(&strconc_1_arg, clnt); if (result_3 == (char **) NULL) { clnt_perror (clnt, "call failed"); } printf( "strconc( \"xyz\", \"abc\" ) = %s\n", *result_3 ); clnt_destroy (clnt); } int main (int argc, char *argv[]) { char *host; if (argc < 2) { exit (1); host = argv[1]; example_prog_1 (host); exit (0); } CSS490 RPC

  15. Sun RPC (Server) #include "example.h" #include <math.h> #include <string.h> int * fact_1_svc(int *argp, struct svc_req *rqstp) { static int result; int i; result = 1; for ( i = *argp; i > 0; i-- ) result *= i; return &result; } double * power_1_svc(doubles *argp, struct svc_req *rqstp) { static double result; result = pow( argp->a, argp->b ); return &result; } char ** strconc_1_svc(strings *argp, struct svc_req *rqstp) { static char * result; result = strcat( argp->dst, argp->src ); return &result; } CSS490 RPC

  16. SunRPC v.s. Java RMI CSS490 RPC

  17. SerializationManual Operations in C++ MainObj class SubObject { public: int id; SubObject( int I ) { id = I; } void print( ) { cout << “SubObject: id=“ << id << endl; } }; class MainObject { public: id id; SubObject *subObj; MainObject( int I, SubObject *s ) { id = I; subObj = j; } void print( ) { cout << “MainObject: id=“ << id << endl; } }; Int main( int argc, char** argv ) { int f1 = create( “sample.dat”, 0744 ); MainObject *obj1 = new MainObject( 1, new SubObject( 2 ) ); write( f1, obj1, sizeof( *obj1 ) ); write( f1, obj1->subObj, sizeof( *obj1->subObj ) ); //manually write data pointed to by obj1 close( f1 ); int f2 = open( “sample.dat”, O_RDONLY ); MainObject *obj2 = new MainObject( 0, new SubObject( 0 ) ); read( f1, obj2, sizeof( MainObject ) ); read( f2, obj2->subObj, sizeof( SubObject ) ); //manually read data pointed to by obj2 close( f2 ); obj2->print( ); obj2->subObj->print( ); } ＳｕＯｂｊ Read/write CSS490 RPC

  18. SerializationAutomatic Operations in Java public class SubObject implements Serializable { private int id; public SubObject( int I ) { id = I; } public void print( ) { System.out.println( “SubObject: id =“ + id ); } } public class MainObject implements Serializable { public int id; public SubObject subObj; public MainObject( int I, SubObject s ) { id = I; subObj = s; } public void print( ) { System.out.println( “MainObject: id =“ + id ); } } Public class Test { public static void main( String args[] ) throws IOException, ClassNotFoundException { FileOutputStream f1 = new FileOutputStream( “sample.dat” ); ObjectOutputStream o = new ObjectOutputStream( f1 ); MainObject obj1 = new MainObject( 1, new SubObject( 2 ) ); o.writeObject( obj1 ); //automatically write all objects traceable from obj1 o.flush( ); o.close( ); FileInputStream f2 = new FileInputStream( “sample.dat” ); ObjectInputStream i = new ObjectInputStream( f2 ); MainObject obj2 = (MainObject)I.readObject( ); // automatically read all object traceable from obj2 I.close( ); obj2.print( ); obj2.subObj.print( ); } } CSS490 RPC

  19. SerializationSerializable or Not Serializable • Serializable • Classes implementing the Serializable interface • Primitive data types such as int and double and their arrays • Not Serializable • Image and Thread classes • Static variables • Variables quantified with Transient • Zero or null initialized upon a de-serialization CSS490 RPC

  20. RMIProgramming Procedure (4) Program a Client.java class (2) Program a Server.java class (5) javac Client.java (7) Run Server with java Server Application Layer: Client .java Server.java (implements remote interface) (8) Run Client with java Client (1) Define a remote interface Stub/Skeleton: Stub Skeleton Server_Stub.class Server_Skel.class (3) javac Server.java rmic Server Remote Reference: rmiregistry [port#] (object manager/name service) (6) Inovke a rmi registry request and result Transport Layer: TCP/IP CSS490 RPC

  21. RMIRemote Interface & Return Object // Remote interface: A server must implements this interface in its class define import java.rmi.* public interface ServerInterface extends Remote { public ReturnObj get( ) throws RemoteException; // A server returns a ReturnObj to a client } // Define the class of a object returned from a server to a client (ReturnObj) import java.io.* import java.util.* public class ReturnObj implements Serializable { // A return object must be serializable. private id; SubObject subObj; public ReturnObj( int i, SubObject s ) { id = i; subObj = s; } public void print( ) throws IOException { System.out.println( “ReturnObj: id=“ + id ); } } CSS490 RPC

  22. RMIServer Implementation import java.io.*; import java.util.*; import java.rmi.*; import java.rmi.server.*; Public class Server extends UnicastRemoteObject implements ServerInterface { static private int i = 0; public Server( ) throws RemoteException{ } public static void main( String args[] ) { try { Server server = new Server( ); Naming.rebind( “server”, server ); } catch ( Exception e ) { System.err.println( “Exception: “ + e ); System.exit( 1 ); } } public ReturnObject get( ) throws RemoteException { ReturnObject f = new ReturnObject( i++, new SubObject( i ) ); return f; } } (1) Implement a remote interface (2) Inherit a RemoteObject (3) Define a constructor (4) Instantiate a RemoteObject (5) Implement all methods declared in a remote interface CSS490 RPC

  23. RMIClient Implementation Import java.rmi.*; Import java.io.*; Public class Client { public static void main( String[] args ) { try { ServerInterface si = (ServerInterface)Naming.lookup( “rmi://adonis1/server” ); ReturnObject f = si.get( ); f.print( ); f.subObj.print( ); } catch ( RemoteException re ) { System.out.println( “Exception : “ + re ); System.exit( 1 ); } catch ( IOException ie ) { System.out.println( “Exception : “ + ie ); System.exit( 1 ); } catch ( NotBoundException nbe ) { System.out.println( “Exception : “ + nbe ); System.exit( 1 ); } } } (1) RMI registry returns a reference to RemoteObject (2) Call a method of this RemoteObject (3) Exception handling for RMI (4) Exception handling for I/O (5) Exception handling for Naming CSS490 RPC

  24. RMICompilation and Execution % javac ReturnObject.java // Compile a return class % javac Server.java // Compile a server class % rmic Server // Create a stub and a skelton % javac Client.java // Compile a client class % ls ReturnObject.java ReturnObject.class Server.java Server.class Server_Stub.class Server_Skel.class % rmiregistry& // Invoke RMI registory % java Server& // Invoke a server % java Client // Invoke a client ReturnObject id = 0 SubObject id = 1 % java Client // Inovke a client again ReturnObject id = 2 SubObject id = 3 % CSS490 RPC

  25. Exercises (No turn-in) • The caller process of an RPC must wait for a reply from the callee process after making a call. Explain how this can actually be done. • Which types of server did you implement for the programming assignment 2, a stateful or a stateless server? Then, why did you implement such a type of server? • Discuss the similarities and differences among the following parameter passing: • Call-by-object-reference • Call-by-move • Call-by-visit • What is an orphan call? How are orphan calls handled in the implementation of the following types of call semantics: • Last-one call semantics • Last-of-many call semantics • At-least-once call semantics • Discuss about the pros and the cons of dynamic binding in RPC. CSS490 RPC

More Related