5th USENIX Conference on Object-Oriented Technologies and Systems (COOTS)
May 3-7, 1999
San Diego, California, USA

Keynote Address Session: Design Patterns Session: Runtime Issues Session: Objects and Databases Invited Talk Session: Optimization Session: Programming in the Large Session: Java Internet Measurements Closing Remarks

These reports were originally published in the October 1999 issue of ;login:. Our thanks to the summarizers: Marina Spivak Irfan Pyarali

by Marina Spivak

Mexican influence is clearly evident in San Diego's architecture and food, which is not surprising given that the city was part of Mexico until 1848. San Diego's weather is near-perfect, and so is its list of attractions: from world-famous San Diego Zoo and Sea World, to 22 miles of beaches and rocky shores, to jazz clubs in the historic Gaslamp Quarter—there is something for everyone to enjoy. In May, this list boasted one more world-class attraction: the 5th Conference on Object-Oriented Technologies and Systems (COOTS '99).

Most of the conference technical sessions focused on the increasing demands of distributed computing. Murthy Devarakonda of the IBM T.J. Watson Research Center was this year's program chair. The tutorial program chair was Douglas C. Schmidt of Washington University. Session topics and tutorials focused on design patterns, runtime issues in distributed systems, objects and databases, ORB and mobile-agents optimization, large-scale programming, and Java virtual machine performance evaluations.

This year, a total of 17 papers were selected out of 61 submissions. The Best Student Paper Award went to Uwe Zdun from the University of Essen, Germany, for his research on language support for design patterns. This year the conference seemed cozier than ever, and the number of attendees remained about the same as last year, at 200.

Keynote Address

Summary by Marina Spivak

What was Left Out of Java and Why?
James Gosling, Sun Microsystems, Inc.

James Gosling, the creator of Java, gave an overview of language features that are not present in Java, but whose presence is a subject of many user debates and enhancement requests. The most wanted additions to the language are asserts and parameterized types. Pre/post conditions and invariants go hand in hand with asserts, but there are many questions and subtleties regarding them. Preprocessor macros are still considered evil because they change the software at compile time. Allocation of everything on the heap can be detrimental to performance but makes security easy, since the code is not allowed to corrupt the stack frame. Operator overloading is easy to abuse and difficult to control. Enums are easy to replace with integer constants. Multi- value returns and in/out values are interesting but not widely required.

Gosling concluded by noting that coping with popularity has been difficult for Java language designers because there are over a million Java developers, resulting in many different opinions. At times it seems that Java is being stretched to meet domain-specific needs such as realtime, scientific, and database. Future changes to the Java language will be dictated by its user community.

Session: Design Patterns
Session chair: Steve Vinoski, IONA Technologies, Inc.

Summary by Irfan Pyarali

Filters as a Language Support for Design Patterns in Object-Oriented Scripting Languages
Gustaf Neumann and Uwe Zdun, University of Essen, Germany
Best Student Paper

Design patterns are often used to simplify large applications. However, classes and objects that implement these design patterns tend to be scattered throughout the whole system, making patterns hard to locate and maintain.

Uwe Zdun described an object-oriented scripting language, XOTCL (Extended Object TCL), which is equipped with several features that help in the implementation of design patterns. XOTCL allows patterns to be described as instantiable meta-classes. Introspection simplifies adaptation and maintenance, and per-object specialization eases implementation of single objects. Language support for filters allows modification, redirection, and interception of messages delivered to an object.

XOTCL is available for evaluation from <https://nestroy.wi-inf.uni-essen.de/xotcl>.

Performance Patterns: Automated Scenario-Based ORB Performance Evaluation
S. Nimmagadda and C. Liyanaarachchi, University of Kansas; A. Gopinath, Sprint Corporation; D. Niehaus, University of Kansas; A. Kaushal, Sprint Corporation

As CORBA (Common Object Request Broker Architecture) specifications stabilize, the number of available mature CORBA implementations is increasing rapidly. Performance is becoming an important criterion for selecting an ORB. Since the performance of an ORB is greatly influenced by the application context, the operating system, and the underlying network, application developers need to evaluate how candidate ORBs will perform within heterogenous computing environments. However, the lack of standard and user-extendable performance benchmark suites that exercise all aspects of the ORB endsystem under realistic application scenarios makes performance evaluation a daunting task.

Doug Niehaus introduced Performance Pattern Language (PPL), a higher-level language for describing application-level interaction scenarios. He also talked about Performance Measurement Object (PMO), a test daemon that specifies the creation of CORBA objects, their execution-time behavior, and the relations that hold among the objects.

Both PPL and PMO address the above-mentioned problems in evaluating ORB performance by providing an automated script-based framework within which extensive ORB endsystem performance benchmarks may be efficiently described and automatically executed. Unfortunately, most of the benchmarking results presented by Niehaus were deemed suspect because some of the target ORBs were not compiled with the correct compiler optimizations. More information on this project can be found at <https://www.ittc.ukans.edu/~niehaus>.

Object-Oriented Pattern-Based Parallel Programming with Automatically Generated Frameworks
Steve MacDonald, Duane Szafron, and Jonathan Schaeffer, University of Alberta, Canada

Steve MacDonald presented the CO2P3S parallel-programming system, which generates frameworks from pattern-template specifications in order to ease complexities of parallel programming. He then introduced phased parallel design patterns that allow specification of time-related aspects in a parallel program. Presented results showed that generated frameworks can be used to quickly implement parallel programs with substantial performance gains over their sequential counterparts.

In light of all the attention design patterns have enjoyed over the recent years, it is interesting to note that their popularity just keeps on growing, but the focus is shifting from their discovery and documentation to development of tools and techniques that make them better integrated into development environments and easier to use — for example, language support, pattern template specifications, and automated code generation. The variety of research and development in support of design patterns is exemplified by the inclusion in this year's technical program of this presentation and those by Uwe Zdun and Lance Tokuda.

Session: Runtime Issues
Session chair: Yi-Min Wang, Microsoft Research

Summary by Irfan Pyarali

Intercepting and Instrumenting COM Applications
Galen C. Hunt, Microsoft Research; Michael L. Scott, University of Rochester

Galen Hunt started by explaining Microsoft's Component Object Model (COM). Runtime interception of binary standard interfaces in COM enables the development of an incredible variety of useful component services. Hunt described the implementation of interception in COM, including (a) inline redirection of object-instantiation functions, (b) interception through interface wrappers, (c) tracking of interface ownership, and (d) support for undocumented interfaces. While the techniques described by Hunt were specific for COM, they have relevance to other object models, such as CORBA.

Implementing Causal Logging Using OrbixWeb Interception
Chanathip Namprempre, Jeremy Sussman, and Keith Marzullo, University of California, San Diego

Keith Marzullo presented COPE, a CORBA service based on causal logging. Causal logging is a useful technique for implementing causal consistency because it trades off bandwidth for latency. Applications ignore an action until they have observed that all actions upon which the observed action causally depended have completed.

Interception facilities provided by OrbixWeb filters were used for implementation of COPE. Filters allow invocations in the system to be captured and processed before continuing with the normal flow of the program. Marzullo described problems encountered during implementation of COPE, in the hope that it will help both those who are implementing and those who are planning on using CORBA interception
facilities.

Quality of Service Aware Distributed Object Systems
Svend Frølund, Hewlett-Packard Laboratories; Jari Koistinen, Commerce One, Inc.

QoS (Quality of Service) requirements vary vastly among applications. Furthermore, QoS requirements may change as operating conditions and available resources vary. To deliver satisfactory QoS in this context, a system must (a) be QoS-aware so that it can communicate its QoS expectations to external services, (b) trade and negotiate QoS agreements, (c) monitor compliance, and (d) adapt to changes in available resources.

Jari Koistinen presented QML, a QoS specification language that captures the fundamental concepts involved in the specification of QoS properties such as contract type, contract, and profile. Then Jari changed the focus to QRR—the runtime representation of QoS expressions. His description of QRR included discussions of its implementation, representation, programming model, and library support. He concluded that QML and QRR could be considered prototypes for common specification language and interchange format for QoS-enabled distributed systems.

Session: Objects and Databases
Session chair: Rajendra Raj, Morgan Stanley & Company

Summary by Irfan Pyarali

Resource Control for Java Database Extensions
Grzegorz Czajkowski, Tobias Mayr, Praveen Seshadri, and Thorsten von Eicken, Cornell University

Ability to extend object-relational database servers with user-defined functions (UDF) provides flexibility but compromises security. Using Java to implement UDFs alleviates some security concerns, but the problem of resource overconsumption and denial of service that are due to a malicious or buggy UDF is not resolved.

JRes, a Java resource-accounting interface and the subject of this presentation, addresses this problem by (a) detecting and neutralizing denial-of-service attacks, (b) monitoring resource consumption, and (c) on-the-fly query optimization based on the feedback of earlier queries.

The work presented was carried out in the context of Java and an OR database, but the results can be generalized to any Java dynamically extensible execution environment, such as a Web server.

Address Translation Strategies in the Texas Persistent Store
Sheetal V. Kakkad, Somerset Design Center, Motorola; Paul R. Wilson, University of Texas at Austin

Sheetal Kakkad presented Texas, "a portable, high-performance persistent object store. Texas can be used with conventional compilers and operating systems without the need for preprocessing or special operating-system privileges." Texas uses pointer swizzling upon page faults to translate persistent addresses into virtual addresses.

Kakkad described the five primary design issues related to granularity choices that affect persistence implementation: (a) address translation, (b) address mapping, (c) data fetching, (d) data caching, and (e) checkpointing.

Kakkad concluded with some benchmarks but added that further performance measurements are necessary, especially using real applications instead of synthetic benchmarks that do not always model reality very well.

Invited Talk

Summary by Marina Spivak

Safe Yet Efficient Data Sharing in Wide-Area Distributed Systems
Barbara Liskov, Massachusetts Institute of Technology

For this year's invited talk, Barbara Liskov, Ford Professor of Engineering at MIT, presented techniques used in implementation of Thor, a highly scalable and reliable distributed object-oriented database. The main requirement for Thor was safe sharing: the system must be used in a type-correct way and work properly in the presence of concurrency and failures; that is, it must implement atomic transactions. The challenge for such a system lies in attaining good performance while staying very scalable. Liskov pointed out that the following principles were key to reaching these goals: (1) every detail matters, (2) think small, and (3) be lazy.

Techniques highlighted in the presentation included:

• use of small pointers, which yield fewer disk accesses and produce better cache utilization;

• use of a modified object buffer for storage management at servers, which allows write absorption and background I/O;

• clock-based optimistic lazy concurrency control (CLOCC);

• hybrid adaptive caching (HAC). HAC is a hybrid of two traditional client caching strategies: object caching, which has high overhead, and page caching, which has low overhead but retains cold objects. In HAC, a whole page is fetched into a page-sized frame; however, when a page is discarded, hot objects from that page are retained.

Professor Liskov concluded the talk by saying that Thor-like persistent object stores provide the basis for distributed computing, and she predicted that they will eventually replace file systems as we know them today.

Information on Thor can be found at <https://www.pmg.lcs.mit.edu>.

Session: Optimization
Session chair: Ken Arnold, Sun Microsystems

Summary by Marina Spivak

JMAS: A Java-Based Mobile Actor System for Distributed Parallel Computation
Legand L. Burge III, Howard University; K. M. George, Oklahoma State University

Legand Burge presented Java-Based Mobile Actor System (JMAS), which aims to form a powerful network computing infrastructure from the resources of several interconnected computers, providing the user with the illusion of a single very powerful machine. JMAS utilizes Java technology and a parallel programming paradigm based on mobile agents and the actor message-passing model.

JMAS is the first actor-based solution for large-scale data-intensive distributed applications, which may be interconnected by costly communication links. Locality of reference and resource management — load balancing—are crucial for the performance of such systems: the efficiency of an actor-based computation on a loosely coupled architecture depends on where different actors are placed and the amount of communication traffic among them. JMAS implements a decentralized fault-tolerant load-balancing scheme based on the CPU market strategy, with systems of buyers and sellers.

Adaptation and Specialization for High Performance Mobile Agents
Dong Zhou and Karsten Schwan, Georgia Institute of Technology

Many inefficiencies in mobile-agent programming stem from underlying heterogenous-environment-shielding agent systems, which are frequently based on interpreted languages like Java or Tcl/Tk. Dong Zhou presented two techniques for improving the performance of mobile agents: agent morphing and agent fusion.

Morphing involves changing, invisibly to end users, a runtime agent representation to native code. Techniques like cross-platform binary code generation and access to code repositories can be used to implement morphing. Given that for an application with a large amount of computationally expensive floating-point operations, compiled code implemented with C is almost ten times faster than the
Java code realization, morphing can provide significant performance improvements, as well as better predictability of execution.

The intent of agent fusion, a second presented technique, is to remove communication overhead from sets of agents residing and collaborating on one machine. Agent fusion involves compiling collaborating agents as one unit, and, therefore, enabling optimizations across agent boundaries, for example, data copying and thread scheduling/context switching.

Applying Optimization Principle Patterns to Design Real-Time ORBs
Irfan Pyarali, Carlos O'Ryan, Douglas Schmidt, Nanbor Wang, and Vishal Kachroo, Washington University, St. Louis; Aniruddha Gokhale, Lucent Technologies, Bell Labs

Irfan Pyarali described a number of ORB Core and Object Adapter optimizations employed in the implementation of TAO—a high-performance realtime ORB developed in the DOC center at Washington University. Presented optimizations included: (1) perfect hashing and active demuxing for improved predictability and performance in request demultiplexing; (2) POA and stubs bypassing for optimized collocation; (3) Thread Specific Storage for efficient memory management; and (4) optional field removal from GIOP header for reduction of ORB protocol overhead.

The key result of this work is that it demonstrates that the ability of CORBA ORBs to support realtime systems is mostly an implementation detail.

TAO source code and information are available at <https://www.cs.wustl.edu/~schmidt/TAO.html>.

Session: Programming in the Large
Session chair: Joe Sventek, HP Labs

Summary by Marina Spivak

The Application of Object-Oriented Design Techniques to the Evolution of the Architecture of a Large Legacy Software System
Jeff Mason and Emil S. Ochotta, Xilinx Inc.

Most Object-Oriented Analysis and Design (OOAD) methods assume that software developers apply the techniques at the beginning of the design process and continue to use them as software matures; however, many large legacy software systems predate OOAD techniques. Furthermore, since pressures of commercial competition focus directly on adding features, fixing bugs, and releasing product on time, software developers often skimp on things that should be done for long-term benefit. The long-term price is the cost of maintenance. Trying to satisfy the needs of business and software engineering proves to be a difficult trick, and the key is to find the right balance.

Emil Ochotta presented the bumps and triumphs of the first stage of the rearchitecturing effort using OOAD for a large legacy system at Xilinx Inc. The shortcomings of the legacy system included long compilation times, lack of encapsulation and insulation, and complex intermodule dependencies. Emil attributed a large portion of the initial rearchitecturing effort's success to the support from the company's senior management and to the development of key concepts, which helped bridge a large semantic gap between the project goals and actual architectural and code changes.

Supporting Automatic Configuration of Component-Based Distributed Systems
Fabio Kon and Roy H. Campbell, University of Illinois at Urbana-Champaign

In many contemporary systems, the graceful failure of one module is not properly detected by other modules, leading to the failure of the whole system. Fabio Kon asserted that explicit representation of intercomponent dependencies would provide the necessary common ground for fault tolerance and automatic dynamic re/configuration. He then described a prototype infrastructure for representing runtime component dependencies.

In the presented model, each component is managed by a component configurator, which is responsible for storing the dependencies between the component it manages and other components in the system. For example, when a component is being destroyed, its component configurator can notify all of its dependents, allowing them to reconfigure—that is, respond to change—if necessary. In the CORBA implementation of this model, prerequisites for software components can be specified in two ways: (a) in terms of persistent IORs—then the implementation repository can be used to create a new object if one is not available; and (b) in terms of service type + attributes—then Trading Service can be used to locate a component satisfying the specified requirements.

Kon concluded the talk with descriptions of two application scenarios: (1) using the framework to support on-the-fly reconfiguration of dynamicTAO, a reflective extension of TAO realtime ORB; and (2) using the model in 2K, a fault-tolerant self-adapting distributed operating system. Information about these projects is available from: <https://choices.cs.uiuc.edu/2k> and <https://choices.cs.uiuc.edu/2k/ComponentConfigurator>.

Automating Three Modes of Evolution for Object-Oriented Software Architectures
Lance Tokuda and Don Batory, University of Texas at Austin

Lance Tokuda started the presentation by pointing out that architectural evolution in software is costly yet unavoidable, and that one way to reduce costs is to use automation whenever possible. The goal of his work is to promote refactoring research: to evaluate refactorings of large applications and to demonstrate that common forms of architectural change can be automated. Refactorings are behavior-preserving program transformations, which directly aid in the implementation of new architectures.

Refactorings are superior to hand coding: they allow evolution to occur at the level of a class diagram and leave the code details to automation. (Refactorings address the need to evolve from simple to complex designs by automating many common design transitions.)

Since "patterns have costs (indirection, complexity)," the design should be "as flexible as needed, not as flexible as possible." Instead of overdesigning, one can start with a simpler structure and, for example, with the help of refactorings, add Bridge, Strategy, and Decorator patterns later, as needed. However, the ability of refactorings to affect algorithms is limited.

Tokuda concluded by saying that the limiting factor in widespread acceptance of refactorings seems to be availability of production-quality tools, and that work in progress includes implementation issues for C++ refactoring tools.

Session: Java Internet Measurements
Session chair: Werner Vogels, Cornell University

Summary by Marina Spivak

The Design and Implementation of Guaraná
Alexandre Oliva and Luiz Eduardo Buzato, Universidade Estadual de Campinas, Brazil

Alexandre Oliva talked about the design and implementation of Guaraná, an extension to Kaffe Open Java Virtual Machine. Guaraná is a reflective architecture that uses the Composite pattern to define meta-configurations. Existing reflective architectures induce developers to create meta-objects that either are tightly coupled or attempt to implement many management aspects of the application "all-in-one." This motivated the development of Guaraná, which improves reuse of meta-level code by defining a meta-object interface that eases flexible composition. It allows meta-objects to be combined through the use of composers. A composer is a meta-object that delegates operations and results to multiple meta-objects, then composes their replies in its own replies. Composers are the glue, and they encourage the separation of the structure of the meta-level from the implementation of individual management aspects.

More information on Guaraná is available from <https://www.dcc.unicamp.br/~oliva>.

Tuning Branch Predictors to Support Virtual Method Invocation in Java
N. Vijaykrishnan, Pennsylvania State University; N. Ranganathan, University of Texas at El Paso

Virtual method invocation, which causes indirect branch execution, has been identified as one of the major bottlenecks for Java performance; furthermore, the proportion of virtual methods in Java programs is likely to increase because of the trend toward fine-grained object design. Accurate target prediction for indirect branches that occur because of virtual methods is critical to the performance of Java applications on deeply pipelined, wide-issue processors: speculative execution is used in such architectures to avoid performance loss associated with branch instructions.

N. Vijaykrishnan presented the results of the study in the use of path history of virtual calls—that is, target addresses of recently executed branches—to accurately predict the target of virtual method invocations and the impact various parameters have on the accuracy of prediction. The following parameters have been varied: number of history buffers, path history length, number of bits of each target address registered in the history buffer, hashing function, and structure of the target buffer.

The XOR hashing scheme with a global path history and a 2-bit update policy performed best for almost all the configurations. These results show that execution of Java code will benefit from more sophisticated branch-predictors.

Comprehensive Profiling Support in the Java Virtual Machine
Sheng Liang and Deepa Viswanathan, Sun Microsystems Inc.

Sheng Liang advocated the use of a general-purpose Java Virtual Machine profiler interface (binary function-call interface) instead of embedding direct profiling support into a virtual-machine implementation. This would make it possible for vendors to ship profilers that work with any virtual machine that implements the interface.

Liang presented such a general-purpose interface, which is efficient and powerful enough to suit the needs of a wide variety of virtual-machine implementations and profiler front ends. He also demonstrated how their approach supports interactive profiling with minimum overhead. Users can selectively enable or disable different types of profiling while an application is running.

Sheng also introduced an algorithm that obtains accurate CPU-time profiles in a multithreaded execution environment with minimum overhead. Since modern OSes do not provide ways to obtain accurate per-thread CPU time, the solution is to determine whether a thread has run in a sampling interval by checking whether its register set has changed.

Closing Remarks

Summary by Marina Spivak

Murthy Devarakonda concluded the proceedings by thanking the attendees, the program committee, and the USENIX staff. Overall, COOTS '99 was a great conference with lots of novel and interesting papers and presentations. We look forward to seeing you at COOTS in early 2001.

Break

Surfing USA