CSS490 RPC and RMI

Textbook Ch4
Instructor: Munehiro Fukuda

These slides were compiled from the course textbook, the reference books, and
the instructors original materials.

Winter, 2004

CSS490 RPC

Why RPC
Calling a function at a remote server:

Advanced form of communication

Transparency in function calls

Sockets and MPI: data transfer

RPC: control transfer
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
Winter, 2004
CSS490 RPC

RPC Model
Caller (Client)

RPC and wait

Callee (Server)

Request message
including arguments

Suspended
Reply message
Including a return value

Request message accepted

Execution environment create
Execution of function body
Send reply and wait for the ne
request

Resume execution

Winter, 2004

CSS490 RPC

Implementation Issues

Transparency property

Analogy in semantics b/w local and remote procedure calls

Syntactic transparency
Semantic transparency
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.

Winter, 2004

CSS490 RPC

RPC Mechanism
Interface Definition Language
File
Client Program
Server Program
Define arguments
Return
Call
Return
Call
Register remote functions
IDL Compiler
Server Stub

Client Stub
Message
marshaling
Decoding Encoding
Retransmission
RPC Runtime acknowledgments
Receive
Send Routing
encryption
args

PRC id client id

(5) Exception?
Message
(4) Invalid arguments?
Decoding Encoding
(3) Invalid procedure?
RPC Runtime
Receive

(2) Unauthorized client?

Send (1) Intelligible messages

type
msg id
(call)
msg id

Winter, 2004

CSS490 RPC

type reply fesults

(reply) status failur

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.

Winter, 2004

CSS490 RPC

Server Creation Semantics

Instance-per-Call Servers

Instance-per-Session Servers

A new server process launched every call

Statelss servers only
OS resource allocation/de-allocation involved every call
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

Winter, 2004

CSS490 RPC

Parameter-Passing
Semantics

Server

Client

class objA {
objB b;
objC c;
}

class objB {
}
class objC {
}

Winter, 2004

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.

CSS490 RPC

Call Semantics

What if Node 1 temporally crash

RPC may result in failure and thus be calledBefore a RPC response?

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

Winter, 2004

CSS490 RPC

Node 1

Orphan
call

2nd
call

Node 2

Node 3

Client-Server Binding
(SunRPC)

Server Machine

Client Machine

(2) Locating server

Client

(3) Server port (xxx)

Portmap
Daemon

port: 111

(1) register port: xxx

(4) RPC with port xxx
Server
write(), read(),
write(), read(),
Sendto(), recvfrom(
Sendto(), recvfrom()

TCP or UDP

Transport level or below TCP or UDP

Network (LAN/WAN)

(1) pmap_set(prognum, versnum, protocol, port)

(2) and (3) pmap_getport(addr, prognum, versnum, protocol)
To check the status of portmap, rpcinfo

Winter, 2004

CSS490 RPC

10

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 servers disk access with server computation

Winter, 2004

CSS490 RPC

11

SunRPC
Modify by yourself
example_client.o
example_client.c
rpcgen a example.x

Client program

Your client
example_clnt.c

example_client

example_clnt.o

Client stub
example_h.c
example.x
Interface
descriptions

gcc c -o

Header
example_xdr.c

ld -o
example_xdr.o

Marshalling
example_svc.c

example_svc.o
Server program

Server stub
example_server.c

example_server.o

example_server

Your server Modify by yourself

Winter, 2004

CSS490 RPC

12

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;
double POWER( doubles )
= 2;
string STRCONC( strings ) = 3;
} = 1;
} = 0x31234567;

Winter, 2004

/* procedure number = 1 */
/* procedure number = 2 */
/* procedure number = 3 */
/* version number = 1 */
/* program number = 0x31234567 */

CSS490 RPC

13

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);

Winter, 2004

CSS490 RPC

int
main (int argc, char *argv[])
{
char *host;

exit (0);
}

if (argc < 2) {
exit (1);
host = argv[1];
example_prog_1 (host);

14

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;

Winter, 2004

CSS490 RPC

15

SunRPC v.s. Java RMI

Advantages

SunRPC

Java RMI

Template generation
Dynamic port
assignment
High performance

Automatic
serialization
Manual IP port
handling
Good security

Disadvantag Manual serialization

es
Weak to hackers

Winter, 2004

Low performance

CSS490 RPC

16

Serialization
Manual Operations in C++
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; }
};

MainObj

Read/write

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( );
}

Winter, 2004

CSS490 RPC

17

Serialization
Automatic 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( );
}
}

Winter, 2004

CSS490 RPC

18

Serialization
Serializable 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

Winter, 2004

CSS490 RPC

19

RMI
Programming Procedure
(4) Program a Client.java class
(5) javac Client.java
(8) Run Client with java Client

Application Layer:

Client .java

(2) Program a Server.java class

(7) Run Server with java Server

Server.java
(implements remote interface)

(1) Define a remote interface

Stub/Skeleton:

Stub

(3) javac Server.java

rmic Server

Skeleton
Server_Stub.class Server_Skel.class

(6) Inovke a rmi registry

Remote Reference:

rmiregistry [port#]
(object manager/name service)

request and result

Transport Layer:

Winter, 2004

TCP/IP

CSS490 RPC

20

RMI
Remote 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 ); }
}

Winter, 2004

CSS490 RPC

21

RMI
Server Implementation
import java.io.*;
import java.util.*;
import java.rmi.*;
import java.rmi.server.*;

(1) Implement a remote interfac

Public class Server extends UnicastRemoteObject implements ServerInterface {

static private int i = 0; (2) Inherit a RemoteObject
public Server( ) throws RemoteException{
(3) Define a constructor
}
public static void main( String args[] ) {
try {
Server server = new Server( ); (4) Instantiate a RemoteObject
Naming.rebind( server, server );
} catch ( Exception e ) {
System.err.println( Exception: + e );
System.exit( 1 );
}
(5) Implement all methods declared in a remote inter
}
public ReturnObject get( ) throws RemoteException {
ReturnObject f = new ReturnObject( i++, new SubObject( i ) );
return f;
}
}

Winter, 2004

CSS490 RPC

22

RMI
Client Implementation
Import java.rmi.*;
Import java.io.*;

Public class Client {

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

Winter, 2004

CSS490 RPC

23

RMI
Compilation 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
%

Winter, 2004

CSS490 RPC

24

Exercises (No turn-in)

1.

2.

3.

4.

5.

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:
1.
Call-by-object-reference
2.
Call-by-move
3.
Call-by-visit
What is an orphan call? How are orphan calls handled in the
implementation of the following types of call semantics:
1.
Last-one call semantics
2.
Last-of-many call semantics
3.
At-least-once call semantics
Discuss about the pros and the cons of dynamic binding in RPC.

Winter, 2004

CSS490 RPC

25