Transcript Distributed Systems - Aatif Kamal

Dated: Nov 2006
Distributed Computing
Class: BIT5
Instructor: Aatif Kamal
Chapter 05:
Distributed Objects and Remote
Invocation
Objectives of the lecture
 Essence of distributed commuting
 To study communication between
distributed objects and the integration of
remote method invocation into a
programming language.
 To be able to use Java RMI to program
applications with distributed objects and
how to use some aspects of reflection
 To study the extension of the event-based
programming model to apply to distributed
event-based programs.
2
Revision
 Two alternative building blocks


Datagram Socket: based on UDP, efficient but
suffer from failures
Stream Socket: based on TCP, reliable but
expensive
 Marshalling

CORBA’s CDR and Java serialization
 Request-Reply protocol

Base on UDP or TCP
 Group communication

IP multicast is a simple multicast protocol
3
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
4
Middleware
 Layers of Middleware
 Provide a programming model
 Provide transparency
 Location
 Communication
protocols
 Computer hardware
 Operating systems
 Programming languages
5
Middleware layers
Applications
RMI, RPC and events
Request reply protocol
Middleware
layers
External data representation
Operating System
6
Distributed programming model
 Remote procedure call (RPC)


Birrel and Nelson (1984)
call procedure in separate process
 Remote method invocation (RMI)


extension of local method invocation in OO model
invoke the methods of an object of another
process
 Event-based model


Register interested events of other objects
Receive notification of the events at other objects
7
Conventional Procedure Call
a)
b)
Parameter passing in a local procedure call: the stack before the call
to read
8
The stack while the called procedure is active
Client and Server Stubs
 Principle of RPC between a client and server program.
9
Steps of a Remote Procedure Call
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
Client procedure calls client stub in normal way
Client stub builds message, calls local OS
Client's OS sends message to remote OS
Remote OS gives message to server stub
Server stub unpacks parameters, calls server
Server does work, returns result to the stub
Server stub packs it in message, calls local OS
Server's OS sends message to client's OS
Client's OS gives message to client stub
Stub unpacks result, returns to client
10
Passing Value Parameters (1)
 Steps involved in doing remote computation through RPC
2-8
11
Passing Value Parameters (2)
a)
b)
c)
Original message on the Pentium
The message after receipt on the SPARC
The message after being inverted. The little numbers in boxes
indicate the address of each byte
12
Interfaces
 Interface


Specifies accessible procedures and variables
Inner alteration won’t affect the user of the
interface
 Interface in distributed system



Can’t access variables directly
Input argument and output argument
Pointers can’t be passed as arguments or
returned results
13
Interface cases
 RPC’s Service interface


specification of the procedures of the server
input and output arguments of each procedure
 RMI’s Remote interface


Specification of the methods of an object that are available
for objects in other processes
may pass objects or remote object references as arguments
or returned result
 Interface definition languages


program language, e.g. Java RMI
Interface definition language (IDL), e.g. CORBA IDL, DCE
IDL and DCOM IDL
14
CORBA IDL example
// In file Person.idl
struct Person {
string name;
string place;
long year;
};
interface PersonList {
readonly attribute string listname;
void addPerson(in Person p) ;
void getPerson(in string name, out Person p);
long number();
};
15
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
16
Discuss RMI under following headings
 The object model
 Distributed objects
 The distributed object model
 Design issues
 semantics
of remote invocations
 Implementation
 RMI
above the request-reply protocol
 Distributed garbage collections
17
The object model
 Object references


Objects can be accessed via object references
First-class values
 Interfaces



A definition of the signatures of a set of methods
No constructers
A class can implement several interfaces, e.g. Java
 Actions


Initiated by an object invoking a method in another object
Two affects
 Change the state of the receiver
 Further invocations on methods in other objects
18
The object model
 Exceptions mechanism




A clean way to deal with error conditions
List exceptions at the method head
throw user know exceptions
Catch exceptions
 Garbage collection



Freeing the space occupied by cancelled objects
C++: collected by programmers
Java: collected by JVM
19
Distributed objects
 Natural extension

physical distribution of objects into different processes or
computers in a distributed system
 Benefits of distributed objects


Enforce encapsulation
 can’t access variables directly
Support heterogeneous systems
 Assume other architectural models then
client/server


Replicated objects
Migrated objects
20
Remote and local method invocations
remote
invocation
local
C
invocation
local
E
invocation
A
B
remote
invocation
F
local
invocation
D
21
The distributed objects model
 Remote object reference


A unique identifier in a distributed system
May be passed as arguments and results of remote method
invocation
 Remote interface

remote object class implements the methods of its remote
interface
 Actions in a distributed systems

may incur a chain of invocations on different computers
 Garbage collection

Usually based on reference counting
 Exception

notify the client and the client handle exceptions
22
A remote object and its remote interface
remoteobject
Data
remote
interface
{
m1
implementation
m2
m3
of methods
m4
m5
m6
23
Design Issues – Invocation semantics
 Choices for different delivery guarantees



retry request message
duplicate filtering
retransmission of results
 Three different semantics
Fault tolerance measures
Retransmit request
message
Duplicate
filtering
Invocation
semantics
Re-execute procedure
or retransmit reply
No
Not applicable
Not applicable
Maybe
Yes
No
Re-execute procedure
At-least-once
Yes
Yes
Retransmit reply
24
At-most-once
Different invocation semantics
 Maybe



For invoker: executed once, or not at all ???
Suffer from: (1) message lost; (2) server crash
Useful for app. in which occasional failed invocation are
acceptable
 At least once


For invoker: execute at least once, or an exception
Suffer from: (1) server crash; (2) arbitrary failures for nonidempotent method
 At most once


For invoker: receives result, or an exception
Prevent: omission failures by retrying, arbitrary failures
25
Design Issues - Transparency
 What can be made transparent



marshaling
message passing
object locating and contacting
 What can’t be made transparent


vulnerable to failure
latency
 Current consensus(Jim Waldo research paper)


Syntax of remote invocation should be same as of local
invocation
Difference in remote and local objects should be expressed
in their interfaces
26
Implementation of RMI
 The inner scene of RMI
 Communication module



Request/reply between client and server
As discussed in chapter 4, figure 4.13
Communication module at Server side Select dispatcher at server
 Remote reference module
 Translate between local and remote object reference
 Create remote object reference
 Remote object table



entries for remote objects held by the process
entries for local proxies
Actions of RRM


When a remote object is to be passed as argument or result for the
first time the remote reference module is asked to create a remote
object reference, which it adds to its table
When a remote object reference arrives in a request or reply message,
the remote reference module is asked for the corresponding local
27
object reference, which may either refer to proxy or remote object
Request-reply message structure (fig 4.13)
messageType
int (0=Request, 1= Reply)
requestId
int
objectReference
RemoteObjectRef
methodId
int or Method
arguments
array of bytes
28
The role of proxy and skeleton in remote method invocation
server
client
object A proxy for B
Request
skeleton
& dispatcher
remote
object B
for B’s class
Reply
Communication
Remote
reference module
module
Communication Remote reference
module
module
29
Implementation of RMI – RMI software
 Proxy



forward invocation to remote object
one remote object one proxy
implement the method in the remote interface

It marshals a reference to the target object , its own methodId and its
arguments into request message and send it to the target, awaits the
reply and message, unmarshals it and returns the results to invoker
 Skeleton





implement the method in the remote interface
unmarshal the arguments in the request
invoke the corresponding method in the remote object
wait for the invocation complete
marshal the result in the reply message
 Dispatcher


Receive the request from communication module and select
appropriate method in the skeleton
one dispatcher and skeleton for one remote object
30
Implementation of RMI - execution
 The classes for proxies, dispatchers and
skeletons

generated automatically by an interface compiler, e.g. rmic
 Server program


create and initialize at least one of the remote objects
register
 Client program



look up the remote object references
Invoke
Factory methods
 Remote object interface cannot have constructors
 Remote objects are either created in initialization section or
in remote methods designed for that purpose, called factory
methods
31
Implementation of RMI - Object state
 The binder

A service that maintains mapping information of textual
names to remote object references
 Activation of remote objects






to avoid resource waste, the servers can be started
whenever they are needed- FTP service
Activators: process that start server processes to host
remote objects.
a remote object could be active or passive
Passive object: consist of two parts
 Implementation of its methods
 Its state in marshaled form
Activation: Making a new object from corresponding passive
object by creating a new instance of its class and initializing
its variables from the stored state
Java RMI uses one activator on each server computer , 32
which is responsible for activating objects on that computer.
Implementation of RMI - Object state (cont..)
 Persistent object stores
 Persistent object


Persistent Object Store


Manage and store the state of persistent objects
different passivate strategies



an object that is guaranteed to live between
activations of processes
at the end of a transaction
when the program exit
E.g., Persistent Java, PerDiS
33
Distributed garbage collection
 The aim of a distributed garbage collector


Retain the object (local&remote) when it is still be referenced
Collect the object when none holds reference to it
 Java distributed garbage collection algorithm

based on reference counting


Whenever a remote object enters a process, a proxy is created and will
stay there for as long as needed. The process where the actual object
lives (server) should be informed, then later when there is no longer a
proxy at the client, server should be informed
Distributed Garbage collection works in corporation with local
garbage collectors
 server maintain processes set that hold remote object
references to it for each of its remote objects
 client notify server to modify the process set
 when the process set becomes empty, server local garbage
collector reclaims the space
34
Distributed garbage collection (cont..)
 Leases in Jini


lease: the granting of the use of a resource for
a period of time
avoid to discover whether the resource users
are still interested or their programs have not
exited
35
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
36
RPC is very similar to RMI




Service interface: the procedures that are available for remote calling
Invocation semantics choice: at-least-once or at-most-once
Generally implemented over request-reply protocol
Building blocks
 Communication module
 Client stub procedure (as proxy in RMI): marshalling, sending,
unmarshalling
 Dispatcher: select one of the server stub procedures
 Server stub procedure (as skeleton in RMI): unmarshalling, calling,
marshalling
client process
server process
Request
client stub
procedure
client
program
Communication
module
Reply
server stub
procedure
Communication
dispatcher
module
service
procedure37
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
38
Event-notification model
 Idea

one object react to a change occurring in another object
 Event examples


modification of a document
A new doc added in an electronically tagged book
 Publish/subscribe paradigm



event generator publish the type of events
event receiver subscribe to the types of events that are interest
to them
When event occur, notify the receiver
 Distributed event-based system – two characteristics


Heterogeneous
asynchronous
39
Example - dealing room system
• Requirements
– allow dealers to see the latest market price information
• System components
– Information provider
• receive new trading information
• publish stocks prices event
• stock price update notification
– Dealer process
• subscribe stocks prices event
• System architecture
40
Dealing room system
Dealer’s computer
Dealer
Dealer’s computer
External
source
Notification
Notification
Information
provider
Notification
Notification
Dealer
Notification
Notification
Notification
Dealer’s computer
Dealer’s computer
Notification
Information
provider
Notification
Notification
Dealer
Dealer
External
source
41
Architecture for distributed event notification
 Event service: maintain a database of published events and of
subscribers’ interests
 decouple the publishers from the subscribers
Event service
subscriber
object of interest
1.
notification
object of interest
2.
object of interest
3.
notification
observer
subscriber
notification
observer
subscriber
notification
42
The roles of the participating objects
 The object of interest

its changes of state might be of interest to other objects
 Event

the completion of a method execution
 Notification

an object that contains information about an event
 Subscriber

an object that has subscribed to some type of events in another
object
 Observer objects

the main purpose is to decouple an object of interest from its
subscribers
 Publisher

an object that declares that it will generate notifications of
particular types of event
43
Notification delivery
 Delivery semantics



Unreliable
Reliable
real-time
 Roles for observers




Forwarding
 send notifications to subscribers on behalf of one or more
objects of interests
Filtering of notifications
Patterns of events
Notification mailboxes
 notification be delayed until subscriber being ready to
receive
44
Jini distributed event specification
 EventGenerator interface



Provide register method
Event generator implement it
Subscriber invoke it to subscribe to the interested events
 RemoteEventListener interface



Provide notify method
subscriber implement it
receive notifications when the notify method is invoked
 RemoteEvent

a notification that is passed as argument to the notify method
 Third-party agents


interpose between an object of interest and a subscriber
equivalent of observer
45
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 RPC Case Study
 Java RMI case study
 Summary
46
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed
objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
49
Chapter 5: Distributed objects and remote invocation
 Introduction
 Communication between distributed objects
 Remote procedure call
 Events and notifications
 Java RMI case study
 Summary
53
Summary
 Two paradigms for distributed programming
 RMI(RPC)/Event notification: sync./async.
 RMI
 Distributed object model
 Remote interface, remote exception, naming service
 Remote invocation semantics
 Once, at-least-once, at-most-once
 Sun RPC
 Event-notification

Publish/subscribe
Event service

Example: dealing room

54
Assignment 6
Q.1 From the book: Distributed Operating Systems, A. S. Tanenbaum,
Summarize section 2.4 in you own words
Q.2 Read the following paper: and summarizes in your own words. Finally give
your own comments on the issues discussed in the paper.
A Note on Distributed Computing, Jim Waldo
Sun Microsystems site:
http://research.sun.com/techrep/1994/smli_tr-94-29.pdf
After carefully reading and understanding the article you have too write
one page overview of this note.
62
Assignment 7
Q.1
5.1
Q.2
5.3
Q.3
5.4
Q.4
5.5
63
Assignment 8
Q.1
5.12
Q.2
5.13
Q.3
5.17
Reading
5.3 RPC
5.5 Java RMI case study
64