Friday, 8 November 10:30-12:00 Ballroom 6C
Technical Papers: Scalability
Chair: Doug Lea
This session covers three very different aspects of software scalability. The first paper measures the performance consequences of using different styles of enterprise Java applications and servers. The second describes a set of mechanisms for reducing communication overhead for Java remote invocations among otherwise isolated tasks running on the same computer system. The third paper takes scalability in the opposite direction. It describes link-time analyses and techniques that can reduce code sizes of C++ applications so that they can be deployed on small devices.
Performance and Scalability of EJB Applications
We investigate the combined effect of application implementation method, container design, and efficiency of communication layers on the performance scalability of J2EE application servers by detailed measurement and profiling of an auction site server.
We have implemented three versions of the auction site. The first version uses stateless session beans with bean-managed persistence, making only minimal use of the services provided by the EJB container. The second version makes extensive use of the container services using entity beans with container-managed persistence. The third version applies the session facade pattern, using session beans as a facade to access entity beans. We evaluate these different implementations on two popular open- source EJB containers with orthogonal designs: JBoss uses dynamic proxies to generate the container classes at run time, making an extensive use of reflection. JOnAS pre-complies classes during deployment, minimizing the use of reflection at run time. We also evaluate the communication optimizations provided by each of these EJB containers.
The most important factor in determining performance is the implementation method. EJB applications with session beans perform as well as a Java servlet implementation and an order-of-magnitude better than most of the implementations based on entity beans. Use of session facade beans improves performance for entity beans, but only if local communication is very efficient. Otherwise, session facade beans degrade performance.
For the implementation using session beans, communication cost forms the major component of the execution time on the EJB server. The design of the container has little effect on performance. For implementations using session facade beans, local communication cost is critically important. With entity beans, the design of the container becomes important as well. In particular, the cost of reflection affects performance.
Incommunicado: Efficient Communication for Isolates
Colocating computations in a single instance of safe-language virtual machine can improve performance and overall platform scalability. It also poses various challenges. One of them is providing a very fast inter-application communication mechanism. In addition to being efficient, such a mechanism should not violate any functional and non-functional properties of its environment, and should also support enforcement of application-specific security policies. This paper explores the design and implementation of a communication substrate for applications executing within a single Java virtual machine. In particular, our goal is to provide a minimal software layer for fast and secure communication between isolated computations in the context of the Multitasking Virtual Machine. Designing an efficient extension that does not break isolation properties and at the same time pragmatically offers an API very closely resembling this of the Java Remote Method Invocation has proven non-trivial. This paper demonstrates a set of techniques that lead to at least an eight-fold performance improvement over the in-process inter-application communication using standard mechanisms offered by the Java platform.
Sifting Out The Mud: Low Level C++ Code Reuse
Bjorn De Sutter
More and more computers are being incorporated in devices where the available amount of memory is limited. This contrasts with the increasing need for additional functionality and the need for rapid application development. While object-oriented programming languages, providing mechanisms such as inheritance and templates, allow fast development of complex applications, they have a detrimental effect on program size. This paper introduces new techniques to reuse the code of whole procedures at the binary level and a supporting technique for data reuse. These techniques benefit specifically from program properties originating from the use of templates and inheritance. Together with our previous work on code abstraction at lower levels of granularity, they achieve additional code size reductions of up to 38% on already highly optimized and compacted binaries, without sacrificing execution speed. We have incorporated these techniques in Squeeze++, a prototype link-time binary rewriter for the Alpha architecture, and extensively evaluate them on a suite of 8 real-life C++ applications. The total code size reductions achieved post link-time (i.e. without requiring any change to the compiler) range from 27 to 70%, averaging at around 43%.