Showing papers presented at "USENIX Conference on Object-Oriented Technologies and Systems in 1997"

Toba: Java For Applications: A Way Ahead of Time (WAT) Compiler

Abstract: Toba is a system for generating efficient standalone Java applications. Toba includes a Java-bytecode-to-C compiler, a garbage collector, a threads package, and Java API support. Toba-compiled Java applications execute 1.5-4.2 times faster than interpreted and Just-In-Time compiled applications.

Harissa: a flexible and efficient java environment mixing bytecode and compiled code

Abstract: The Java language provides a promising solution to the design of safe programs, with an application spectrum ranging from Web services to operating system components. The well-known tradeoff of Java's portability is the inefficiency of its basic execution model, which relies on the interpretation of an object-based virtual machine. Many solutions have been proposed to overcome this problem, such as just-in-time (JIT) and off-line bytecode compilers. However, most compilers trade efficiency for either portability or the ability to dynamically load bytecode. In this paper, we present an approach which reconciles portability and efficiency, and preserves the ability to dynamically load bytecode. We have designed and implemented an efficient environment for the execution of Java programs, named Harissa. Harissa permits the mixing of compiled and interpreted methods. Harissa's compiler translates Java bytecode to C, incorporating aggressive optimizations such as virtual-method call optimization based on the Class Hierarchy Analysis. To evaluate the performance of Harissa, we have conducted an extensive experimental study aimed at comparing the various existing alternatives to execute Java programs. The C code produced by Harissa's compiler is more efficient than all other alternative ways of executing Java programs (that were available to us): it is up to 140 times faster than the JDK interpreter, up to 13 times faster than the Softway Guava JIT, and 30% faster than the Toba bytecode to C compiler.

Krakatoa: decompilation in java (dose bytecode reveal source?)

Abstract: This paper presents our technique for automatically decompiling Java bytecode into Java source. Our technique reconstructs source-level expressions from bytecode, and reconstructs readable, high-level control statements from primitive goto-like branches. Fewer than a dozen simple code-rewriting rules reconstruct the high-level statements.

Making CORBA objects persistent: the object database adapter approach

Abstract: This paper discusses a realization of object persistence in a CORBA-based distributed system In our approach, persistence of CORBA objects is accomplished by the integration of the ORB with an ODBMS This approach is not limited to pure object-oriented database systems, as the ODBMS may be a combination of a relational DBMS and an object-relational mapper The design and implementation of an Object Database Adapter that integrates an ORB and an ODBMS with C++ bindings is presented The ODA uses delegation (rather than inheritance) to connect user-provided implementation classes and IDL-generated classes Only the user-defined parts of CORBA objects are actually stored in a database Their IDL-generated parts are dynamically instantiated, in transient memory, by the ODA Persistent relationships between CORBA objects within a server are not realized at the CORBA level, but at the level of implementation objects Database traversals and queries can therefore be executed at ODBMS speeds The paper discusses in some detail a number of implementation issues, such as caching ODA support to local transactions, ODA interfaces, and CORBA server organization are also examined

Reliability with CORBA Event Channels

Abstract: Reliability with CORBA Event Channels X. Defago, P. Felber, B. Garbinato, and R. Guerraoui This paper presents a pragmatic way to build a Reliable CORBA Event Service. Our approach is pragmatic in the sense that, rather than building the service from scratch, we show how to obtain it, through a simple transformation, from any standard (unreliable) CORBA 2.0 Event Service. Our extension does not introduce any modification to the CORBA specification, nor any communication overhead. The Reliable CORBA Event Service provides the adequate semantics for building reliable notification-based applications, and an interesting light-weight and open alternative to existing group oriented systems.

Implementing optimized distributed data sharing using scoped behaviour and a class library

Abstract: Sometimes, it is desirable to alter or optimize the behaviour of an object according to the needs of a specific portion of the source code (i.e., context), such as a particular loop or phase. One technique to support this form of optimization flexibility is a novel approach called scoped behaviour. Scoped behaviour allows the programmer to incrementally tune applications on a per-object and per-context basis within standard C++. We explore the use of scoped behaviour in the implementation of the Aurora distributed shared data (DSD) system. In Aurora, the programmer uses scoped behaviour as the interface to various data sharing optimizations. We detail howa class library implements the basic data sharing functionality and how scoped behaviour co-ordinates the compile-time and run-time interaction between classes to implement the optimizations. We also explore how the library can be expanded with new classes and new optimization behaviours. The good performance of Aurora suggests that using scoped behaviour and a class library is a viable approach for supporting this form of optimization flexibility.

Embedded programming with C

Abstract: This paper presents uCR, a C++ runtime package for embedded program development. We make the case that in certain situations embedded programming is best done without the aid of a conventional operating system. A programming environment in the form of a C++ runtime is presented, and the environment, including the C++ language, is evaluated for appropriateness. Important factors are code size, performance, simplicity and applicability to a wide range of embedded targets.