[concurrency-interest] 10 years later after Aglets ---the new techs for migration of Java Objects across JVMs
wangbing.nudt at gmail.com
Mon Jan 5 04:24:18 EST 2009
10 years later after Aglets ---the Tech for migration of Java Objects
across JVMs(Object level mobility)
Mobility and migration of Java object is a grundstein for many others
,such as Mobile Agent and loadballance.
There have been lots of efforts towards the mobility of Java Object
,IBM's Aglets Architecture and ObjectSpace's Voyager System,ProActive
,to name a few. some are commercial software ,some are not maintained
At the drawn of the Java 7 ,I would like to cast a brick on the
migration of Java Objects across JVMs. what new insight and new
technics we have gained after ten years' advance?
I would mark some of Point I thought is important and raise some opent
questions that puzzled me .
I notice that all the ways falls in two catalogues, the way with the
modification of the semantic of JVM and the ways keeping the
semantics by introducing restriction to how the Object would looks
I would like to focus on several concern of the later.
one way to achieve the migration is to exactly copy the state of the
Object .and create a new one with the state in the destination while
eradicating the original in an eligant way . Eligance ,here ,means
that before and after the migration , the Object should keep 2 kinds
of consistency: first , the consistency of the inside state ,and
second,apears consistency in the communication with other Objects
for example, a forwarder could help to forward the calls to the new
place and a naming service should tell others that he has change his
1 treatment to the referenced objects of the object being migrated
normally ,there could be three catologues for the referenced
objects involved in migreation
in the reference graph of the Object being migrated
* shared by all across all the JVM
* locally used by one JVM
* by the object itself
refering to the location : there could be 2 types of
references an object holds:
remote reference and local reference
which reference need to be transferred by object copy
,and which only need to by reference copy?
2 the definition of the the state and consistency of the state:
a what is state ?
is the thread stack or the Register Context a necessary part
of the state(see Appedix1) ?
or ,how do we elegantly pause the execution of a object to
hold the inner consisitency
how the forwarder pointing to the destination from the start
place to maintain the outer consistency?
or , we introduce highlevel agreement to the semantic of the
object we want to migrate .
b something can not be migrate trivially: threads.
3 What is the the sufficient and necessary wayto provide the feature
of mobile Agent.
a Does the java language (include the concurrency solution and the
java memory model ) provide all the mechanism for the migration?
b Is the ristriction in conducting a Object while keeping the semantic of Java
I would like to take the restriction introduced by
ProActive (http://proactive.inria.fr/)as an example :
* no public member ,for we can only monitor the call of function
* A no-argument constructor is necessary to create the stub
class needed for communication: prevent the making of the default
* provide remote functionalities as public methods with
return types that can be subclassed and are serializable - Since the
stub is created through inheritance, the only methods it can use for
communication are the inherited public methods from the superclass.
The return types of the methods have to be subclassable and therefore
* class and the argument for the constructor need to be serializable .
* special callback such as afterMigration and beforeMigration.
* no direct access to field variables
4 ways for the state transportation:
based on Serialization :involving all the reference in a naive way
based on the Java Bean
Thank you !
in" Mobile Agents with Java: The Aglet API "(1998.)
Danny B. Lange and Mitsuru Oshima argued that
No support for preservation and resumption of the execution state. It
impossible in Java to retrieve the full execution state of an object.
Information such as the
status of the program counter and frame stack is permanently forbidden
territory for Java
programs. Therefore, for a mobile agent to properly resume a
computation on a remote
host, it must rely on internal attribute values and external events to
direct it. An
embedded automaton can keep track of the agent's travels and ensure
are properly halted and properly resumed.
Lehrstuhl Modellierung und Simulation
Institut für Informatik
High Performance Simulation Group
School of Computer Science,
NUDT,Changsha Hunan 410073
P R China
More information about the Concurrency-interest