Home
Call for Participation
Register
Program
Tutorials
List of Papers
List of Posters
People
Java Grande Charter
Related Links
Old:
CFP (TXT)
Paper Submissions page
|
JGI'02 - Posters Accepted
Title: Scalable Distributed Concurrency Services for Hierarchical Locking
Authors: Nirmit Desai, North Carolina State University
Frank Mueller, North Carolina State University
Title: Gain Time Reclaiming in High Performance Real-Time Java Systems
Authors: Erik Yu-Shing Hu, University of York
Andy Wellings, University of York
Guillem Bernat, University of York
Title: Improving the Memory Management Performance of RTSJ
Authors: M. Teresa Higuera-Toledano, Universidad Complutense de Madrid
Title: Measuring the Impact of Object-oriented Techniques in Grande
Applications: a method-level analysis
Authors: James Power, National University of Ireland Maynooth
John Waldron, Trinity College Dublin
Title: Compiler Transformations for Optimizing OoLaLa
Authors: Mikel Lujan, University of Manchester
T.L. Freeman, University of Manchester
John R. Gurd, University of Manchester
Title: Edge-Server Caching of Enterprise JavaBeans: Architecture and
Implementation
Authors: Avraham Leff, IBM T. J. Watson Research Center
James Rayfield, IBM T. J. Watson Research Center
Title: Using MPI with C# and the Common Language Infrastructure
Authors: Jeremiah Willcock, Open Systems Laboratory, Indiana University
Andrew Lumsdaine, Open Systems Laboratory, Indiana University
Arch Robison, KAI Software Laboratories, Intel Corporation
Title: Execution of Monolithic Java Programs on Large Non-Dedicated
Collections of Commodity Workstations
Authors: Michael Factor, IBM Research Lab in Haifa
Assaf Schuster, Technion - Israel Institute of Technology
Konstantin Shagin, Technion - Israel Institute of Technology
Title: RMIX: Multiprotocol RMI Framework for Java
Authors: Dawid Kurzyniec, Emory University
Tomasz Wrzosek, Emory University
Vaidy Sunderam, Emory University
Aleksander Slominski, Indiana University
Title: Using Java.nio for High Performance Message Passing
Authors: William Pugh, University of Maryland
Jaime Spacco, University of Maryland
Title: Parallel Operation of CartaBlanca on Shared and Distributed
Memory Computers
Authors: Nely Padial-Collins, Los Alamos National Laboratory
William VanderHeyden, Los Alamos National Laboratory
Duan Zhang, Los Alamos National Laboratory
Edward Dendy, Los Alamos National Laboratory
Daniel Livescu, Los Alamos National Laboratory
Title: Efficiently Distributing Component-based Applications Across
Wide-Area Environments
Authors: Deni Llambiri, New York University
Alexander Totok, New York University
Vijay Karamcheti, New York University
Title: Support and Optimization of Java RMI over Bluetooth Environments
Authors: Pu-Chen Wei, National Tsing Hua University
Chung-Hsin Chen, National Tsing Hua University
Cheng-Wei Chen, National Tsing Hua University
Jenq-Kuen Lee, National Tsing Hua University
Title: Understanding the Performance of the Java Operating System JX
using Visualization Techniques
Authors: Michael Golm, University of Erlangen
Christian Wawersich, University of Erlangen
Joerg Baumann, University of Erlangen
Meik Felser, University of Erlangen
Juergen Kleinoeder, University of Erlangen
Title: A Java Embedded MIcro-kernel Infrastructure
Authors: Mark Baker, Distributed Systems Group, Unversity of Portsmouth
Hong Ong, Distributed Systems Group, Unversity of Portsmouth
Title: Benchmarking Java against C/C++ for Interactive Scientific
Visualization
Authors: Sudhir Sangappa, Advanced Visual Systems Inc
Richard Tollerton, Visualization Lab,
CECS University of Missouri - Columbia
Palaniappan K, Visualization Lab,
CECS University of Missouri - Columbia
Title: Experience with integrating Java with new technologies: C#, XML
and web services
Authors: Judith Bishop, University of Pretoria
R Nigel Horspool, University of Victoria
Basil Worrall, University of Pretoria
Title: Application/Kernel Cooperation Towards the Efficient Execution of
Shared-memory Parallel Java Codes
Authors: Jordi Guitart, Computer Architecture Dept.
- Technical University of Catalonia
Xavier Martorell, Computer Architecture Dept.
- Technical University of Catalonia
Jordi Torres, Computer Architecture Dept.
- Technical University of Catalonia
Eduard Ayguade, Computer Architecture Dept.
- Technical University of Catalonia
Title: CSFS: A Java Enabled Network File Storage System
Authors: Hua HAN, Dept. of Computer Science and Technology, Peking Univ.
Yafei DAI, Dept. of Computer Science and Technology, Peking Univ.
Xiaoming LI, Dept. of Computer Science and Technology, Peking Univ.
Title: Zero overhead Java thread serialization
Authors: Sara Bouchenak, INRIA
Daniel Hagimont, INRIA
Title: An Object Oriented Approach to the Direct Simulation Monte
Carlo Method
Authors: Darryl Genovesi, The Pennsylvania State University
Lyle Long, The Pennsylvania State University
Scalable Distributed Concurrency Services for Hierarchical Locking
Middleware components are becoming increasingly important as
applications share computational resources in distributed
environments. One of the main challenges in such environments is to
achieve scalability of synchronization. Another challenge is to ensure
low latency and predictable response time. In general, concurrency
services arbitrate resource requests in distributed systems. But
concurrency protocols currently lack predictability and scalability.
Adding such guarantees enables resource sharing and computing with
distributed objects in systems with a large number of nodes.
The objective of our work is to enhance middleware services to provide
scalability of synchronization on one side and predictability on the
other side. We have designed and implemented middleware components in
support of these objectives that result in low message complexity, a
high degree of concurrency and scalability for a large number of
nodes. Experiments indicate significant savings in message overhead,
in particular with regard to large number of nodes, when compared with
another scalable protocol for distributed resource allocation. We
promote extensions to existing standards for concurrency controls. Our
technical contribution is a novel protocol to enhance concurrency in
distributed resource allocation following the specification of general
concurrency services for large-scale data and object repositories.
While our approach is motivated by CORBA, its principles are
applicable to any distributed concurrency services and transaction
models.
The results of this work impact predictability and scalability for
distributed computing facilities ranging from embedded computing with
distributed objects over peer-to-peer computing environments to
arbitrating accesses in vary large database environments. The
strengths of our approach are its simplicity, its compatibility
with existing standards and its scalability to ensure performance for
such systems.
Gain Time Reclaiming in High Performance Real-Time Java Systems
The run-time characteristics of Java, such as high frequency
of method invoking, dynamic dispatching and dynamic load-
ing, make Java more difficult than other object-oriented pro-
gramming languages, such as C++, for conducting Worst-
Case Execution Time (WCET) analysis. There have been
efforts to address WCET analysis of the dynamic behaviour
in object-oriented programs in order to apply them in high
performance real-time systems. However, most approaches
result in developing environments which are inflexible and
very limited. To offer a more flexible way to develop object-
oriented real-time applications in the real-time Java environ-
ment without loss of the predicability and performance, we
propose a novel gain time reclaiming framework integrated
with WCET analysis. This paper demonstrates how to im-
prove the utilisation and performance of the whole system
by reclaiming gain time at run-time. Our approach shows
that integrating WCET with gain time reclaiming not only
can provide a more flexible environment to develop high
performance real-time Java applications, but it also does
not necessarily result in unsafe or unpredictable timing be-
haviour.
Improving the Memory Management Performance of RTSJ
From a real-time perspective, the GC introduces unpredictable pauses
that are not tolerated by real-time tasks.
Real-time collectors eliminate this problem but introduce
a high overhead.
However, this must not lead to undertake the unsafe primitive solution
that consists in letting the application programmer
to explicitly deal with memory reclamation.
An intermediate approach is to use Memory Regions (MR)
within wich allocation and deallocation is customized.
This facility is supported by the memory model
of the Real-Time Specification of Java (RTSJ).
The strict assignment rules imposesb by RTSJ to avoid dangling
inter-region pointers incur high amounts of overhead, which
it is possible to reduce by taking advantages of hardware features.
This paper provides an indepth analitical investigation of the overhead
of dynamic assignments checks in RTSJ, describing
and analizing several solutions to reduce the introduced overhead.
Measuring the Impact of Object-oriented Techniques in Grande
Applications: a method-level analysis
In this paper we seek to provide a foundation for the study of the
level of use of object-oriented techniques in Java programs in
general, and scientific applications in particular. Specifically, we
focus on the use of small methods, and the frequency with which they
are called, since this forms the basis for the study of method
inlining, an important optimisation technique. We compare the Grande
and SPEC benchmark suites, and note a significant difference in the
nature and composition of these suites, with the programs from the
Grande suite demonstrating a less object-oriented approach. On
average, they make less use of the class library than SPEC
applications, make greater use of static methods, and use longer
methods.
Compiler Transformations for Optimizing OoLaLa
OoLaLa is an object oriented linear algebra library de-
signed to reduce the effort of software development and
maintenance. In contrast with traditional (Fortran-based)
libraries, it provides two high abstraction levels that signifi-
cantly reduce the number of implementations necessary for
particular linear algebra operations.
Initial performance evaluations of a Java implementation
of OoLaLa show that the two high abstraction levels are
not competitive with the low abstraction level of traditional
libraries. One of the high abstraction levels is consistently
slower than the low abstraction, while the other is slower in
most cases.
These performance results motivate the present contri-
bution the characterisation of a set of storage formats
(data structures) and matrix properties (special features)
for which a set of standard transformations are able to map
implementations at the two high abstraction levels into im-
plementations at the low (more efficient) abstraction level.
Edge-Server Caching of Enterprise JavaBeans: Architecture and
Implementation
We discuss key issues involved in the caching of Enterprise JavaBeans (EJBs) on an Edge-Server, and then
present the architecture and algorithms that we have used to build an edge-server that solves these issues.
The ability to cache EJBs is important because current edge-servers permit only caching of data such as
static HTML pages. Applications that access stateful data must therefore access the back-end server fre-
quently, so that performance is affected by network latency and the existence of system "hot spots". With
cached EJBs, edge-servers can run transactional applications that access dynamically changing data using
a well known application programming interface. The behavior of the EJB runtime is functionally indistin-
guishable from that of a standard J2EE server, and thus the application behavior is unchanged. We also
show that, with relatively little effort, non-cached applications can be transparently transformed into edge- server applications.
Using MPI with C# and the Common Language Infrastructure
We describe two interfaces for using the Message Passing Interface
(MPI) with the C# programming language and the Common Lan-
guage Infrastructure (CLI). The first interface provides CLI bind-
ings that closely match the original MPI library specification. The
second library presents a fully object-oriented interface to MPI and
exploits modern language features of C#. The interfaces described
here use the P/Invoke feature of the CLI to dispatch to a native im-
plementation of MPI (in our case, LAM/MPI). Performance results
using the Shared Source CLI demonstrate there is only a small per-
formance overhead incurred.
Execution of Monolithic Java Programs on Large Non-Dedicated
Collections of Commodity Workstations
The use of the Internet and intranets within organizations has linked
a great number of commodity workstations, a large portion of which
may be idle at any given moment. Together, these idle workstations
constitute a substantial computational force. We describe the general
design of a runtime that executes a standard Java application on
available idle workstations. Our work allows a high-level programming
paradigm in a non-dedicated environment. The runtime
distributes the application?s threads and objects among the currently idle nodes.
The described system possesses the following features. First, it is fault
tolerant, preserving the correctness of the distributed execution even
if a large portion of nodes fails. By use of the system?s fault tolerance
we make it non-intrusive with respect to the ?owners? of the participating
nodes. Second, our runtime is completely transparent to the programmer
and can execute any multithreaded Java program. Third, the proposed runtime
is orthogonal to the implementation of the JVM and therefore heterogeneous.
It rewrites the application?s bytecodes, using the node?s standard JVM to
execute the rewritten application. Finally, the described runtime is highly
scalable, using an efficient and scalable multithreaded software distributed
shared memory (DSM) and a fault tolerance scheme
that does not require global cooperation.
RMIX: Multiprotocol RMI Framework for Java
Web Service technologies have recently attracted attention
as promising vehicles for interoperability in e-commerce and
enterprise collaboration. Attempts to leverage Web Ser-
vices for high performance scientific and distributed com-
puting, however, have encountered performance problems
owing to the unsuitability of SOAP (the de facto Web Ser-
vices wire protocol) for large volume data transfers. Alter-
native standards are likely to emerge, but currently, many
different protocols remain in use. Supporting a scheme to
dynamically select from multiple protocols as appropriate
to the situation seems to be a sound solution. In the con-
text of distributed computing with Java, RMI is a natu-
ral programming paradigm. However, the default RMI im-
plementation is bound to a concrete wire protocol, JRMP,
that is neither interoperable nor very efficient. In this pa-
per, we propose a framework than permits the use of mul-
tiple wire protocols within the unified model of RMI. The
wire protocols are defined in terms of pluggable transport
protocol service providers that may be added to the sys-
tem at any time. A suite of protocols with varying prop-
erties can then be used seamlessly and collectively. This
approach facilitates applications that communicate with dif-
ferent classes of peers using various protocols, applications
that are protocol-independent and migratable between dif-
ferent protocols, or distributed systems with dynamic peer-
to-peer protocol negotiation. Additionally, enhancements
to the RMI model towards multi-user environments are pro-
posed. We describe the design and implementation of the
framework, and present two transport service providers: the
JRMPX provider using the standard RMI wire protocol
(JRMP), and the XSOAP provider using SOAP. We include
benchmark results demonstrating performance characteris-
tics of these two providers in comparison to standard RMI.
Using Java.nio for High Performance Message Passing
We evaluate advances in JVM technology along with new
high performance I/O libraries in Java 1.4, and find that
Java is increasingly an attractive platform for scientific cluster
based message passing codes.
We report that these new technologies allow pure Java im-
plementations of cluster communication libraries that match
or exceed the performance of standard MPI implementa-
tions.
Parallel Operation of CartaBlanca on Shared and Distributed
Memory Computers
We describe the parallel performance of the pure Java
CartaBlanca code on heat transfer and multiphase fluid
flow problems. CartaBlanca is designed for parallel
computations on partitioned unstructured meshes. It uses
Java's thread facility to manage computations on each of
the mesh partitions. Inter-partition communications are
handled by two compact objects for node-by-node
communication along partition boundaries and for global
reduction calculations across the entire mesh. For
distributed calculations, the JavaParty package from the
University of Karlsruhe is demonstrated to work with
CartaBlanca although scaling will require additional
effort. On shared memory machines, CartaBlanca is
shown to scale well provide the problem is large enough.
Efficiently Distributing Component-based Applications Across
Wide-Area Environments
Distribution and replication of network-accessible applications has
been shown to be an effective approach for delivering improved
Quality of Service to end users. Even though current-day compo-
nent-based applications are nominally suitable for distributed de-
ployment, much work remains before achieving efficient service
distribution in wide-area environments.
In this paper, we investigate application design patterns and their
accompanying system-level support essential to a beneficial and ef-
ficient service distribution process. Our study targets the Java 2
Platform Enterprise Edition (J2EE) platform and Java Pet Store as
a sample application.
Our results present strong experimental evidence that component-
based applications can be efficiently distributed in wide-area en-
vironments using a small set of generally-applicable design pat-
terns for orchestrating interactions and managing component state.
Moreover, we show how the design patterns can be enforced and
automated by container frameworks.
Support and Optimization of Java RMI over Bluetooth Environments
Distributed object-oriented platforms over wireless environ-
ments for high-performance computing and collaborative frame
works have become essential components for pervasive com-
putings. In this paper, we investigate the issues to support
Java RMI over Bluetooth environments. First, we develop
a set of protocol stack layers for Bluetooth. The system
is written in Java and known as JavaBT. Next, we pro-
vide support in L2CAP layer with sockets to support RMI
socket. This enables the support of Java RMI over Blue-
tooth environments with efficiency. In addition, we model
the cost for the access patterns of Java RMI communica-
tions. The cost model is used to guide the formation and
optimizations of the scatternets of Bluetooth environments
associated Java RMI environments. In our approach, we
first employ a well-known BTCP algorithm to observe initial
configurations for the number of piconets. With the com-
munication access cost, we then employ a spectral-bisection
method to cluster the nodes in a piconet. We then give a
method to connect the cluster together based on the cost
model. We give experimental results with the prototypes
of Java RMI support over Bluetooth environments. Ex-
perimental results also show that our scatternet formation
algorithm incorporating access cost model out-perform the
one without considering the access graphs of Java RMI over
Bluetooth environments.
Understanding the Performance of the Java Operating System JX
using Visualization Techniques
During the development of the Java-based operating sys-
tem JX we frequently needed tools to assess the perfor-
mance of the microkernel and the Java components. We
instrumented the microkernel and the bytecode-to-native-
code translator to get information about nearly every aspect
of the systems behavior. The gathered data can be visualized
to show CPU time consumption of methods, thread schedul-
ing, object allocation behavior, and object ages.
A Java Embedded MIcro-kernel Infrastructure
In this paper we outline a prototype implementation of a
Java Embedded Micro-kernel (JEM) infrastructure that is
capable of dynamically loading service modules at runtime
onto devices with limited system resources, such as
intelligent network cards or PDAs. The JEM system allows
for a range of Java-based modules to be developed and
utilized to, for example, dramatically improve the
communications performance of Java applications, move
operating system or application level services down into the
network layer, or provide other specialized services.
Benchmarking Java against C/C++ for Interactive Scientific
Visualization
JLoop is a high performance platform independent workstation
software to interactively visualize extremely large time varying
datasets. It allows full interactive loop, roam and zoom
capabilities. It's a re-implementation of the existing Loop
software developed at NASA/Goddard, in Java (JLoop) to
evaluate java for high performance visualization applications in
terms of portability, speed, memory usage, multiprocessing, etc
and portability of visualization software across computer
platforms. The performance of JLoop/Loop has been compared
across a number of platforms both for interactive animation
(display) and numerical computation.
Experience with integrating Java with new technologies: C#, XML
and web services
Java programmers cannot but be aware of the new
initiative from Microsoft of a complete language, C#,
network environment, .NET, and host of supporting
technologies such as web services. Before moving all
development to a Microsoft environment,
programmers will want to know what are the
additional advantages of C# as a language over Java,
and whether the new and interesting features of C# and
.NET be incorporated into existing Java software. This
paper surveys the advantages of C# and then presents
experience with connecting it to Java in a variety of
ways. The first is by providing a common XML-based
class for the development of programmer controlled
GUIs, which can run independently of the expensive
(resource-intensive) Visual Studio development
environment that would otherwise be needed for using
C#. The second provides evidence that C# can be
linked to Java at the source code level, albeit through
C++ wrappers. The third is a means for retaining the
useful applet feature of Java in a server-side
architecture of .NET's web services.
The paper concludes that there are many common
shared technologies that bring Java and C# close
together, and that innovative ways of using others can
open up opportunities not hitherto imagined.
Application/Kernel Cooperation Towards the Efficient Execution of
Shared-memory Parallel Java Codes
In this paper we propose mechanisms to improve the performance
of parallel Java applications executing on multiprogrammed
shared-memory multiprocessors. The proposal is based on a
dialog between each Java application and the underlying
execution environment (mainly the resource manager in the
kernel) so that both cooperate on improving the overall
performance (individual application speedup and system
throughput). This dialog implies modifications at the application
(or compiler), the threading library and kernel levels. Although a
similar cooperation has been analyzed for other environments, the
Java environment offers a different execution environment
through the Java Virtual Machine. The paper includes
experimental results based on OpenMP-like benchmarks that
show the benefits of this cooperation between malleable Java
applications and the execution environment.
CSFS: A Java Enabled Network File Storage System
CSFS is a network file storage system which supports file storage
on the Internet. In CSFS, numbers of distributed file servers are
consolidated together and provide service as a whole. File name is
location independent. System architecture is of good scalability
and the system is expected to scale up to hundreds of servers. Due
to Java's advantages in distributed computing and compatibility
with heterogeneous operating systems, we implemented CSFS in
pure Java and tested the prototype by a Java versioned distributed
file system benchmark. Benchmark result shows: CSFS delivers
acceptable performance for general file operations; performance of
file upload and download is as efficient as FTP; more than 450
concurrent online users can be supported.
Zero overhead Java thread serialization
The Java system supports the transmission of code via dynamic
class loading, and the transmission or storage of data via object
serialization. However, Java does not provide any mechanism for
the transmission/storage of the computation (i.e.,
thread
serialization). Several projects have recently addressed the issue
of Java thread serialization, e.g., Sumatra, Wasp, JavaGo, Brakes,
Merpati. Some of them have attempted to minimize the overhead
incurred by the thread serialization mechanism on thread
performance, but none of them has been able to completely avoid
this overhead. We propose a Java thread serialization mechanism
that does not impose any performance overhead on serializable
threads. In this paper, we present the design choices which
allowed us to cancel the performance overhead, and we describe
the implementation details of our thread serialization prototype in
Sun Microsystems' JDK. We report on a comparative
performance evaluation of the main thread serialization
techniques, and confirm the elimination of the performance
overhead with our thread serialization mechanism.
An Object Oriented Approach to the Direct Simulation Monte
Carlo Method
A Direct Simulation Monte Carlo (DSMC) code has been
developed in Java 2, based on the original FORTRAN DSMC
code of G.A. Bird [1] and extensions to it by Anderson and Dunn
[2] and Long and Anderson [3]. Although these FORTRAN
codes perform quite well, the emergence of object-oriented
programming has led to the initiative to develop a more
maintainable DSMC code while keeping with the goal of a
retaining a high-performance numerical solution to rarefied gas
dynamics problems. The code discussed in this paper was written
in Java 2 and compiled using both GNU GCJ and Sun's Java
Development Kit. The code is much more readable and
maintainable than its FORTRAN predecessors while its serial and
parallel performance have been found to be comparable to the
FORTRAN codes in call cases and, on some computer
architectures, superior to the FORTRAN codes on a performance
basis.
While it was written to solve the pulse detonation engine problem
[4,5], the software discussed herein can be extended to solve
many gas dynamics problems. In fact, by taking advantage of the
object-oriented program structure of Java and some of the
language's advanced features, a solution to many problems can
now be found in very elegant manner. For instance, by using the
Vector foundation class, the complicated sort routine found in
traditional DSMC codes is greatly simplified. The code was
parallelized in a manner similar to the multiple-serial-jobs
approach of [6] and using Java's intrinsic multithreading
capabilities. A graphics package has been implemented, which
allows the used to qualitatively verify the collision dynamics of
flow throughout a data run. More graphical output can easily be
added in order to monitor the progress of the code real-time as it
converges to a statistically valid solution over many ensembles.
|
