J-Orchestra: Automatic Java Application Partitioning
Eli Tilevich and Yannis Smaragdakis
Center for Experimental Research in Comp. Science (CERCS), College of Computing
Georgia Institute of Technology, Atlanta, GA 30332
{tilevich, yannis}@cc.gatech.edu
http://j-orchestra.org
Abstract. J-Orchestra is an automatic partitioning system for Java programs. J-
Orchestra takes as input Java applications in bytecode format and transforms
them into distributed applications, running on distinct Java Virtual Machines. To
accomplish such automatic partitioning, J-Orchestra uses bytecode rewriting to
substitute method calls with remote method calls, direct object references with
proxy references, etc. Using J-Orchestra does not require great sophistication in
distributed system methodology the user only has to specify the network loca-
tion of various hardware and software resources and their corresponding appli-
cation classes. J-Orchestra has signi cant generality, exibility, and degree of
automation advantages compared to previous work on automatic partitioning.
For instance, J-Orchestra can correctly partition almost any pure Java program,
allowing any application object to be placed on any machine, regardless of how
application objects access each other and Java system objects. This power is due
to the novel way that J-Orchestra deals with unmodi able code (e.g., native code
in the Java system classes). Additionally, J-Orchestra offers support for object
migration and run-time optimizations, like the lazy creation of distributed
objects.
We have used J-Orchestra to successfully partition several realistic applications
including a command line shell, a ray tracer, and several applications with native
dependencies (sound, graphics).
1 Introduction
Application partitioning is the task of breaking up the functionality of an application
into distinct entities that can operate independently, usually in a distributed setting.
Application partitioning has been advocated strongly in the computing press [11] as a
way to use resources ef ciently. Traditional partitioning entails re-coding the applica-
tion functionality to use a middleware mechanism for communication between the dif-
ferent entities. In this paper, we present an automatic partitioning system for Java
applications. Our system, called J-Orchestra, utilizes compiler technology to partition
existing applications without manual editing of the application source code.
Automatic partitioning aims to satisfy functional constraints (e.g., resource availabil-
ity). For instance, an application may be getting input from sensors, storing it in a data-
base, processing it, and presenting the results on a graphical screen. All four hardware
resources (sensors, database, fast processor, graphical screen) may be on different
machines. Indeed, the con guration may change several times in the lifetime of the
application. Automatic partitioning can accommodate such requirements without
needing to hand-modify the application source code. Thus, automatic partitioning is a

sophisticated alternative to input-output re-direction protocols (Java servlets, telnet, X-
Windows [15]). Automatic partitioning can do whatever these technologies do, with
the additional advantage that the partitioning of the application is completely exi-
ble different parts of the application can run on different machines in order to mini-
mize network traf c or reduce server load. For instance, instead of using X-Windows
to send graphics over the network, one can keep the code generating the graphics on
the same site as the graphics hardware.
J-Orchestra operates at the Java bytecode level and rewrites the application code to
replace local data exchange (function calls, data sharing through pointers) with remote
communication (remote function calls through Java RMI [18], indirect pointers to
mobile objects). The resulting application is guaranteed to have the same behavior as
the original one (with a few, well-identi ed exceptions). J-Orchestra receives input
from the user specifying the network locations of various hardware and software
resources and the code using them directly. A separate pro ling phase and static analy-
sis are used to automatically compute a partitioning that minimizes network traf c.
Although the signi cance of J-Orchestra may appear Java-speci c, there is a general
conceptual problem that J-Orchestra is the rst system to solve. This is the problem of
supporting transparent reference indirection in the presence of unmodi able code.
More speci cally, J-Orchestra is one of many systems that work by changing all direct
references to objects into indirect references (i.e., references to proxy objects). This
approach is hard to implement transparently when the program consists partly of
unmodi able code. We show that J-Orchestra can work around unmodi able code,
ensuring that it is clearly isolated from modi able code by dynamically wrapping
direct references to make them indirect (and vice versa), when the references are
passed from unmodi able to modi able code (and vice versa).
The result of solving the problems with unmodi able code is that J-Orchestra is the
rst automatic partitioning system that imposes no partitioning constraints on applica-
tion code. (We make a clear distinction between automatic partitioning systems and
general Distributed Shared Memory mechanisms in our related work discussion.)
Unlike previous systems (e.g., Addistant [19] the most mature and closest alternative
to J-Orchestra in the design space) J-Orchestra can partition any Java application,
allowing any application object to be placed on any machine, regardless of how appli-
cation objects interact among them and with system objects. Any system object can be
remotely accessed from anywhere in the network, although it has to be co-located with
system objects that may potentially reference it. (The terms application and sys-
tem objects roughly correspond to instances of regular classes of a Java application,
and of Java system classes with native dependencies, respectively.)
In this paper, we present the main elements of the J-Orchestra rewrite engine. We
describe the J-Orchestra rewrite algorithm, discuss its power and detail how J-Orches-
tra deals with various features of the Java language. Finally, we examine some J-
Orchestra optimizations and present performance measurements that demonstrate the
advantage of J-Orchestra over input/output redirection with X-Windows.