Find JSRs
Submit this Search

Ad Banner

Summary  |  Proposal  |  Detail (Summary & Proposal)
JSRs: Java Specification Requests
JSR 323: Strong Mobility for JavaTM

Stage Access Start Finish
JSR Review Ballot Failed   22 Jan, 2008  
Rejected   22 Jan, 2008  
JSR Review Ballot View results 08 Jan, 2008 22 Jan, 2008
Status: Rejected
Reason: This JSR was not approved by the SE/EE Executive Committee in the JSR Approval Ballot.
JCP version in use: 2.6
Java Specification Participation Agreement version in use: 2.0

Strong Mobility is the movement of code, data and execution state from one location to another. This specification defines byte-code transformation to achieve Strong Mobility for Java-based programs.

Please direct comments on this JSR to the Spec Lead(s)

Specification Leads
  Hiroki Suguri Suguri, Hiroki
Expert Group
  Curdt, Torsten Keil, Werner Suguri, Hiroki

This JSR has been Rejected
Reason: This JSR was not approved by the SE/EE Executive Committee in the JSR Approval Ballot.

If you would like to be added to the observer alias for this JSR and receive e-mail updates on the progress of the JSR, please send e-mail to the Spec Lead with "Add to observer alias" in the subject line.

Original Java Specification Request (JSR)

Identification | Request | Contributions | Additional Information

Section 1. Identification

Submitting Member: Hiroki Suguri

Name of Contact Person: Hiroki Suguri

E-Mail Address:

Telephone Number: +81 22 222 2591

Fax Number: +81 22 222 2545

Specification Lead: Hiroki Suguri

E-Mail Address:

Telephone Number: +81 22 222 2591

Fax Number: +81 22 222 2545

Initial Expert Group Membership:

Hiroki Suguri (Individual)
Naveed Khan (Individual)
Hafiz Farooq Ahmad (Individual)
Misbah Mubarak (Individual)

Supporting this JSR:

Hiroki Suguri (Individual)
Naveed Khan (Individual)
Hafiz Farooq Ahmad (Individual)
Misbah Mubarak (Individual)

Section 2: Request

2.1 Please describe the proposed Specification:

The proposed specification will define a technique to achieve Strong Mobility for programs that are written in Java programming language. Strong Mobility is the movement of code, data and execution state of a program from one location to another, which leads to fault tolerance, reliability and efficient use of resources.

To achieve Strong Mobility in Java, information is required about the data and the execution state of a program. JVM contains all the information required to achieve Strong Mobility. However, for security reasons, JVM does not allow user threads to access the information.

In the past, several techniques were proposed and implemented in order to facilitate the Java threads with transparent migration. But those techniques were devised for specific applications such as mobile agents. They cannot be used in a generic way. The procedure of using those techniques for achieving Strong Mobility was also complex. The software quality parameters like efficiency, optimum use of memory, network resources, fault tolerance, reliability, portability and minimum code overhead were not given too much attention in the previous techniques. For example, one technique is to extend the JVM in order to allow user threads to access the execution state information required for the Strong Mobility. But this will compromise the portability feature of Java. Another technique is to modify the compilation model. This technique involves the insertions of state saving and resuming constructs at the source code or at the byte-code level.

The proposed solution comes under the compilation model modification category. This specification defines byte-code modification techniques for adding the feature of Strong Mobility to programs written in Java. The API transforms the class file to insert byte code instructions in order to enable the class to save its data and execution state before migration. The first task is to extract the byte code attributes like line number table, fields, methods, inner classes, exception table and other byte code attributes using reflection. The second task is to convert those instructions into portable Java format. These instructions are then used by the transformer to insert them into the class file for the purpose of state saving and resumption.

2.2 What is the target Java platform? (i.e., desktop, server, personal, embedded, card, etc.)

Java SE

2.3 The Executive Committees would like to ensure JSR submitters think about how their proposed technology relates to all of the Java platform editions. Please provide details here for which platform editions are being targeted by this JSR, and how this JSR has considered the relationship with the other platform editions.

The proposed specification is targeted for Java SE 1.3 or above because it utilizes reflection.

2.4 Should this JSR be voted on by both Executive Committees?

No. SE/EE EC only.

2.5 What need of the Java community will be addressed by the proposed specification?

This specification enables efficient byte-code transformation for Strong Mobility in Java. The technique is presented in the form of Java Strong Mobility API that addresses the need of reliability, fault tolerance, optimum use of resources (in terms of memory and network bandwidth) and load balancing by making the Java threads persistent and strongly mobile. The Strong Mobility API saves all of the computation states while the program is executing. The computation can then be restored at some later time on the same machine or at some remote machine.

2.6 Why isn't this need met by existing specifications?

Java Development Kit provides enough native facilities to support weak code mobility, which does not preserve the execution state of the threads. Due to the compilation of source code into intermediate byte-code, Java is perfect for weak code mobility.

However, the JVM doesn't support strong thread migration. To implement Strong Mobility, JVM code should be modified in order to extract Java stack and program counter of a thread to be moved. In particular program counter is an internal variable of the JVM that can be easily accessed, transferred and restored at the remote destination. The main difficulty is related with the JVM stack because JVM accumulates operands of each microinstruction at the stack, whose elements are generic type. Since each microinstruction knows exactly which type of operands to use, JVM works even if real type of stack elements is unknown.

The problem arises when we want to transfer one JVM stack to another JVM. Since JVM is written in C language, it is not assured that the same type has the same internal representation in terms of both bit representation of types and order of bytes. Therefore, a parallel stack is required to safely transfer each element of the stack with the right representation from source node to the destination node. Moreover, to make the thread persistent, it must be serialized in order to be written to the stream of bytes. However, threads execute native instructions. Therefore, it is not directly serializable and cannot written to a file in the form of stream of bytes.

2.7 Please give a short description of the underlying technology or technologies:

Strong Mobility is realized by the following two sets of APIs:

1) Transformer
This component is for transformation of the class file. It takes any class file and inserts state saving and resuming instructions at the byte-code level. The byte-code attributes like line number tables, exceptions, java frames local variables and operand stacks are extracted from the class file and transformed. After that, those attributes are converted to portable Java format.

2) Executer
After the transformation of the class file, a mechanism to execute that class file is necessary. When a thread is executing in JVM, we cannot serialize it because of native code. So in order to make the thread persistent and mobile, we have to make it serializable. This component wraps a thread with a class that has implemented serializable interface.

In target Java source file, a method named yield with argument true is called to prepare the migration. Then an object of Mobile class is instantiated with the arguments that are the object of target class and string name of the class. The transformation is performed by giving target class file as an input to Renovator class. The Renovator transforms that class and inserts the state saving and resuming instructions to the class file at byte-code level. When the transformed class is invoked, the thread is serialized and written to the file as a stream of bytes. The serialized file can then be transferred to any remote location where its execution can be resumed from the point it was suspended.

2.8 Is there a proposed package name for the API Specification? (i.e., javapi.something, org.something, etc.)


2.9 Does the proposed specification have any dependencies on specific operating systems, CPUs, or I/O devices that you know of?


2.10 Are there any security issues that cannot be addressed by the current security model?

As far as we know, there are no security issues. However, this must be investigated by the group of experts.

2.11 Are there any internationalization or localization issues?


2.12 Are there any existing specifications that might be rendered obsolete, deprecated, or in need of revision as a result of this work?


2.13 Please describe the anticipated schedule for the development of this specification.

Formation of the Expert Group February 2008
Early Draft Submitted May 2008
Early Draft Review Closed August 2008
Public Draft Submitted November 2008
Public Review Closed February 2009
Final Draft Submitted May 2009

2.14 Please describe the anticipated working model for the Expert Group working on developing this specification.

The primary means of communication between Expert Group members will be email. Conference calls and face-to-face meetings will be arranged as needed.

2.15 It is important to the success of the community and each JSR that the work of the Expert Group be handled in a manner which provides the community and the public with insight into the work the Expert Group is doing, and the decisions that the Expert Group has made. The Executive Committees would like to ensure Spec Leads understand the value of this transparency and ask that each JSR have an operating plan in place for how their JSR will address the involvement of the community and the public. Please provide your plan here, and refer to the Spec Lead Guide for a more detailed description and a set of example questions you may wish to answer in your plan.

Standard practices of open source development will be fully exercised. The membership of the EG will remain open until the submission of the final draft. The project will utilize services to provide up-to-date information on the development of the specification, RI and TCK, to solicit feedback from public, and to facilitate distributed development of the source code.

2.16 Please describe how the RI and TCK will de delivered, i.e. as part of a profile or platform edition, or stand-alone, or both. Include version information for the profile or platform in your answer.

The RI and TCK will be delivered as stand-alone package for Java SE 1.3 or above.

2.17 Please state the rationale if previous versions are available stand-alone and you are now proposing in 2.13 to only deliver RI and TCK as part of a profile or platform edition (See sections 1.1.5 and 1.1.6 of the JCP 2 document).


2.18 Please provide a description of the business terms for the Specification, RI and TCK that will apply when this JSR is final.

The Specification, RI and TCK will be licensed under some open-source license such as GPL. Details will be determined by the submission of the final draft.

Section 3: Contributions

3.1 Please list any existing documents, specifications, or implementations that describe the technology. Please include links to the documents if they are publicly available.

(1) A. Acharya, M. Ranganathan, J. Saltz, "Sumatra: a Language for Resource Aware Mobile Programs, Mobile Object Systems, Lecture Notes in Computer Science, No. 1222, Springer Verlag (D), pp. 111-130, February 1997.
(2) Stefan Funfrocken, Transparent Migration of Java-Based Mobile Agents: Capturing and Reestablishing the State of Java Programs, In Proceedings of the Second International Workshop on Mobile Agents, Lecture Notes in Computer Science, No. 1477, Springer-Verlag, pp. 26-37, Stuttgart, September 1998.
(3) Takahiro Sakamoto, Tatsurou Sekiguchi, and Akinori Yonezawa. Bytecode Transformation for Portable Thread Migration in Java. In Proceedings of the Joint Sym- posium on Agent Systems and Applications / Mobile Agents (ASA/MA), pages 16--28, September 2000.
(4) Misbah Mubarak. A review of mobility techniques. In proceedings of 19th Assurance Systems Symposium, pp. 25-32, Tokyo Institute of Technology, Japan, 2006
(5) Tim Lindholm, Frank Yellin. "The Java Virtual Machine Specification, Second Edition.

3.2 Explanation of how these items might be used as a starting point for the work.

Paper (4) surveys various mobility techniques including (1)-(3) and it makes a good starting point. The initial members of the JSR have implemented and evaluated the proposed Strong Mobility framework and are preparing the journal paper submission.

Section 4: Additional Information (Optional)

4.1 This section contains any additional information that the submitting Member wishes to include in the JSR.