4th International Conference on Principles and Practices ... - MADOC

Enabling Java Mobile Computing on the IBM Jikes
Research Virtual Machine
Giacomo Cabri
Dipartimento di Ingegneria
dell’Informazione – Università di
Modena e Reggio Emilia
cabri.giacomo@unimore.it
Letizia Leonardi
Dipartimento di Ingegneria
dell’Informazione – Università di
Modena e Reggio Emilia
leonardi.letizia@unimore.it
Raffaele Quitadamo
Dipartimento di Ingegneria
dell’Informazione – Università di
Modena e Reggio Emilia
quitadamo.raffaele@unimore.it
ABSTRACT
Today’s complex applications must face the distribution of data
and code among different network nodes. Java is a wide-spread
language that allows developers to build complex software, even
distributed, but it cannot handle the migration of computations
(i.e. threads), due to intrinsic limitations of many traditional
JVMs. After analyzing the approaches in literature, this paper
presents our research work on the IBM Jikes Research Virtual
Machine: exploiting some of its innovative VM techniques, we
implemented an extension of its scheduler that allows applications
to easily capture the state of a running thread and makes it
possible to restore it elsewhere (i.e. on a different hardware or
software architecture, but still with a version of JikesRVM
installed). Our thread serialization mechanism provides support
for both proactive and reactive migration of single- and multithreaded
Java applications. With respect to previous approaches,
we implemented the mobility framework without recompiling a
previous JVM source code, but simply extending its
functionalities with a full Java package.
Categories and Subject Descriptors
D.3.3 [Programming Languages]: Language Constructs and
Features D.1.3 [Concurrent Programming]: Distributed
Programming; D.3.3 [Programming Languages]: Language
Constructs and Features.
General Terms
Design, Experimentation, Languages.
Keywords
Java Virtual Machine, thread persistence, code mobility,
distributed applications.
1. INTRODUCTION
Modern distributed systems are becoming more and more
complex, leading to the need for flexibility, that has to be
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that
copies bear this notice and the full citation on the first page. To copy
otherwise, or republish, to post on servers or to redistribute to lists,
requires prior specific permission and/or a fee.
PPPJ2006, August 30 – September 1, 2006, Mannheim, Germany.
Copyright 2006 ACM …$5.00.
considered very desirable, if not mandatory, when large scale
distributed computations are performed. Conventional software
components, scattered among network nodes, provide services to
other components or to end users, but are often statically bound to
their hosting environment. This view is being challenged by
technical developments that introduce a degree of mobility in
distributed systems. Wireless LANs and mobile devices have
already highlighted the potentials of physical mobility [15, 4].
Code mobility is instead reshaping the logical structure of modern
distributed systems as it enriches software components (in
particular, execution units) with the capability to dynamically
reconfigure their bindings with the underlying execution
environments. The concept is simple and elegant; an object (that
may be active or passive) that resides on one node is migrated to
another node where execution is continued. The main advantages
of mobile computations, be they object-based or not, are as
follows: (i) load balancing: distributing computations (e.g. Java
threads) among many processors as opposed to one processor
gives faster performance for tasks that can be fragmented; (ii)
communication performance: active objects that interact
intensively can be moved to the same node to reduce the
communication cost for the duration of their interaction; (iii)
availability: objects can be moved to different nodes to improve
the service and provide better failure coverage or to mitigate
against lost or broken connections; (iv) reconfiguration: migrating
objects permits continued service during upgrade or node failure.
(v) location independence: an object visiting a node can rebind to
generic services without needing to specifically locate them. They
can also move to take advantage of services or capabilities of
particular nodes.
It can be argued that Java has all the prerogatives to make thread
mobility possible: its platform-independent bytecode language
and the support for object serialization. Regular Java object can
be easily made persistent or migrated to other machines, by means
of the JVM built-in serialization facility. Java threads are
coherently presented to the programmer as objects as well, but
their serialization does not produce the desired effect of
“capturing their current execution flow and resuming it
elsewhere”; it is just the java.lang.Thread object, with its
fields, that is serialized, while the real execution flow is still
tightly bound to the execution environment. The Java
programming language does not therefore support the migration
of execution units (e.g. threads), which exists for other languages
and specific operating systems [17].
Some kind of framework or “JVM enhancement” is thus needed
to enable mobile computations in distributed Java applications.
62