[concurrency-interest] 10 years later after Aglets ---the new techs for migration of Java Objects across JVMs

bing wang 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
     Open Question:
             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:

         Open Questions:

         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.
        Open Questions:
  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
constructor :
    *       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
not final.
    *      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 !

Appendix 1
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
is currently
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
that computations
are properly halted and properly resumed.

Lehrstuhl Modellierung und Simulation
Institut für Informatik
Universität Rostock
Joachim-Jungius-Str. 10
18059 Rostock

Original Affiliation
High Performance Simulation Group
School of Computer Science,
NUDT,Changsha Hunan 410073
P R China

More information about the Concurrency-interest mailing list