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

Quality of services specification in distributed object systems design

Abstract: Traditional object-oriented design methods deal with the functional aspects of systems, but they do not address quality of service (QoS) aspects such as reliability, availability, performance, security, and timing. However, deciding which QoS properties should be provided by individual system components is an important part of the design process. Different decisions are likely to result in different component implementations and system structures. Thus, decisions about component-level QoS should be made at design time, before the implementation is begun. Since these decisions are an important part of the design process, they should be captured as part of the design. We propose a general Quality-of-Service specification language, which we call QML. In this paper we show how QML can be used to capture QoS properties as part of designs. In addition, we extend UML, the de-facto standard object-oriented modeling language, to support the concepts of QML. QML is designed to integrate with object-oriented features, such as interfaces, classes, and inheritance. In particular, it allows specification of QoS properties through refinement of existing QoS specifications. Although we exemplify the use of QML to specify QoS properties within the categories of reliability and performance, QML can be used for specification within any QoS category-QoS categories are user-defined types in QML.

Execution patterns in object-oriented visualization

Abstract: Execution patterns are a new metaphor for visualizing execution traces of object-oriented programs We present an execution pattern view that lets a programmer visualize and explore a program's execution at varied levels of abstraction The view employs visual, navigational, and analytical techniques that accommodate lengthy, real-world traces By classifying repetitive behavior automatically into high-order execution patterns, we drastically reduce the inform ation a programmer must assimilate, with little loss of in sight

COBEA: a CORBA-based event architecture

Abstract: Events are an emerging paradigm for composing applications in an open, heterogeneous distributed world. In Cambridge we have developed scalable event handling based on a publish-register-notify model with event object classes and server-side filtering based on parameter templates. After experience in using this approach in a home-built RPC system we have extended CORBA, an open standard for distributed object computing, to handle events in this way. In this paper, we present the design of COBEA - a COrba-Based Event Architecture. A service that is the source of (parameterised) events publishes in a Trader the events it is prepared to notify, along with its normal interface specification. For scalability, a client must register interest (by invoking a register method with appropriate parameters or wild cards) at the service, at which point an access control check is carried out. Subsequently, whenever a matching event occurs, the client is notified. We outline the requirements on the COBEA architecture, then describe its components and their interfaces. The design and implementation aim to support easy construction of applications by using COBEA components. The components include event primitives, an event mediator and a composite event service; each features well-defined interfaces and semantics for event registration, notification and filtering. We demonstrate that COBEA is flexible in supporting various application scenarios yet handles efficiently the most common event communications. The performance of server-side filtering for various registration scenarios is presented. Our initial experience with applications is also described.

Efficient implementations of java remote method invocation (RMI)

Abstract: Java and the Remote Method Invocation (RMI) mechanism supported by it make it easy to build distributed applications and services in a heterogeneous environment. When the applications are interactive and require low response time, efficient implementations of RMI are needed. We explore both transport level protocols as well as object caching in the RMI framework to meet the performance requirements of interactive applications. We have developed a prototype system that offers new transport protocols and allows objects to be cached at client nodes. We describe the design issues and the implementation choices made in the prototype along with some preliminary performance results.

COMERA: COM extensible remoting architecture

Abstract: In a distributed object system, remoting architecture refers to the infrastructure that allows client programs to invoke methods on remote server objects in a transparent way. In this paper, we study the strength and limitations of current remoting architecture of COM (Component Object Model), and propose a new architecture called COMERA (COM Extensible Remoting Architecture) to enhance the extensibility and flexibility. We describe several application scenarios and implementations to demonstrate the power of such a componentized remoting architecture.

The architecture of a distributed virtual worlds system

Abstract: We have developed an object model that facilitates the development of shared virtual environments. We have implemented our object model on top of COM and OLE Automation and facilitated access from Active Scripting enabled languages. This paper provides a brief description of the work we have done on the V-Worlds project.

Filterfresh: hot replication of java RMI server objects

Abstract: This paper presents the design and implementation of a Java package called Filterfresh for building replicated fault-tolerant servers. Maintaining the correctness and integrity of replicated servers is supported by a GroupManager object instantiated with each replica to form a logical group. The Group Managers use a Group Membership algorithm to maintain a consistent group view and a Reliable Multicast mechanism to communicate with other Group Managers. We then demonstrate how Filterfresh can be integrated into the Java RMI facilities. First we use the GroupManager class to construct a fault-tolerant RMI registry called FT Registry-a group of replicated RMI registry servers. Second, we describe our implementation of the FT Unicast-a client-side mechanism that tolerates and masks server failures below the stub layer, transparent to the client. We also present initial performance results, and discuss how general purpose RMI servers can be made highly available using the Filterfresh package.

Java transactions for the internet

Abstract: The Web frequently suffers from failures which affect the performance and consistency of applications run over it. An important fault-tolerance technique is the use of atomic transactions for controlling operations on services. While it has been possible to make server-side Web applications transactional, browsers typically did not possess such facilities. However, with the advent of Java it is now possible to consider empowering browsers so that they can fully participate within transactional applications. In this paper we present the design and implementation of a standards compliant transactional toolkit for the Web. The toolkit allows transactional applications to span Web browsers and servers and supports application specific customisation, so that an application can be made transactional without compromising the security policies operational at browsers and servers.

Secure delegation for distributed object environments

Abstract: SDM is a Secure Delegation Model for Java-based distributed object environments. SDM extends current Java security features to support secure remote method invocations that may involve chains of delegated calls across distributed objects. The framework supports a control API for application developers to specify mechanisms and security policies surrounding simple or cascaded delegation. Delegation may also be disabled and optionally revoked. These policies may be controlled explicitly in application code, or implicitly via administrative tools.

Dynamic management of CORBA trader federation

Abstract: In Wide Area Networks, tools for discovering objects that provide a given service, and for choosing one out of many are essential. The CORBA trading service is one of these tools. A trader federation extends the limit of a discovery, thanks to the cooperation of several trading servers. However, in a federation, cooperation links are manually and statically established. In this article, we propose an Extended Trading Service, which manages a trader federation dynamically. With Extended Trading Service, optimized links between traders are automatically set up thanks to the use of a minimum-weight spanning tree. Cycles in discovery propagation are eliminated. Links evolve dynamically in order to adapt to the modification of the underlying topology and the failure of an intermediate trader or link. The Extended Trading Service is able to organize discovered objects from the nearest to the furthest according to a distance function chosen for the federation. Such management is provided by specialized trading servers conforming to OMG Trading Service Specification.

An object-oriented framework for distributed computational simulation of aerospace propulsion systems

Abstract: Designing and developing new aerospace propulsion systems is time-consuming and expensive. Computational simulation is a promising means for alleviating this cost, but requires a flexible software simulation system capable of integrating advanced multidisciplinary and multifidelity analysis methods, dynamically constructing arbitrary simulation models, and distributing computationally complex tasks. To address these issues, we have developed Onyx, a Java-based object-oriented application framework for aerospace propulsion system simulation. The Onyx framework defines a common component object model which provides a consistent component interface for the construction of hierarchal object models. Because Onyx is a framework, component analysis models may be changed dynamically to adapt simulation behavior as required. A customizable visual interface provides high-level symbolic control of propulsion system construction and execution. For computationally-intensive analysis, components may be distributed across heterogeneous computing architectures and operating systems. This paper describes the design concepts and object-oriented architecture of Onyx. As a representative simulation, a set of lumped-parameter gas turbine engine components are developed and used to simulate a turbojet engine.

Compile time symbolic derivation with C++ templates

Abstract: C++ templates are already recognized as a powerful linguistic mechanism, whose usefulness transcends the realization of traditional generic containers. In the same venue, this paper reports on a somewhat surprising application of templates-for computing the symbolic derivative of expression. Specifically, we describe a software package based on templates, called SEMT, which allows the programmer to create symbolic expressions, substitute variables in them, and compute their derivatives. SEMT is unique in that these manipulations are all done at compile time. In other words, SEMT effectively coerces the compiler to do symbolic computation as part of the compilation process. Beyond the theoretical interest, SEMT can be practically applied in the efficient, generic and easy to use implementation of many numerical algorithms.

Object and concurrency in Triveni: a telecommunication case study in java

Abstract: We describe the interaction of objects and concurrency in the design of Triveni, a framework for concurrent programming with threads and events. Triveni has been realized as JavaTriveni, a collection of tools for the Java programming language. We describe our experiences in JavaTriveni with an example from telecommunication.

Programming network components using NetPebbles: an early report

Abstract: A network-centric application developer faces a number of challenges, including distributed program design, efficient remote object access, software reuse, and program deployment issues. This level of complexity hinders the developer's ability to focus on the application logic. NetPebbles removes this complexity from the developer through a network-component based scripting environment where remote object access and program deployment are transparent to the developer. In Net-Pebbles, a developer selects needed network components from a distributed catalog, and then writes a script invoking its methods as if the components are local. When the script is launched, the run-time determines the component sites in the network and transparently moves the script as needed. Using three simple examples with different data flow patterns, we show that the NetPebbles approach is superior to the traditional client/server systems and mobile agent technologies because a scripting language is easy to use, it requires less code, and the distributed systems complexity is hidden from the programmer. This paper is an early report on the NetPebbles project, describing the motivation, design, prototype implementation, and the experiments using the NetPebbles approach.

Mobile objects and agents (MOA)

Abstract: This paper describes the design and implementation of the Mobile Objects and Agents (MOA) project at the Open Group Research Institute. MOA was designed to support migration, communication and control of agents. It was implemented on top of the Java Virtual Machine, without any modifications to it. The initial project goals were to support communication across agent migration, as a means for collaborative work; and to provide extensive resource control, as a basic support for countering denial of service attacks. In the course of the project we added two further goals: compliance with the Java Beans component model which provides for additional configurability and customization of agent system and agent applications; and interoperability which allows cooperation with other agent systems. This paper analyzes the architecture of MOA, in particular the support for mobility, naming and locating, communication, and resource management. Object and component models of MOA are discussed and some implementation details described. We summarize the lessons learned while developing and implementing MOA and compare it to related work.

The design and performance of MedJava: a distributed electronic medical imaging system developed with java applets and web tools

Abstract: The Java programming language has gained substantial popularity in the past two years. Java's networking features, along with the growing number of Web browsers that execute Java applets, facilitate Internet programming. Despite the popularity of Java, however, there are many concerns about its efficiency. In particular, networking and computation performance are key concerns when considering the use of Java to develop performance-sensitive distributed applications. This paper makes three contributions to the study of Java for performance-sensitive distributed applications. First, we describe an architecture using Java and the Web to develop Med-Java, which is a distributed electronic medical imaging system with stringent networking and computation requirements. Second, we present benchmarks of MedJava image processing and compare the results to the performance of xv, which is an equivalent image processing application written in C. Finally, we present performance benchmarks using Java as a transport interface to exchange large medical images over high-speed ATM networks. For computationally intensive algorithms, such as image filters, hand-optimized Java code, coupled with use of a JIT compiler, can sometimes compensate for the lack of compile-time optimization and yield performance commensurate with identical compiled C code. With rigorous compile-time optimizations employed, C compilers still tend to generate more efficient code. However, with the advent of highly optimizing Java compilers, it should be feasible to use Java for the performance-sensitive distributed applications where C and C++ are currently used.

Building a scalable and efficient component oriented system sing CORBA: active badge system case study

Abstract: This paper presents experience gathered when implementing the localization system for an office environment in CORBA. It describes methods which enable preserving fine-grained object-oriented structure of the system and achieving efficient performance at the same time. The presented study is a practical lesson about the implementation of a scalable system oriented towards information dissemination. The key idea is to represent a large observable collection of objects by a repository that provides access to them both as individual CORBA objects and data records. The proper usage of this duality may have substantial influence on the overall system performance. The repository is equipped with a scalable notification mechanism built around a notification dispatcher and notification tree concepts. Fundamental features of the proposed solution are illustrated by a performance study and a representative application.

Improving scalability with loop transformations and message aggregation in parallel object-oriented frameworks for scientific computing

Abstract: Application codes reliably achieve performance far less than the advertised capabilities of existing architectures, and this problem is worsening with increasingly-parallel machines. For large-scale numerical applications, stencil operations often impose the great part of the computational cost, and the primary sources of inefficiency are the costs of message passing and poor cache utilization. This paper proposes and demonstrates optimizations for stencil and stencil-like computations for both serial and parallel environments that ameliorate these sources of inefficiency. Achieving scalability, they believe, requires both algorithm design and compile-time support. The optimizations they present are automatable because the stencil-like computations are implemented at a high level of abstraction using object-oriented parallel array class libraries. These optimizations, which are beyond the capabilities of today compilers, may be performed automatically by a preprocessor such as the one they are currently developing.

IBDL: a language for interface behavior specification and testing

Abstract: A methodology and language for specifying behaviors of interfaces (a la OMG's IDL, JavaTM, C++, etc.) for object-oriented systems is proposed based on the message-passing paradigm. Signatures of messages are enhanced to include semantic information, expressing behavior clients can expect from a server. Formulas are given to disambiguate normal termination from abnormal termination of a message using the return values and exceptions to reflect whether the pre-condition associated with the message is satisfied or not. State changes caused by a message invocation are specified by explicitly enumerating subsequent messages that a message invocation enables (and/or) disables, by establishing (or violating, respectively) their pre-conditions. Special operators on sequences of messages are defined to specify such semantic information. A specification language IBDL, Interface Behavior Description Language, based on this methodology is developed. As IBDL specifications explicitly capture the interactions between messages, they are ideal for validating implementation behaviors with sequences of messages. We present a scheme for sequence testing by translating IBDL specifications into code.