Java Grande Special Issue of Concurrency:Practice and Experience
Note that on November 25 99, we updated paper links but NOT abstracts and
titles
Last Update (All Papers Now inexcept two from Least Squares 17 December 99
Editorial is at editorialjg99.html
Original Conference URL http://www.cs.ucsb.edu/conferences/java99/
- C413: Locality optimization in JavaParty by means of static type
analysis
- Abstract: On clusters and DMPs, locality of objects and threads and
hence avoidance of network communication, are crucial for performance. We show
that an extension of known type inference mechanisms can be used to compute
placement decisions that improve locality. In addition to this general
contribution, the paper specifically addresses the problems that are caused by
the distributed Java environment. Since the JVM is assumed to be fixed, the
optimization is done as source- to-source transformation.
- Michael Philippsen and Bernhard Haumacher University of Karlsruhe, Germany
- phlipp@ira.uka.de and
hauma@ira.uka.de
- C413JGFSIphilipFINAL/static/static.pdf
- Resubmit PDF:
C413JGFSIphilipFINAL/resubmit/static.pdf
- Resubmit Info: C413JGFSIphilipFINAL/resubmit
- C414: More Efficient Serialization and RMI for Java
- Abstract:. In current Java implementations, Remote Method Invoca-
tion (RMI) is too slow, especially for high performance computing. RMI is
designed for wide-area and high-latency networks, it is based on a slow object
serialization, and it does not support high-performance commu- nication
networks. The paper demonstrates that a much faster drop-in RMI and an ecient
drop-in serialization can be designed and implemented completely in Java
without any native code. Moreover, the re-designed RMI supports non- TCP/IP
communication networks, even with heterogeneous transport protocols. We
demonstrate that for high performance computing some of the official
serialization's generality can and should be traded for speed. As a by-product,
a benchmark collection for RMI is presented. On PCs connected through Ethernet,
the better serialization and the improved RMI save a median of 45% (maximum of
71%) of the runtime for some set of arguments. On our Myrinet-based ParaStation
network (a cluster of DEC Alphas) we save a median of 85% (maximum of 96%),
compared to standard RMI, standard serialization, and Fast Ethernet; a remote
method invocation runs as fast as 80 mus round trip time, compared to about 1.5
ms.
- Michael Philippsen, Bernhard Haumacher, and Christian Nester
- Computer Science Department, University of Karlsruhe Am Fasanengarten 5,
76128 Karlsruhe, Germany
- [phlipp,hauma,nester]@ira.uka.de
- http://wwwipd.ira.uka.de/JavaParty/
- C414JGFSIphilipFINAL/serialrmi/serialrmi.pdf
- Resubmit PDF:
C414JGFSIphilipFINAL/c414serialrmiresubmit/serialrmi.pdf
- Resubmit Info: C414JGFSIphilipFINAL/c414serialrmiresubmit
- C423: Jaguar: Enabling Efficient Communication and I/O in Java
- Abstract: Implementing efficient communication and I/O mechanisms in
Java requires both fast access to low-level system resources (such as network
and raw disk interfaces) and direct manipulation of memory regions external to
the Java heap (such as communication and I/O buffers). Java native methods are
too expensive to perform these operations and raise serious protection
concerns. We present Jaguar, a new mechanism which provides Java applications
with efficient access to system resources while retaining the protection of the
Java environment. This is accomplished through compile-time translation of
certain Java bytecodes to inlined machine code segments. We demonstrate the use
of Jaguar through a Java interface to the VIA fast communications layer, which
achieves nearly identical performance to that of C, and Pre-Serialized Objects,
a mechanism which greatly reduces the cost of Java object serialization.
- Matt Welsh and David Culler
- University of California, Berkeley
- mdw,culler@cs.berkeley.edu
- C423JGFSIWelshFINAL/c423.pdf
- Resubmit PDF: C423JGFSIWelshFINAL/jaguar-journal.pdf
- Resubmit Info: C423JGFSIWelshFINAL
- C424: Performance Measurement of Dynamically Compiled Java
Executions
- Abstract With the development of dynamic compilers for Java,
Java’s performance promises to rival that of equivalent C/C++ binary
executions. This should ensure that Java will become the platform of choice for
ubiquitous Web-based supercomputing. Therefore, being able to build performance
tools for dynamically compiled Java executions will become increasingly
important. In this paper we discuss those aspects of dynamically compiled Java
executions that make performance measurement difficult: (1) some Java
application methods may be transformed from byte-code to native code at
run-time; and (2), even in native form, application code may interact with the
Java virtual machine. We describe Paradyn-J, an experimental version of the
Paradyn Parallel Performance Tool that addresses this environment by describing
performance data from dynamically compiled executions in terms of the multiple
execution forms (interpreted byte-code and directly executed native code) of a
method, costs of the dynamic compilation, and costs of residual dependencies of
the application on the virtual machine. We use performance data from Paradyn-J
to tune a Java application method, and improve its interpreted byte-code
execution by 11% and its native form execution by 10%. As a result of tuning
just one method, we improve the application’s total execution time by 10%
when run under Sun’s ExactVM (included in the Platform2 release of JDK).
Results of our work are guide to virtual machine designers as what type of
performance data should be available through Java VM performance tool APIs.
- Tia Newhall and Barton P. Miller
- {newhall,bart}@cs.wisc.edu
- Computer Sciences Department University of Wisconsin Madison, WI 53706-1685
- C424JGFSINewhallFINAL/c424.pdf
- Resubmit PDF: C424JGFSINewhallFINAL/c424resubmit.pdf
- Resubmit Info: C424JGFSINewhallFINAL
- C426: The Gateway System: Uniform Web Based Access to Remote
Resources
- Abstract: Exploiting our experience developing the WebFlow system,
we designed the Gateway system to provide seamless and secure access to
computational resources at ASC MSRC. The Gateway follows our commodity
components strategy, and it is implemented as a modern three-tier system. Tier
1 is a high-level front end for visual programming, steering, run-time data
analysis and visualization that is built on top of the Web and OO commodity
standards. Distributed object-based, scalable, and reusable Web server and
Object broker middleware forms Tier 2. Back-end services comprise Tier 3. In
particular, access to high-performance computational resources is provided by
implementing the emerging standard for metacomputing API.
- Tomasz Haupt, Erol Akarsu, Geoffrey Fox, Alexey Kalinichenko, Kang-Seok
Kim, Praveen Sheethalnath, Choon-Han Youn
- Northeast Parallel Architecture Center at Syracuse University
- haupt@npac.syr.edu
- C426JGFSIhaupt/JavaGrande99.pdf
- Resubmit PDF:C426JGFSIhaupt/JavaGrande99-submit.pdf
- Resubmit Info:C426JGFSIhaupt
- C427: Object Serialization for Marshalling Data in a Java
Interface to MPI
- Abstract: Several Java bindings to Message Passing Interface (MPI)
software have been developed recently. Message bu ers have usually been
restricted to arrays with elements of primitive type. We discuss adoption of
the Java object serialization model for marshalling general communication data
in MPI-like APIs. This approach is compared with a Java transcription of the
standard MPI derived datatype mechanism. We describe an imple- mentation of the
mpiJava interface to MPI that incorporates automatic object serialization.
Benchmark results con rm that current JDK im- plementations of serialization
are not fast enough for high performance messaging applications. Means of
solving this problem are discussed, and benchmarks for greatly improved schemes
are presented.
- Bryan Carpenter, Geoffrey Fox, Sung Hoon Ko and Sang Lim
- NPAC at Syracuse University Syracuse, NY 13244
- {dbc,gcf,shko,slim}@npac.syr.edu
- C427JGFSIdbcFINAL/c427serialize.pdf
- Resubmit PDF: C427JGFSIdbcFINAL/c427resubmit.pdf
- Resubmit Info: C427JGFSIdbcFINAL
- C428: Wide-Area Parallel Programming using the Remote Method
Invocation Model
- Abstract: Java’s support for parallel and distributed
processing makes the language attractive for metacomputing applications, such
as parallel applications that run on geographically distributed (wide-area)
systems. To obtain actual experience with a Java-centric approach to
metacomput-ing, we have built and used a high-performance wide-area Java
system, called Manta. Manta implements the Java Remote Method Invocation (RMI)
model using different communication protocols (active messages and TCP/IP) for
different networks. The paper shows how wide-area parallel applications can be
expressed and optimized using Java RMI. Also, it presents performance results
of several applications on a wide-area system consisting of four Myrinet-based
clusters connected by ATMWANs. We finally discuss alternative programming
models, namely object replication, JavaSpaces, and MPI for Java.
- Rob van Nieuwpoort, Jason Maassen, Henri E. Bal, Thilo Kielmann, Ronald
Veldema
- Department of Computer Science, Vrije Universiteit, Amsterdam, The
Netherlands.
- rob@cs.vu.nl, jason@cs.vu.nl, bal@cs.vu.nl, kielmann@cs.vu.nl,
rveldema@cs.vu.nl
- http://www.cs.vu.nl/albatross/
- C428JGFSIbalFINAL/c428.pdf
- Resubmit PDF: C428JGFSIbalFINAL/jgfsi_c428/cpe99.pdf
- Resubmit Info: C428JGFSIbalFINAL/jgfsi_c428
- C429: Performance Limitations of the Java Core Libraries
- Abstract: Unlike applets, traditional systems programs written in
Java place significant demands on the Java runtime and core libraries, and
their performance is often critically important. This paper describes our
experiences using Java to build such a systems program, namely, a
high-performance web crawler. We found that our runtime, which includes a
just-in-time compiler that compiles Java bytecodes to native machine code,
performed well. However, we encountered several performance problems with the
Java core libraries, including excessive synchronization, excessive allocation,
and other programming inefficiencies. The paper describes the most serious
pitfalls and how we programmed around them. In total, these workarounds more
than doubled the speed of our crawler.
- Allan Heydon, Marc Najork
- Compaq Computer Corporation, Systems Research Center, 130 Lytton Avenue,
Palo Alto, CA 94301, USA
- {heydon,najork}@pa.dec.com
- C429JGFSIheydonFINAL/c429.pdf
- Resubmit PDF: C429JGFSIheydonFINAL/c429resubmit.pdf
- Resubmit Info: C429JGFSIheydonFINAL
- C430:A Java/CORBA based Visual Program Composition Environment
for PSEs
- Abstract: A Problem Solving Environment (PSE) is a complete,
integrated com- puting environment for composing, compiling and running
applications in a speci c problem area or domain. A Visual Programming
Composition Environment (VPCE) is described, which serves as a user interface
for a PSE, and uses Java and CORBA to provide a framework of tools to enable
the construction of scienti c applications from components. The VPCE consists
of a component repository, from which the user can select o -the-shelf or
in-house components, a graphical composition area on which components can be
combined, various tools that facilitate the con guration of components, the
integration of legacy codes into com- ponents and the design and building of
new components. The VPCE produces output using data ow techniques in the form
of a task graph, annotated with a performance model plus constraints for each
component, expressed in XML. In addition, the VPCE supports a domain speci c
expert system based on JESS [9] to guide the user in component selection and to
perform integrity checking.
- Matthew S. Shields, Omer F. Rana, David W. Walker, Maozhen Li
- Department of Computer Science, Cardiff University, POBox 916, Cardiff,
CF24 3XF, UK
- David Golby
- Department of Mathematical Modelling, British Aerospace Sowerby Research
Center, PO Box 5, Filton, Bristol, BS34 7QW, UK
- Omer F Rana
<O.F.Rana@cs.cf.ac.uk>
- C430JGFSIranaFINAL/C430shields-rana-walker-li-golby.pdf
- Resubmit PDF:
C430JGFSIranaFINAL/shields-rana-walker-li-golby-final.pdf
- Resubmit Info: C430JGFSIranaFINAL
- C431:Ajents: Towards an Environment for Parallel, Distributed and
Mobile Java Applications
- Abstract: The rapid proliferation of the World-Wide Web has been due
to the seamless access it provides to information that is distributed both
within organizations and around the world. In this paper, we describe the
design and implementation of a system, called Ajents, which provides the
software infras- tructure necessary to support a similar level of seamless ac-
cess to organization-wide or world-wide heterogeneous com- puting resources.
Ajents introduces class libraries which are written en- tirely in Java and that
run on any standard compliant Java virtual machine. These class libraries
implement and com- bine several important features that are essential to sup-
porting distributed and parallel computing using Java. Such features include:
the ability to easily create objects on re- mote hosts, interact with those
objects through either syn- chronous or asynchronous remote method invocations,
and to freely migrate objects to heterogeneous hosts. Our experimental results
show that in our test environ- ment: we are able to achieve good speedup on a
sample parallel application; the overheads introduced by our imple- mentation
do not adversely a ect remote method invocation times; and (somewhat
surprisingly) the cost of migration does not greatly impact the execution time
of an example application.
- Matthew Izatt, Patrick Chan
- Department of Computer Science York University, Toronto, Ontario, M3J 1P3
- {izatt,y-chan}@cs.yorku.ca
- Tim Brecht Department of Computer Science University of Waterloo, Waterloo,
Ontario, N2L 3G1
- brecht@cs.uwaterloo.ca
- C431JGFSIbrechtFINAL/C431.pdf
- Resubmit PDF: C431JGFSIbrechtFINAL/c431resubmit.pdf
- Resubmit Info: C431JGFSIbrechtFINAL
- C432: A Mobile Agent Based Push Methodology for Global Parallel
Computing
- Abstract: The 1990s are seeing the explosive growth of the Internet
and Web-based information sharing and dissemination systems. The Internet is
also showing a potential of forming of a supercomputing resource out of
networked computers. Metacomputing on the Internet often works in a
machine-centric “pull” execution model. That is, a coordinator
machine maintains a pool of tasks and distributes the tasks to other
participants on demand. This paper proposes a novel mobile agent based
“push” methodology from the perspective of applications. In the
method, users declare their compute-bound jobs as autonomous agents. The
computational agents will roam on the Internet to find servers to run. Since
the agents can be programmed to satisfy their goals, even if they move and lose
contact with their creators, they can survive intermittent or unreliable
network connection. Dur-ing their lifetime, the agents can also move themselves
autonomously from one machine to another for load balancing, enhancing data
locality, and tolerating faults. We present an agent-oriented programming and
resource brokerage infrastructure, TRAVELER, in support of wide area parallel
applications. TRAVELER provides a mecha-nism for clients to wrap their parallel
applications as mobile agents. It allows clients to dispatch their
computational agents via a resource broker. The broker forms a parallel virtual
machine atop servers to execute the agents. TRAVELER relies on an integrated
dis-tributed shared array runtime system to support agent communications on
clusters of servers. We demonstrated the feasibility of the TRAVELER in
parallel sorting and LU factorization problems.
- Cheng-Zhong Xu and Brian Wims
- Department of Electrical and Computer Engineering Wayne State University,
Detroit, MI 48202
- czxu@ece.eng.wayne.edu
- C432JGFSIxuFINAL/c432xu.pdf
- Resubmit PDF: C432JGFSIxuFINAL/c432resubmit.pdf
- Resubmit Info: C432JGFSIxuFINAL
- C433:A Tale of Two Directories: Implementing Distributed Shared
Objects in Java
- Abstract: A directory service keeps track of the location and status
of mobile objects in a distributed system. This paper describes our experience
im- plementing two distributed directory protocols as part of the Aleph
toolkit, a distributed shared object system implemented in Java. One protocol
is a conventional home-based protocol, in which a xed node keeps track of the
object's location and status. The other is a novel arrow protocol, based on a
simple path-reversal algorithm. We were surprised to discover that the arrow
protocol outperformed the home protocol, sometimes substantially, across a
range of system sizes. This paper describes a series of experiments testing
whether the discrep- ancy is due to an artifact of the Java run-time system
(such as di erences in thread management or object serialization costs), or
whether it is some- thing inherent in the protocols themselves. In the end, we
use insights gained from these experimental results to design a new directory
protocol
- Maurice Herlihy
- Computer Science Department Brown University Providence, RI 02912
- herlihy@cs.brown.edu
- Michael P. Warres
- Sun Microsystems
- mpw@east.sun.com
- C433JGFSIherlihy/c433.pdf
- Resubmit PDF:C433JGFSIherlihy/c433resubmit.pdf
- Resubmit Info: C433JGFSIherlihy
- C434:A Benchmark Suite for High Performance Java
- Abstract: Increasing interest is being shown in the use of Java for
large scale or Grande applications. This new use of Java places speci c demands
on the Java execution environments that could be tested and compared using a
standard benchmark suite. We describe the design and implementation of such a
suite, paying particular attention to Java-speci c issues. Sample results are
presented for a number of implementa- tions of the Java Virtual Machine (JVM).
- J. M. Bull, L. A. Smith, M. D. Westhead, D. S. Henty and R. A. Davey
- EPCC, James Clerk Maxwell Building, The King's Buildings, The University of
Edinburgh, Mayfield Road, Edinburgh EH9 3JZ, Scotland, U.K.
- epcc-javagrande@epcc.ed.ac.uk
- markb@epcc.ed.ac.uk
- C434JGFSIbullFINAL/c434cpe.pdf
- Resubmit PDF: C434JGFSIbullFINAL/c434resubmit.pdf
- Resubmit Info: C434JGFSIbullFINAL
- C435:Annotating Java Class Files with Virtual Registers for
Performance
- Abstract: The Java .class file is a compact encoding of programs for
a stack-based virtual machine. It is intended for use in a networked
environment, which re-quires machine independence and minimized consumption of
network bandwidth. However, as in all interpreted virtual machines, performance
does not match that of code generated for the target machine. We propose
verifiable, machine-independent annotations to the Java class file to bring the
quality of the code generated by a “just-in-time” compiler closer to
that of an optimizing compiler without a sig-nificant increase in code
generation time. This division of labor has expensive machine-independent
analysis performed off-line and inexpensive machine-dependent code-generation
performed on the client. We call this phenomenon “super-linear analysis
and linear exploitation.” These annotations were designed mindful of the
concurrency features of the Java language. In this paper we report results from
our a machine-independent, prioritized register assignment. We also discuss
other possible annotations.
- Joel Jones and Samuel Kamin
- Department of Computer Science University of Illinois at Urbana-Champaign
- jjones@uiuc.edu
- C435JGFSIjonesFINAL/c435cpe1999.pdf
- Resubmit PDF: C435JGFSIjonesFINAL/c435resubmit.pdf
- Resubmit Info: C435JGFSIjonesFINAL
- C436:Javia: A Java Interface to the Virtual Interface
Architecture
- Abstract: The Virtual Interface (VI) architecture has become the
industry standard for user-level network interfaces. This paper presents the
implementation and evaluation of Javia, a Java interface to the VI
architecture. Javia explores two points in the design space. The first approach
manages buffers in C and requires data copies between the Java heap and native
buffers. The second approach relies on a Java-level buffer abstraction that
eliminates the copies in the first approach. Javia achieves an effective
bandwidth of 80Mbytes/sec for 8Kbyte messages, which is within 1% of those
achieved by C programs. Performance evaluations of parallel matrix
multiplication and of the active messages communication protocol show that
Javia can serve as an efficient building block for Java cluster applications.
- Chi-Chao Chang and Thorsten von Eicken
- Department of Computer Science Cornell University
- {chichao,tve}@cs.cornell.edu
- C436JGFSIchangFINAL/C436oldchang.pdf
- Resubmit PDF: C436JGFSIchangFINAL/c436newchang.pdf
- Resubmit Info: C436JGFSIchangFINAL
- C437:The jCrunch Java Numerical Libraries
- Abstract: The jCrunch project was initiated to address this lack of
high quality numerical libraries. The jCrunch libraries are set of proprietary,
commercial-grade Java numerical libraries. Our approach is very similar to the
F2J project at UTK. Rather than “reinvent the wheel” by
re-implementing all known numerical algorithms, we have instead decided to
leverage the existing body of Fortran numerical libraries by implementing an
automatic Fortran-to-Java translator.
- William N. Reynolds
- Least Squares Software LLC, PO Box 91405, Albuquerque, NM 87199
- bill@leastsquares.com
- http://www.leastsquares.com
- C437JGFSIreynolds/c437Crunch.pdf
- No Publication Version
- C438:JCArray – the jCrunch(TM) Java Array Classes
- Abstract: In connection with jCrunch TM Lapack, Least Squares
Software has developed Java array classes to encapsulate a Fortran-like data
array implementation. These classes are designed to provide 1-D and 2-D arrays
directly to Native methods while presenting the Java programmer with a useful,
well-behaved, object-oriented API. The proposed representation has much in
common with other proposals, such as JAMA 1 , JNL 2 and NINJA 3 . The principal
differences among these proposals are: degree of exposure to the internal data
representation; persistence; reliance on specific implementations of Blas,
Lapack, Linpack, etc.; and utility methods useful to “array jockeys”
familiar with APL, Python, etc. Design goals of the JCArray classes include
providing the same API to both pure Java and Native methods, and to support
special matrices such as tri-diagonal, banded, etc.
- David S. Dixon
- Least Squares Software Albuquerque, NM
- bill@leastsquares.com
- http://www.leastsquares.com
- C438JGFSIdixon/c438Poster.pdf
- No Publication Version
- C439:Extending Java Virtual Machine with Integer-Reference
Conversion
- Abstract: Java virtual machine (JVM) is an architecture-independent
code ex- ecution environment. It is recently used not only for Java language
but also for other languages such as Scheme and ML. On JVM, however, all values
are statically-typed as either immediate or reference, and types are checked
before the execution of a program to prove that invalid memory access will
never occur. This property sometimes makes implementation of other languages on
JVM inecient. In particular, implementation of dynamically-typed language is
very inecient because all possible values including frequently-used ones such
as integers must be represented by instances of a class. In this paper, we
introduce a new type into JVM, which is a super- type of reference types and a
tagged integer type. This allows a more efficient implementation of
dynamically-typed language on JVM. It does not require any new instruction,
maintains binary-compatibility of exist- ing bytecode, and retains the safety
of the original JVM. We modi ed an existing Scheme system running on JVM to
exploit this extension and got factor of 20 speedup for simple integer
functions. Our extension imposes little performance penalty on existing JVM
code generated from Java; we observed essentially no penalty for Spec JVM
benchmarks.
- Yutaka Oiwa, Kenjiro Taura, Akinori Yonezawa
- University of Tokyo
- oiwa@is.s.u-tokyo.ac.jp
- C439JGFSIoiwaFINAL/journal.pdf
- Resubmit PDF: C439JGFSIoiwaFINAL/c439resubmitjournal.pdf
- Resubmit Info: C439JGFSIoiwaFINAL
- C440:An Annotation-aware JVM Implementation
- Abstract: The Java Bytecode language lacks expressiveness for
traditional compiler optimizations, making this portable, secure software
distribution format inecient as a program representation for high performance.
This ineciency results from the underlying stack model, as well as the fact
that many bytecode oper- ations intrinsically include sub-operations (e.g.,
iaload includes the address computation, array bounds checks and the actual
load of the array element). The stack model, with no operand registers and
limiting access to the top of the stack, prevents the reuse of values and
bytecode reordering. In addition, the bytecodes have no mechanism to indicate
which sub-operations in the bytecode stream are redundant or subsumed by
previous ones. As a consequence, the Java Bytecode language inhibits the
expression of important compiler optimizations, including common sub-expression
elimination, register allocation and instruction scheduling. The bytecode
stream generated by the Java front-end is a signi cantly under-optimized
program representation. The most common solution to overcome this aspect of the
language is the use of a Just- in-Time (JIT) compiler to not only generate
native code, but perform optimization as well. However, the latter is a time
consuming operation in an already time-constrained translation process. In this
paper we present an alternative to an optimizing JIT compiler that makes use of
code annotations generated by the Java front-end. These annotations carry
information concerning compiler optimization. During the translation process,
an annotation-aware JVM system then uses this information to produce high-
performance native code without performing much of the necessary analyses or
transformations. We describe the implementation of our rst prototype of an
annotation-aware JVM system consisting of a JIT compilation system. We also
discuss basic ideas on how to verify annotated class les. We conclude the
paper showing performance results comparing our system with other Java Virtual
Machines (JVMs) running on SPARC architecture.
- Ana Azevedo, Alex Nicolau ,Joe Hummel
- University of California, Irvine University of Illinois, Chicago
- aazevedo, nicolau@ics.uci.edu
- jhummel@eecs.uic.edu
- C440JGFSIazevedoFINAL/c440cpande99.pdf
- Resubmit PDF: C440JGFSIazevedoFINAL/c440resubmit.pdf
- Resubmit Info: C440JGFSIazevedoFINAL
- C441:Design of the Kan Distributed Object System
- Abstract: Distributed software problems are often addressed with
object-oriented solutions. Objects provide the benefits of encapsulation and
abstraction that have proven useful in managing the complexity of sequential
code. However, the management of distributed objects is typically by means of
complex APIs, such as CORBA or DCOM. The complexity of the APIs is itself a
hurdle to the writing of efficient, robust programs. An alternate approach is
to provide the programmer with a simple interface to an underlying object
management layer that provides efficient access to objects, reliability, and
sufficient power for common distributed programming tasks. We have implemented
such a system, called Kan. It has a clear, simple object model with powerful
semantics, embodying such concepts as atomic transactions, asynchronous method
calls, and multithreading. The model constructs help the programmer avoid
common concurrent programming errors, allowing clean expressions of concurrent
algorithms. We describe the implemen-tation, and investigate several runtime
optimizations that make performance efficient for some classes of applications.
These optimizations concentrate on reducing method invocation costs. Local
method invocations are optimized with a thread pool, thread inlining, and
pointer swizzling. Remote method invocations are optimized with object
management routines that adapt to access patterns.
- Jerry James and Ambuj Singh
- Department of Computer Science University of California at Santa Barbara
Santa Barbara, California
- james@eecs.ukans.edu (email
changed from UCSB)
- C441JGFSIjamesFINAL/c441cpe99.pdf
- Resubmit PDF: C441JGFSIjamesFINAL/c441resubmit.pdf
- Resubmit Info: C441JGFSIjamesFINAL
- C442:The Java Memory Model is Fatally Flawed
- Abstract: The Java memory model described in Chapter 17 of the Java
Language Specification gives constraints on how threads interact through
memory. This chapter is hard to interpret and poorly understood; it imposes
constraints that prohibit common compiler optimizations and are expensive to
implement on existing hardware. Most JVMs violate the constraints of the
existing Java memory model; conforming to the existing specification would
impose significant performance penalties. In addition, programming idioms used
by some programmers and used within Sun's Java Development Kit is not
guaranteed to be valid according the existing Java memory model. Furthermore,
implementing Java on a shared memory multiprocessor that implements a weak
memory model poses some implementation challenges not previously considered.
- William Pugh
- Dept. of Computer Science Univ. of Maryland, College Park
- pugh@cs.umd.edu
- C442JGFSIpughFINAL/jmm2.pdf
- Resubmit PDF: C442JGFSIpughFINAL/c442resubmit.pdf
- Resubmit Info: C442JGFSIpughFINAL
- C443:Javelin++: Scalability Issues in Global Computing
- Abstract: Javelin is a Java-based infrastructure for global
computing. This paper presents Javelin++, an extension of Javelin, intended to
support a much larger set of computational hosts. First, Javelin++'s switch
from Java applets to Java applications is explained. Then, two scheduling
schemes are presented: probabilistic work stealing and deterministic work
stealing. The distributed deterministic work stealing is integrated with a
distributed deterministic eager scheduler. An additional fault tolerance
mechanism is implemented for replacing hosts that have failed or retreated. A
Javelin++ API is sketched, then illustrated on a raytracing application.
Performance results for the two schedulers are reported, indicating that
Javelin++, with its broker network, scales better than the original Javelin.
- Michael O. Neary, Sean P. Brydon, Paul Kmiec, Sami Rollins, Peter Cappello,
- Department of Computer Science University of California, Santa Barbara
Santa Barbara, CA 93106
- {neary, brydon, virus, srollins,
cappello}@cs.ucsb.edu
- C443JGFSInearyFINAL/c443top.pdf
- Resubmit PDF: C443JGFSInearyFINAL/c443topresubmit.pdf
- Resubmit Info: C443JGFSInearyFINAL
- C444:Design, Implementation, and Evaluation of Optimizations in a
Java™ Just-In-Time Compiler
- Abstract:The Java language incurs a runtime overhead for exception
checks and object accesses, which are executed without an interior pointer in
order to ensure safety. It also requires type inclusion test, dynamic class
loading, and dynamic method calls in order to ensure flexibility. A
“Just-In-Time” (JIT) compiler generates native code from Java byte
code at runtime. It must improve the run-time performance without compromising
the safety and flexibility of the Java language. We designed and implemented
effective optimizations for a JIT compiler, such as exception check
elimination, common subexpression elimination, simple type inclusion test,
method inlining, and devirtualization of dynamic method call. We evaluate the
performance benefits of these optimizations based on various statistics
collected using SPECjvm98, its candidates, and two JavaSoft applications with
byte code sizes ranging from 23000 to 280000 bytes. Each optimization
contributes to an improvement in the performance of the programs.
- Kazuaki Ishizaki, Motohiro Kawahito, Toshiaki Yasue, Mikio Takeuchi,
Takeshi Ogasawara, Toshio Suganuma, Tamiya Onodera, Hideaki Komatsu, and Toshio
Nakatani
- IBM Tokyo Research Laboratory 1623-14, Shimotsuruma, Yamato, Kanagawa,
242-8502, Japan
- ishizaki@trl.ibm.co.jp
- C444JGFSIishizakiFINAL/C444oldishizaki.pdf
- Resubmit PDF: C444JGFSIishizakiFINAL/C444newishizaki-2nd.pdf
- Resubmit Info: C444JGFSIishizakiFINAL
- C445:Complex numbers for Java
- C457:Cooperating distributed garbage collectors for Clusters and
beyond
- Abstract:The contribution of this paper is twofold. First a
distributed garbage collector (DGC) is presented that is optimized for remote
method invocation in reliable networks, such as cur-rent clusters of
workstations. Since the algorithm does not require extra acknowledgement
messages, even while col-lecting, it does not increase the latency of a remote
call. Then it is discussed how several DGCs can cooperate in networks that
consist of different areas with respect to communication, i.e., of areas with
different reliability prop-erties. Proper placement and use of bridge objects
allow to select an optimized DGC for every area.
- Michael Philippsen
- University of Karlsruhe
- phlipp@ira.uka.de
- http://wwwipd.ira.uka.de/JavaParty/
- Resubmit PDF:C457JGFSIgarbagephillippsenFINAL/dgc.pdf
- Resubmit Info:C457JGFSIgarbagephillippsenFINAL