ACM Logo

Joint ACM Java Grande - ISCOPE 2002 Conference

Seattle, Washington, November 3-5, 2002

Sponsored by ACM SIGPLAN

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.
Home |CFP (TXT) |People |Charter |Related Links | Webmaster: jdesouza@uiuc.edu